AOP中的动态代理的区别--JDK和CGLIB

区别

spring AOP的底层实现机制是动态代理，动态代理有JDK 和CGLIB 动态代理
下面说一下这两种动态代理的区别：

1、JDK动态代理只提供接口的代理，不支持类的代理

• jdk会在运行时为目标类生成一个 动态代理类$proxy*.class
• 该代理类是实现了目标类接口的一个类，并且会实现接口所有的方法增强代码
• 调用时 通过先去调用处理类进行增强，再通过反射的方式进行调用目标方法，从而实现AOP

2、如果代理类 没有实现接口，那么spring AOP会选择使用CGLIB来动态代理目标类

• CGLIB的底层是通过ASM在运行时动态的生成目标类的一个子类，（还有其他相关的多个类，主要是为了增强调用时的效率）
• 并且会重写父类所有的方法增强代码
• 调用时会先通过代理类进行增强，再直接调用父类对应的方法进行调用目标方法，从而实现AOP

CGLIB是通过继承的方式做动态代理，因此如果某个类被标记final，那么它是无法使用CGLIB做动态代理的
CGLIB除了生成目标子类代理类，还有一个FastClass（路由类），可以让本类方法调用进行增强，而不会像JDK代理那样
本类方法调用增强会失效

从性能来说：

jdk和CGLIB的性能：jdk动态代理生成类速度快，调用慢， CGLIB生成类速度慢，但后续调用快，

在老版本的CGLIB的速度是jdk速度的10倍左右，但是实际上jdk的速度在版本升级的时候每次都提高很多性能，而CGLIB止步不前

在对jdk动态代理和CGLIB动态dialing的代码实验中看，1w次执行下，jdk7以及8的动态代理性能要比CGLIB要好20% 左右

二、基于接口的 JDK 动态代理

现在有一个 saveUser() 方法，我想在不改变这个方法代码的情况下，在方法前后做一下增强，分别打印一条日志，模拟一下业务代码的增强效果。

这里我们创建一个工具类，用来编写两种代理模式的代码：MyProxyUtil。

1、接口类：UserService

public interface UserService {

    void saveUser();
}

2、实现类：UserServiceImpl

public class UserServiceImpl implements UserService {

    @Override
    public void saveUser() {
        System.out.println("调用 saveUser() 方法");
    }
}

3、工具类方法：MyProxyUtil.getProxyByJDK()

public static UserService getProxyByJDK(UserService service) {
	UserService userService = (UserService) Proxy.newProxyInstance(service.getClass().getClassLoader(),
			service.getClass().getInterfaces(),
			new InvocationHandler() {
				@Override
				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
					System.out.println("记录日志-开始");
					// 下面的代码是反射中 API 的用法
					// 改行代码，实际调用的是目标对象的方法
					Object obj = method.invoke(service, args);
					System.out.println("记录日志-结束");
					return obj;
				}
			});
	return userService;
}

这里的 Proxy 是 JDK 中的 api，newProxyInstance() 方法中的参数如下：

• 第一个参数：目标对象的类加载器
• 第二个参数：目标对象的接口
• 第三个参数：代理对象的执行处理器
• 注意：使用 JDK 的动态代理目标对象必须是接口

@Test
public void testJDKProxy() {
	// 创建目标对象
	UserService userService = new UserServiceImpl();
	// 生成代理对象
	UserService proxy = MyProxyUtil.getProxyByJDK(userService);
	// 调用目标对象方法
	userService.saveUser();
	System.out.println("===================================");
	// 调用代理对象方法
	proxy.saveUser();
}

从结果可以看出，我们在未修改 saveUser() 方法的前提下，在执行 saveUser() 前后均添加了模拟代码，这就是所谓的增强。

三、基于继承的 CGLib 动态代理

CGLib 动态代理相对于 JDK 动态代理局限性就小了很多，目标对象不需要实现接口，底层是通过继承目标对象产生代理子对象。（代理子对象中继承了目标对象的方法，并可以对该方法进行增强）

这里使用的接口类、实现类以及测试代码均和上一小节相同，不再给出，这里我想计算一下 saveUser() 执行需要多长时间，前提依旧是不改变 saveUser() 的代码，下面我们来看一下实现过程吧。

1、工具类方法：MyProxyUtil.getProxyByCglib()

public static UserService getProxyByCglib(UserService service) {
	// 创建增强器
	Enhancer enhancer = new Enhancer();
	// 设置需要增强的类的对象
	enhancer.setSuperclass(UserServiceImpl.class);
	// 设置回调方法
	enhancer.setCallback(new MethodInterceptor() {
		@Override
		public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
			long begin = System.currentTimeMillis();
			System.out.println("记录程序开始时间 => " + begin);
			Object object = methodProxy.invokeSuper(o, args);
			long end = System.currentTimeMillis();
			System.out.println("记录程序结束时间 => " + end);
			System.out.println("记录程序运行总时长 => " + (end - begin));
			return object;
		}
	});
	UserService userService = (UserService) enhancer.create();
	return userService;
}
注意：这里我们如果想要使用 Enhancer，需要导入 Spring 相关依赖包。

2、测试代码：

@Test
public void testCglibProxy() {
	// 创建目标对象
	UserService userService = new UserServiceImpl();
	// 生成代理对象
	UserService proxy = MyProxyUtil.getProxyByCglib(userService);
	// 调用目标对象方法
	userService.saveUser();
	System.out.println("===================================");
	// 调用代理对象方法
	proxy.saveUser();
}

四、静态代理和动态的本质区别

• 静态代理只能通过手动完成代理操作，如果被代理类增加新的方法，代理类需要同步新增，违背开闭原则。
• 动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则。
• 若动态代理要对目标类的增强逻辑扩展，结合策略模式，只需要新增策略类便可完成，无需修改代理类的代码。

参考：
掘金
知乎