动态代理（JDK Proxy & cjlib）

JAVA安全|基础文章:反射应用-动态代理 (qq.com)

Java反射与动态代理的区别（JDK Proxy和Cglib，常见面试题 (qq.com)

反射需要通过关键方法来调用类中的方法“invoke()实现的方法调用也分为三种:

• 静态（static）方法调用
• 调用普通方法
• 调用私有方法

以下将演示各种调用的实现代码和各种调用的公共代码部分，如下：

// 这个代码是公共代码interface People {   int parentAge = 18;   public void sayHi(String name);}class PeopleImpl implements People {   private String privSex = "男";   public String race = "汉族";   @Override   public void sayHi(String name) {       System.out.println("hello," + name);  }   private void prvSayHi() {       System.out.println("prvSayHi~");  }   public static void getSex() {       System.out.println("18岁");  }}

调用静态方法

// 核心代码(省略了抛出异常声明)public static void main(String[] args) {   Class myClass = Class.forName("example.PeopleImpl");   // 调用静态（static）方法   Method getSex = myClass.getMethod("getSex");   getSex.invoke(myClass);}

静态方法的调用相对简单，使用方法 getMethod(xx) 获取相应的方法，直接使用 invoke(xx)就可以了。

调用普通方法

通过“普通非静态方法调用”，需要先获得类别示例newInstance()获取方法的核心代码如下:

Class myClass = Class.forName("example.PeopleImpl");Object object = myClass.newInstance();Method method = myClass.getMethod("sayHi",String.class);method.invoke(object,"老王");

getMethod 获取方法可以声明需要传输的参数类型。

调用私有方法

必须使用“调用私有方法”getDeclaredMethod(xx)代码如下：

Class myClass = Class.forName("example.PeopleImpl");Object object = myClass.newInstance();Method privSayHi = myClass.getDeclaredMethod("privSayHi");privSayHi.setAccessible(true); // 修改访问限制privsayHi.invoke(object);

除了“getDeclaredMethod(xx)可以看出，调用私有方法的关键是设置 setAccessible(true) 属性，修改访问限制，以便在设置后调用。

总结

newinstance()获取类实例是反射的核心方法，getMethod(...)采用invokee获取方法(...)通过setaccesible修改访问私有变量/方法的限制

获取属性/方法时是否存在“Declared“不同之处在于，有 Declared 修改方法或属性，可获得本类的所有方法或属性（private 到 public），但是不能得到任何关于父类的信息；非 Declared 修饰的方法或属性只能获得 public 修饰的方法或属性，并且可以获得父亲的信息，比如 getMethod(..)和getdeclaredmethod(..)。

代理模式属于结构模式。使用一个类代表另一个类的功能。在某些情况下，一个对象不适合或不能直接引用另一个对象，代理对象可以在客户端和目标对象之间发挥中介作用。 例如，对于生活中常见的中介机构和租赁机构，租户不需要直接与房东互动，房东将房屋租赁交给中介机构。代理模式的目的是：

(1)通过引入代理对象间接访问目标对象，防止直接访问目标对象给系统带来不必要的复杂性；

(2)通过代理对象控制访问；

代理模式通常有三个角色：

抽象角色：指代理角色和真实角色提供的公共方法，通常是一个界面

真实角色：需要实现抽象角色接口，定义真实角色需要实现的业务逻辑，以便代理角色调用。这就是真正的业务逻辑。

代理角色：需要实现抽象角色接口，是真实角色的代理，通过真实角色的业务逻辑方法实现抽象方法，并可以添加自己的操作。将统一的过程控制放入代理角色中！

实例如下：

首先，我们必须有一个界面(如ClothFactory、服装厂)，有两个类别(代理类，如NikeClothFactory)；代理类，如ProxyClothFactory)实现了这个界面，并希望通过代理类调用到代理类的同名方法，因此代理对象必须包装代理对象。

如何通过代码实现包装？代理对象中的一个属性应该是代理对象，通过构造器传输，并在代理对象的方法中调用代理对象的同名方法，以便通过代理调用原始对象。具体代码如下：

/interface共同接口 ClothFactory{   void produceCloth();}///被代理classclasss NikeClothFactory implements ClothFactory{   @Override   public void produceCloth() {       System.out.println("Nike工厂生产了一批运动服");  }}///代理class代理classs ProxyClothFactory implements ClothFactory{   private ClothFactory factory;////用被代理对象实例化   public ProxyClothFactory(ClothFactory factory) {       this.factory = factory;  }   @Override   public void produceCloth() {       System.out.println("代理工厂做一些准备");       factory.produceCloth();       System.out.println("代理工厂做一些后续的收尾工作");  }}

测试代码：

///测试类publiccicc class StaticProxyTest {   public static void main(String[] args) {       ////创建代理对象       ClothFactory nikeClothFactory = new NikeClothFactory();       ////创建代理对象       ClothFactory proxyClothFactory = new ProxyClothFactory(nikeClothFactory);       ////通过代理对象访问代理对象       proxyClothFactory.produceCloth();  }}

运行结果：

代理工厂做一些准备 Nike工厂生产了一批运动服 代理工厂做一些后续的收尾工作

动态代理是一种方便运行时动态构建代理、动态处理代理方法调用的机制。许多场景都是通过类似的机制实现的，如包装RPC调用和切割编程（AOP）。

实现动态代理的方法有很多。例如，JDK本身提供的动态代理主要使用上述反射机制。还有其他实现方法，如使用传说中更高性能的字节码操作机制，类似于ASM、cglib(基于ASM)等。

JDK Proxy 是通过实现 InvocationHandler 代码如下：

interface Animal {   void eat();}class Dog implements Animal {   @Override   public void eat() {       System.out.println("The dog is eating");  }}class Cat implements Animal {   @Override   public void eat() {       System.out.println("The cat is eating");  }}// JDK 代理class AnimalProxy implements InvocationHandler {   private Object target; // 代理对象   public Object getInstance(Object target) {       this.target = target;       // 获取代理对象       return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);  }   @Override   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {       System.out.println("调用前");       Object result = method.invoke(target, args); // 方法调用       System.out.println("调用后");       return result;  }}public static void main(String[] args) {   // JDK 动态代理调用   AnimalProxy proxy = new AnimalProxy();   Animal dogProxy = (Animal) proxy.getInstance(new Dog());   dogProxy.eat();}

以上代码，我们通过动态代理在所有请求之前和之后打印了一个简单的信息。

注意： JDK Proxy 只能代理实现接口的类别(即使是extends继承类也不能代理)。

JDK Proxy 为什么只能代理实现接口类？

这个问题应该从动态代理的实现方法出发 newProxyInstance 源码说起：

@CallerSensitivepublic static Object newProxyInstance(ClassLoader loader,                                     Class<?>[] interfaces,                                     InvocationHandler h)   throws IllegalArgumentException{// 省略其他代码

前两个源代码参数说明

* @param   loader the class loader to define the proxy class* @param   interfaces the list of interfaces for the proxy class to implement

• loader：为类加载器，即 target.getClass().getClassLoader()
• interfaces：接口代理类的接口实现列表

因此，这个问题的来源在于 JDK Proxy 源代码设计。如果你想坚持动态代理，非接口实现类会报错：

Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to xxx

JDK 动态代理机制只能代理实现接口类，Cglib 实现代理是针对类的。他的原则是为指定的目标类生成子类，并覆盖增强方法的方法。然而，由于它是继承的，它不能是正确的 final 代理修饰类。

Cglib 可以通过 Maven 版本直接引用，Maven 版本地址：https://mvnrepository.com/artifact/cglib/cglib

本文使用最新版本 3.2.9 的 Cglib，在 pom.xml 添加以下引用：

<dependency>   <groupId>cglib</groupId>   <artifactId>cglib</artifactId>   <version>3.2.9</version></dependency>

Cglib 实现代码，如下所示：

class Panda {   public void eat() {       System.out.println("The panda is eating");  }}class CglibProxy implements MethodInterceptor {   private Object target; // 代理对象   public Object getInstance(Object target) {       this.target = target;       Enhancer enhancer = new Enhancer();       // 以父类为例类       enhancer.setSuperclass(this.target.getClass());       // 回调方法       enhancer.setCallback(this);       // 创建代理对象       return enhancer.create();  }   @Override   public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {       System.out.println("调用前");       Object result = methodProxy.invokeSuper(o, objects); // 调用执行方法       System.out.println("调用后");       return result;  }}public static void main(String[] args) {   // CGLIB 动态代理调用   CglibProxy proxy = new CglibProxy();   Panda panda = (Panda)proxy.getInstance(new Panda());   panda.eat();}

cglib 通过实现调用 MethodInterceptor 接口的 intercept 方法，调用 invokeSuper 对于动态代理，可以直接对普通类进行动态代理。

JDK动态代理:利用反射机制生成代理类，可以动态指定代理类的目标类，要求实现invovationhandler接口，重写invoke方法增强功能，目标类必须实现接口。

Cjlib动态代理:使用ASM开源包加载代理对象的Class文件，修改其字节码文件生成子类。如果子类重写目标类的方法被final修改，则不允许使用子类拦截技术拦截父类，编织逻辑(定义拦截器实现methodinterceptor接口)

JDK Proxy 的优势：

• 最小化依赖关系，减少依赖意味着简化开发和维护，JDK 本身的支持，更可靠；
• 平滑进行 JDK 版本升级，字节码类库通常需要更新，以确保在新版本中使用；

Cglib 框架的优点：

• 无需实现接口即可调用普通类；
• 以ASM为基础，高性能；