动态代理:JDK原生动态代理(Java Proxy)和CGLIB动态代理原理+附静态态代理

时间:2023-12-24 11:55:19

本文只是对原文的梳理总结,以及自行理解。自己总结的比较简单,而且不深入,不如直接看原文。不过自己梳理一遍更有助于理解。

详细可参考原文:http://www.cnblogs.com/CarpenterLee/p/8241042.html原文很强大,多看几遍,深入理解。

原文中参考:https://www.jianshu.com/p/e2917b0b9614 (比原文的代码更详细,更有助于理解)


自行总结:
  1. 两种代理方式,都是提供一个方法调用的中转站用于实现代理:CGLIG中MethodInterceptor和跟JDK代理中的InvocationHandler;
  2. 都是通过特定类的特定方法得到代理对象:
    1. Proxy.newProxyInstance() 方法入参中包含:类加载器(被代理对象的)、代理需要实现的接口,可以有多个(被代理对象的)、方法调用的实际处理者(即实际代理对象)
    2. Enhancer.create() 方法入参中包含:Superclass (被代理的类) 和 Callback (代理类)
  3. 调用代理对象的对应方法,会自动被代理到 invoke() 方法和 intercept() 方法。可在方法中加入代理的逻辑
  4. 最终还需要调用实际被代理对象的方法:Method. invoke() 和 MethodProxy.invokeSuper() 。

一、静态代理的实现
  1. 声明接口;
  2. 编码接口实现类,需继承对应接口,实现对应方法;
  3. 编码代理类,需继承对应接口,实现对应方法。代理类内部方法实际调用具体实现类的方法,同时加入额外逻辑。

具体实现可参考原文。

二、JDK原生动态代理:基于接口

1、动态代理:实际就是JDK定义类和方法(Proxy.newProxyInstance()),我们只需传入相关入参,JDK会自行为我们创建代理类,以实现代理功能。

2、使用实现:

// Java Proxy
// 1. 首先实现一个InvocationHandler,方法调用会被转发到该类的invoke()方法。
class LogInvocationHandler implements InvocationHandler{
...
private Hello hello;
public LogInvocationHandler(Hello hello) {
this.hello = hello;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if("sayHello".equals(method.getName())) {
logger.info("You said: " + Arrays.toString(args));
}
return method.invoke(hello, args);
}
}
// 2. 然后在需要使用Hello的时候,通过JDK动态代理获取Hello的代理对象。
Hello hello = (Hello)Proxy.newProxyInstance(
getClass().getClassLoader(), // 1. 类加载器(被代理对象的)
new Class<?>[] {Hello.class}, // 2. 代理需要实现的接口,可以有多个(被代理对象的)
new LogInvocationHandler(new HelloImp()));// 3. 方法调用的实际处理者(即实际代理对象)
System.out.println(hello.sayHello("I love you!"));

3、具体使用总结:

  1. 首先实现一个InvocationHandler,方法调用会被转发到该类的invoke()方法。invoke() 方法就是实际的代理方法。
  2. 需要使用Hello时,通过JDK动态代理获取Hello的代理对象。
  3. 调用代理对象的接口声明方法,会被自动转发到invoke()方法上。

4、上述代码理解:

关键是:Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler)方法
该方法会根据指定的参数动态创建代理对象。三个参数的意义如下: loader,指定代理对象的类加载器;
interfaces,代理对象需要实现的接口,可以同时指定多个接口;
handler,方法调用的实际处理者,代理对象的方法调用都会转发到这里(*注意1)。 newProxyInstance()会返回一个实现了指定接口的代理对象,对该对象的所有方法调用都会转发给InvocationHandler.invoke()方法。
理解上述代码需要对Java反射机制有一定了解。动态代理神奇的地方就是:
-代理对象是在程序运行时产生的,而不是编译期;
-对代理对象的所有接口方法调用都会转发到InvocationHandler.invoke()方法,在invoke()方法里我们可以加入任何逻辑,比如修改方法参数,加入日志功能、安全检查功能等;之后我们通过某种方式执行真正的方法体,示例中通过反射调用了Hello对象的相应方法,还可以通过RPC调用远程方法。

5、其他理解:参考JDK官方文档即可

  1. InvocationHandler(接口)和其invoke()方法理解:
接口:
java.lang.reflect.InvocationHandler
方法:在代理实例上处理方法调用并返回结果。
Object invoke(Object proxy, Method method, Object[] args)
参数:
proxy - 在其上调用方法的代理实例(即代理对象)
method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口,该接口可以是代理类赖以继承方法的代理接口的超接口。(即代理方法)
args - 包含传入代理实例上方法调用的参数值的对象数组,如果接口方法不使用参数,则为 null。基本类型的参数被包装在适当基本包装器类(如 java.lang.Integer 或 java.lang.Boolean)的实例中。
返回:
从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型,则此方法返回的值一定是相应基本包装对象类的实例;否则,它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null 并且接口方法的返回类型是基本类型,则代理实例上的方法调用将抛出 NullPointerException。否则,如果此方法返回的值与上述接口方法的声明返回类型不兼容,则代理实例上的方法调用将抛出 ClassCastException。
  1. Proxy(类)的理解:
类:java.lang.reflect.Proxy

方法:返回一个指定接口的代理类实例,该接口可以将方法调用指派到指定的调用处理程序。
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
参数:
loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
h - 指派方法调用的调用处理程序
返回:
一个带有代理类的指定调用处理程序(即入参:h )的代理实例,它由指定的类加载器(即入参:loader)定义,并实现指定的接口(即入参:interfaces)
  1. 对于不同invoke()方法的理解:
java.lang.reflect.Method.invoke(Object, Object...)
对带有指定参数的指定对象调用由此 Method 对象表示的底层方法
//即该方法所属对象的该方法调用。 java.lang.reflect.InvocationHandler.invoke(Object, Method, Object[])

三、CGLIB动态代理

大致原理和JDK动态代理一致,方便使用。

优点在于:可以代理没有实现任何接口的类;

1、使用实现:

//需被代理的类
public class HelloConcrete {
public String sayHello(String str) {
return "HelloConcrete: " + str;
}
} // CGLIB动态代理
// 1. 首先实现一个MethodInterceptor,方法调用会被转发到该类的intercept()方法。
class MyMethodInterceptor implements MethodInterceptor{
...
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
logger.info("You said: " + Arrays.toString(args));
return proxy.invokeSuper(obj, args);
}
}
// 2. 然后在需要使用HelloConcrete的时候,通过CGLIB动态代理获取代理对象。
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloConcrete.class); //被代理的类
enhancer.setCallback(new MyMethodInterceptor());//代理类 HelloConcrete hello = (HelloConcrete)enhancer.create(); //代理对象
System.out.println(hello.sayHello("I love you!"));

2、具体使用总结:

  1. 首先实现一个MethodInterceptor,方法调用会被转发到该类的intercept()方法。
  2. 然后在需要使用HelloConcrete的时候,设置参数,同时通过CGLIB动态代理获取代理对象。
  3. 调用代理对象的代理方法,然后会自行实现其调用

3、上述代码理解:

1、通过CGLIB的Enhancer来指定要代理的目标对象、实际处理代理逻辑的对象,
2、最终通过调用create()方法得到代理对象,对这个对象所有非final方法的调用都会转发给MethodInterceptor.intercept()方法,
3、在intercept()方法里我们可以加入任何逻辑,比如修改方法参数,加入日志功能、安全检查功能等;
4、通过调用MethodProxy.invokeSuper()方法,我们将调用转发给原始对象,具体到本例,就是HelloConcrete的具体方法。 CGLIG中MethodInterceptor的作用跟JDK代理中的InvocationHandler很类似,都是方法调用的中转站。

三、结束。