【重温设计模式】JDK动态代理和CGLIB动态代理

如果目标类实现接口，采用JDK动态代理；如果目标类没有实现接口，采用CGLIB动态代理

一.JDK动态代理

//JDK动态代理 
public class SomeServiceTest { 
       @Test 
       public void someServiceTest(){ 
                
               SomeService target = new SomeServiceImpl(); 

              //loader:一个ClassLoader对象，定义了由哪个ClassLoader对象来生成代理对象进行加载
              //interfaces:一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
             //h:一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上，间接通过invoke来执行

               SomeService proxy = (SomeService) Proxy.newProxyInstance(target.getClass().getClassLoader(),//目标类的类加载器 
                                                          target.getClass().getInterfaces(),//目标类实现的所有接口 
                                                          new InvocationHandler() {//调用处理器 
                                                               /** 
                                                                * proxy:代理对象 
                                                                * method：目标方法 
                                                                * args：目标方法的参数 
                                                                */ 
                                                               @Override 
                                                               public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                                                                       SomeServiceUtil.doTransaction(); 
                                                                       //执行目标方法 (注意invoke中的第一个参数写的是被代理对象)
                                                                       Object result = method.invoke(target, args); 
                                                                       SomeServiceUtil.doLog(); 
                                                                       return result; 
                                                               } 
                                                       }); 
              //通过代理对象调用方法
               proxy.doSome(); 
    
       }

总结
1.JDK内置的Proxy动态代理可以在运行时动态生成字节码，而没必要针对每个类编写代理类。中间主要使用到了一个接口InvocationHandler与Proxy.newProxyInstance静态方法;
2.使用内置的Proxy实现动态代理有一个问题：被代理的类必须实现接口，未实现接口则没办法完成动态代理。
3.如果项目中有些类没有实现接口，则不应该为了实现动态代理而刻意去抽出一些没有实例意义的接口，通过cglib可以解决该问题。

二.CGLIB动态代理

CGLIB(Code Generation Library)是一个开源项目,是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口，通俗说cglib可以在运行时动态生成字节码。

使用cglib完成动态代理，大概的原理是：cglib继承被代理的类，重写方法，织入通知，动态生成字节码并运行，因为是继承所以final类是没有办法动态代理的

package com.zhangguo.Spring041.aop04;

import java.lang.reflect.Method;
import java.util.Random;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/*
 * 动态代理类
 * 实现了一个方法拦截器接口
 */
public class DynamicProxy implements MethodInterceptor {

    // 被代理对象
    Object targetObject;

    //Generate a new class if necessary and uses the specified callbacks (if any) to create a new object instance. 
    //Uses the no-arg constructor of the superclass.
    //动态生成一个新的类，使用父类的无参构造方法创建一个指定了特定回调的代理实例
    public Object getProxyObject(Object object) {
        this.targetObject = object;
        //增强器，动态代码生成器
        Enhancer enhancer=new Enhancer();
        //回调方法
        enhancer.setCallback(this);
        //设置生成类的父类类型
        enhancer.setSuperclass(targetObject.getClass());
        //动态生成字节码并返回代理对象
        return enhancer.create();
    }

    // 拦截方法
    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // 被织入的横切内容，开始时间 before
        long start = System.currentTimeMillis();
        // 调用方法
        Object result = methodProxy.invoke(targetObject, args);
        // 被织入的横切内容，结束时间
        Long span = System.currentTimeMillis() - start;
        System.out.println("共用时：" + span);
      
        return result;
    }
}

总结:
使用cglib可以实现动态代理，即使被代理的类没有实现接口，但被代理的类必须不是final类。

最后编辑于：2019.04.26 07:45:10