动态代理
从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。 意思是说：不用事先定义好一个代理类，JVM在运行时会自动创建一个 字节码对象。
JDK动态代理机制
在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。
Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。
1
2
3
4
5
6
7
|
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
......
}
|
方法一共有 3 个参数：
- loader :类加载器，用于加载代理对象。
- interfaces : 被代理类实现的一些接口；
- h : 实现了
InvocationHandler 接口的对象；
实现动态代理的话，还必须需要实现InvocationHandler 来 自定义处理逻辑。 当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用，即：一个invoke方法，统一负责接管代理对象的所有方法处理。
可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。
注：InvocationHandler 中文译为：调用句柄。这里个人理解为 代理对象的逻辑处理方法。
JDK 动态代理类使用步骤
- 定义一个接口及其实现类；
- 自定义
InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
- 通过
Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；
代码示例
1.定义发送短信的接口
1
2
3
|
public interface SmsService {
String send(String message);
}
|
2.实现发送短信的接口
1
2
3
4
5
6
|
public class SmsServiceImpl implements SmsService {
public String send(String message) {
System.out.println("send message:" + message);
return message;
}
}
|
3.定义一个 JDK 动态代理类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class DebugInvocationHandler implements InvocationHandler {
/**
* 代理类中的真实对象——target为被代理类对象
*/
private final Object target;
public DebugInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
//调用方法之前，我们可以添加自己的操作
System.out.println("before method " + method.getName());
Object result = method.invoke(target, args);
//调用方法之后，我们同样可以添加自己的操作
System.out.println("after method " + method.getName());
return result;
}
}
|
当我们的 动态代理对象 调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。
4.获取代理对象的工厂类
这种代理模式产生的对象 似乎运用到了 工厂设计模式？
1
2
3
4
5
6
7
8
9
|
public class JdkProxyFactory {
public static Object getProxy(Object target) {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(), // 目标类的类加载器
target.getClass().getInterfaces(), // 代理需要实现的接口，可指定多个
new DebugInvocationHandler(target) // 代理对象对应的自定义 InvocationHandler
);
}
}
|
getProxy()：主要通过Proxy.newProxyInstance（）方法获取某个类的代理对象
5.实际使用
1
2
|
SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
smsService.send("java");
|
注：
- 动态代理对象 也是 实现了
SmsService接口，这里运用接口多态 用接口对象来接收 动态生成的代理对象。
- 生成动态代理对象，调用
getProxy方法，实则是封装了Proxy.newProxyInstance方法，该方法的第三个参数 传入InvocationHandler h 需要手动传入一个参数 — 就是被代理的对象 Object target，这个被代理对象无法自动获取。(注意和下边的CGLIB调用进行对比)
CGLIB 动态代理机制
JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。 例如：上边没有实现SmsService 接口的类，是不能走 JDK动态代理的。因为在JDK动态代理中，代理的方法是以接口中定义方法为准。
CGLIB(Code Generation Library) 是一个基于ASM的字节码生成库，允许在运行时对字节码进行修改和动态生成。
CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB， 例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。
在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。
需要自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法。
1
2
3
4
5
|
public interface MethodInterceptor
extends Callback{
// 拦截被代理类中的方法
public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,MethodProxy proxy) throws Throwable;
}
|
- obj : 被代理的对象（需要增强的对象）
- method : 被拦截的方法（需要增强的方法）
- args : 方法入参
- proxy : 用于调用原始方法
通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。
CGLIB动态代理类使用步骤
- 定义一个类(这里不用实现接口)
- 自定义
MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
- 通过
Enhancer 类的 create()创建代理类；
代码示例
不同于 JDK 动态代理不需要额外的依赖。CGLIBopen in new window(Code Generation Library) 实际是属于一个开源项目，如果你要使用它的话，需要手动添加相关依赖。
1
2
3
4
5
|
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
|
1. 实现一个发送短信的类
1
2
3
4
5
6
|
public class AliSmsService {
public String send(String message) {
System.out.println("send message:" + message);
return message;
}
}
|
2.自定义 MethodInterceptor（方法拦截器）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* 自定义MethodInterceptor
*/
public class DebugMethodInterceptor implements MethodInterceptor {
/**
* @param o 被代理的对象（需要增强的对象）
* @param method 被拦截的方法（需要增强的方法）
* @param args 方法入参
* @param methodProxy 用于调用原始方法
*/
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//调用方法之前，我们可以添加自己的操作
System.out.println("before method " + method.getName());
Object object = methodProxy.invokeSuper(o, args);
//调用方法之后，我们同样可以添加自己的操作
System.out.println("after method " + method.getName());
return object;
}
}
|
3.获取代理类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import net.sf.cglib.proxy.Enhancer;
public class CglibProxyFactory {
public static Object getProxy(Class<?> clazz) {
// 创建动态代理增强类
Enhancer enhancer = new Enhancer();
// 设置类加载器
enhancer.setClassLoader(clazz.getClassLoader());
// 设置被代理类
enhancer.setSuperclass(clazz);
// 设置方法拦截器
enhancer.setCallback(new DebugMethodInterceptor());
// 创建代理类
return enhancer.create();
}
}
|
注：上边设置 参数：类加载器、被代理类和 方法拦截器都和JDK动态代理中 Proxy.newProxyInstance方法传入参数差不多，后边的enhancer.create()就是实例化代理类。
4.实际使用
1
2
3
|
// 注意：下边传入的 AliSmsService.class ,在getProxy方法中就是Class<?> clazz 表示被代理类的字节码文件对象
AliSmsService aliSmsService = (AliSmsService)CglibProxyFactory.getProxy(AliSmsService.class);
aliSmsService.send("java");
|
注意：
- CGLIB动态代理创建对象中创建 代理类，调用
getProxy方法，实则封装了enhancer.create()方法，这个方法设置的参数需要传入第二个参数：被代理类的字节码文件对象，不用传递被代理的对象(JDK动态代理处理方式)。可以看到MethodInterceptor接口中的intercept方法其实是通过 enhancer对象第二个参数字节码文件对象 来获取被代理类 对象Object o(参数一)、被拦截的方法Method method(参数二)、方法入参Object[] args(参数三)、调用原始方法MethodProxy methodProxy(参数四)。
JDK动态代理 和 CGLIB动态代理的对比
- JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。
- CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。
- 效率来说：大部分情况都是 JDK 动态代理效率更高，随着 JDK 版本的升级，这个优势更加明显
静态代理和动态代理对比
- 灵活性：
- 动态代理更加灵活，不需要实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。
- 静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，繁琐
- JVM层面：
- 静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件
- 动态代理是在运行时动态生成类字节码，并加载到 JVM 中的
附录
参考文献
版权信息
本文原载于kitebin.top，遵循CC BY-NC-SA 4.0协议，复制请保留原文出处。
