一、为什么需要代理模式
假设需实现一个计算的类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 }
原标题:AOP、静态代理、JDK动态代理、CGLIB动态代理、Spring实现AOP、IOC+AOP
关键词:Spring