spring AOP 两种底层实现（ JDK动态代理 和 CGLIB代理）

最新推荐文章于 2024-05-27 18:56:24 发布
最新推荐文章于 2024-05-27 18:56:24 发布
阅读量1.1k 收藏
点赞数
分类专栏： Spring学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SUNFC_nbu/article/details/50958558
版权

  AOP的底层实现:

1.底层实现就是代理机制:
          JDK动态代理   和  CGLIB代理 .
2.JDK动态代理:

         原理：并没有使用多余的技术，纯粹的原java方式，类运用，即生成了一个接口的实现类.

 JDK动态代理的使用:  添加Proxy类，一般会继承: InvocationHandler接口生成invoke方法。

static Object





 InvocationHandler

接口

newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

 ClassLoader    :类的加载器.

 Class[]        :实现的所有接口.

 InvocationHandler  :处理接口.


 Object invoke(Object proxy,Method method,Object[] args);

 Object:代理对象.

 Method:执行的方法.

 Object[]:执行这个方法的参数列表.

2.1.调用真实对象的方法的时候;

* UserDao(接口)---->UserDaoImpl(实现类)

* 对UserDaoImpl生成一个代理类.

* UserDao userDao = Proxy.newProxyInstance(..);

* userDao.add();

* userDao.update();

***** 都相当于调用了InvocationHandler中的invoke()方法.

 

2.2.JDK动态代理的代码实现:
    
    

     
     

      
      生成代理类==>

     
     

     
     

      
      public class JdkProxy implements InvocationHandler{
     
     

     
     

      
       
     
     

     
     

      
      private UserDao userDao;
     
     

     
     

      
       
     
     

     
     

      
      public JdkProxy(UserDao userDao) {
     
     

     
     

      
          this.userDao = userDao;
     
     

     
     

      
      }
     
     

     
     

      
       
     
     

     
     

      
      public UserDao createProxy(){
     
     

     
     

      
          Object proxy = Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), this);
     
     

     
     

      
          return (UserDao) proxy;
     
     

     
     

      
      }
     
     

     
     

      
       
     
     

     
     

      
      @Override
     
     

     
     

      
      public Object invoke(Object proxy, Method method, Object[] args)
     
     

     
     

      
              throws Throwable {
     
     

     
     

      
          // 判断执行的方法
     
     

     
     

      
          // 对add方法进行增强
     
     

     
     

      
          if("add".equals(method.getName())){
     
     

     
     

      
              // 增强
     
     

     
     

      
              System.out.println("增强的代码...");
     
     

     
     

      
              return method.invoke(userDao, args);
     
     

     
     

      
          }else{
     
     

     
     

      
              // 不增强
     
     

     
     

      
              return method.invoke(userDao, args);
     
     

     
     

      
          }
     
     

     
     

      
      }
     
     

     
     

      
      }
     
     

    
    
     
     

      
      

       
       测试主体
       
       ==>
      
      

      
      

       
       

      
      

      
      

       
       package cn.green.demo;
      
      

      
      

       
       import org.junit.Test;
      
      

      
      

       
       public class TestCase {
      
      

      
      

       
       	@Test
      
      

      
      

       
       	public void demo01(){
      
      

      
      

       
       		UserDao userDao = new UserDaoImpl();
      
      

      
      

       
       		UserDao userProxy = new JdkProxy(userDao).createProxy();
      
      

      
      

       
       		userProxy.add();
      
      

      
      

       
       		userProxy.delete();
      
      

      
      

       
       	}
      
      

      
      

       
       }
      
      

     
     
      
      

       
       

        
        applicationContext.xml==>
       
       

       
       

        
        

       
       

       
       

        
        <?xml version="1.0" encoding="UTF-8"?>
       
       

       
       

        
        <beans xmlns="http://www.springframework.org/schema/beans"
       
       

       
       

        
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       
       

       
       

        
               xmlns:aop="http://www.springframework.org/schema/aop"
       
       

       
       

        
               xsi:schemaLocation="
       
       

       
       

        
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       
       

       
       

        
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
       
       

       
       

        
         
       
       

       
       

        
        <aop:aspectj-autoproxy />
       
       

       
       

        
        <bean id="userDao" class="cn.green.demo.UserDaoImpl"></bean>
       
       

       
       

        
        <bean id="jdkProxy" class="cn.green.demo.JdkProxy"></bean>
       
       

       
       

        
         
       
       

       
       

        
        </beans>

3. CGLIB的代理:

JDK的动态代理有局限性:类必须实现接口,才能生成代理.(一个类没有实现接口,JDK无法生成代理对象.)

CGLIB代理:可以对没有实现接口的类生成代理.

CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。Hibernate支持它来实现PO(Persistent Object 持久化对象)字节码的动态生成。

* Hibernate  :javassist

原理:

* 通过字节码技术,对这个类生成了一个子类对象.

   
   

    
    

     
     package cn.itcast.spring3.demo2;
    
    

    
    

     
      
    
    

    
    

     
     public class ProductDao {
    
    

    
    

     
     	public void add(){
    
    

    
    

     
     		System.out.println("添加商品...");
    
    

    
    

     
     	}
    
    

    
    

     
     	public void update(){
    
    

    
    

     
     		System.out.println("修改商品...");
    
    

    
    

     
     	}
    
    

    
    

     
     	public void delete(){
    
    

    
    

     
     		System.out.println("删除商品...");
    
    

    
    

     
     	}
    
    

    
    

     
     	public void find(){
    
    

    
    

     
     		System.out.println("查询商品...");
    
    

    
    

     
     	}
    
    

    
    

     
     }
    
    

   
   
    
    

     
     

      
      package cn.green.demo1;
     
     

     
     

      
       
     
     

     
     

      
      import java.lang.reflect.Method;
     
     

     
     

      
       
     
     

     
     

      
      import org.springframework.cglib.proxy.Enhancer;
     
     

     
     

      
      import org.springframework.cglib.proxy.MethodInterceptor;
     
     

     
     

      
      import org.springframework.cglib.proxy.MethodProxy;
     
     

     
     

      
       
     
     

     
     

      
      public class CglibProxy implements MethodInterceptor {
     
     

     
     

      
       
     
     

     
     

      
      	private OrderDao orderDao;
     
     

     
     

      
      	
     
     

     
     

      
      	public CglibProxy(OrderDao orderDao){
     
     

     
     

      
      		this.orderDao = orderDao;
     
     

     
     

      
      	}
     
     

     
     

      
      	//生成代理的方法
     
     

     
     

      
      	public OrderDao createProxy(){
     
     

     
     

      
      		//CGLIB核心对象
     
     

     
     

      
      		Enhancer enhancer = new Enhancer();
     
     

     
     

      
      		//原理：对这个类生成一个子类对象
     
     

     
     

      
      		//设置父类
     
     

     
     

      
      		enhancer.setSuperclass(orderDao.getClass());
     
     

     
     

      
      		//设置回调
     
     

     
     

      
      		enhancer.setCallback(this);
     
     

     
     

      
      		//创建代理对象
     
     

     
     

      
      		return (OrderDao) enhancer.create();
     
     

     
     

      
      	}
     
     

     
     

      
      	
     
     

     
     

      
      	public Object intercept(Object proxy, Method method, Object[] args,
     
     

     
     

      
      			MethodProxy methodProxy) throws Throwable {
     
     

     
     

      
      		if("add".equals(method.getName())){
     
     

     
     

      
      			System.out.println("方法前增强代码===============");
     
     

     
     

      
      			Object obj = methodProxy.invokeSuper(proxy, args);
     
     

     
     

      
      			System.out.println("方法后增强代码===============");
     
     

     
     

      
      			return obj;
     
     

     
     

      
      		}else{
     
     

     
     

      
      			return methodProxy.invokeSuper(proxy, args);
     
     

     
     

      
      		}
     
     

     
     

      
      	}
     
     

     
     

      
      }
     
     

    
    
    
    

     
     

      
      package cn.green.demo1;
     
     

     
     

      
      import org.junit.Test;
     
     

     
     

      
       
     
     

     
     

      
      public class TestDemo {
     
     

     
     

      
      	@Test
     
     

     
     

      
      	public void test01(){
     
     

     
     

      
      		OrderDao orderDao = new OrderDao();
     
     

     
     

      
      		OrderDao proxy = new CglibProxy(orderDao).createProxy();
     
     

     
     

      
      		proxy.add();
     
     

     
     

      
      		proxy.delete();
     
     

     
     

      
      		proxy.update();
     
     

     
     

      
      		proxy.find();
     
     

     
     

      
      	}
     
     

     
     

      
      }
     
     

    
    
   
   

    
    

     
     <?xml version="1.0" encoding="UTF-8"?>
    
    

    
    

     
     <beans xmlns="http://www.springframework.org/schema/beans"
    
    

    
    

     
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    
    

    
    

     
            xmlns:aop="http://www.springframework.org/schema/aop"
    
    

    
    

     
            xsi:schemaLocation="
    
    

    
    

     
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    
    

    
    

     
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    

    
    

     
     	
    
    

    
    

     
     	<bean id="orderDao" class="cn.green.demo1.OrderDao"></bean>
    
    

    
    

     
     	<bean id="cglibProxy" class="cn.green.demo1.CglibProxy"></bean> 
    
    

    
    

     
     </beans>
效果如下： 
   
   

    
    

     
     方法前增强代码===============
    
    

    
    

     
     add run....
    
    

    
    

     
     方法后增强代码===============
    
    

    
    

     
     delete run....
    
    

    
    

     
     update run....
    
    

    
    

     
     find run....

4.Spring中使用这两种技术完成代理(AOP):

* 如果类实现了接口,使用JDK动态代理,为你生成代理对象.

* 如果类没有实现接口,使用CGLIB动态代理,生成代理对象.

 

总结:

Spring在运行期，生成动态代理对象，不需要特殊的编译器

Spring AOP的底层就是通过JDK动态代理或CGLib动态代理技术 为目标Bean执行横向织入

1.若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。

2.若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。

* 程序中应优先对接口创建代理，便于程序解耦维护

3.标记为final的方法，不能被代理，因为无法进行覆盖

JDK动态代理，是针对接口生成子类，接口中方法不能使用final修饰

CGLib 是针对目标类生产子类，因此类或方法 不能使final的

4.Spring只支持方法连接点，不提供属性连接.



sunfengcai
关注
专栏目录
Spring 学习 （四）三种代理模式（动态代理AOP底层实现的两种方式）
杨大侠不是奥特曼的博客
09-27 978
目录 Java代理模式 一、静态代理 二、AOP底层原理的两种实现方式 （一）动态代理（又叫JDK代理（实现接口）） JDK代理底层原理： （二）CGlib动态代理（继承类） 我们用CGLib代理就需要知道 动态代理技术是整个java技术中最重要的一个技术，它是学习java框架的基础，不会动态代理技术，那么在学习Spring这些框架时是学不明白的。 Java代理模式 代理(Pr...
浅谈Spring中JDK动态代理和CGLIB动态代理
CharlesYooSky的博客
10-21 1733
浅谈Spring中JDK动态代理和CGLIB动态代理
Spring笔记六: AOP的底层实现--JDK动态代理和CGLIB动态代理
SoP_KaiXinHaHa的博客
08-23 256
代理模式 定义：给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问，即客户不直接操控原对象，而是通过代理对象间接地操控原对象。 • RealSubject 是原对象（本文把原对象称为”委托对象”），Proxy 是代理对象。 • Subject 是委托对象和代理对象都共同实现的接口。 • Request() 是委托对象和代理对象共同拥有的方法。 代理的实现分为： ...
Spring框架的AOP的底层实现之JDK的动态代理（代码了解，理解原理）
weixin_30649641的博客
12-17 67
1.创建接口UserDao: package com.huida.demo1; public interface UserDao { public void save(); public void update(); } 2.创建实现接口的类UserDaoImpl: package com.huida.demo1; public class ...
JDK动态代理一定要有代理对象吗?请结合Mybatis回答
微笑的小小刀
06-16 408
动态代理有一段时间没有写文章了, 主要是回想起这两年多的时间,多多少少,每个知识点差不多都有写到了, 一时也想不起什么新鲜的知识分享给大家.今天写动态代理,主要是在看Mybatis源码时...
Spring AOP中两种动态代理方式
wsh622827的专栏
10-21 6358
1. JDk 反射机制    实现java.lang.reflect.InvocationHandler接口，复写其中的invoke方法。    生成代理核心方法是：     newProxyInstance (obj.getClass().getClassLoader(),obj.getClass().getInterfaces(), InvocationHandler invoc
【Spring】Spring AOP底层原理：JDK动态代理和CGLIB动态代理
最新发布
m0_65277261的博客
05-27 1756
Spring AOP 的实现原理是基于动态代理和字节码操作的。而动态代理是基于反射机制的。 在编译时， Spring 会使用 AspectJ 编译器将切面代码编译成字节码文件。在运行时， Spring 会使用 Java 动态代理或 CGLIB 代理生成代理类，这些代理类会在目标对象方法执行前后插入切面代码，从而实现AOP的功能。
Java两种动态代理JDK动态代理和CGLIB动态代理
热门推荐
Java相关领域
08-07 14万+
目录 代理模式 JDK动态代理 cglib动态代理 测试 代理模式 代理模式是23种设计模式的一种，他是指一个对象A通过持有另一个对象B，可以具有B同样的行为的模式。为了对外开放协议，B往往实现了一个接口，A也会去实现接口。但是B是“真正”实现类，A则比较“虚”，他借用了B的方法去实现接口的方法。A虽然是“伪军”，但它可以增强B，在调用B的方法前后都做些其他的事情。Spring AOP...
Spring AOP的底层实现有两种方式 JDK动态代理和CGLib动态代理
qq_40331861的博客
06-19 802
首先，我们知道Spring AOP的底层实现有两种方式：一种是JDK动态代理，另一种是CGLib的方式。 自Java 1.3以后，Java提供了动态代理技术，允许开发者在运行期创建接口的代理实例，后来这项技术被用到了Spring的很多地方。 JDK动态代理主要涉及java.lang.reflect包下边的两个类：Proxy和InvocationHandler。其中，InvocationHandler是一个接口，可以通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态地将横切逻辑和业务逻辑贬值
JAVA动态代理实现Demo（JDK动态代理和CGLIB动态代理）
12-19
Java提供了两种主要的动态代理实现方式：JDK动态代理和CGLIB动态代理。 **JDK动态代理**： JDK动态代理基于接口实现，也就是说，被代理的对象必须实现至少一个接口。代理机制的核心是`java.lang.reflect.Proxy`类和...
Spring AOP底层实现- JDK动态代理和CGLIB动态代理
JavaLab
12-21 6776
Spring AOP是运行时织入的，那么运行时织入到底是怎么实现的呢?答案就是代理对象。 代理又可以分为静态代理和动态代理。 静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 动态代理：在程序运行时，运用反射机制动态创建而成。 静态代理的每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且...
Spring—AOP三种实现方式(JDK动态代理与CGLIB动态代理)
Starry Sea
05-22 432
JDK动态代理 JDK 动态代理只提供接口的代理，不支持类的代理。 核心InvocationHandler 接口和 Proxy 类，InvocationHandler 通过 invoke()方法 反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起； 接着，Proxy利用 InvocationHandler 动态创建一个符合某一接口的的实例, 生成目标类的代理对象。 CGLIB动态代理 如果代理类没有实现 InvocationHandler 接口，那么 Spring A..
Spring Boot 中的 AOP，到底是 JDK 动态代理还是 Cglib 动态代理？
m0_71777195的博客
09-02 374
大家都知道，AOP 底层是动态代理，而 Java 中的动态代理有两种实现方式：基于 JDK 的动态代理基于 Cglib 的动态代理这两者最大的区别在于基于 JDK 的动态代理需要被代理的对象有接口，而基于 Cglib 的动态代理并不需要被代理对象有接口。那么小伙伴们不禁要问，Spring 中的 AOP 是怎么实现的？是基于 JDK 的动态代理还是基于 Cglib 的动态代理？
CGLIB动态代理
缥缈
02-13 228
CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。 package cn.cglib.proxy; import java.lang.reflect.Method; import org.springframework.cglib.proxy.Enhancer; imp...
JDK动态代理原理
weixin_39590058的博客
03-18 2248
给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用。 假设我们想请明星来唱歌，我们是先联系他的经纪人，在经纪人告诉明星，然后明星唱歌。其中经纪人就是代理。 静态代理与动态代理的区别： 静态代理中的代理类是需要用户自己写的，这样代理类在程序运行前就已经存在了。 动态代理中的代理类是在程序运行中自动生成的。 //静态代理 //接口 public interface Fru...
Spring的AOP自动代理（含AspectJ的AOP开发）
LOADING
03-22 2524
1. 自动代理:  上面这两种代理的方式不好,需要为每一个类配置一个独立的ProxyFactoryBean.(如果需要代理的类特别的多,每个类都需要创建一个代理的类.)  根据切面Advisor的定义的信息,看到哪些类的哪些方法需要增强.(为这些需要增强的类生成代理.  自动代理:基于后处理BeanPostProcessor完成代理.  代理机制不同      基于P
Spring中的传统AOP开发
LOADING
03-22 539
AOP:AOP联盟提出思想.AOP联盟为增强定义一些接口:org.aopalliance.aop.Interface.Advice 1.Spring的Advice的类型: Advice就是增强: 前置通知(在方法之前增强) org.springframework.aop.MethodBeforeAdvice    在目标方法执行前实施增
Spring AOP：动态代理详解与JDK/CGLIB应用
Spring AOP提供了两种主要的动态代理实现方式：JDK动态代理和CGLIB动态代理。 1. **JDK动态代理**： - JDK动态代理基于Java的反射机制，它要求被代理的类必须实现一个接口。`InvocationHandler`接口是核心，它定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值