java jdk动态代理 + cglib动态代理 / 及 @Async异步注解失效问题

曾经终败给现在 2022-12-02 12:27 660阅读 0赞

## 什么是代理模式 ##

代理模式主要对我们方法执行之前与之后实现增强

#### 代理模式应用场景 ####

1.日志的采集  
2.权限控制  
3.实现aop  
4.Mybatis mapper  
5.Spring的事务  
6.全局捕获异常  
7.Rpc远程调用接口  
8.代理数据源

#### Jdk与Cglib动态代理的区别 ####

1.Jdk动态代理利用反射技术生成匿名的代理类走 InvokeHandler回调方法实现增强，同时也是一种基于接口的方式实现代理。

2.Cglib动态代理利用 asm字节码技术生成一个子类 覆盖其中的方法实现增强，同时采用fastClass机制对整个代理类建立索引比反射效率要高

3.在Spring中如果需要被代理的对象

*  如果实现了接口则采用的 Jdk动态代理
 *  没有实现接口则使用的 Cglib动态代理

## 一、JDK 动态代理 ##

JDK动态代理的一般步骤如下：

1.创建被代理的接口和类；

2.实现InvocationHandler接口，对目标接口中声明的所有方法进行统一处理；

3.调用Proxy的静态方法，创建代理类并生成相应的代理对象；

实现原理：利用拦截器机制必须实现InvocationHandler接口中的invoke方法实现对  
我们的目标方法增强。

### 1、代理方法 ###

package com.xijia.proxy.jdk;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
      * jdk 动态代理
      * @author wangsong
      * @mail  1720696548@qq.com
      * @date  2020/8/30 0030 12:35
      * @version 1.0.0
      */
    public class JdkInvocationHandler implements InvocationHandler {
    
        /**
         * 目标对象（需要被代理对象）
         */
        private Object target;
    
        /**
         * 获取目标对象
         * @param target
         */
        public JdkInvocationHandler(Object target) {
            this.target = target;
        }
    
    
        /**
         * 代理执行方法
         * @author wangsong
         * @param proxy JavaJdk动态生成代理类对象$proxy0
         * @param method 目标方法 反射获取到的
         * @param args  目标方法需要传递的参数
         * @return java.lang.Object
         */
        @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动态代理方式结束:");
            /***
             * Method method 类型接口的方法 采用java反射机制执行我们的对应目标对象的方法
             */
            return result;
        }
    
        /**
         * 生成目标对象，通过Jdk动态代理反射技术生成代理对象 调用代理类对象的方法的时候会走InvocationHandlerinvoke方法
         *
         * @param <T>
         * @return
         */
        public <T> T getProxy() {
            return (T) Proxy.newProxyInstance(
                    target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(),
                    this
            );
        }
    }

### 2、OrderService 接口 ###

public interface OrderService {
    
        String addOrder(String orderId, String orderName);
        //      String addOrder(String v1,String v2 );
    }

### 3、OrderServiceImpl 实现 ###

public class OrderServiceImpl implements OrderService {
        @Override
        public String addOrder(String orderId, String orderName) {
            System.out.println("业务方法 " + orderId);
            return orderId + "-" + orderName;
        }
    }

### 4、测试使用 ###

/**
     * jdk 动态代理
     */
    public class Test {
        public static void main(String[] args) {
            useJdkInvocation();
        }
        
        /**
         * 使用jdk 的动态代理方法生成class文件并执行
         */
        public static void useJdkInvocation() {
            JdkInvocationHandler jdkInvocationHandler = new JdkInvocationHandler(new OrderServiceImpl());
            // 保存动态代理生成的 class 到本地
            // System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
            // 获取代理类对象
            OrderService proxy = jdkInvocationHandler.getProxy();
            String res = proxy.addOrder("12345689", "测试");
            System.out.println("返回数据为:" + res);
        }
     }

![在这里插入图片描述][20200830220843327.png_pic_center]

## 二、Cjlib动态代理 ##

Cglib依赖于ASM字节码技术，直接生成class文件，在采用类加载器读取到程序中  
使用 fastclass 对被代理类的方法建立索引, 文件不需要依赖于反射查找到目标方法  
所以效率比Jdk动态代理要高。

### 1、Cjlib 动态代理方法 ###

/**
     *  cglib动态代理
     */
    public class CglibMethodInterceptor implements MethodInterceptor {
        /**
         * @param obj 执行对象class(被代理类)
         * @param method 执行对象class的方法
         * @param args 执行对象class的方法的参数
         * @param proxy 代理类
         * @return
         * @throws Throwable
         */
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            System.out.println(">> cglib动态代理执行开始");
            Object result = proxy.invokeSuper(obj, args);
            System.out.println(">> cglib动态代理执行结束");
            return result;
        }
    }

### 2、接口 ###

public interface MemberService {
    
        String addMember(String userName);
    }

### 3、实现 ###

public class MemberServiceImpl  implements MemberService  {
        public String addMember(String userName) {
            System.out.println("执行方法-------");
            return userName;
        }
    }

### 4、测试使用 ###

public class Test2 {
        public static void main(String[] args) {
            // 保存class 文件到-->
            System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code");
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(MemberServiceImpl.class);
            enhancer.setCallback(new CglibMethodInterceptor());
            // 创建代理代理对象
            MemberService memberService = (MemberService) enhancer.create();
            String res = memberService.addMember("1720696548");
            System.out.println("----> cglib动态代理返回数据为：" + res);
        }
    }

![在这里插入图片描述][20200830220936371.png_pic_center]

## 三 、@Async 异步注解失效处理 ##

#### 失效说明 ####

*  1、MemberServiceImpl 只要继承了接口(implements MemberService )，那么 @RestController 注解和 @Async 注解就不能同时存在, （jdk动态代理的bug）
 *  2、在 MemberServiceImpl 实现类中, 直接使用this 调用当前类带有 @Async 注解的方法异步将不生效, 因为this直接调用当前类，没有经过代理对象, 创建异步是在代理时执行的，所有this不会进行异步操作
 *  3、在 MemberServiceImpl 实现类中, 使用@Async， 先获取当前类的代理对象, 在使用当前类的代理对象调用带有 @Async 注解的方法就ok了， 或者把需要 @Async 注解执行异常操作的方法单独建立一个类, 就能避免this调用了，不经过代理对象了(如: aop)

下面经过一个案例来证明

### 1、创建 @ExtAsync 注解 ###

/**
      * 异步注解
      * @author wangsong
      * @mail  1720696548@qq.com
      * @date  2020/8/30 0030 20:59
      * @version 1.0.0
      */
    @Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface ExtAsync {
    }

### 2、创建 @ExtAsyncAop 开启异步线程 ###

package com.xijia.aop.aop;
    
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    
    /**
      * 判断是否需要异步执行方法的aop代理
      * @author wangsong
      * @mail  1720696548@qq.com
      * @date  2020/8/30 0030 20:58
      * @version 1.0.0
      */
    @Component
    @Aspect
    @Slf4j
    public class ExtAsyncAop {
    
        private ExecutorService executorService;
    
        public ExtAsyncAop() {
            executorService = Executors.newFixedThreadPool(10);
        }
    
        @Around(value = "@annotation(com.xijia.aop.ext.ExtAsync)")
        public void doBefore(ProceedingJoinPoint joinPoint) throws Throwable {
            // 直接获取到方法上有加上ExtAsync
            log.info(">>>拦截到我们方法上有加上ExtAsync");
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    // 执行我们的目标方法
                    try {
                        joinPoint.proceed();
                    } catch (Throwable throwable) {
                        throwable.printStackTrace();
                    }
                }
            });
    
        }
    }

### 3、SpringUtils 工具类，获取bend ###

package com.xijia.aop.utils;
    
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    /**
     * SpringUtils 工具类
     */
    @Component
    public class SpringUtils implements ApplicationContextAware {
    
    
        private static ApplicationContext applicationContext = null;
    
        public static ApplicationContext getApplicationContext() {
            return applicationContext;
        }
    
    
        public static <T> T getBean(String beanId) {
            return (T) applicationContext.getBean(beanId);
        }
    
        public static <T> T getBean(Class<T> requiredType) {
            return (T) applicationContext.getBean(requiredType);
        }
    
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            SpringUtils.applicationContext = applicationContext;
        }
    
    }

### 4、创建接口 ###

public interface MemberService {
        String addUser();
    }

### 5、创建实现 ###

package com.xijia.aop.service.impl;
    
    import com.xijia.aop.ext.ExtAsync;
    import com.xijia.aop.service.MemberService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * 1、MemberServiceImpl 只要继承了接口(implements MemberService )，那么 @RestController 注解和 @Async 注解就不能同时存在, （jdk动态代理的bug）
     * 2、在 MemberServiceImpl 实现类中, 直接使用this 调用异步 @Async 将不生效, 因为this直接调用当前类，没有经过代理对象, 创建异步是在代理时执行的，所有this不会进行异步操作
     * 3、在 MemberServiceImpl 实现类中, 使用@Async， 直接获取当前类的代理对象, 使用代理对象调用带有 @Async 注解的方法就ok了
     * 4、在 MemberServiceImpl 实现类中, 使用@Async， 或者把 @Async异常操作方法单独建立一个类, 就能避免this调用了，不经过代理对象了(如: aop)
     * @author wangsong
     * @mail 1720696548@qq.com
     * @date 2020/8/30 0030 21:16
     * @version 1.0.0
     */
    @RestController
    @Slf4j
    public class MemberServiceImpl  implements MemberService {  // implements MemberService
    
        // 方法二: 使用新的类来处理异步操作
      //  @Autowired
      //   private MemberServiceImplAsync memberServiceImplAsync;
    
        @Override
        @GetMapping("/addUser")
        public String addUser() {
            log.info(">>>流程1");
    
            // 方法一： 先获得代理对象,在通过代理对象调用本类的 addUserLog方法
            MemberServiceImpl proxy = SpringUtils.getBean("memberServiceImpl");
            proxy.addUserLog();
    
            // 方法二: 使用新的类来处理异步操作
            //  memberServiceImplAsync.addUserLog();
    
            //  直接调用调用无效不会被动态代理，@Async注解自然也无效, 因为开启异步是在动态代理中开启的
           //  this.addUserLog();
            log.info(">>>流程3");
            return "success";
        }
    
        /**
         * 异步方法
         * @return
         */
        @ExtAsync // 自定义
        //@Async  // 该注解不能和@RestController 或 @Controller 同时存在
        public void addUserLog() {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
            }
            log.info(">>>流程2");
        }
    }

正常异常，测试如果使用this 的话异步将无效  
![在这里插入图片描述][2020083022244372.png_pic_center]

*  以上部分内容来自于蚂蚁课堂
 *  个人开源项目（通用后台管理系统）–> [ https://gitee.com/wslxm/spring-boot-plus2][https_gitee.com_wslxm_spring-boot-plus2] , 喜欢的可以看看
 *  ***本文到此结束，如果觉得有用，动动小手点赞或关注一下呗，将不定时持续更新更多的内容…，感谢大家的观看！***

[20200830220843327.png_pic_center]: /images/20221123/ef7a62b54e2e4f57968d662477408b1b.png
[20200830220936371.png_pic_center]: /images/20221123/24ab7d1836c54aa8947f5e391eb144c4.png
[2020083022244372.png_pic_center]: /images/20221123/a117d096654445bc8cadfaed00308e74.png
[https_gitee.com_wslxm_spring-boot-plus2]: https://gitee.com/wslxm/spring-boot-plus2