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();
}

AOP中的动态代理的区别--JDK和CGLIB_第1张图片

从结果可以看出,我们在未修改 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();
}

AOP中的动态代理的区别--JDK和CGLIB_第2张图片

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

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

参考:
掘金
知乎

你可能感兴趣的:(Spring,代理模式,java,spring)