java动态代理——JDK和CGLIB原理解析与使用

CGLIB的动态代理 

原理

      代理为控制要访问的目标对象提供了一种途径。当访问对象时,它引入了一个间接的层。JDK自从1.3版本开始,就引入了动态代理,并且经常被用来动态地创建代理。JDK的动态代理用起来非常简单,当它有一个限制,就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的继承的类,该怎么办?现在我们可以使用CGLIB包。

二、什么是cglib

     CGLIB是一个强大的高性能的代码生成包。

      1>它广泛的被许多AOP的框架使用,例如:spring AOP和dynaop,为他们提供方法的interception(拦截);

       2>hibernate使用CGLIB来代理单端single-ended(多对一和一对一)关联(对集合的延迟抓取,是采用其他机制实现的);

       3>EasyMock和jMock是通过使用模仿(moke)对象来测试Java代码的包。

     它们都通过使用CGLIB来为那些没有接口的类创建模仿(moke)对象。

三、底层

      CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM(Java字节码操控框架),来转换字节码并生成新的类。除了CGLIB包,脚本语言例如 Groovy和BeanShell,也是使用ASM来生成java的字节码。当不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。所以cglib包要依赖于asm包,需要一起导入。下图为cglib与一些框架和语言的关系(CGLIB Library and ASM Bytecode Framework)

      Spring AOP和Hibernate同时使用JDK的动态代理和CGLIB包。Spring AOP,如果不强制使用CGLIB包,默认情况是使用JDK的动态代理来代理接口。

四、实例场景模拟

1. 我们创建一个对Table操作的DAO类,提供了CRUD方法。 
    BookServiceBean.java

[java] view plain copy
  1. package com.tech.cglibx;  
  2. public class BookServiceBean {  
  3.  public void create(){     
  4.         System.out.println("create() is running !");     
  5.     }     
  6.     public void query(){     
  7.         System.out.println("query() is running !");     
  8.     }     
  9.     public void update(){     
  10.         System.out.println("update() is running !");     
  11.     }     
  12.     public void delete(){     
  13.         System.out.println("delete() is running !");     
  14.     }     
  15. }  

    OK,它就是一个javaBean,提供了CRUD方法的javaBean。 
    下面我们创建一个DAO工厂,用来生成DAO实例。

[java] view plain copy
  1. package com.tech.cglibx;  
  2. public class BookServiceFactory {  
  3.  private static BookServiceBean service = new BookServiceBean();  
  4.  private BookServiceFactory() {  
  5.  }  
  6.  public static BookServiceBean getInstance() {  
  7.   return service;  
  8.  }  
  9. }  

    接下来我们创建客户端,用来调用CRUD方法。

[java] view plain copy
  1. public class Client {     
  2.     
  3.     public static void main(String[] args) {     
  4.         BookServiceBean service = BookServiceFactory.getInstance();   
  5.         doMethod(service);     
  6.     }     
  7.     public static void doMethod(BookServiceBean service){     
  8.         service.create();  
  9.         service.update();  
  10.         service.query();  
  11.         service.delete();   
  12.     }     
  13. }   

    OK,完成了,CRUD方法完全被调用了。

    当然这里并没有CGlib的任何内容。问题不会这么简单的就结束,新的需求来临了。

 
2. one day,Boss告诉我们这些方法不能开放给用户,只有“boss”才有权使用。怎么办,难道我们要在每个方法上面进行判断吗?好像这么做也太那啥了吧?对了,Proxy可能是最好的解决办法。jdk的代理就可以解决了。 好了我们来动手改造吧。等等jdk的代理需要实现接口,这样, 我们的dao类需要改变了。既然不想改动dao又要使用代理,我们这就请出CGlib。
我们只需新增一个权限验证的方法拦截器。

[java] view plain copy
  1. package com.tech.cglibx;  
  2. import java.lang.reflect.Method;  
  3. import net.sf.cglib.proxy.Enhancer;  
  4. import net.sf.cglib.proxy.MethodInterceptor;  
  5. import net.sf.cglib.proxy.MethodProxy;  
  6. import org.apache.log4j.Logger;  
  7. public class MyCglibProxy implements MethodInterceptor{  
  8.  private Logger log=Logger.getLogger(MyCglibProxy.class);  
  9.  public Enhancer enhancer = new Enhancer();  
  10.  private String name;  
  11.    
  12.  public MyCglibProxy(String name) {  
  13.        this.name = name ;  
  14.  }  
  15.  /** 
  16.   * 根据class对象创建该对象的代理对象 
  17.   * 1、设置父类;2、设置回调 
  18.   * 本质:动态创建了一个class对象的子类 
  19.   *  
  20.   * @param cls 
  21.   * @return 
  22.   */  
  23.  public Object getDaoBean(Class cls) {  
  24.   enhancer.setSuperclass(cls);  
  25.   enhancer.setCallback(this);  
  26.   return enhancer.create();  
  27.  }  
  28.    
  29.  @Override  
  30.  public Object intercept(Object object, Method method, Object[] args,  
  31.    MethodProxy methodProxy) throws Throwable {  
  32.   log.info("调用的方法是:" + method.getName());  
  33.   //用户进行判断  
  34.   if(!"张三".equals(name)){   
  35.    System.out.println("你没有权限!");   
  36.    return null;   
  37.   }   
  38.   Object result = methodProxy.invokeSuper(object, args);  
  39.     
  40.   return result;  
  41.  }  
  42. }  

        当然不能忘了对我们的dao工厂进行修改,我们提供一个使用代理的实例生成方法。上面的类中已经提供了一个通用的获取代理实例的方法,没有特殊需求(如下3)的方式可以使用上面的方式获取代理对象。

[java] view plain copy
  1. public static BookServiceBean getProxyInstance(MyCglibProxy myProxy){    
  2.      Enhancer en = new Enhancer();     
  3.      //进行代理     
  4.      en.setSuperclass(BookServiceBean.class);     
  5.      en.setCallback(myProxy);     
  6.      //生成代理实例     
  7.      return (BookServiceBean)en.create();     
  8.  } <span style="font-family: Arial, Verdana, sans-serif; white-space: normal; "> </span>  

     我们这就可以看看客户端的实现了。添加了两个方法用来验证不同用户的权限

[java] view plain copy
  1. BookServiceBean service = BookServiceFactory.getProxyInstance(new MyCglibProxy("boss"));  
  2. service.create();  
  3. BookServiceBean service2 = BookServiceFactory.getProxyInstance(new MyCglibProxy("john"));  
  4. service2.create();  

OK,"boss"的正常执行,"john"的没有执行。 
看到了吗?简单的aop就这样实现了 
难道就这样结束了么? 

3.grd Boss又来训话了,不行不行,现在除了"boss"其他人都用不了了,现在不可以这样。必须使用开放查询功能。 
 哈哈,现在可难不倒我们了,因为我们使用了CGlib。当然最简单的方式是去修改我们的方法拦截器,不过这样会使逻辑变得复杂,且不利于维护。

还好CGlib给我们提供了方法过滤器(CallbackFilter),CallbackFilte可以明确表明,被代理的类中不同的方法,被哪个拦截器所拦截。

下面我们就来做个过滤器用来过滤query方法。 

[java] view plain copy
  1. package com.tech.cglibx;  
  2. import java.lang.reflect.Method;  
  3. import net.sf.cglib.proxy.CallbackFilter;  
  4. public class MyProxyFilter implements CallbackFilter {  
  5.  @Override  
  6.  public int accept(Method arg0) {     
  7.         if(!"query".equalsIgnoreCase(arg0.getName()))     
  8.             return 0;     
  9.         return 1;     
  10.     }  
  11. }  

我们在工场中新增一个使用了过滤器的实例生成方法。 

[java] view plain copy
  1. public static BookServiceBean getAuthInstanceByFilter(MyCglibProxy myProxy){    
  2.      Enhancer en = new Enhancer();     
  3.      en.setSuperclass(BookServiceBean.class);     
  4.      en.setCallbacks(new Callback[]{myProxy,NoOp.INSTANCE});     
  5.      en.setCallbackFilter(new MyProxyFilter());     
  6.      return (BookServiceBean)en.create();     
  7.  }  

   setCallbacks中定义了所使用的拦截器,其中NoOp.INSTANCE是CGlib所提供的实际是一个没有任何操作的拦截器, 
   他们是有序的,一定要和CallbackFilter里面的顺序一致。上面return返回(0/1)的就是返回的顺序。也就是说如果调用query方法就使用NoOp.INSTANCE进行拦截。
现在看一下客户端代码。

[java] view plain copy
  1. BookServiceBean service = BookServiceFactory.getProxyInstanceByFilter(new MyCglibProxy("jhon"));  
  2.  service.create();  
  3.  BookServiceBean service2 = BookServiceFactory.getProxyInstanceByFilter(new MyCglibProxy("jhon"));  
  4.  service2.query();  


ok,现在"李四"也可以使用query方法了,其他方法仍然没有权限。 
当然这个代理的实现没有任何侵入性,无需强制让dao去实现接口。 



二、CGLib动态代理使用

JDK实现动态代理需要实现类通过接口定义业务方法,对于没有接口的类,如何实现动态代理呢,这就需要CGLib了。CGLib采用了非常底层的字节码技术,其原理是通过字节码技术为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

   简单的实现举例:

这是一个需要被代理的类,也就是父类,通过字节码技术创建这个类的子类,实现动态代理。

[java] view plain copy
  1. public class SayHello {  
  2.  public void say(){  
  3.   System.out.println("hello everyone");  
  4.  }  
  5. }  
该类实现了创建子类的方法与代理的方法。getProxy(SuperClass.class)方法通过入参即父类的字节码,通过扩展父类的class来创建代理对象。intercept()方法拦截所有目标类方法的调用,obj表示目标类的实例,method为目标类方法的反射对象,args为方法的动态入参,proxy为代理类实例。proxy.invokeSuper(obj, args)通过代理类调用父类中的方法。

[java] view plain copy
  1. public class CglibProxy implements MethodInterceptor{  
  2.  private Enhancer enhancer = new Enhancer();  
  3.  public Object getProxy(Class clazz){  
  4.   //设置需要创建子类的类  
  5.   enhancer.setSuperclass(clazz);  
  6.   enhancer.setCallback(this);  
  7.   //通过字节码技术动态创建子类实例  
  8.   return enhancer.create();  
  9.  }  
  10.  //实现MethodInterceptor接口方法  
  11.  public Object intercept(Object obj, Method method, Object[] args,  
  12.    MethodProxy proxy) throws Throwable {  
  13.   System.out.println("前置代理");  
  14.   //通过代理类调用父类中的方法  
  15.   Object result = proxy.invokeSuper(obj, args);  
  16.   System.out.println("后置代理");  
  17.   return result;  
  18.  }  
  19. }  

具体实现类:

[java] view plain copy
  1. public class DoCGLib {  
  2.  public static void main(String[] args) {  
  3.   CglibProxy proxy = new CglibProxy();  
  4.   //通过生成子类的方式创建代理类  
  5.   SayHello proxyImp = (SayHello)proxy.getProxy(SayHello.class);  
  6.   proxyImp.say();  
  7.  }  
  8. }  

输出结果:

[plain] view plain copy
  1. 前置代理  
  2. hello everyone  
  3. 后置代理  
    CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少,但是CGLib在创建代理对象时所花费的时间却比JDK多得多,所以对于单例的对象,因为无需频繁创建对象,用CGLib合适,反之,使用JDK方式要更为合适一些。同时,由于CGLib由于是采用动态创建子类的方法,对于final方法,无法进行代理。


三、JAVA的代理模式


代理模式 
代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务。 
按照代理的创建时期,代理类可以分为两种。 
静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。 
动态代理:在程序运行时,运用反射机制动态创建而成。 

 

首先看一下静态代理: 
1、Count.java 

  1. package net.battier.dao;  
  2.   
  3. /** 
  4.  * 定义一个账户接口 
  5.  *  
  6.  * @author Administrator 
  7.  *  
  8.  */  
  9. public interface Count {  
  10.     // 查看账户方法  
  11.     public void queryCount();  
  12.   
  13.     // 修改账户方法  
  14.     public void updateCount();  
  15.   
  16. }  


2、CountImpl.java 

  1. package net.battier.dao.impl;  
  2.   
  3. import net.battier.dao.Count;  
  4.   
  5. /** 
  6.  * 委托类(包含业务逻辑) 
  7.  *  
  8.  * @author Administrator 
  9.  *  
  10.  */  
  11. public class CountImpl implements Count {  
  12.   
  13.     @Override  
  14.     public void queryCount() {  
  15.         System.out.println("查看账户方法...");  
  16.   
  17.     }  
  18.   
  19.     @Override  
  20.     public void updateCount() {  
  21.         System.out.println("修改账户方法...");  
  22.   
  23.     }  
  24.   
  25. }  
  26.   
  27. 、CountProxy.java  
  28. package net.battier.dao.impl;  
  29.   
  30. import net.battier.dao.Count;  
  31.   
  32. /** 
  33.  * 这是一个代理类(增强CountImpl实现类) 
  34.  *  
  35.  * @author Administrator 
  36.  *  
  37.  */  
  38. public class CountProxy implements Count {  
  39.     private CountImpl countImpl;  
  40.   
  41.     /** 
  42.      * 覆盖默认构造器 
  43.      *  
  44.      * @param countImpl 
  45.      */  
  46.     public CountProxy(CountImpl countImpl) {  
  47.         this.countImpl = countImpl;  
  48.     }  
  49.   
  50.     @Override  
  51.     public void queryCount() {  
  52.         System.out.println("事务处理之前");  
  53.         // 调用委托类的方法;  
  54.         countImpl.queryCount();  
  55.         System.out.println("事务处理之后");  
  56.     }  
  57.   
  58.     @Override  
  59.     public void updateCount() {  
  60.         System.out.println("事务处理之前");  
  61.         // 调用委托类的方法;  
  62.         countImpl.updateCount();  
  63.         System.out.println("事务处理之后");  
  64.   
  65.     }  
  66.   
  67. }  

 

3、TestCount.java 

  1. package net.battier.test;  
  2.   
  3. import net.battier.dao.impl.CountImpl;  
  4. import net.battier.dao.impl.CountProxy;  
  5.   
  6. /** 
  7.  *测试Count类 
  8.  *  
  9.  * @author Administrator 
  10.  *  
  11.  */  
  12. public class TestCount {  
  13.     public static void main(String[] args) {  
  14.         CountImpl countImpl = new CountImpl();  
  15.         CountProxy countProxy = new CountProxy(countImpl);  
  16.         countProxy.updateCount();  
  17.         countProxy.queryCount();  
  18.   
  19.     }  
  20. }  

 

观察代码可以发现每一个代理类只能为一个接口服务,这样一来程序开发中必然会产生过多的代理,而且,所有的代理操作除了调用的方法不一样之外,其他的操作都一样,则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能,那么此时就必须使用动态代理完成。 
再来看一下动态代理: 
JDK动态代理中包含一个类和一个接口: 
InvocationHandler接口: 
public interface InvocationHandler { 
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 

参数说明: 
Object proxy:指被代理的对象。 
Method method:要调用的方法 
Object[] args:方法调用时所需要的参数 

可以将InvocationHandler接口的子类想象成一个代理的最终操作类,替换掉ProxySubject。 

Proxy类: 
Proxy类是专门完成代理的操作类,可以通过此类为一个或多个接口动态地生成实现类,此类提供了如下的操作方法: 
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, 
InvocationHandler h) 
                               throws IllegalArgumentException 
参数说明: 
ClassLoader loader:类加载器 
Class<?>[] interfaces:得到全部的接口 
InvocationHandler h:得到InvocationHandler接口的子类实例 

Ps:类加载器 
在Proxy类中的newProxyInstance()方法中需要一个ClassLoader类的实例,ClassLoader实际上对应的是类加载器,在Java中主要有一下三种类加载器; 
Booststrap ClassLoader:此加载器采用C++编写,一般开发中是看不到的; 
Extendsion ClassLoader:用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类; 
AppClassLoader:(默认)加载classpath指定的类,是最常使用的是一种加载器。 

动态代理 
与静态代理类对照的是动态代理类,动态代理类的字节码在程序运行时由Java反射机制动态生成,无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作,而且提高了软件系统的可扩展性,因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

动态代理示例: 
1、BookFacade.java 

  1. package net.battier.dao;  
  2.   
  3. public interface BookFacade {  
  4.     public void addBook();  
  5. }  

 

2、BookFacadeImpl.java 

  1. package net.battier.dao.impl;  
  2.   
  3. import net.battier.dao.BookFacade;  
  4.   
  5. public class BookFacadeImpl implements BookFacade {  
  6.   
  7.     @Override  
  8.     public void addBook() {  
  9.         System.out.println("增加图书方法。。。");  
  10.     }  
  11.   
  12. }  
  13.   
  14. 、BookFacadeProxy.java  
  15.   
  16. package net.battier.proxy;  
  17.   
  18. import java.lang.reflect.InvocationHandler;  
  19. import java.lang.reflect.Method;  
  20. import java.lang.reflect.Proxy;  
  21.   
  22. /** 
  23.  * JDK动态代理代理类 
  24.  *  
  25.  * @author student 
  26.  *  
  27.  */  
  28. public class BookFacadeProxy implements InvocationHandler {  
  29.     private Object target;  
  30.     /** 
  31.      * 绑定委托对象并返回一个代理类 
  32.      * @param target 
  33.      * @return 
  34.      */  
  35.     public Object bind(Object target) {  
  36.         this.target = target;  
  37.         //取得代理对象  
  38.         return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
  39.                 target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷,cglib弥补了这一缺陷)  
  40.     }  
  41.   
  42.     @Override  
  43.     /** 
  44.      * 调用方法 
  45.      */  
  46.     public Object invoke(Object proxy, Method method, Object[] args)  
  47.             throws Throwable {  
  48.         Object result=null;  
  49.         System.out.println("事物开始");  
  50.         //执行方法  
  51.         result=method.invoke(target, args);  
  52.         System.out.println("事物结束");  
  53.         return result;  
  54.     }  
  55.   
  56. }  

 

3、TestProxy.java 

  1. package net.battier.test;  
  2.   
  3. import net.battier.dao.BookFacade;  
  4. import net.battier.dao.impl.BookFacadeImpl;  
  5. import net.battier.proxy.BookFacadeProxy;  
  6.   
  7. public class TestProxy {  
  8.   
  9.     public static void main(String[] args) {  
  10.         BookFacadeProxy proxy = new BookFacadeProxy();  
  11.         BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
  12.         bookProxy.addBook();  
  13.     }  
  14.   
  15. }  

 

但是,JDK的动态代理依靠接口实现,如果有些类并没有实现接口,则不能使用JDK代理,这就要使用cglib动态代理了。 

Cglib动态代理 
JDK的动态代理机制只能代理实现了接口的类,而不能实现接口的类就不能实现JDK的动态代理,cglib是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对final修饰的类进行代理。 
示例 
1、BookFacadeCglib.java 

  1. package net.battier.dao;  
  2.   
  3. public interface BookFacade {  
  4.     public void addBook();  
  5. }  

 

2、BookCadeImpl1.java 

  1. package net.battier.dao.impl;  
  2.   
  3. /** 
  4.  * 这个是没有实现接口的实现类 
  5.  *  
  6.  * @author student 
  7.  *  
  8.  */  
  9. public class BookFacadeImpl1 {  
  10.     public void addBook() {  
  11.         System.out.println("增加图书的普通方法...");  
  12.     }  
  13. }  


3、BookFacadeProxy.java 

  1. package net.battier.proxy;  
  2.   
  3. import java.lang.reflect.Method;  
  4.   
  5. import net.sf.cglib.proxy.Enhancer;  
  6. import net.sf.cglib.proxy.MethodInterceptor;  
  7. import net.sf.cglib.proxy.MethodProxy;  
  8.   
  9. /** 
  10.  * 使用cglib动态代理 
  11.  *  
  12.  * @author student 
  13.  *  
  14.  */  
  15. public class BookFacadeCglib implements MethodInterceptor {  
  16.     private Object target;  
  17.   
  18.     /** 
  19.      * 创建代理对象 
  20.      *  
  21.      * @param target 
  22.      * @return 
  23.      */  
  24.     public Object getInstance(Object target) {  
  25.         this.target = target;  
  26.         Enhancer enhancer = new Enhancer();  
  27.         enhancer.setSuperclass(this.target.getClass());  
  28.         // 回调方法  
  29.         enhancer.setCallback(this);  
  30.         // 创建代理对象  
  31.         return enhancer.create();  
  32.     }  
  33.   
  34.     @Override  
  35.     // 回调方法  
  36.     public Object intercept(Object obj, Method method, Object[] args,  
  37.             MethodProxy proxy) throws Throwable {  
  38.         System.out.println("事物开始");  
  39.         proxy.invokeSuper(obj, args);  
  40.         System.out.println("事物结束");  
  41.         return null;  
  42.   
  43.   
  44.     }  
  45.   
  46. }  


4、TestCglib.java 

  1. package net.battier.test;  
  2.   
  3. import net.battier.dao.impl.BookFacadeImpl1;  
  4. import net.battier.proxy.BookFacadeCglib;  
  5.   
  6. public class TestCglib {  
  7.       
  8.     public static void main(String[] args) {  
  9.         BookFacadeCglib cglib=new BookFacadeCglib();  
  10.         BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
  11.         bookCglib.addBook();  
  12.     }  
  13. }  
展开阅读全文

没有更多推荐了,返回首页