Cglib Dynamic Proxy(Cglib 动态代理)

使用JDK创建动态代理只能为接口创建代理实例，这第一点从Proxy的接口签名newProxyInstance(ClassLoader loader,Class[]interfaces,InvocationHandler h)中就可以看的很清楚：第二个入参interfaces就是需要代理实例的接口列表。对于没有接口定义的业务方法的类，则使用Cglib动态代理。

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

实例一:使用Cglib动态代理，对方法执行时间进行监控

Computer类

public class Computer {

   public int add(int a,int b){

      System.out.println("perform add method...");

      try {

         Thread.sleep(20);

      }catch(InterruptedException e) {

         e.printStackTrace();

      }

      return a+b;

   }

   public int plus(int a,int b){

      System.out.println("perform plus method...");

      try {

         Thread.sleep(40);

      }catch(InterruptedException e) {

         e.printStackTrace();

      }

      return a-b;

   }

}

监视器类

/**

 * 用于记录性能监视信息

 * method为目标类方法的全限定名

 */

public class MethodPerformance {

   private long begin;

   private long end;

   private String serviceMethod;

   public MethodPerformance(String serviceMethod){

      this.serviceMethod=serviceMethod;

      begin=System.currentTimeMillis();

   }

   public void printPerformance(){

      end=System.currentTimeMillis();

      long elapse=end-begin;

      System.out.println(serviceMethod+" cost "+elapse+" ms");

   }

}

/**

 *性能监视器类

 */

public class PerformanceMonitor {

   /*

    * 通过一个ThreadLocal保存调用线程相关的性能监视信息,ThreadLocal是将非线程安全类改造为线程安全类的法宝

    */

   private static ThreadLocal<MethodPerformance> performanceRecord=newThreadLocal<MethodPerformance>();

   //启动对某一目标方法的性能监视

   public static void begin(String method){

      System.out.println("begin monitor...");

      MethodPerformance mp=new MethodPerformance(method);

      performanceRecord.set(mp);

   }

   public static void end(){

      System.out.println("end monitor...");

      MethodPerformance  mp=performanceRecord.get();

      mp.printPerformance();//打印方法性能监视结果

   }

}

Cglib动态代理类

public class  CglibProxy  implements  MethodInterceptor{

   private Enhancer enhancer=new Enhancer();

   public Object  getProxy(Class<?>  clazz){

      enhancer.setSuperclass(clazz);//设置需要创建子类的类

      enhancer.setCallback(this);

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

   }

   public Object intercept(Object obj, Method method, Object[] args,//拦截父类所有方法的调用

         MethodProxy  proxy) throwsThrowable {

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

      Object  result=proxy.invokeSuper(obj, args); //通过代理类调用父类中的方法

      PerformanceMonitor.end();

      return result;

   }

}

测试类：

public class Test {

   public static void main(String[] args) {

      CglibProxyproxy=new CglibProxy();

      Computer c=(Computer)proxy.getProxy(Computer.class);

      c.add(5,2);

      c.plus(10,3);

   }

}

 

输出结果：

begin monitor...

perform add method...

end monitor...

cglib1.Computer$$EnhancerByCGLIB$$5658ac9d.addcost 38 ms

begin monitor...

perform plus method...

end monitor...

cglib1.Computer$$EnhancerByCGLIB$$5658ac9d.pluscost 40 ms

 

在intercept(Object obj,Method method,Objects[] args,MethodProxy proxy)是CGLIB定义的Interceptor接口的方法，它拦截所有目标类方法的调用，obj标示目标类的实例，method为目标类方法的反射对象；args为方法的动态入参；而proxy为代理类的实例。

 

 

实例二：利用cglib动态代理，对增删改查方法进行权限过滤

BookBean实现了增删改查的业务功能

public class BookBean {

   public void create(){

      System.out.println("create is running");

   }

   public void delete(){

      System.out.println("delete is running");

   }

   public void query(){

      System.out.println("query is running");

   }

   public void update(){

      System.out.println("update is running");

   }

}

动态代理，实现业务逻辑横切面拦截（即权限过滤）

public class CglibProxy implementsMethodInterceptor {

   private Logger  log=Logger.getLogger(CglibProxy.class);

   private String  name;

   private Enhancer   enhancer=new Enhancer();

   public CglibProxy(String  name){

      this.name=name;

   }

   public Object  getBookBeanProxy(Class<?> clazz){

      enhancer.setSuperclass(clazz);

      enhancer.setCallback(this);

      return enhancer.create();

   }

   public Object  intercept(Object  obj, Method method, Object[] args,

         MethodProxy  proxy) throws  Throwable {

      log.info("invoke method is "+method.getName());

      if("zhangsan".equals(name)){

         System.out.println("Permission denied! ");

         return null;

      }

      Object result=proxy.invokeSuper(obj, args);

      return result;

   }

}

 

创建一个获取Bean工厂类

public class BookBeanFactory {

   private static BookBean service=new BookBean();

   public BookBeanFactory(){};

   public static BookBean getInstance(){

      return service;

   }

   /*

    * 用于获取BookBean代理类而特别提供的方法，也可以忽略直接用上面通用的方法

    */

   public static BookBean   getBookBeanProxyInstance(CglibProxy proxy){

      Enhancer  enhancer=new  Enhancer();

      enhancer.setSuperclass(BookBean.class);

      enhancer.setCallback(proxy);

      return (BookBean)enhancer.create();

   }

}

测试类：

public class Client {

   public static void doMethod(BookBean   bean){

      bean.create();

      bean.delete();

      bean.query();

      bean.update();

   }

   public static void main(String[] args) {

      //BookBean bean=BookBeanFactory.getInstance();

      CglibProxyproxy=new   CglibProxy("zhangsan");

//    BookBeanbean=(BookBean)proxy.getBookBeanProxy(BookBean.class);

     

      BookBeanbean =BookBeanFactory.getBookBeanProxyInstance(proxy);

      doMethod(bean);

   }

}

无权限的结果：

Permission denied!

Permission denied!

Permission denied!

Permission denied!

有权限的结果：

create is running

delete is running

query is running

update is running

 

通过动态代理实现对方法权限的使用，如果不用动态代理的话，就需要在每个方法中判断某人是否具有使用自己的权限，这将是很麻烦的。