spring aop动态代理中：java代理与cglib动态代理区别，及同一个业务类里事务方法调用处理

傷城~ 2023-10-04 12:06 36阅读 0赞

## [Spring的两种动态代理：Jdk和Cglib 的区别和实现][Spring_Jdk_Cglib] ##

Spring通过AopProxy接口，抽象了这两种实现，实现了一致的AOP方式：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQ4MjgxNg_size_16_color_FFFFFF_t_70][]

一、原理区别：

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。（通过反射的机制来调用被拦截实例方法的）

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

> 1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
> 
> 2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
> 
> 3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

*  **如何强制使用CGLIB实现AOP？**

> （1）添加CGLIB库，SPRING\_HOME/cglib/\*.jar  
> （2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>

*  **JDK动态代理和CGLIB字节码生成的区别？**

> （1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类  
> （2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法  
> 因为是继承，所以该类或方法最好不要声明成final

### 二、代码实现 ###

package com.example.demo.service;
    
    public interface UserService {
    	
    	public void addUser(String userName, String password);
    
    	public void delUser(String userName);
    	
    }

package com.example.demo.service.impl;
    
    import org.springframework.stereotype.Service;
    import com.example.demo.service.UserService;
    
    @Service
    public class UserServiceImpl implements UserService {
    	
    	@Override
    	public void addUser(String userName, String password) {
    		System.out.println("调用了新增的方法！");
            System.out.println("传入参数为 userName: "+userName+" password: "+password);
    	}
    	
    	//重写删除用户方法
        @Override
        public void delUser(String userName) {
            System.out.println("调用了删除的方法！");
            System.out.println("传入参数为 userName: "+userName);
        }
    
    }

#### JDK动态代理 ####

package com.example.demo.aop;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    import com.example.demo.service.UserService;
    import com.example.demo.service.impl.UserServiceImpl;
    
    //JDK动态代理实现InvocationHandler接口
    public class JdkProxy implements InvocationHandler {
        private Object target ;//需要代理的目标对象
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("JDK动态代理，监听开始！");
            Object result = method.invoke(target, args);
            System.out.println("JDK动态代理，监听结束！");
            return result;
        }
        //定义获取代理对象方法
        public Object getJDKProxy(Object targetObject){
            //为目标对象target赋值
            this.target = targetObject;
            //JDK动态代理只能针对实现了接口的类进行代理，newProxyInstance 函数所需参数就可看出
            return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
        }
        
        public static void main(String[] args) {
        	//将内存中生成的代理类Class文件输出出来,输出到指定的包下
    	    System.getProperties().put("com.example.aop.saveGeneratedFiles", "true");
    	    
            JdkProxy jdkProxy = new JdkProxy();//实例化JDKProxy对象
            UserService user = (UserService) jdkProxy.getJDKProxy(new UserServiceImpl());//获取代理对象
            user.addUser("admin", "123123");//执行新增方法
        }
        
    }

#### Cglib动态代理 ####

> 需要导入两个jar包，asm-5.2.jar,cglib-3.2.5.jar。版本自行选择

package com.example.demo.aop;
    
    import java.lang.reflect.Method;
    
    import org.springframework.cglib.core.DebuggingClassWriter;
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    
    import com.example.demo.service.UserService;
    import com.example.demo.service.impl.UserServiceImpl;
    
    
    //Cglib动态代理，实现MethodInterceptor接口
    public class CglibProxy implements MethodInterceptor {
        private Object target;//需要代理的目标对象
        
        //重写拦截方法
        @Override
        public Object intercept(Object obj, Method method, Object[] arr, MethodProxy proxy) throws Throwable {
            System.out.println("Cglib动态代理，监听开始！");
            Object invoke = method.invoke(target, arr);//方法执行，参数：target 目标对象 arr参数数组
            System.out.println("Cglib动态代理，监听结束！");
            return invoke;
        }
        //定义获取代理对象方法
        public Object getCglibProxy(Object objectTarget){
            //为目标对象target赋值
            this.target = objectTarget;
            Enhancer enhancer = new Enhancer();
            //设置父类,因为Cglib是针对指定的类生成一个子类，所以需要指定父类
            enhancer.setSuperclass(objectTarget.getClass());
            enhancer.setCallback(this);// 设置回调 
            Object result = enhancer.create();//创建并返回代理对象
            return result;
        }
        
        public static void main(String[] args) {
        	//CGLIB动态代理生成的Class代理输出出来，输出到指定目录下
            System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:/");
            
            CglibProxy cglib = new CglibProxy();//实例化CglibProxy对象
            UserService user =  (UserService) cglib.getCglibProxy(new UserServiceImpl());//获取代理对象
            user.delUser("admin");//执行删除方法
        }
        
    }

### 三、事务传播 ###

在默认情况下，大部分使用spring的事务都是使用代理的模式，代理实现的事务有一定的局限性：

>  *  仅在公有方法上标记的@Transactional有效；
>  *  仅在 外部方法调用过程才会被代理截获，事务才会有效，也就是说，**一个方法调用本对象的另一个方法，没有通过代理类**，事务也就无法生效。下面来说明下解决的方法；
>  *  如果想在本类 内部方法调用可以正常使用事务，使用**AopContext.currentProxy()**来**获取代理类**再调用。例如： **(**(UserService)**AopContext.currentProxy()****).方法()**
> 
>   
> 通过注解添加配置（加在类上）：
> 
> **@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)**
> 
> 或通过xml配置文件添加配置：
> 
> **<aop:aspectj-autoproxy expose-proxy="true" proxy-target-class="false" />**
> 
> **expose-proxy** 属性是为了目标对象内部的自我调用无法实施切面中增加。例如我们在A类的对象内部x方法中调用另外一个内部方法y时，y方法不会被切面增强，这时可以配置expose-proxy为true并将this.y()改为((A)AopContext.currentProxy()).y()，即可让y方法被切面增强。
> 
> **proxy-target-class="false" 默认为false,表示使用jdk的动态代理。**
> 
> **proxy-target-class="true" 为true时，表示使用CGLib动态代理技术来实现增强处理。**
> 
> **只有exposeProxy为true时，才会把proxy动态代理对象设置到AopContext上下文中**。
> 
> 详细说明：[https://www.cnblogs.com/ithfm/p/10281355.html][https_www.cnblogs.com_ithfm_p_10281355.html]

同一个业务类里面 ，即 声明事务的方法methodA，调用 另一个声明为 Propagation.REQUIRES\_NEW的方法methodB。此时 方法methodB不会新开事务。

必须调用另一个类的Propagation.REQUIRES\_NEW方法才行。

表面上是事务声明失效的问题，实质上很可能是Spring的AOP机制实现角度的问题。

对于以Cglib方式增强的AOP目标类，会创建两个对象，一个是Bean实例本身，一个是Cglib增强代理对象，而不仅仅是只有后者。  
现在看来，jdk AOP这种抽象同样带了一个缺陷，那就是抹杀了Cglib能够直接创建普通类的增强子类的能力，Spring相当于把Cglib动态生成的子类，当普通的代理类了，这也是为什么会创建两个对象的原因。下图显示了Spring的AOP代理类的实际调用过程：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQ4MjgxNg_size_16_color_FFFFFF_t_70 1][]  
因此，从上面的分析可以看出，methodB没有被AopProxy通知到，导致最终结果是：被Spring的AOP增强的类，在同一个类的内部方法调用时，其被调用方法上的增强通知将不起作用。

而这种结果，会造成什么影响呢：

1：内部调用时，被调用方法的事务声明将不起作用。

2：换句话说，Spring的事务传播策略在内部方法调用时将不起作用。不管你希望某个方法需要单独事务，是RequiresNew，还是要嵌套事务，要Nested，等等，统统不起作用。

3：不仅仅是事务通知，所有你自己利用Spring实现的AOP通知，都会受到同样限制。。。。

其实，我理想中的AOP实现，应该是下面这样：只要一个Cglib增强对象就好。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQ4MjgxNg_size_16_color_FFFFFF_t_70 2][]

至于前面的事务问题，只要避开Spring目前的AOP实现上的限制，要么分开成两个类，要么直接在方法里使用编程式事务。

[Spring_Jdk_Cglib]: https://www.cnblogs.com/leifei/p/8263448.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQ4MjgxNg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210428172418776.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQ4MjgxNg==,size_16,color_FFFFFF,t_70
[https_www.cnblogs.com_ithfm_p_10281355.html]: https://www.cnblogs.com/ithfm/p/10281355.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQ4MjgxNg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210428180008582.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQ4MjgxNg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQ4MjgxNg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210428180412165.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQ4MjgxNg==,size_16,color_FFFFFF,t_70