静态代理、JDK与CGLIB动态代理

目录

• 一、为什么需要代理模式
• 二、静态代理
• 三、动态代理，使用JDK内置的Proxy实现
• 四、动态代理，使用cglib实现

一、为什么需要代理模式

假设需实现一个计算的类Math、完成加、减、乘、除功能，如下所示：

 1 package com.zhangguo.Spring041.aop01; 2  3 public class Math { 4     //加 5     public int add(int n1,int n2){ 6         int result=n1+n2; 7         System.out.println(n1+"+"+n2+"="+result); 8         return result; 9     }10     11     12     //减13     public int sub(int n1,int n2){14         int result=n1-n2;15         System.out.println(n1+"-"+n2+"="+result);16         return result;17     }18     19     //乘20     public int mut(int n1,int n2){21         int result=n1*n2;22         System.out.println(n1+"X"+n2+"="+result);23         return result;24     }25     26     //除27     public int div(int n1,int n2){28         int result=n1/n2;29         System.out.println(n1+"/"+n2+"="+result);30         return result;31     }32 }

现在需求发生了变化，要求项目中所有的类在执行方法时输出执行耗时。最直接的办法是修改源代码，如下所示：

 1 package com.zhangguo.Spring041.aop01; 2  3 import java.util.Random; 4  5 public class Math { 6     //加 7     public int add(int n1,int n2){ 8         //开始时间 9         long start=System.currentTimeMillis();10         lazy();11         int result=n1+n2;12         System.out.println(n1+"+"+n2+"="+result);13         Long span= System.currentTimeMillis()-start;14         System.out.println("共用时："+span);15         return result;16     }17     18     //减19     public int sub(int n1,int n2){20         //开始时间21         long start=System.currentTimeMillis();22         lazy();23         int result=n1-n2;24         System.out.println(n1+"-"+n2+"="+result);25         Long span= System.currentTimeMillis()-start;26         System.out.println("共用时："+span);27         return result;28     }29     30     //乘31     public int mut(int n1,int n2){32         //开始时间33         long start=System.currentTimeMillis();34         lazy();35         int result=n1*n2;36         System.out.println(n1+"X"+n2+"="+result);37         Long span= System.currentTimeMillis()-start;38         System.out.println("共用时："+span);39         return result;40     }41     42     //除43     public int div(int n1,int n2){44         //开始时间45         long start=System.currentTimeMillis();46         lazy();47         int result=n1/n2;48         System.out.println(n1+"/"+n2+"="+result);49         Long span= System.currentTimeMillis()-start;50         System.out.println("共用时："+span);51         return result;52     }53     54     //模拟延时55     public void lazy()56     {57         try {58             int n=(int)new Random().nextInt(500);59             Thread.sleep(n);60         } catch (InterruptedException e) {61             e.printStackTrace();62         }63     }64 }

测试运行：

package com.zhangguo.Spring041.aop01;public class Test {        @org.junit.Test    public void test01()    {        Math math=new Math();        int n1=100,n2=5;        math.add(n1, n2);        math.sub(n1, n2);        math.mut(n1, n2);        math.div(n1, n2);    }}

运行结果：

缺点：

1、工作量特别大，如果项目中有多个类，多个方法，则要修改多次。

2、违背了设计原则：开闭原则（OCP），对扩展开放，对修改关闭，而为了增加功能把每个方法都修改了，也不便于维护。

3、违背了设计原则：单一职责（SRP），每个方法除了要完成自己本身的功能，还要计算耗时、延时；每一个方法引起它变化的原因就有多种。

4、违背了设计原则：依赖倒转（DIP），抽象不应该依赖细节，两者都应该依赖抽象。而在Test类中，Test与Math都是细节。

使用静态代理可以解决部分问题。

二、静态代理

 1、定义抽象主题接口。

package com.zhangguo.Spring041.aop02;/** * 接口 * 抽象主题 */public interface IMath {    //加    int add(int n1, int n2);    //减    int sub(int n1, int n2);    //乘    int mut(int n1, int n2);    //除    int div(int n1, int n2);}

2、主题类，算术类，实现抽象接口。

package com.zhangguo.Spring041.aop02;/** * 被代理的目标对象 *真实主题 */public class Math implements IMath {    //加    public int add(int n1,int n2){        int result=n1+n2;        System.out.println(n1+"+"+n2+"="+result);        return result;    }        //减    public int sub(int n1,int n2){        int result=n1-n2;        System.out.println(n1+"-"+n2+"="+result);        return result;    }        //乘    public int mut(int n1,int n2){        int result=n1*n2;        System.out.println(n1+"X"+n2+"="+result);        return result;    }        //除    public int div(int n1,int n2){        int result=n1/n2;        System.out.println(n1+"/"+n2+"="+result);        return result;    }}

3、代理类

 1 package com.zhangguo.Spring041.aop02; 2  3 import java.util.Random; 4  5 /** 6  * 静态代理类 7  */ 8 public class MathProxy implements IMath { 9 10     //被代理的对象11     IMath math=new Math();12     13     //加14     public int add(int n1, int n2) {15         //开始时间16         long start=System.currentTimeMillis();17         lazy();18         int result=math.add(n1, n2);19         Long span= System.currentTimeMillis()-start;20         System.out.println("共用时："+span);21         return result;22     }23 24     //减法25     public int sub(int n1, int n2) {26         //开始时间27         long start=System.currentTimeMillis();28         lazy();29         int result=math.sub(n1, n2);30         Long span= System.currentTimeMillis()-start;31         System.out.println("共用时："+span);32         return result;33     }34 35     //乘36     public int mut(int n1, int n2) {37         //开始时间38         long start=System.currentTimeMillis();39         lazy();40         int result=math.mut(n1, n2);41         Long span= System.currentTimeMillis()-start;42         System.out.println("共用时："+span);43         return result;44     }45     46     //除47     public int div(int n1, int n2) {48         //开始时间49         long start=System.currentTimeMillis();50         lazy();51         int result=math.div(n1, n2);52         Long span= System.currentTimeMillis()-start;53         System.out.println("共用时："+span);54         return result;55     }56 57     //模拟延时58     public void lazy()59     {60         try {61             int n=(int)new Random().nextInt(500);62             Thread.sleep(n);63         } catch (InterruptedException e) {64             e.printStackTrace();65         }66     }67 }

4、测试运行

 1 package com.zhangguo.Spring041.aop02; 2  3 public class Test { 4      5     IMath math=new MathProxy(); 6     @org.junit.Test 7     public void test01() 8     { 9         int n1=100,n2=5;10         math.add(n1, n2);11         math.sub(n1, n2);12         math.mut(n1, n2);13         math.div(n1, n2);14     }15 }

 

5、小结

通过静态代理，是否完全解决了上述的4个问题：

已解决：

5.1、解决了“开闭原则（OCP）”的问题，因为并没有修改Math类，而扩展出了MathProxy类。

5.2、解决了“依赖倒转（DIP）”的问题，通过引入接口。

5.3、解决了“单一职责（SRP）”的问题，Math类不再需要去计算耗时与延时操作，但从某些方面讲MathProxy还是存在该问题。

未解决：

5.4、如果项目中有多个类，则需要编写多个代理类，工作量大，不好修改，不好维护，不能应对变化。

如果要解决上面的问题，可以使用动态代理。

三、动态代理，使用JDK内置的Proxy实现

只需要一个代理类，而不是针对每个类编写代理类。

在上一个示例中修改代理类MathProxy如下：

 1 package com.zhangguo.Spring041.aop03; 2  3 import java.lang.reflect.InvocationHandler; 4 import java.lang.reflect.Method; 5 import java.lang.reflect.Proxy; 6 import java.util.Random; 7  8 /** 9  * 动态代理类10  */11 public class DynamicProxy implements InvocationHandler {12 13     //被代理的对象14     Object targetObject;15     16     /**17      * 获得被代理后的对象18      * @param object 被代理的对象19      * @return 代理后的对象20      */21     public Object getProxyObject(Object object){22         this.targetObject=object;23         return Proxy.newProxyInstance(24                 targetObject.getClass().getClassLoader(), //类加载器25                 targetObject.getClass().getInterfaces(),  //获得被代理对象的所有接口26                 this);  //InvocationHandler对象27         //loader:一个ClassLoader对象，定义了由哪个ClassLoader对象来生成代理对象进行加载28         //interfaces:一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了29         //h:一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上，间接通过invoke来执行30     }31     32     33     /**34      * 当用户调用对象中的每个方法时都通过下面的方法执行，方法必须在接口35      * proxy 被代理后的对象36      * method 将要被执行的方法信息（反射）37      * args 执行方法时需要的参数38      */39     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {40         //被织入的内容，开始时间41         long start=System.currentTimeMillis();42         lazy();43         44         //使用反射在目标对象上调用方法并传入参数45         Object result=method.invoke(targetObject, args);46         47         //被织入的内容，结束时间48         Long span= System.currentTimeMillis()-start;49         System.out.println("共用时："+span);50         51         return result;52     }53     54     //模拟延时55     public void lazy()56     {57         try {58             int n=(int)new Random().nextInt(500);59             Thread.sleep(n);60         } catch (InterruptedException e) {61             e.printStackTrace();62         }63     }64 65 }

测试运行：

 1 package com.zhangguo.Spring041.aop03; 2  3 public class Test { 4      5     //实例化一个MathProxy代理对象 6     //通过getProxyObject方法获得被代理后的对象 7     IMath math=(IMath)new DynamicProxy().getProxyObject(new Math()); 8     @org.junit.Test 9     public void test01()10     {11         int n1=100,n2=5;12         math.add(n1, n2);13         math.sub(n1, n2);14         math.mut(n1, n2);15         math.div(n1, n2);16     }17     18     IMessage message=(IMessage) new DynamicProxy().getProxyObject(new Message());19     @org.junit.Test20     public void test02()21     {22         message.message();23     }24 }

 

 小结：

 JDK内置的Proxy动态代理可以在运行时动态生成字节码，而没必要针对每个类编写代理类。中间主要使用到了一个接口InvocationHandler与Proxy.newProxyInstance静态方法，参数说明如下：

 使用内置的Proxy实现动态代理有一个问题：被代理的类必须实现接口，未实现接口则没办法完成动态代理。

如果项目中有些类没有实现接口，则不应该为了实现动态代理而刻意去抽出一些没有实例意义的接口，通过cglib可以解决该问题。

四、动态代理，使用cglib实现

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

 4.1、引用cglib，通过maven

 修改pom.xml文件，添加依赖

保存pom.xml配置文件，将自动从共享资源库下载cglib所依赖的jar包，主要有如下几个：

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

 1 package com.zhangguo.Spring041.aop04; 2  3 import java.lang.reflect.Method; 4 import java.util.Random; 5  6 import net.sf.cglib.proxy.Enhancer; 7 import net.sf.cglib.proxy.MethodInterceptor; 8 import net.sf.cglib.proxy.MethodProxy; 9 10 /*11  * 动态代理类12  * 实现了一个方法拦截器接口13  */14 public class DynamicProxy implements MethodInterceptor {15 16     // 被代理对象17     Object targetObject;18 19     //Generate a new class if necessary and uses the specified callbacks (if any) to create a new object instance. 20     //Uses the no-arg constructor of the superclass.21     //动态生成一个新的类，使用父类的无参构造方法创建一个指定了特定回调的代理实例22     public Object getProxyObject(Object object) {23         this.targetObject = object;24         //增强器，动态代码生成器25         Enhancer enhancer=new Enhancer();26         //回调方法27         enhancer.setCallback(this);28         //设置生成类的父类类型29         enhancer.setSuperclass(targetObject.getClass());30         //动态生成字节码并返回代理对象31         return enhancer.create();32     }33 34     // 拦截方法35     public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {36         // 被织入的横切内容，开始时间 before37         long start = System.currentTimeMillis();38         lazy();39 40         // 调用方法41         Object result = methodProxy.invoke(targetObject, args);42 43         // 被织入的横切内容，结束时间44         Long span = System.currentTimeMillis() - start;45         System.out.println("共用时：" + span);46         47         return result;48     }49 50     // 模拟延时51     public void lazy() {52         try {53             int n = (int) new Random().nextInt(500);54             Thread.sleep(n);55         } catch (InterruptedException e) {56             e.printStackTrace();57         }58     }59 60 }

测试运行：

package com.zhangguo.Spring041.aop04;public class Test {    //实例化一个DynamicProxy代理对象    //通过getProxyObject方法获得被代理后的对象    Math math=(Math)new DynamicProxy().getProxyObject(new Math());    @org.junit.Test    public void test01()    {        int n1=100,n2=5;        math.add(n1, n2);        math.sub(n1, n2);        math.mut(n1, n2);        math.div(n1, n2);    }    //另一个被代理的对象,不再需要重新编辑代理代码    Message message=(Message) new DynamicProxy().getProxyObject(new Message());    @org.junit.Test    public void test02()    {        message.message();    }}

 

运行结果：

4.3、小结

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