你的位置:首页 > Java教程

[Java教程]AOP、静态代理、JDK动态代理、CGLIB动态代理、Spring实现AOP、IOC+AOP


一、为什么需要代理模式

假设需实现一个计算的类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.

保存pom.

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类。

五、使用Spring实现AOP

SpringAOP中,通过Advice定义横切逻辑,Spring中支持5种类型的Advice:

5.1、新建 一个Maven项目,在项目中引入Spring核心库与AOP,修改pom.

  <dependency>    <groupId>org.springframework</groupId>    <artifactId>spring-context</artifactId>    <version>4.3.0.RELEASE</version>  </dependency>

 

当保存pom.

5.2、定义通知(Advice)

 前置通知

 1 package com.zhangguo.Spring041.aop05; 2  3 import java.lang.reflect.Method; 4  5 import org.springframework.aop.MethodBeforeAdvice; 6  7 /** 8  * 前置通知 9 */10 public class BeforeAdvice implements MethodBeforeAdvice {11 12   /**13    * method 方法信息14    * args 参数15    * target 被代理的目标对象16   */17   public void before(Method method, Object[] args, Object target) throws Throwable {18     System.out.println("-----------------前置通知-----------------");19   }20 }

后置通知

 1 package com.zhangguo.Spring041.aop05; 2  3 import java.lang.reflect.Method; 4  5 import org.springframework.aop.AfterReturningAdvice; 6  7 /** 8  * 后置通知 9  *10 */11 public class AfterAdvice implements AfterReturningAdvice {12 13   /*14    * returnValue 返回值15    * method 被调用的方法16    * args 方法参数17    * target 被代理对象18   */19   public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {20     System.out.println("-----------------后置通知-----------------");21   }22 23 }

环绕通知

 1 package com.zhangguo.Spring041.aop05; 2  3 import org.aopalliance.intercept.MethodInterceptor; 4 import org.aopalliance.intercept.MethodInvocation; 5  6 /** 7  * 环绕通知 8  * 方法拦截器 9  *10 */11 public class SurroundAdvice implements MethodInterceptor {12 13   public Object invoke(MethodInvocation i) throws Throwable {14     //前置横切逻辑15     System.out.println("方法" + i.getMethod() + " 被调用在对象" + i.getThis() + "上,参数 " + i.getArguments());16     //方法调用17     Object ret = i.proceed();18     //后置横切逻辑19     System.out.println("返回值:"+ ret);20     return ret;21   }22 }

5.3、创建代理工厂、设置被代理对象、添加通知。

 1 package com.zhangguo.Spring041.aop05; 2  3 import org.springframework.aop.framework.ProxyFactory; 4  5 public class Test { 6  7   @org.junit.Test 8   public void test01() 9   {10     //实例化Spring代理工厂11     ProxyFactory factory=new ProxyFactory();12     //设置被代理的对象13     factory.setTarget(new Math());14     //添加通知,横切逻辑15     factory.addAdvice(new BeforeAdvice());16     factory.addAdvice(new AfterAdvice());17     factory.addAdvice(new SurroundAdvice());18     //从代理工厂中获得代理对象19     IMath math=(IMath) factory.getProxy();20     int n1=100,n2=5;21     math.add(n1, n2);22     math.sub(n1, n2);23     math.mut(n1, n2);24     math.div(n1, n2);25   }26   @org.junit.Test27   public void test02()28   {29     //message.message();30   }31 }

运行结果:

5.4、封装代理创建逻辑

 在上面的示例中如果要代理不同的对象需要反复创建ProxyFactory对象,代码会冗余。同样以实现方法耗时为示例代码如下:

5.4.1、创建一个环绕通知:

 1 package com.zhangguo.Spring041.aop05; 2  3 import java.util.Random; 4  5 import org.aopalliance.intercept.MethodInterceptor; 6 import org.aopalliance.intercept.MethodInvocation; 7  8 /** 9  * 用于完成计算方法执行时长的环绕通知10 */11 public class TimeSpanAdvice implements MethodInterceptor {12 13   public Object invoke(MethodInvocation invocation) throws Throwable {14     // 被织入的横切内容,开始时间 before15     long start = System.currentTimeMillis();16     lazy();17     18     //方法调用19     Object result = invocation.proceed();20     21     // 被织入的横切内容,结束时间22     Long span = System.currentTimeMillis() - start;23     System.out.println("共用时:" + span);24     25     return result;26   }27 28   // 模拟延时29   public void lazy() {30     try {31       int n = (int) new Random().nextInt(500);32       Thread.sleep(n);33     } catch (InterruptedException e) {34       e.printStackTrace();35     }36   }37 }

 5.4.2、封装动态代理类

 1 package com.zhangguo.Spring041.aop05; 2  3 import org.springframework.aop.framework.ProxyFactory; 4  5 /** 6  * 动态代理类 7  * 8 */ 9 public abstract class DynamicProxy {10   /**11    * 获得代理对象12    * @param object 被代理的对象13    * @return 代理对象14   */15   public static Object getProxy(Object object){16     //实例化Spring代理工厂17     ProxyFactory factory=new ProxyFactory();18     //设置被代理的对象19     factory.setTarget(object);20     //添加通知,横切逻辑21     factory.addAdvice(new TimeSpanAdvice());22     return factory.getProxy();23   }24 }

5.4.3、测试运行

 1 package com.zhangguo.Spring041.aop05; 2  3 import org.springframework.aop.framework.ProxyFactory; 4  5 public class Test { 6  7   @org.junit.Test 8   public void test01() 9   {10     //从代理工厂中获得代理对象11     IMath math=(IMath) DynamicProxy.getProxy(new Math());12     int n1=100,n2=5;13     math.add(n1, n2);14     math.sub(n1, n2);15     math.mut(n1, n2);16     math.div(n1, n2);17   }18   @org.junit.Test19   public void test02()20   {21     IMessage message=(IMessage) DynamicProxy.getProxy(new Message());22     message.message();23   }24 }

运行结果:

6、使用IOC配置的方式实现AOP

1、引入Spring IOC的核心jar包,方法与前面相同。

2、创建IOC的配置文件beans.

 1 <??> 2 <beans ="http://www.springframework.org/schema/beans" 3   ="http://www.w3.org/2001/ ="http://www.springframework.org/schema/p" 4   xsi:schemaLocation="http://www.springframework.org/schema/beans 5     http://www.springframework.org/schema/beans/spring-beans.xsd"> 6   <!-- 被代理的目标对象 --> 7   <bean id="target" class="com.zhangguo.Spring041.aop06.Math"></bean> 8   <!--通知、横切逻辑--> 9   <bean id="advice" class="com.zhangguo.Spring041.aop06.AfterAdvice"></bean>10   <!--代理对象 -->11   <!--interceptorNames 通知数组 -->12   <!--p:target-ref 被代理的对象-->13   <!--p:proxyTargetClass 被代理对象是否为一个类,如果是则使用cglib,否则使用jdk动态代理 -->14   <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean"15     p:interceptorNames="advice"16     p:target-ref="target"17     p:proxyTargetClass="true"></bean>18 </beans>

 

3、获得代理类的实例并测试运行

 1 package com.zhangguo.Spring041.aop06; 2  3 import org.springframework.context.ApplicationContext; 4 import org.springframework.context.support.ClassPath 5  6 public class Test { 7  8   @org.junit.Test 9   public void test01()10   {11     //容器12     ApplicationContext ctx=new ClassPath);13     //从代理工厂中获得代理对象14     IMath math=(IMath)ctx.getBean("proxy");15     int n1=100,n2=5;16     math.add(n1, n2);17     math.sub(n1, n2);18     math.mut(n1, n2);19     math.div(n1, n2);20   }21 }