AOP实现原理详解[通俗易懂]

AOP实现原理详解[通俗易懂]转载地址:https://my.oschina.net/elain/blog/382494一、什么是AOPAOP(Aspect-OrientedProgramming,面向切面编程),可以说是OOP(Object-OrientedPrograming,面向对象编程)的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需要为分散的对象引入…

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全家桶1年46,售后保障稳定



转载地址:https://my.oschina.net/elain/blog/382494

一、什么是 AOP

AOP(Aspect-OrientedProgramming,面向切面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为(日志、安全、事务)的时候,OOP则显得无能为力。也就是说,OOP允许你定义从上到下的关系,但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中,而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码,如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切(cross-cutting)代码,在OOP设计中,它导致了大量代码的重复,模块间的藕合度高,而不利于各个模块的重用。

 

而AOP技术则恰恰相反,它利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其名为“Aspect”,即切面。所谓“切面”,简单地说,就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系,如果说“对象”是一个空心的圆柱体,其中封装的是对象的属性和行为;那么面向方面编程的方法,就仿佛一把利刃,将这些空心圆柱体剖开,以获得其内部的消息。而剖开的切面,也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原,不留痕迹。

 

使用“横切”技术,AOP把软件系统分为两个部分:核心业务逻辑组件和横切关注点。横切关注点模块化为特殊的类,这些类被称为“切面”,好处:1.横切关注点都集中于一块,不会出现大量重复代码;2.核心模块只关注核心功能的代码,模块间藕合度降低。

二、AOP 的实现原理

三、AOP相关概念

连接点(Joinpoint):在程序执行过程中某个特定的点,比如某方法调用的时候或者处理异常的时候。在Spring AOP中,一个连接点总是表示一个方法的执行。通俗的说就是加入切点的那个点

通知(Advice):在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知(通知的类型将在后面部分进行讨论)。许多AOP框架(包括Spring)都是以拦截器做通知模型,并维护一个以连接点为中心的拦截器链。

切入点(Pointcut):匹配连接点的断言。通知和一个切入点表达式关联,并在满足这个切入点的连接点上运行(例如,当执行某个特定名称的方法时)。切入点表达式如何和连接点匹配是AOP的核心:Spring缺省使用AspectJ切入点语法。

引入(Introduction):用来给一个类型声明额外的方法或属性(也被称为连接类型声明(inter-type declaration))。Spring允许引入新的接口(以及一个对应的实现)到任何被代理的对象。例如,你可以使用引入来使一个bean实现IsModified接口,以便简化缓存机制。

织入(Weaving):将切面应用到目标对象来创建新的代理对象的过程。这些可以在编译时(例如使用AspectJ编译器),类加载时和运行时完成。Spring和其他纯Java AOP框架一样,在运行时完成织入。

增强(Advice):是织入到目标类连接点上的一段程序代码。Spring使用增强类定义横切逻辑,同时由于Spring只支持方法连接点,增强还包括了在方法上的哪一点加入横切代码的方位信息,所以增强既包括横切逻辑、还包含部分连接点的信息。

引介(Introduction):是一种特殊的增强,为类添加一些属性和方法。

切面(Advisor):代表一般切面,包含了横切代码和连接点信息,本身是一个简单的切面,横切的连接点是目标类的所有方法。3种类型:一般切面(advisor)、切点切面(PointcutAdvisor)、引介切面(IntroductionAdvisor)。


四、Spring中AOP的实现

第一种是基于xml配置文件方式的实现,

第二种是基于注解方式的实现。

首先我们来看一下业务逻辑service层:

  1. <span style=‘font-family: “Microsoft YaHei”;’>/**  
  2.  * RegisterService的实现类  
  3.  * @author 曹胜欢 */    
  4. public class RegisterServiceImpl implements RegisterService {    
  5.     private  RegisterDao registerDao;    
  6.     public RegisterServiceImpl() {}    
  7.     /** 带参数的构造方法 */    
  8.     public RegisterServiceImpl(RegisterDao  registerDao){    
  9.         this.registerDao =registerDao;    
  10.     }    
  11.     public void save(String loginname, String password) {    
  12.         registerDao.save(loginname, password);    
  13.         throw new RuntimeException(“故意抛出一个异常。。。。”);    
  14.     }    
  15.       /** set方法 */    
  16.     public void setRegisterDao(RegisterDao registerDao) {    
  17.         this.registerDao = registerDao;    
  18. }}</span>  
/** * RegisterService的实现类 * @author 曹胜欢 */ public class RegisterServiceImpl implements RegisterService { private RegisterDao registerDao; public RegisterServiceImpl() {} /** 带参数的构造方法 */ public RegisterServiceImpl(RegisterDao registerDao){ this.registerDao =registerDao; } public void save(String loginname, String password) { registerDao.save(loginname, password); throw new RuntimeException("故意抛出一个异常。。。。"); } /** set方法 */ public void setRegisterDao(RegisterDao registerDao) { this.registerDao = registerDao; }}

Jetbrains全家桶1年46,售后保障稳定

对于业务系统来说,RegisterServiceImpl类就是目标实现类,它的业务方法,如save()方法的前后或代码会出现异常的地方都是AOP的连接点。

 

下面是日志服务类的代码:

  1. <span style=‘font-family: “Microsoft YaHei”;’>/**  
  2.  * 日志切面类  
  3.  * @author 曹胜欢  
  4.  */    
  5. public class LogAspect {    
  6.     //任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型     
  7.     public void before(JoinPoint call) {    
  8.         //获取目标对象对应的类名    
  9.         String className = call.getTarget().getClass().getName();    
  10.         //获取目标对象上正在执行的方法名    
  11.         String methodName = call.getSignature().getName();    
  12.         System.out.println(“前置通知:” + className + “类的” + methodName + “方法开始了”);    
  13.     }    
  14.     public void afterReturn() {    
  15.         System.out.println(“后置通知:方法正常结束了”);    
  16.     }    
  17.     public void after(){    
  18.         System.out.println(“最终通知:不管方法有没有正常执行完成,一定会返回的”);    
  19.     }    
  20.     public void afterThrowing() {    
  21.         System.out.println(“异常抛出后通知:方法执行时出异常了”);    
  22.     }    
  23.     //用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型    
  24.     public Object doAround(ProceedingJoinPoint call) throws Throwable {    
  25.         Object result = null;    
  26.         this.before(call);//相当于前置通知    
  27.         try {    
  28.             result = call.proceed();    
  29.             this.afterReturn(); //相当于后置通知    
  30.         } catch (Throwable e) {    
  31.             this.afterThrowing();  //相当于异常抛出后通知    
  32.             throw e;    
  33.         }finally{    
  34.             this.after();  //相当于最终通知    
  35.         }    
  36.         return result;    
  37.     }    
  38. }</span>  
/** * 日志切面类 * @author 曹胜欢 */ public class LogAspect { //任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型 public void before(JoinPoint call) { //获取目标对象对应的类名 String className = call.getTarget().getClass().getName(); //获取目标对象上正在执行的方法名 String methodName = call.getSignature().getName(); System.out.println("前置通知:" + className + "类的" + methodName + "方法开始了"); } public void afterReturn() { System.out.println("后置通知:方法正常结束了"); } public void after(){ System.out.println("最终通知:不管方法有没有正常执行完成,一定会返回的"); } public void afterThrowing() { System.out.println("异常抛出后通知:方法执行时出异常了"); } //用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型 public Object doAround(ProceedingJoinPoint call) throws Throwable { Object result = null; this.before(call);//相当于前置通知 try { result = call.proceed(); this.afterReturn(); //相当于后置通知 } catch (Throwable e) { this.afterThrowing(); //相当于异常抛出后通知 throw e; }finally{ this.after(); //相当于最终通知 } return result; } }


这个类属于业务服务类,如果用AOP的术语来说,它就是一个切面类,它定义了许多通知。Before()、afterReturn()、after()和afterThrowing()这些方法都是通知。

下面我们就来看具体配置,首先来看一下:

<1>.基于xml配置文件的AOP实现:这种方式在实现AOP时,有4个步骤。

  1. <span style=‘font-family: “Microsoft YaHei”;’><?xml version=“1.0” encoding=“UTF-8”?>    
  2. <beans xmlns=“http://www.springframework.org/schema/beans”    
  3.         xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”    
  4.         xmlns:aop=“http://www.springframework.org/schema/aop”    
  5.         xsi:schemaLocation=”    
  6.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd    
  7.             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>    
  8.     <bean id=“registerDaoImpl” class=“com.zxf.dao.RegisterDaoImpl”/>    
  9.     <bean id=“registerService” class=“com.zxf.service.RegisterServiceImpl”>    
  10.         <property name=” registerDaoImpl “ ref=” RegisterDaoImpl “/>    
  11.     </bean>    
  12.     <!– 日志切面类 –>    
  13.     <bean id=“logAspectBean” class=“com.zxf.aspect.LogAspect”/>    
  14.     <!– 第1步: AOP的配置 –>    
  15.     <aop:config>    
  16.         <!– 第2步:配置一个切面 –>    
  17.         <aop:aspect id=“logAspect” ref=“logAspectBean”>    
  18.             <!– 第3步:定义切入点,指定切入点表达式 –>    
  19.             <aop:pointcut id=“allMethod”     
  20.                 expression=“execution(* com.zxf.service.*.*(..))”/>     
  21.             <!– 第4步:应用前置通知 –>    
  22.             <aop:before method=“before” pointcut-ref=“allMethod” />    
  23.             <!– 第4步:应用后置通知 –>    
  24.             <aop:after-returning method=“afterReturn” pointcut-ref=“allMethod”/>    
  25.             <!– 第4步:应用最终通知 –>    
  26.             <aop:after method=“after” pointcut-ref=“allMethod”/>    
  27.             <!– 第4步:应用抛出异常后通知 –>    
  28.             <aop:after-throwing method=“afterThrowing” pointcut-ref=“allMethod”/>    
  29.             <!– 第4步:应用环绕通知 –>    
  30.             <!–    
  31.             <aop:around method=“doAround” pointcut-ref=“allMethod” />   
  32.              –>    
  33.         </aop:aspect>    
  34.     </aop:config>    
  35. </beans></span>  
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd> <bean id="registerDaoImpl" class="com.zxf.dao.RegisterDaoImpl"/> <bean id="registerService" class="com.zxf.service.RegisterServiceImpl"> <property name=" registerDaoImpl " ref=" RegisterDaoImpl "/> </bean> <!-- 日志切面类 --> <bean id="logAspectBean" class="com.zxf.aspect.LogAspect"/> <!-- 第1步: AOP的配置 --> <aop:config> <!-- 第2步:配置一个切面 --> <aop:aspect id="logAspect" ref="logAspectBean"> <!-- 第3步:定义切入点,指定切入点表达式 --> <aop:pointcut id="allMethod" expression="execution(* com.zxf.service.*.*(..))"/> <!-- 第4步:应用前置通知 --> <aop:before method="before" pointcut-ref="allMethod" /> <!-- 第4步:应用后置通知 --> <aop:after-returning method="afterReturn" pointcut-ref="allMethod"/> <!-- 第4步:应用最终通知 --> <aop:after method="after" pointcut-ref="allMethod"/> <!-- 第4步:应用抛出异常后通知 --> <aop:after-throwing method="afterThrowing" pointcut-ref="allMethod"/> <!-- 第4步:应用环绕通知 --> <!-- <aop:around method="doAround" pointcut-ref="allMethod" /> --> </aop:aspect> </aop:config> </beans>


上述配置针对切入点应用了前置、后置、最终,以及抛出异常后通知。这样在测试执行RegisterServiceImpl类的save()方法时,控制台会有如下结果输出:

 

前置通知:com.zxf.service.RegisterServiceImpl类的save方法开始了。

针对MySQL的RegisterDao实现中的save()方法。

后置通知:方法正常结束了。

最终通知:不管方法有没有正常执行完成,一定会返回的。

下面我们在来看一下第二种配置方式:

<2>基于注解的AOP的实现

 

     首先创建一个用来作为切面的类LogAnnotationAspect,同时把这个类配置在spring的配置文件中。

        在spring2.0以后引入了JDK5.0的注解Annotation的支持,提供了对AspectJ基于注解的切面的支持,从而 更进一步地简化AOP的配置。具体的步骤有两步。

 

Spring的配置文件是如下的配置:


  1. <span style=‘font-family: “Microsoft YaHei”;’><?xml version=“1.0” encoding=“UTF-8”?>    
  2. <beans xmlns=“http://www.springframework.org/schema/beans”    
  3.         xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”    
  4.         xmlns:aop=“http://www.springframework.org/schema/aop”    
  5.         xsi:schemaLocation=”    
  6.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd    
  7.             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>    
  8.     <bean id=“registerDao” class=“com.zxf.dao.RegisterDaoImpl”/>    
  9.     <bean id=“registerService” class=“com.zxf.service.RegisterServiceImpl”>    
  10.         <property name=“registerDao” ref=“registerDao”/>    
  11.     </bean>    
  12.     <!– 把切面类交由Spring容器来管理 –>    
  13.     <bean id=“logAspectBean” class=“com.zxf.aspect.LogAnnotationAspect”/>    
  14.     <!– 启用spring对AspectJ注解的支持 –>    
  15.     <aop:aspectj-autoproxy/>    
  16. </beans></span>  
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd> <bean id="registerDao" class="com.zxf.dao.RegisterDaoImpl"/> <bean id="registerService" class="com.zxf.service.RegisterServiceImpl"> <property name="registerDao" ref="registerDao"/> </bean> <!-- 把切面类交由Spring容器来管理 --> <bean id="logAspectBean" class="com.zxf.aspect.LogAnnotationAspect"/> <!-- 启用spring对AspectJ注解的支持 --> <aop:aspectj-autoproxy/> </beans>

这是那个切面的类LogAnnotationAspect

  1. <span style=‘font-family: “Microsoft YaHei”;’>/**  
  2.  * 日志切面类  
  3.  */    
  4. @Aspect  //定义切面类    
  5. public class LogAnnotationAspect {    
  6.     @SuppressWarnings(“unused”)    
  7.     //定义切入点,提供一个方法,这个方法的名字就是改切入点的id    
  8.     @Pointcut(“execution(* com.zxf.service.*.*(..))”)    
  9.     private void allMethod(){}    
  10.     //针对指定的切入点表达式选择的切入点应用前置通知    
  11.     @Before(“execution(* com. zxf.service.*.*(..))”)    
  12.     public void before(JoinPoint call) {    
  13.         String className = call.getTarget().getClass().getName();    
  14.         String methodName = call.getSignature().getName();    
  15.         System.out.println(“【注解-前置通知】:” + className + “类的”     
  16.                 + methodName + “方法开始了”);    
  17.     }    
  18.     //访问命名切入点来应用后置通知    
  19.     @AfterReturning(“allMethod()”)    
  20.     public void afterReturn() {    
  21.         System.out.println(“【注解-后置通知】:方法正常结束了”);    
  22.     }    
  23.     //应用最终通知    
  24.     @After(“allMethod()”)    
  25.     public void after(){    
  26.         System.out.println(“【注解-最终通知】:不管方法有没有正常执行完成,”     
  27.                 + “一定会返回的”);    
  28.     }    
  29.     //应用异常抛出后通知    
  30.     @AfterThrowing(“allMethod()”)    
  31.     public void afterThrowing() {    
  32.         System.out.println(“【注解-异常抛出后通知】:方法执行时出异常了”);    
  33.     }    
  34.     //应用周围通知    
  35.     //@Around(“allMethod()”)    
  36.     public Object doAround(ProceedingJoinPoint call) throws Throwable{    
  37.         Object result = null;    
  38.         this.before(call);//相当于前置通知    
  39.         try {    
  40.             result = call.proceed();    
  41.             this.afterReturn(); //相当于后置通知    
  42.         } catch (Throwable e) {    
  43.             this.afterThrowing();  //相当于异常抛出后通知    
  44.             throw e;    
  45.         }finally{    
  46.             this.after();  //相当于最终通知    
  47.         }    
  48.         return result;    
  49.     }    
  50. }</span>  
/** * 日志切面类 */ @Aspect //定义切面类 public class LogAnnotationAspect { @SuppressWarnings("unused") //定义切入点,提供一个方法,这个方法的名字就是改切入点的id @Pointcut("execution(* com.zxf.service.*.*(..))") private void allMethod(){} //针对指定的切入点表达式选择的切入点应用前置通知 @Before("execution(* com. zxf.service.*.*(..))") public void before(JoinPoint call) { String className = call.getTarget().getClass().getName(); String methodName = call.getSignature().getName(); System.out.println("【注解-前置通知】:" + className + "类的" + methodName + "方法开始了"); } //访问命名切入点来应用后置通知 @AfterReturning("allMethod()") public void afterReturn() { System.out.println("【注解-后置通知】:方法正常结束了"); } //应用最终通知 @After("allMethod()") public void after(){ System.out.println("【注解-最终通知】:不管方法有没有正常执行完成," + "一定会返回的"); } //应用异常抛出后通知 @AfterThrowing("allMethod()") public void afterThrowing() { System.out.println("【注解-异常抛出后通知】:方法执行时出异常了"); } //应用周围通知 //@Around("allMethod()") public Object doAround(ProceedingJoinPoint call) throws Throwable{ Object result = null; this.before(call);//相当于前置通知 try { result = call.proceed(); this.afterReturn(); //相当于后置通知 } catch (Throwable e) { this.afterThrowing(); //相当于异常抛出后通知 throw e; }finally{ this.after(); //相当于最终通知 } return result; } }

五:Spring中AOP的两种代理方式(Java动态代理和CGLIB代理)

Spring AOP使用动态代理技术在运行期织入增强代码。使用两种代理机制:基于JDK的动态代理(JDK本身只提供接口的代理);基于CGlib的动态代理。

1. JDK的动态代理主要涉及java.lang.reflect包中的两个类:Proxy和InvocationHandler。其中InvocationHandler只是一个接口,可以通过实现该接口定义横切逻辑,并通过反射机制调用目标类的代码,动态的将横切逻辑与业务逻辑织在一起。而Proxy利用InvocationHandler动态创建一个符合某一接口的实例,生成目标类的代理对象。(只能为接口创建代理实例)

  1. <span style=‘font-family: “Microsoft YaHei”;’>//需要被代理的接口  
  2. public interface ForumService {  
  3.     public void removeTopic(int topicId);  
  4.     public void removeForum(int forumId);  
  5. }  
  6.   
  7. //被代理接口的实现类,包含核心的业务逻辑  
  8. public class ForumServiceImpl implements ForumService{  
  9.     @Override  
  10.     public void removeTopic(int topicId) {  
  11.         System.out.println(“模拟删除Topic记录:”+ topicId);  
  12.         try {  
  13.             Thread.currentThread().sleep(20);  
  14.         } catch (InterruptedException e) {  
  15.             e.printStackTrace();  
  16.         }  
  17.     }  
  18.   
  19.     @Override  
  20.     public void removeForum(int forumId) {  
  21.         System.out.println(“模拟删除Forum记录:”+ forumId);  
  22.         try {  
  23.             Thread.currentThread().sleep(40);  
  24.         } catch (InterruptedException e) {  
  25.             e.printStackTrace();  
  26.         }  
  27.     }  
  28.       
  29. }  
  30. //性能监控核心代码生成  
  31. public class MethodPerformance {  
  32.     private long begin;  
  33.     private long end;  
  34.     private String serviceMethod;  
  35.       
  36.     public MethodPerformance(String serviceMethod) {  
  37.         this.serviceMethod = serviceMethod;  
  38.         this.begin = System.currentTimeMillis();  
  39.     };  
  40.       
  41.     public void printPerformance(){  
  42.         this.end = System.currentTimeMillis();  
  43.         long elapse = this.end – this.begin;  
  44.         System.out.println(serviceMethod + ” cost “ + elapse +“ms”);  
  45.     }  
  46. }  
  47.   
  48. //线程安全的横切逻辑  
  49. public class PerformanceMonitor {  
  50.     private static ThreadLocal<MethodPerformance> tl= new ThreadLocal<MethodPerformance>();  
  51.       
  52.     public static void begin(String method){  
  53.         System.out.println(“begin monitor”);  
  54.         MethodPerformance mp = new MethodPerformance(method);  
  55.         tl.set(mp);  
  56.     }  
  57.       
  58.     public static void end(){  
  59.         System.out.println(“end monitor”);  
  60.         MethodPerformance mp = tl.get();  
  61.         mp.printPerformance();  
  62.     }  
  63. }  
  64.   
  65. //AOP横切模块  
  66. public class PerfermanceHandler implements InvocationHandler{  
  67.     private Object target;  
  68.       
  69.     public PerfermanceHandler(Object target) {  
  70.         this.target = target;  
  71.     }  
  72.   
  73.     @Override  
  74.     public Object invoke(Object proxy, Method method, Object[] args)  
  75.             throws Throwable {  
  76.         PerformanceMonitor.begin(target.getClass().getName()+“.”+method.getName());  
  77.         Object object = method.invoke(target, args);  
  78.         PerformanceMonitor.end();  
  79.         return object;  
  80.     }  
  81.   
  82. }  
  83. //测试  
  84. public class TestForumService {  
  85.     public static void main(String[] args) {  
  86.         ForumService target = new ForumServiceImpl();  
  87.         //将目标业务类与横切代码编织到一起  
  88.         PerfermanceHandler handler = new PerfermanceHandler(target);  
  89.         //创建代理实例  
  90.         ForumService proxy = (ForumService) Proxy.newProxyInstance(target.getClass().getClassLoader(),   
  91.                                                     target.getClass().getInterfaces(), handler);  
  92.         proxy.removeForum(10);  
  93.         proxy.removeTopic(1012);  
  94.           
  95.     }  
  96. }</span>  
//需要被代理的接口 public interface ForumService { public void removeTopic(int topicId); public void removeForum(int forumId); } //被代理接口的实现类,包含核心的业务逻辑 public class ForumServiceImpl implements ForumService{ @Override public void removeTopic(int topicId) { System.out.println("模拟删除Topic记录:"+ topicId); try { Thread.currentThread().sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } } @Override public void removeForum(int forumId) { System.out.println("模拟删除Forum记录:"+ forumId); try { Thread.currentThread().sleep(40); } catch (InterruptedException e) { e.printStackTrace(); } } } //性能监控核心代码生成 public class MethodPerformance { private long begin; private long end; private String serviceMethod; public MethodPerformance(String serviceMethod) { this.serviceMethod = serviceMethod; this.begin = System.currentTimeMillis(); }; public void printPerformance(){ this.end = System.currentTimeMillis(); long elapse = this.end - this.begin; System.out.println(serviceMethod + " cost " + elapse +"ms"); } } //线程安全的横切逻辑 public class PerformanceMonitor { private static ThreadLocal<MethodPerformance> tl= new ThreadLocal<MethodPerformance>(); public static void begin(String method){ System.out.println("begin monitor"); MethodPerformance mp = new MethodPerformance(method); tl.set(mp); } public static void end(){ System.out.println("end monitor"); MethodPerformance mp = tl.get(); mp.printPerformance(); } } //AOP横切模块 public class PerfermanceHandler implements InvocationHandler{ private Object target; public PerfermanceHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { PerformanceMonitor.begin(target.getClass().getName()+"."+method.getName()); Object object = method.invoke(target, args); PerformanceMonitor.end(); return object; } } //测试 public class TestForumService { public static void main(String[] args) { ForumService target = new ForumServiceImpl(); //将目标业务类与横切代码编织到一起 PerfermanceHandler handler = new PerfermanceHandler(target); //创建代理实例 ForumService proxy = (ForumService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler); proxy.removeForum(10); proxy.removeTopic(1012); } }

begin monitor

模拟删除Forum记录:10

end monitor

com.baobaotao.proxy.ForumServiceImpl.removeForum cost 42ms

begin monitor

模拟删除Topic记录:1012

end monitor

com.baobaotao.proxy.ForumServiceImpl.removeTopic cost 21ms


2.CGLib采用底层的字节码技术,为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类的调用方法,并顺势织入横切逻辑。

  1. <span style=‘font-family: “Microsoft YaHei”;’>package com.baobaotao.proxy;  
  2.   
  3. import java.lang.reflect.Method;  
  4.   
  5. import org.springframework.cglib.proxy.Enhancer;  
  6. import org.springframework.cglib.proxy.MethodInterceptor;  
  7. import org.springframework.cglib.proxy.MethodProxy;  
  8.   
  9. public class CglibProxy implements MethodInterceptor{  
  10.   
  11.     private Enhancer enhancer = new Enhancer();  
  12.       
  13.     public Object getProxy(Class clazz){  
  14.         enhancer.setSuperclass(clazz);//设置创建子类的类  
  15.         enhancer.setCallback(this);  
  16.         return enhancer.create();//通过字节码技术动态创建子类实例  
  17.     }  
  18.       
  19.     @Override  
  20.     public Object intercept(Object target, Method method, Object[] args,  
  21.             MethodProxy proxy) throws Throwable {  
  22.         PerformanceMonitor.begin(target.getClass().getName()+“.”+method.getName());  
  23.         Object object = proxy.invokeSuper(target, args);  
  24.         PerformanceMonitor.end();  
  25.         return object;  
  26.     }  
  27. }  
  28. package com.baobaotao.proxy;  
  29.   
  30. import java.lang.reflect.Proxy;  
  31. //测试  
  32. public class TestForumService {  
  33.     public static void main(String[] args) {      
  34.         CglibProxy cglibProxy = new CglibProxy();  
  35.         ForumServiceImpl service = (ForumServiceImpl) cglibProxy.getProxy(ForumServiceImpl.class);  
  36.         service.removeForum(10);  
  37.         service.removeTopic(1012);  
  38.     }  
  39. }</span>  
package com.baobaotao.proxy; import java.lang.reflect.Method; import org.springframework.cglib.proxy.Enhancer; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy; public class CglibProxy implements MethodInterceptor{ private Enhancer enhancer = new Enhancer(); public Object getProxy(Class clazz){ enhancer.setSuperclass(clazz);//设置创建子类的类 enhancer.setCallback(this); return enhancer.create();//通过字节码技术动态创建子类实例 } @Override public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable { PerformanceMonitor.begin(target.getClass().getName()+"."+method.getName()); Object object = proxy.invokeSuper(target, args); PerformanceMonitor.end(); return object; } } package com.baobaotao.proxy; import java.lang.reflect.Proxy; //测试 public class TestForumService { public static void main(String[] args) { CglibProxy cglibProxy = new CglibProxy(); ForumServiceImpl service = (ForumServiceImpl) cglibProxy.getProxy(ForumServiceImpl.class); service.removeForum(10); service.removeTopic(1012); } }

begin monitor

模拟删除Forum记录:10

end monitor

com.baobaotao.proxy.ForumServiceImpl

EnhancerByCGLIB EnhancerByCGLIB

626e31f5(子类).removeForum cost 67ms

begin monitor

模拟删除Topic记录:1012

end monitor

com.baobaotao.proxy.ForumServiceImpl

EnhancerByCGLIB EnhancerByCGLIB

626e31f5.removeTopic cost 20ms


Spring增强类

Spring支持5种增强类型:

1)前置增强:org.springframework.aop.BeforeAdvice代表前置增强,spring只支持方法级的增强,目前可用MethodBeforeAdvice。

  1. <span style=‘font-family: “Microsoft YaHei”;’>public interface Waiter {  
  2.     public void greetTo(String name);  
  3.     public void serveTo(String name);  
  4. }  
  5. public class NaiveWaiter implements Waiter {  
  6.   
  7.     @Override  
  8.     public void greetTo(String name) {  
  9.         System.out.println(“greetTo “+ name +“…”);  
  10.     }  
  11.   
  12.     @Override  
  13.     public void serveTo(String name) {  
  14.         System.out.println(“serveTo “+ name +“…”);          
  15.     }  
  16. }  
  17. import java.lang.reflect.Method;  
  18. import org.springframework.aop.MethodBeforeAdvice;  
  19.   
  20. public class GreeteBeforeAdvice implements MethodBeforeAdvice{  
  21.   
  22.     @Override  
  23.     public void before(Method arg0, Object[] arg1, Object arg2)  
  24.             throws Throwable {  
  25.         String client = (String) arg1[0];  
  26.         System.out.println(“How are you!”+client+“.”);  
  27.     }  
  28. }  
  29. import org.springframework.aop.BeforeAdvice;  
  30. import org.springframework.aop.framework.ProxyFactory;  
  31.   
  32. public class TestBeforeAdvice {  
  33.   
  34.     public static void main(String[] args) {  
  35.         Waiter target = new NaiveWaiter();  
  36.         BeforeAdvice advice = new GreeteBeforeAdvice();  
  37.         //Spring提供的代理工厂  
  38.         ProxyFactory pf = new ProxyFactory();//使用Cglib2AOPProx 即CGlib代理技术创建代理  
  39. //      pf.setInterfaces(target.getClass().getInterfaces());//使用JdkDynamicAopProxy  
  40.         //设置代理目标  
  41.         pf.setTarget(target);  
  42.         //添加增强处理  
  43.         pf.addAdvice(advice);  
  44.         //生成代理实例  
  45.         Waiter waiter = (Waiter) pf.getProxy();  
  46.         waiter.greetTo(“Tom”);  
  47.         waiter.serveTo(“Lucy”);  
  48.           
  49. //      ApplicationContext ctx = new ClassPathXmlApplicationContext(“beans.xml”);  
  50. //      Waiter waiter1 = (Waiter) ctx.getBean(“waiter”);  
  51. //      waiter1.greetTo(“John”);          
  52.     }  
  53. }  
  54. <bean id=“target” class=“com.baobaotao.advice.NaiveWaiter” />  
  55.     <bean id=“greeteAdvice” class=“com.baobaotao.advice.GreeteBeforeAdvice” />  
  56.     <bean id=“waiter” class=“org.springframework.aop.framework.ProxyFactoryBean”  
  57.         p:proxyInterfaces=“com.baobaotao.advice.Waiter” p:interceptorNames=“greeteAdvice”  
  58.         p:target-ref=“target” /></span>  
public interface Waiter { public void greetTo(String name); public void serveTo(String name); } public class NaiveWaiter implements Waiter { @Override public void greetTo(String name) { System.out.println("greetTo "+ name +"..."); } @Override public void serveTo(String name) { System.out.println("serveTo "+ name +"..."); } } import java.lang.reflect.Method; import org.springframework.aop.MethodBeforeAdvice; public class GreeteBeforeAdvice implements MethodBeforeAdvice{ @Override public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable { String client = (String) arg1[0]; System.out.println("How are you!"+client+"."); } } import org.springframework.aop.BeforeAdvice; import org.springframework.aop.framework.ProxyFactory; public class TestBeforeAdvice { public static void main(String[] args) { Waiter target = new NaiveWaiter(); BeforeAdvice advice = new GreeteBeforeAdvice(); //Spring提供的代理工厂 ProxyFactory pf = new ProxyFactory();//使用Cglib2AOPProx 即CGlib代理技术创建代理 // pf.setInterfaces(target.getClass().getInterfaces());//使用JdkDynamicAopProxy //设置代理目标 pf.setTarget(target); //添加增强处理 pf.addAdvice(advice); //生成代理实例 Waiter waiter = (Waiter) pf.getProxy(); waiter.greetTo("Tom"); waiter.serveTo("Lucy"); // ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); // Waiter waiter1 = (Waiter) ctx.getBean("waiter"); // waiter1.greetTo("John"); } } <bean id="target" class="com.baobaotao.advice.NaiveWaiter" /> <bean id="greeteAdvice" class="com.baobaotao.advice.GreeteBeforeAdvice" /> <bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean" p:proxyInterfaces="com.baobaotao.advice.Waiter" p:interceptorNames="greeteAdvice" p:target-ref="target" />


2)后置增强:org.springframework.aop.AfterReturningAdvice代表后置增强,在目标方法执行后实施增强。

  1. <span style=‘font-family: “Microsoft YaHei”;’>import java.lang.reflect.Method;  
  2. import org.springframework.aop.AfterReturningAdvice;  
  3. public class GreeteAfterAdvice implements AfterReturningAdvice{  
  4.     @Override  
  5.     public void afterReturning(Object arg0, Method arg1, Object[] arg2,  
  6.             Object arg3) throws Throwable {  
  7.         System.out.println(“Please enjoy yourself!”);  
  8.     }  
  9. }  
  10. <bean id=“waiter” class=“org.springframework.aop.framework.ProxyFactoryBean”  
  11.         p:proxyInterfaces=“com.baobaotao.advice.Waiter” p:interceptorNames=“greeteBefore,greeteAfter”  
  12.         p:target-ref=“target” /></span>  
import java.lang.reflect.Method; import org.springframework.aop.AfterReturningAdvice; public class GreeteAfterAdvice implements AfterReturningAdvice{ @Override public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable { System.out.println("Please enjoy yourself!"); } } <bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean" p:proxyInterfaces="com.baobaotao.advice.Waiter" p:interceptorNames="greeteBefore,greeteAfter" p:target-ref="target" />

3)环绕增强:org.aopalliance.intercept.MethodInterceptor代表环绕增强,在目标方法执行前后实施增强。

  1. <span style=‘font-family: “Microsoft YaHei”;’>import org.aopalliance.intercept.MethodInterceptor;  
  2. import org.aopalliance.intercept.MethodInvocation;  
  3.   
  4. public class GreeteInterceptor implements MethodInterceptor{  
  5.   
  6.     @Override  
  7.     public Object invoke(MethodInvocation inv) throws Throwable {  
  8.         Object[] args = inv.getArguments();  
  9.         String client = (String) args[0];  
  10.         System.out.println(“How are you!”+client+“.”);  
  11.         Object obj = inv.proceed();  
  12.         System.out.println(“Please enjoy yourself!”);  
  13.         return obj;  
  14.     }  
  15.   
  16. }</span>  
import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; public class GreeteInterceptor implements MethodInterceptor{ @Override public Object invoke(MethodInvocation inv) throws Throwable { Object[] args = inv.getArguments(); String client = (String) args[0]; System.out.println("How are you!"+client+"."); Object obj = inv.proceed(); System.out.println("Please enjoy yourself!"); return obj; } }

4)异常抛出增强:org.springframework.aop.ThrowsAdvice,在目标方法执行抛出异常后实施增强。方法名必须为afterThrowing,如参前三个可选,最后一个是Throwable或其子类。

  1. <span style=‘font-family: “Microsoft YaHei”;’>import java.lang.reflect.Method;  
  2. import org.springframework.aop.ThrowsAdvice;  
  3. public class TransactionManager implements ThrowsAdvice {  
  4.     public void afterThrowing(Method method, Object[] args, Object target,  
  5.             Exception ex) throws Throwable {  
  6.         System.out.println(“———–“);  
  7.         System.out.println(“method:” + method.getName());  
  8.         System.out.println(“抛出异常:” + ex.getMessage());  
  9.         System.out.println(“成功回滚事务。”);  
  10.     }  
  11. }</span>  
import java.lang.reflect.Method; import org.springframework.aop.ThrowsAdvice; public class TransactionManager implements ThrowsAdvice { public void afterThrowing(Method method, Object[] args, Object target, Exception ex) throws Throwable { System.out.println("-----------"); System.out.println("method:" + method.getName()); System.out.println("抛出异常:" + ex.getMessage()); System.out.println("成功回滚事务。"); } }

5)引介增强:org.springframework.aop.IntroductionInterceptor,表示目标类添加一些新的方法和属性,连接点是类级别,而不是方法级别。

  1. <span style=‘font-family: “Microsoft YaHei”;’>import org.aopalliance.intercept.MethodInvocation;  
  2. import org.springframework.aop.support.DelegatingIntroductionInterceptor;  
  3.   
  4. import com.baobaotao.proxy.PerformanceMonitor;  
  5.   
  6. public class ControllablePerformaceMonitor extends DelegatingIntroductionInterceptor implements Monitorable{  
  7.     private ThreadLocal<Boolean> MonitorStatusMap = new ThreadLocal<Boolean>();  
  8.     @Override  
  9.     public void setMonitorActive(boolean active) {  
  10.         MonitorStatusMap.set(active);  
  11.     }  
  12.     @Override  
  13.     public Object invoke(MethodInvocation mi) throws Throwable {  
  14.         Object obj = null;  
  15.         if (MonitorStatusMap.get() != null && MonitorStatusMap.get()) {  
  16.             PerformanceMonitor.begin(mi.getClass().getName() + “.”  
  17.                     + mi.getMethod().getName());  
  18.             obj = super.invoke(mi);  
  19.             PerformanceMonitor.end();  
  20.         } else {  
  21.             obj = super.invoke(mi);  
  22.         }  
  23.         return obj;  
  24.     }  
  25.   
  26. }  
  27. <bean id=“forumService” class=“org.springframework.aop.framework.ProxyFactoryBean”  
  28.         p:interfaces=“com.baobaotao.introduce.Monitorable” //引入引介增强要实现的接口  
  29.         p:target-ref=“forumServiceTarget”  
  30.         p:interceptorNames=“pmonitor”   
  31.         p:proxyTargetClass=“true” />//只能通过为目标类型类创建子类的方式生成增强的代理</span>  
import org.aopalliance.intercept.MethodInvocation; import org.springframework.aop.support.DelegatingIntroductionInterceptor; import com.baobaotao.proxy.PerformanceMonitor; public class ControllablePerformaceMonitor extends DelegatingIntroductionInterceptor implements Monitorable{ private ThreadLocal<Boolean> MonitorStatusMap = new ThreadLocal<Boolean>(); @Override public void setMonitorActive(boolean active) { MonitorStatusMap.set(active); } @Override public Object invoke(MethodInvocation mi) throws Throwable { Object obj = null; if (MonitorStatusMap.get() != null && MonitorStatusMap.get()) { PerformanceMonitor.begin(mi.getClass().getName() + "." + mi.getMethod().getName()); obj = super.invoke(mi); PerformanceMonitor.end(); } else { obj = super.invoke(mi); } return obj; } } <bean id="forumService" class="org.springframework.aop.framework.ProxyFactoryBean" p:interfaces="com.baobaotao.introduce.Monitorable" //引入引介增强要实现的接口 p:target-ref="forumServiceTarget" p:interceptorNames="pmonitor" p:proxyTargetClass="true" />//只能通过为目标类型类创建子类的方式生成增强的代理



AOP切面的配置方式

1)基于Schema的配置:在xml中描述切点、增强类型,切面类为pojo

2)基于AspectJ的配置:切点、增强类型使用注解进行描述

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/227295.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • ActiveMQ入门系列之应用:Springboot+ActiveMQ+JavaMail实现异步邮件发送「建议收藏」

    我们都买过火车票,买完后会有邮件提醒,有时候邮件并不是买完票立马就能收到邮件通知,这个就用到了异步邮件发送。这篇文章介绍了怎么实现异步邮件发送

  • java nio 详_java NIO 详解

    java nio 详_java NIO 详解JavaNIO(NewIO)是从Java1.4版本开始引入的一个新的IOAPI,可以替代标准的JavaIOAPI。本系列教程将有助于你学习和理解JavaNIO。JavaNIO提供了与标准IO不同的IO工作方式:ChannelsandBuffers(通道和缓冲区):标准的IO基于字节流和字符流进行操作的,而NIO是基于通道(Channel)和缓冲区(Buffer)进行操作,数据总…

  • python ==和is_python中issubset

    python ==和is_python中issubset前置知识点当我们创建一个对象时,我们要知道它内部干了些什么1.创建了一个随机id,开辟了一片内存地址2.自动声明了这个对象的类型type3.给这个对象赋值value小例子a=1pri

  • linux中quota信息查看,quota命令_Linux quota命令使用详解:显示磁盘已使用的空间与限制…

    quota命令用于显示用户或者工作组的磁盘配额信息。输出信息包括磁盘使用和配额限制。语法quota(选项)(参数)选项-g:列出群组的磁盘空间限制;-q:简明列表,只列出超过限制的部分;-u:列出用户的磁盘空间限制;-v:显示该用户或群组,在所有挂入系统的存储设备的空间限制;-V:显示版本信息。参数用户或者工作组:指定要显示的用户或者工作组。实例我们可以限制某一群组所能使用的最大磁盘配额,而且可以…

  • libzplay库

    libzplay目前,非开源,只可以在windows上应用;关于MP3文件播放:通常步骤是:获取MP3相关参数->解码->相关平台播放音频接口播放声音;可以播放解码播放MP3的库很多,如果VLC,ffplay,或者directshow,解码库一般可以用lame,播放播放库可以用SDL,或者Windows上的waveout,directsound等很多方法,这里例举

  • 银行家算法 C语言实现

    银行家算法 C语言实现C语言实现银行家算法这几天老师要求使用C语言实现银行家算法,数据可以自定义。想来想去还是照着书现成的数据来模拟一下。教材使用的是西安电子科大出版社的《计算机操作系统》汤小丹第四版。模拟数据使用的是P121页第4题的数据。听到老师布置题目的第一时间我还是有点懵,看了下书更懵了,这条条框框的判断条件怎么这么多。。沉下心来慢慢看,其实还是挺简单的算法。/*Author:Cnkizy…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号