Spring之CGLIB和JDK动态代理底层实现

这篇具有很好参考价值的文章主要介绍了Spring之CGLIB和JDK动态代理底层实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

CGLIB

使用示例-支持创建代理对象,执行代理逻辑

使用示例-多个方法,走不同的代理逻辑

JDK动态代理

使用示例-支持创建代理对象,执行代理逻辑

ProxyFactory

如何自动在CGLIB和JDK动态代理转换

使用示例-使用CGLIB代理方式

使用示例-使用JDK动态代理方式


Spring会自动在JDK动态代理和CGLIB之间转换:

1、如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP

2、如果目标对象实现了接口,可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口,必须采用CGLIB库

本文主要讲解CGLIB和JDK动态代理的使用和底层原理,以及Spring如何自动在JDK动态代理和CGLIB之间转换

CGLIB

CGLIB动态代理是利用ASM开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。

使用示例-支持创建代理对象,执行代理逻辑

新建一个UserService类,这个类是目标类,后续会被代理

public class UserService {
	public void test() {
		System.out.println("userService execute test....");
	}
}

使用Enhancer类设置代理类UserService,设置代理逻辑,创建代理对象

public class CylTest {
	public static void main(String[] args) {
		UserService target = new UserService();

		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(UserService.class);

		//设置代理逻辑
		enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
			@Override
			public Object intercept(/*目标对象*/Object o,
                                    /*目标对象方法*/Method method,
                                    /*参数*/Object[] args,
                                    /*代理对象方法*/MethodProxy methodProxy) 
            throws Throwable {
				System.out.println("before");
				Object result = method.invoke(target, args);
				System.out.println("after");
				return result;
			}
		}});

        //创建代理对象=>类型是UserService,但却是代理对象
		UserService userService = (UserService) enhancer.create();
		userService.test();
	}
}

这个阶段会产生三个对象:

1.目标对象-targetUserService

2.负责创建代理对象的工厂对象enhancer

3.代理对象-proxyUserService

Spring之CGLIB和JDK动态代理底层实现,Spring,java,开发语言

最终执行效果:

before

userService execute test....

after

使用示例-多个方法,走不同的代理逻辑

新建一个UserService类,设置两个方法

public void test() {
		System.out.println("userService execute test....");
	}

	public void a() {
		System.out.println("userService execute a....");
	}

在enhancer对象中设置两个代理逻辑,test方法走代理逻辑1,a方法走代理逻辑2

public static void main(String[] args) {
		UserService targetUserService = new UserService();

		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(UserService.class);

		//代理逻辑:1
		MethodInterceptor firstCallback = new MethodInterceptor() {
			@Override
			public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
				System.out.println("before");
				Object result = method.invoke(targetUserService, args);
				System.out.println("after");
				return result;
			}
		};
		//代理逻辑:2
		NoOp secondCallback = NoOp.INSTANCE;

		enhancer.setCallbacks(new Callback[]{firstCallback, secondCallback});

		enhancer.setCallbackFilter(new CallbackFilter() {
			@Override
			public int accept(Method method) {
				//方法test执行=》firstCallback代理逻辑:1
				if (method.getName().equals("test")) {
					return 0;
				}
				//其他执行=》secondCallback代理逻辑:2
				return 1;
			}
		});

		UserService proxyUserService = (UserService) enhancer.create();
		System.out.println("执行proxyUserService.test:");
		proxyUserService.test();
		System.out.println("--------------------------------------------------------");
		System.out.println("执行proxyUserService.a:");
		proxyUserService.a();
	}

最终执行效果:

执行proxyUserService.test:

before

userService execute test....

after

--------------------------------------------------------

执行proxyUserService.a:

userService execute a....

JDK动态代理

JDK动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。

使用示例-支持创建代理对象,执行代理逻辑

//接口
public interface UserInterface {
	void test();
	void a();
}
//实现类
public class UserService implements UserInterface {
	@Override
	public void test() {
		System.out.println("userService execute test....");
	}
	@Override
	public void a() {
		System.out.println("userService execute a....");
	}
}

使用Proxy.newProxyInstance创建一个代理接口,InvocationHandler制定代理逻辑

public class CylTest {
	public static void main(String[] args) {
		UserService targetUserService = new UserService();

		UserInterface proxyUserInterface = (UserInterface) Proxy.newProxyInstance(
				UserInterface.class.getClassLoader(),
				new Class[]{UserInterface.class},
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						System.out.println("before");
						Object result = method.invoke(targetUserService, args);
						System.out.println("after");
						return result;
					}
				});

		proxyUserInterface.test();
	}
}

最终执行效果:

before

userService execute test....

after

ProxyFactory

如何自动在CGLIB和JDK动态代理转换

ProxyFactory是Spring封装的代理工厂,对目标对象使用CGLIB或者JDK动态代理有处理逻辑。

代理方式
CGLIB isProxyTargetClass属性=true
只实现了SpringProxy接口
被代理对象没有实现接口
JDK动态代理 被代理类只实现了接口,且实现了非SpringProxy接口

org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy

@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		// 如果ProxyFactory的isOptimize为true,Spring认为cglib比jdk动态代理要快
		// 或者isProxyTargetClass为true,
		// 或者被代理对象没有实现接口,
		// 或者只实现了SpringProxy这个接口
		// 那么则利用Cglib进行动态代理,但如果被代理类是接口,或者被代理类已经是进行过JDK动态代理而生成的代理类了则只能进行JDK动态代理

		// 其他情况都会进行JDK动态代理,比如被代理类实现了除SpringProxy接口之外的其他接口

		// 是不是在GraalVM虚拟机上运行
		if (!NativeDetector.inNativeImage() &&
				(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {

			Class<?> targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

使用示例-使用CGLIB代理方式

设置目标类 

public class UserService {

	public void test() {
		System.out.println("test...");
	}

}
public static void main(String[] args) {
    UserService userService = new UserService();
    ProxyFactory proxyFactory = new ProxyFactory();
    //
    proxyFactory.setTarget(userService);
    
    
    //代理逻辑1
    MethodBeforeAdvice methodBeforeAdvice = new MethodBeforeAdvice() {
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("begin");
        }
    };
    
     //代理逻辑2
    AfterReturningAdvice afterReturningAdvice = new AfterReturningAdvice() {
    
        @Override
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
            System.out.println("end");
        }
    };
    
    //添加多个代理逻辑
    proxyFactory.addAdvice(0, methodBeforeAdvice);
    proxyFactory.addAdvice(1, afterReturningAdvice);
    
    UserService proxyUserService = (UserService) proxyFactory.getProxy();
    proxyUserService.test();
	}

使用示例-使用JDK动态代理方式

设置目标接口文章来源地址https://www.toymoban.com/news/detail-857274.html

//UserInterface
public interface UserInterface {
	void test();
}

//UserService
public class UserService implements UserInterface {

	@Override
	public void test() {
		System.out.println("test...");
	}
}
public static void main(String[] args) {
    UserService userService = new UserService();
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setTarget(userService);
    proxyFactory.setInterfaces(UserInterface.class);
    
    
    //代理逻辑1
    MethodBeforeAdvice methodBeforeAdvice = new MethodBeforeAdvice() {
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("begin");
        }
    };
    
     //代理逻辑2
    AfterReturningAdvice afterReturningAdvice = new AfterReturningAdvice() {
    
        @Override
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
            System.out.println("end");
        }
    };
    
    //添加多个代理逻辑
    proxyFactory.addAdvice(0, methodBeforeAdvice);
    proxyFactory.addAdvice(1, afterReturningAdvice);
    
    UserInterface proxyUserService = (UserInterface) proxyFactory.getProxy();
    proxyUserService.test();
}

到了这里,关于Spring之CGLIB和JDK动态代理底层实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • java中的静态代理、jdk动态代理以及CGLIB 动态代理

    代理模式是一种比较好理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问,这样就可以在不修改原目标对象的前提下,提供额外的功能操作,扩展目标对象的功能 那以下文章主要谈三种代理模式, 分别是静态代理,jdk的动态代理,cglib的动

    2024年02月11日
    浏览(44)
  • Spring学习(五):一篇讲清楚动态代理(jdk和cglib)的使用、原理和源码

    目录 一、jdk动态代理的基本使用 二、cglib动态代理的基本使用 2.1 方法一:method.invoke() 方法反射调用 2.2 方法二(spring使用的这个方法): methodProxy.invoke() 2.3 方法三:methodProxy.invokeSuper() 三、jdk实现代理的原理  四、jdk实现代理的源码 五、jdk对代理的优化  六、cglib实现动

    2023年04月14日
    浏览(46)
  • 代理模式 静态代理和动态代理(jdk、cglib)——Java入职第十一天

            一个类代表另一个类去完成扩展功能,在主体类的基础上,新增一个代理类,扩展主体类功能,不影响主体,完成额外功能。比如买车票,可以去代理点买,不用去火车站,主要包括静态代理和动态代理两种模式。 代理类中包含了主体类 无法根据业务扩展,每一次

    2024年02月10日
    浏览(51)
  • JDK动态代理和CGLIB动态代理

    JDK动态代理和CGLIB动态代理 ① JDK动态代理只提供接口的代理,不支持类的代理,要求被代理类实现接口。JDK动态代理的核心是InvocationHandler接口和Proxy类,在获取代理对象时,使用Proxy类来动态创建目标类的代理类(即最终真正的代理类,这个类继承自Proxy并实现了我们定义的

    2024年02月07日
    浏览(45)
  • 【动态代理】JDK动态代理与cglib动态代理源码解析

    UserService ,接口类 UserServiceImpl ,实现类 使用代理,测试效果。 控制台输出: Proxy#newProxyInstance ,生成代理类的实例。 核心在于 getProxyClass0 ,生成代理类的类信息 使用自定义的InvocationHandler作为参数,调用构造函数获取代理类对象实例 WeakCache#get ProxyClassFactory#apply ,实现了

    2024年02月04日
    浏览(45)
  • 代理模式:静态代理+JDK/CGLIB 动态代理

    代理模式是一种比较好理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问,这样就可以在不修改原目标对象的前提下,提供额外的功能操作,扩展目标对象的功能。 代理模式的主要作用是扩展目标对象的功能,比如说在目标对象的某个方法

    2024年02月13日
    浏览(37)
  • 通俗易懂 快速理解 JDK动态代理 和 cglib动态代理

    动态代理的实现方案有两种, JDK动态代理 和 CGLIB动态代理 ,区别在于JDK自带的动态代理,必须要有接口,而CGLIB动态代理有没有接口都可以。 JDK动态代理 :JDK原生的实现方式,需要被代理的目标类必须实现接口。因为这个技术要求 代理对象和目标对象实现同样的接口 (兄

    2024年02月08日
    浏览(50)
  • SpringAOP-说说 JDK动态代理和 CGLIB 代理

    Spring 的 AOP 是通过动态代理来实现的,动态代理主要有两种方式 JDK 动态代理和 Cglib 动态代理,这两种动态代理的使用和原理有些不同。 JDK 动态代理 Interface :JDK动态代理是基于接口的代理,它要求目标类实现一个接口。 InvocationHandler :InvocationHandler 是一个接口,可以通过

    2024年01月18日
    浏览(48)
  • 3_代理模式(动态代理JDK原生和CGLib)

    1.概念 代理模式(Proxy Pattern )是指 为其他对象提供一种代理,以控制对这个对象的访问 ,属于结构型模式。 在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。 使用代理模式主要有两个目的: 一是保护目标

    2024年01月17日
    浏览(41)
  • AOP、AspectJ、JDK动态代理、CGLIB

    AOP(Aspect Orient Programming),作为面向对象编程的一种补充,广泛应用于处理一些具有横切性质的系统级服务,如事务管理、安全检查、缓存、日志记录管理等。 AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理,AOP 代理则可分为静态代理和动态代理两大类。 其中静态代理是

    2024年02月11日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包