代理模式&JDK动态代理&CGLIB动态代理

野性酷女 2022-12-10 03:36 454阅读 0赞

https://yuanyu.blog.csdn.net/article/details/105607656

1 代理模式

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70

2 静态代理

静态代理的代理对象和被代理对象在代理之前就已经确定，它们都实现相同的接口或继承相同的抽象类。静态代理模式一般由业务实现类和业务代理类组成，业务实现类里面实现主要的业务逻辑，业务代理类负责在业务方法调用的前后作一些你需要的处理，如日志记录、权限拦截等功能，实现业务逻辑与业务方法外的功能解耦，减少了对业务方法的入侵；静态代理又可细分为基于继承的方式和基于聚合的方式实现

场景：假设一个预减库存的操作，需要在预减的前后加日志记录

2.1 基于继承的方式实现静态代理

  1. /**
  2.  * 业务实现类接口
  3.  */
  4. public interface OrderService {
  5.     // 减库存操作
  6.     void reduceStock();
  7. }
  8. /**
  9.  * 业务实现类
  10.  */
  11. @Slf4j
  12. public class OrderServiceImpl implements OrderService {
  13.     @Override
  14.     public void reduceStock() {
  15.         try {
  16.             log.info("预减库存中...");
  17.             TimeUnit.SECONDS.sleep(3);
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  22. }
  24. /**
  25.  * 代理类
  26.  */
  27. @Slf4j
  28. public class OrderServiceLogProxy extends OrderServiceImpl {
  29.     @Override
  30.     public void reduceStock() {
  31.         log.info("预减库存开始...");
  32.         super.reduceStock();
  33.         log.info("预减库存结束...");
  34.     }
  35. }
  37. /**
  38.  * 测试继承方式实现的静态代理
  39.  */
  40. @Test
  41. public void testOrderServiceProxy() {
  42.     OrderServiceLogProxy proxy = new OrderServiceLogProxy();
  43.     proxy.reduceStock();
  44. }

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 1

输出结果 

  1. 16:10:18.683 [main] INFO  OrderServiceLogProxy - 预减库存开始...
  2. 16:10:18.687 [main] INFO  OrderServiceImpl - 预减库存中...
  3. 16:10:21.688 [main] INFO  OrderServiceLogProxy - 预减库存结束...

可以看到，OrderServiceLogProxy已经实现了为OrderServiceImpl的代理，通过代理类的同名方法来增强了业务方法前后逻辑。

2.2 基于聚合的方式实现静态代理

聚合的意思就是把业务类引入到了代理类中，接口和业务实现类还是之前的OrderService、OrderServiceImpl，代理类改为如下

  1. /**
  2.  * 业务实现类接口
  3.  */
  4. public interface OrderService {
  5.     // 减库存操作
  6.     void reduceStock();
  7. }
  8. /**
  9.  * 业务实现类
  10.  */
  11. @Slf4j
  12. public class OrderServiceImpl implements OrderService {
  13.     @Override
  14.     public void reduceStock() {
  15.         try {
  16.             log.info("预减库存中...");
  17.             TimeUnit.SECONDS.sleep(3);
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  22. }
  24. /**
  25.  * 聚合方式实现静态代理：代理类中引入业务类
  26.  */
  27. @Slf4j
  28. public class OrderServiceLogProxy implements OrderService {
  29.     // 引入业务类
  30.     private final OrderServiceImpl orderService;
  31.     public OrderServiceLogProxy(OrderServiceImpl orderService) {
  32.         this.orderService = orderService;
  33.     }
  34.     @Override
  35.     public void reduceStock() {
  36.         log.info("预减库存开始...");
  37.         orderService.reduceStock();
  38.         log.info("预减库存结束...");
  39.     }
  40. }

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 2

  1. /**
  2.  * 测试聚合方式实现的静态代理
  3.  */
  4. @Test
  5. public void testOrderServiceProxy() {
  6.     OrderServiceImpl orderService = new OrderServiceImpl();
  7.     OrderServiceLogProxy proxy = new OrderServiceLogProxy(orderService);
  8.     proxy.reduceStock();
  9. }

2.3 继承方式vs聚合方式

结合上面的代码来看，如果此时需要叠加代理功能，我不仅要记录预减日志，还要增加权限拦截功能，这个时候如果采用继承的方式的话，就得新建一个代理类，里面包含日志和权限逻辑；那要是再增加一个代理功能，又要新增代理类，如果要改变下代理功能的执行顺序，还是得增加代理类，结合上面分析来看，这样做肯定是不妥的。但是如果使用聚合方式，我们只需要稍微改造一下上面使用聚合方式实现的静态代理代码

  1. /**
  2.  * 业务实现类接口
  3.  */
  4. public interface OrderService {
  5.     // 减库存操作
  6.     void reduceStock();
  7. }
  8. /**
  9.  * 业务实现类
  10.  */
  11. @Slf4j
  12. public class OrderServiceImpl implements OrderService {
  13.     @Override
  14.     public void reduceStock() {
  15.         try {
  16.             log.info("预减库存中...");
  17.             TimeUnit.SECONDS.sleep(3);
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  22. }

首先是日志代理类代码

  1. /**
  2.  * 聚合方式实现静态代理--日志记录功能叠加改造
  3.  */
  4. @Slf4j
  5. public class OrderServiceLogProxy implements OrderService {
  6.     // 注意，这里换成了接口
  7.     private final OrderService orderService;
  8.     public OrderServiceLogProxy(OrderService orderService) {
  9.         this.orderService = orderService;
  10.     }
  11.     @Override
  12.     public void reduceStock() {
  13.         log.info("预减库存开始...");
  14.         orderService.reduceStock();
  15.         log.info("预减库存结束...");
  16.     }
  17. }

然后是新增的权限验证代理类代码 

  1. /**
  2.  * 聚合方式实现静态代理--日志记录功能叠加改造
  3.  */
  4. @Slf4j
  5. public class OrderServicePermissionProxy implements OrderService {
  6.     //注意，这里换成了接口
  7.     private OrderService orderService;
  8.     public OrderServicePermissionProxy(OrderService orderService) {
  9.         this.orderService = orderService;
  10.     }
  11.     @Override
  12.     public void reduceStock() {
  13.         log.info("权限验证开始...");
  14.         orderService.reduceStock();
  15.         log.info("权限验证结束...");
  16.     }
  17. }

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 3

测试用例 

  1. /**
  2.  * 测试聚合方式实现的静态代理-功能叠加
  3.  */
  4. @Test
  5. public void testOrderServiceProxy3() {
  6.     OrderServiceImpl orderService = new OrderServiceImpl();
  7.     OrderServiceLogProxy logProxy = new OrderServiceLogProxy(orderService);
  8.     OrderServicePermissionProxy permissionProxy = new OrderServicePermissionProxy(logProxy);
  9.     permissionProxy.reduceStock();
  10. }

测试结果 

  1. 16:34:46.603 [main] INFO  OrderServicePermissionProxy - 权限验证开始...
  2. 16:34:46.607 [main] INFO  OrderServiceLogProxy3 - 预减库存开始...
  3. 16:34:46.607 [main] INFO  OrderServiceImpl - 预减库存中...
  4. 16:34:47.607 [main] INFO  OrderServiceLogProxy3 - 预减库存结束...
  5. 16:34:47.607 [main] INFO  OrderServicePermissionProxy - 权限验证结束...

如果你需要调换一下代理类逻辑执行顺序问题，你只需要在使用（像测试一样）时调换一下实例化顺序即可实现日志功能和权限验证的先后执行顺序了，而不需要像继承方式一样去不断的新建代理类

3 动态代理

看完上面的静态代理，我们发现，静态代理模式的代理类，只是实现了特定类的代理，比如上面OrderServiceLogProxy实现的OrderServiceimpl的代理，如果我还有个UserService也许要日志记录、权限校验功能，又得写双份的UserServiceLogProxy、UserServicePermissionProxy代理类，里面的逻辑很多都是相同的，也就是说你代理类对象的方法越多，你就得写越多的重复的代码，那么有了动态代理就可以比较好的解决这个问题，动态代理就可以动态的生成代理类，实现对不同类下的不同方法的代理

3.1 JDK动态代理

jdk动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用业务方法前调用InvocationHandler处理，代理类必须实现InvocationHandler接口，并且jdk动态代理只能代理实现了接口的类，没有实现接口的类是不能实现jdk动态代理

  1. /**
  2.  * 业务实现类接口
  3.  */
  4. public interface OrderService {
  5.     // 减库存操作
  6.     void reduceStock();
  7. }
  8. /**
  9.  * 业务实现类
  10.  */
  11. @Slf4j
  12. public class OrderServiceImpl implements OrderService {
  13.     @Override
  14.     public void reduceStock() {
  15.         try {
  16.             log.info("预减库存中...");
  17.             TimeUnit.SECONDS.sleep(3);
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  22. }
  24. /**
  25.  * JDK动态代理实现，必须实现InvocationHandler接口，InvocationHandler可以理解为事务处理器，所有切面级别的逻辑都在此完成
  26.  */
  27. @Slf4j
  28. public class DynamicLogProxy implements InvocationHandler {
  29.     // 需要代理的对象类
  30.     private final Object target;
  31.     public DynamicLogProxy(Object target) {
  32.         this.target = target;
  33.     }
  34.     /**
  35.      * 获取代理对象
  36.      */
  37.     public Object getProxyInstance(){
  38.         Class<?> clazz = target.getClass();
  39.         // 通过Proxy.newProxyInstance(代理类的类加载器, 代理类实现的所有接口, Handler) 加载动态代理
  40.         return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
  41.     }
  42.     /**
  43.      * @param obj    被代理对象
  44.      * @param method 对象方法
  45.      * @param args   方法参数
  46.      */
  47.     @Override
  48.     public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
  49.         // 不处理
  50.         if (Object.class.equals(method.getDeclaringClass())){
  51.             return method.invoke(this, args);
  52.         }
  54.         log.info("这里是日志记录切面，日志开始...");
  55.         // 使用方法的反射
  56.         Object invoke = method.invoke(target, args);
  57.         log.info("这里是日志记录切面，日志结束...");
  58.         return invoke;
  59.     }
  60. }

使用时代码 

  1. /**
  2.  * 测试JDK动态代理实现的日志代理类
  3.  */
  4. @Test
  5. public void testDynamicLogProxy() {
  6.     OrderServiceImpl orderService = new OrderServiceImpl();
  7.     DynamicLogProxy proxy = new DynamicLogProxy(orderService);
  8.     OrderService os = (OrderService)proxy.getProxyInstance();
  9.     os.reduceStock();
  10. }

输出结果

  1. 16:42:59.158 [main] INFO  DynamicLogProxy - 这里是日志记录切面，日志开始...
  2. 16:42:59.163 [main] INFO  OrderServiceImpl - 预减库存中...
  3. 16:43:00.164 [main] INFO  DynamicLogProxy - 这里是日志记录切面，日志结束...

使用JDK动态代理类基本步骤：

  1. 编写需要被代理的类和接口（我这里就是OrderServiceImpl、OrderService）
  2. 编写代理类（例如我这里的OrderServiceProxy），需要实现InvocationHandler接口，重写invoke方法
  3. 使用 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 动态创建代理类对象，通过代理类对象调用业务方法

这个时候，如果我需要在代理类中叠加功能，比如不仅要日志，还新增权限认证，思路还是上面的聚合方式实现静态代理里的那样，贴下代码，先新增权限认证代理类

  1. /**
  2.  * 基于JDK动态代理实现的权限认证代理类
  3.  */
  4. @Slf4j
  5. public class DynamicPermissionProxy implements InvocationHandler {
  6.     private Object target;
  7.     public DynamicPermissionProxy(Object target) {
  8.         this.target = target;
  9.     }
  10.     /**
  11.      * 获取代理对象
  12.      */
  13.     public Object getProxyInstance(){
  14.         Class<?> clazz = target.getClass();
  15.         return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
  16.     }
  17.     /**
  18.      * @param obj    被代理对象
  19.      * @param method 对象方法
  20.      * @param args   方法参数
  21.      */
  22.     @Override
  23.     public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
  24.         // 不处理
  25.         if (Object.class.equals(method.getDeclaringClass())){
  26.             return method.invoke(this, args);
  27.         }
  28.         log.info("这里是权限认证切面，开始验证...");
  29.         Object invoke = method.invoke(target, args);
  30.         log.info("这里是权限认证切面，结束验证...");
  31.         return invoke;
  32.     }
  33. }

然后使用时候，需要稍微改动下

  1. /**
  2.  * 测试JDK动态代理实现的日志、权限功能代理类
  3.  */
  4. @Test
  5. public void testDynamicLogAndPermissProxy() {
  6.     OrderServiceImpl orderService = new OrderServiceImpl();
  7.     DynamicLogProxy logProxyHandler = new DynamicLogProxy(orderService);
  8.     OrderService os = (OrderService) logProxyHandler.getProxyInstance();
  9.     //注：这里把日志代理类实例对象传入权限认证代理类中
  10.     DynamicPermissionProxy dynamicPermissionProxy = new DynamicPermissionProxy(os);
  11.     OrderService os2 = (OrderService)dynamicPermissionProxy.getProxyInstance();
  12.     os2.reduceStock();
  13. }

如上即可，后面还需要叠加功能代理类的话，按照上面的思路依次传入代理对象实例即可

3.2 Cglib动态代理

cglib是针对类来实现代理的，它会对目标类产生一个代理子类，通过方法拦截技术对过滤父类的方法调用，代理子类需要实现MethodInterceptor接口

如果你是基于Spring配置文件形式开发，那你需要显示声明：

  1. <aop:aspectj-autoproxy proxy-target-class="true"/>

如果你是基于Spring注解形式或者是SpringBoot开发，那你需要显示声明：

  1. @EnableAspectJAutoProxy(proxyTargetClass = true)
  3. <!-- 
  4.     org.springframework.cglib.proxy.Enhancer
  5.     org.springframework.cglib.proxy.MethodInterceptor
  6.     org.springframework.cglib.proxy.MethodProxy
  7.  -->
  8. <dependency>
  9.     <groupId>org.springframework</groupId>
  10.     <artifactId>spring-core</artifactId>
  11.     <version>5.2.6.RELEASE</version>
  12. </dependency>

都不是引入下面依赖

  1. <!-- 
  2.     net.sf.cglib.proxy.Enhancer
  3.     net.sf.cglib.proxy.MethodInterceptor
  4.     net.sf.cglib.proxy.MethodProxy
  5. -->
  6. <dependency>
  7.     <groupId>cglib</groupId>
  8.     <artifactId>cglib</artifactId>
  9.     <version>3.3.0</version>
  10. </dependency>
  12. /**
  13.  * 业务实现类，注意这里没用实现接口
  14.  */
  15. @Slf4j
  16. public class OrderService {
  17.     // 减库存操作
  18.     public void reduceStock() {
  19.         try {
  20.             log.info("预减库存中...");
  21.             TimeUnit.SECONDS.sleep(3);
  22.         } catch (Exception e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26. }
  28. /**
  29.  * 基于Cglib方式实现动态代理-日志功能，它是针对类实现代理的，类不用实现接口，CGlib对目标类产生一个子类，通过方法拦截技术拦截所有的方法调用
  30.  */
  31. @Slf4j
  32. public class DynamicCglibLogProxy implements MethodInterceptor {
  33.     // 目标对象
  34.     private final Object target;
  35.     public DynamicCglibLogProxy(Object target) {
  36.         this.target = target;
  37.     }
  38.     /**
  39.      * 返回一个代理对象
  40.      */
  41.     public Object getProxyObj() {
  42.         // 1.创建一个工具类
  43.         Enhancer enhancer = new Enhancer();
  44.         // 2.设置父类
  45.         enhancer.setSuperclass(target.getClass());
  46.         // 3.设置回调函数
  47.         enhancer.setCallback(this);
  48.         // 4.
  49.         enhancer.setUseCache(false);
  50.         // 5.传教子类对象，即代理对象
  51.         return enhancer.create();
  52.     }
  53.     /**
  54.      * 拦截目标类的方法调用
  55.      *
  56.      * @param obj           目标对象
  57.      * @param method      目标方法
  58.      * @param args        方法参数
  59.      * @param methodProxy 代理类实例
  60.      */
  61.     @Override
  62.     public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
  63.         // 不做处理
  64.         if (Object.class.equals(method.getDeclaringClass())) {
  65.             return method.invoke(target, args);
  66.         }
  67.         log.info("这里是日志记录切面，日志开始...");
  68.         Object res = method.invoke(target, args);
  69.         log.info("这里是日志记录切面，日志结束...");
  70.         return res;
  71.     }
  72. }
  74. /**
  75.  * 测试Cglib实现的动态代理-日志功能
  76.  */
  77. @Test
  78. public void testGclibDynamicLogProxy(){
  79.     // 创建目标对象
  80.     OrderService orderService = new OrderService();
  81.     // 获取代理对象
  82.     DynamicCglibLogProxy dynamicCglibLogProxy = new DynamicCglibLogProxy(orderService);
  83.     // 执行代理对象的方法，触发intercept方法，从而实现对目标对象的调用
  84.     OrderService proxy  = (OrderService)dynamicCglibLogProxy.getProxyObj();
  85.     proxy.reduceStock();
  86.     System.out.println(proxy);
  87. }

JDK与Cglib动态代理对比

  1. JDK动态代理只能代理实现了接口的类，没有实现接口的类不能实现JDK的动态代理
  2. Cglib动态代理是针对类实现代理的，运行时动态生成被代理类的子类拦截父类方法调用，因此不能代理声明为final类型的类和方法

动态代理和静态代理的区别

  1. 静态代理在代理前就知道要代理的是哪个对象，而动态代理是运行时才知道
  2. 静态代理一般只能代理一个类，而动态代理能代理实现了接口的多个类

Spring如何选择两种代理模式的

  1. 如果目标对象实现了接口，则默认采用JDK动态代理；
  2. 如果目标对象没有实现接口，则使用Cglib代理；
  3. 如果目标对象实现了接口，但强制使用了Cglib，则使用Cglib进行代理
  1. //<dependency>
  2. //    <groupId>org.springframework</groupId>
  3. //    <artifactId>spring-context</artifactId>
  4. //    <version>5.2.6.RELEASE</version>
  5. //</dependency>
  6. // org.springframework.aop.framework.DefaultAopProxyFactory
  7. public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
  8.     public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
  9.         if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
  10.             return new JdkDynamicAopProxy(config);
  11.         } else {
  12.             Class<?> targetClass = config.getTargetClass();
  13.             if (targetClass == null) {
  14.                 throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
  15.             } else {
  16.                 return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
  17.             }
  18.         }
  19.     }
  20. }

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 4

3.3 在Spirng框架中使用JKD动态代理

  1. /**
  2.  * 业务实现类接口
  3.  */
  4. public interface OrderService {
  5.     // 减库存操作
  6.     void reduceStock();
  7. }
  8. /**
  9.  * 业务实现类
  10.  */
  11. @Slf4j
  12. @Service
  13. public class OrderServiceImpl implements OrderService {
  14.     @Override
  15.     public void reduceStock() {
  16.         try {
  17.             log.info("预减库存中...");
  18.             TimeUnit.SECONDS.sleep(3);
  19.         } catch (Exception e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23. }
  25. //<dependency>
  26. //    <groupId>org.springframework</groupId>
  27. //    <artifactId>spring-context</artifactId>
  28. //    <version>5.2.6.RELEASE</version>
  29. //</dependency>
  30. /**
  31.  * 配置类
  32.  */
  33. @Configuration
  34. @ComponentScan("cn.yuanyu.app")
  35. public class AppConfig {
  36. }
  38. @Component
  39. public class LogPostProcessor implements BeanPostProcessor {
  40.     /**
  41.      * @param bean     刚创建的实例
  42.      * @param beanName 实例在容器中的名字
  43.      * @return 返回bean实例，可以返回原来的对象，也可以返回包装后对象
  44.      */
  45.     @Override
  46.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  47.         if (bean instanceof OrderService) {
  48.             // 传入bean
  49.             DynamicLogProxy dynamicLogProxy = new DynamicLogProxy(bean);
  50.             Object proxyBean = Proxy.newProxyInstance(bean.getClass().getClassLoader(), bean.getClass().getInterfaces(), dynamicLogProxy);
  51.             // 返回的不是原来的bean，而是代理bean
  52.             return proxyBean;
  53.         }
  54.         return bean;
  55.     }
  56. }
  58. @Slf4j
  59. public class DynamicLogProxy implements InvocationHandler {
  60.     // 需要代理的对象类
  61.     private final Object target;
  62.     public DynamicLogProxy(Object target) {
  63.         this.target = target;
  64.     }
  65.     /**
  66.      * @param obj    代表动态代理对象
  67.      * @param method 代表正在执行的方法
  68.      * @param args   代表调用目标方法时传入的实参
  69.      */
  70.     @Override
  71.     public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
  72.         // 不做处理
  73.         if (Object.class.equals(method.getDeclaringClass())) {
  74.             return method.invoke(this, args);
  75.         }
  76.         // 这里还要根据实际情况判断，不是所有的都需要记录日志
  77.         log.info("方法执行前添加日志记录等...");
  78.         // 使用方法的反射
  79.         Object invoke = method.invoke(target, args);
  80.         log.info("方法执行后添加日志记录等...");
  81.         // 其他操作...
  82.         return invoke;
  83.     }
  84. }
  86. @Test
  87. public void test() {
  88.     AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
  89.     OrderService orderService = applicationContext.getBean(OrderService.class);
  90.     orderService.reduceStock();
  91. }
  93. [main] INFO  DynamicLogProxy - 方法执行前添加日志记录等...
  94. [main] INFO  OrderServiceImpl - 预减库存中...
  95. [main] INFO  DynamicLogProxy - 方法执行后添加日志记录等...
  97. /**
  98.  * ConcurrentModificationException 并发修改异常
  99.  */
  100. public class ArrayListDemo {
  101.     public static void main(String[] args) {
  102.         List<String> list = new ArrayList<>();
  103.         List<String> proxy = (List<String>) Proxy.newProxyInstance(ArrayList.class.getClassLoader(), ArrayList.class.getInterfaces(), new InvocationHandler() {
  104.             @Override
  105.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  106.                 synchronized (ArrayListDemo.class) {
  107.                     return method.invoke(list, args);
  108.                 }
  109.             }
  110.         });
  111.         for (int i = 0; i < 100; i++) {
  112.             new Thread(() -> {
  113.                 proxy.add(UUID.randomUUID().toString().substring(0, 3));
  114.                 proxy.add(UUID.randomUUID().toString().substring(0, 3));
  115.                 proxy.add(UUID.randomUUID().toString().substring(0, 3));
  116.                 System.out.println(proxy);
  117.             }, String.valueOf(i)).start();
  118.         }
  119.     }
  120. }
  122. <?xml version="1.0" encoding="UTF-8"?>
  123. <Configuration status="warn" monitorInterval="5">
  124.     <Appenders>
  125.         <Console name="console" target="SYSTEM_OUT">
  126.             <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
  127.         </Console>
  128.     </Appenders>
  129.     <Loggers>
  130.         <Root level="trace">
  131.             <AppenderRef ref="console"/>
  132.         </Root>
  133.     </Loggers>
  134. </Configuration>
  135. <!--
  136.     log4j2.xml
  137.     https://yuanyu.blog.csdn.net/article/details/105607656
  138. -->
  • https://blog.csdn.net/fanrenxiang/article/details/81939357
  • https://blog.csdn.net/jiankunking/article/details/52143504
  • https://blog.csdn.net/maoyeqiu/article/details/76546468
  • https://blog.csdn.net/csdn_20150804/article/details/102734317
  • https://blog.csdn.net/caoxiaohong1005/article/details/80039656

发表评论

表情：
评论列表 （有 0 条评论，454人围观）

还没有评论，来说两句吧...

相关阅读

    相关 JDK动态代理和CGLib动态代理

        JDK 动态代理是 JVM 根据传进来的对象，动态的创建对象的代理对象并返回。     CGLib 动态代理比较复杂，它是通过继承的方式来实现类的代理。 JDK

    墨蓝墨蓝/ 0 赞/ 447 阅读