springAOP的底层实现技术

springAop使用了两种代理机制：

• 基于JDK的动态代理（接口代理）
• 基于CGLib的动态代理（类代理）

1 订单服务实例

假设有这样的一个订单服务，它提供新增订单的方法，我们需要对这个方法的性能做监控。

OrderService:

public interface OrderService{

        void  add();

}

public class OrderServiceImpl  implements OrderService{

    public void add(){

             PerformanceMonitor.begin("net.deniro.spring4.aop.add");//开启监视

             System.out.println("模拟新增订单")；

             try{

                    Thread.currentThread().sleep(50);            

             }catch（InterrruptedException e）{

                    throw  new RuntimeException();

            } 

            PerformanceMonitor.end();//结束监视

     }

}

public  class PerformanceMonitor{

               private   static   ThreadLocal<PerformanceRecord>      record = new  ThreadLocal<PerformacnceRecord>();

              /**开启监视/

              public static void begin(String method){

                           System.out.println("开启监视")；

                            record.set(new  PerformanceRecord(method));

              }

              /**结束监视/

              public static void end(){

                       System.out.println("结束监视")；

                       record.get.print();

              }

          

}

 

    ThreadLocal  可以将非线程安全的类改造为线程安全的类。

     PerformanceRecord(性能记录)：

     public  class PerformanceRecord{

              private final String methodName;//方法名称

              private final  long begin;//开始时间

              public   PerformanceRecord(String method){

                this.methodName = method;

                this.begin = System.currentTimeMills();

               }

              /**

             打印性能信息

              */

             public void print(){

                  long end = System.currentTimeMills();

                  long elapse = end - begin ;

                  System.out.println(methodName+"耗费时间："+elapse + "毫秒")；

              }

     }

  虽然方法添加了性能监视功能，但这些性能监视代码侵入了业务逻辑。我们可以通过JDK与CGLib动态代理技术把这些具有横切性质的代码动态织入目标方法。

2  JDK动态代理

   java1.3以后，java实现了动态代理技术，允许开发者在运行期创建接口的代理实例。

  JDK的动态代理主要涉及java.lang.reflect 包中的两个类：Proxy 和  InvocationHandler。

• InvocationHandler 是接口，可以通过实现该接口来定义横切逻辑，并通过反射机制调用目标类的代码，动态地将横切逻辑和业务逻辑编织在一起。
•  Proxy利用InvocationHandler动态创建出一个实现某一接口的实例，来生成目标类的代理对象。

在OrderServiceImpl中，新建一个只包含业务逻辑的方法 addByJDKProxy;

/**

     新增（JDK代理）

*/

public void addByJDKProxy(){

       addOrder();

}

/**

     private void addOrder(){

         System.out.println("模拟新增订单")；

    }

     

*/ 

  接着动态创建代理类

PerformanceHandler:

public class PerformanceHandler implements InvocationHandler{

       private final Object target://目标类

       public    PerformanceHandler(Object target){

                this.target = target;

       }

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

                 PerformanceMontior.begin(target.getClass().getName()+"."+method.getName());

                 Object obj = mehtod.invoke（target,args）;//调用业务类的目标方法

                 PerformanceMonitor.end();

                 return obj;

     }

  InvocationHandler  接口定义了一个方法：public  Object invoke(Object proxy,Method method,Object[] args)参数如下:

  proxy:  最终生成的代理实例，很少用到  

  method: 被代理目标实例的某个具体方法,通过它可以发起目标实例方法的反射调用

  args：被代理实例某个方法的入参,在方法反射调用时使用。

  在构造函数中，我们通过target参数传入希望被代理的目标对象。

单元测试：

//编织目标业务类与横切代码

PerformanceHandler handler = new PerformanceHandler(orderService);

//创建代理实例

OrderService proxy = (OrderService) Proxy.newProxyInstance(orderService.getClass().getClassLoader(),orderService.getClass().getInterfaces(),handler);

proxy.addByJDKProxy();

这里通过Proxy 的newProxyInstance()的静态方法为编织了业务逻辑和性能监视逻辑的handler创建了一个符合OrderService接口的代理实例。这个方法的各参数说明如下：

 参数     类型         说明

loader   classloader    类加载器

interfaces   class[]       创建代理实例所需要实现的一组接口

h                 InvocationHandler       整合了业务逻辑和横切逻辑的编织器对象

3 CGLib动态代理

JDK创建代理时只能为接口创建代理实例。Proxy的newProxyInstance 方法定义为：

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h){

      

}

第二个参数interfaces 就是需要代理实例实现的接口列表。

所以对于没有通用接口定义业务方法的类，可以CGLib实现动态代理。

CGLib采用底层的字节码技术，可以为一个类创建子类，在子类中采用方法拦截技术来拦截所有父类方法的调用并顺势织入横切逻辑。

代理类：

public class PerformanceProxy implements MethodInterceptor{

       private  Enhancer   enhancer  = new Enhancer();

       public    Object        getProxy （Class clazz）{

               enhancer.setSuperclass(Class clazz) ；//设置父类

               enhancer.setCallback(this);

               return    enhancer.create();//使用字节码技术动态创建子类的实例

       }

      /**

      拦截父类所有方法的调用

      */

      public   Object    intercept(Object o,Method  method,Object[]args,MethodProxy)throws Throwable{

              PerformanceMonitor.begin(o.getClass().getName()+"."+method.getName())   ;

             Object   result   = methodProxy.invokeSuper(o,args)；   

             PerformanceMonitor.end();

            return result;

   

    }

}

单元测试:

PerformanceProxy  proxy  =  new  PerforManceProxy();

OrderServiceImpl  orderService = (OrderServiceImpl) proxy.getProxy(OrderServiceImpl.class);

 

orderService.addOrder();

代理类名变为 OrderServiceImpl  这个特殊的类就是CGLib 为OrderServiceImpl动态创建的子类。

SpringAop 通过切点（Pointcut）来决定需要在哪些类的哪些方法上织入横切逻辑；接着通过增强（Advice）来描述横切逻辑和方法的具体织入点；然后通过切面（Advisor） 把切点与增强装配起来；最后，利用JDK或CGLib的动态代理技术为目标类创建已织入切面的代理对象。

所创建的动态代理对象的性能，

CGLib  时JDK的 10 倍；而创建动态代理对象所花费的时间上，CGLib却比JDK多花8倍的时间。所以，对于单例模式或者具有实例池的代理类，适合采用CGLib技术；反之，则适合采用JDK技术。

原文章地址

https://blog.csdn.net/deniro_li/article/details/80537924

 

 

 

}