Spring Aop配置使用示例及实现过程和原理介绍_鹿晗的晗的博客-程序员秘密

相信只要使用过Spring框架的，大家对于AOP都不陌生，尤其提起它就能立刻随口说出，一般用在日志处理、异常处理、权限验证等方面。今天通过例子了解了Spring Aop的配置使用（注意不是AspectJ的配置使用）及通过源码了解了Spring Aop大致的实现过程和原理。

一、相关概念

JointPoint

系统在运行之前，AOP的功能模块需要织入到OOP的功能模块中。要进行这种织入过程，需要知道在系统的哪些功能点上进行织入操作，这些将要在其上进行织入操作的系统功能点就称为JointPoint。如某方法调用的时候或者处理异常的时候，在Spring AOP中，一个连接点总是表示一个方法的执行。常见的几种类型的JoinPoint:

Ø 方法调用：当某个方法被调用的时候所处的程序执行点；

Ø 方法执行：该类型表示的是某个方法内部执行开始时的点，应该与方法调用相区分；

Ø 构造方法调用：程序执行过程中对某个对象调用其构造方法进行初始化时的点；

Ø 构造方法执行：它与构造方法调用关系如同方法调用与方法执行间的关系；

Ø 字段设置：对象的某个属性通过setter方法被设置或直接被设置的执行点；

Ø 字段获取：某个对象相应属性被访问的执行点；

Ø 异常处理执行：某些类型异常抛出后，对应的异常处理逻辑执行点；

Ø 类初始化：类中某些静态类型或静态块的初始化时的执行点。

Pointcut

Pointcut代表的是JoinPoint的表述方式，简单容易理解的说就是JoinPoint的集合。在将横切逻辑织入当前系统的过程中，虽然知道需要在哪些功能点上织入AOP的功能模块，但需要一种表达方法。Pointcut和一个切入点表达式关联，并在满足这个切入点的Joinpoint上运行。目前通常使用的Pointcut方式有以下几种：

Ø 直接指定Joinpoint所在的方法名称；

Ø 正则表达式，Spring的AOP支持该种方式；

Ø 使用特定的Pointcut表述语言，Spring 2.0后支持该方式。

Advice

Advice是单一横切关注点逻辑的载体，它代表将会织入到JoinPoint的横切逻辑。在切面的某个特定的连接点上执行的逻辑。根据它在Joinpoint位置执行时机的差异或完成功能的不同，可分为以下几种形式：

Ø Before Advice：在Joinpoint指定位置之前执行的Advice类型，可以采用它来做一些系统的初始化工作，如设置系统初始值，获取必要系统资源等。

Ø After Advice：在相应连接点之后执行的Advice类型，它还可以细分为以下三种：

² After Returning Advice：只有当前Joinpoint处执行流程正常完成后，它才会执行；

² After throwing Advice：在当前Joinpoint执行过程中抛出异常的情况下会执行；

² After Advice：该类型的Advice不管JoinPoint处执行流程是正常还是抛出异常都会执行。

Ø Around Advice：对附加其上的Joinpoint进行包裹，可以在joinpoint之前和之后都指定相应的逻辑，甚至中断或忽略joinpoint处原来程序流程的执行。

Aspect

它是对系统中横切关注点逻辑进行模块化封装的AOP概念实体，它可以包含多个Pointcut以及相关的Advice定义。

Weave织入器

经过织入过程后，以Aspect模块化的横切关注点才会集成到oop的现存系统中，而完成织入过程实体称为织入器。Spring中使用一组类来完成最终的织入操作，ProxyFactory类是Spring AOP最通用的织入器。

Target 目标对象

符合Pointcut所指定的条件，将在织入过程中被织入横切逻辑的对象，称之为目标对象。

单看上述的概念，可能会觉得有点眼花缭乱，其实通过一个简单的AOP的实例即可以帮助我们很快的了解其内部的机制。其实对于方法拦截有不同的实现方式，常用的即有直接采用Spring提供的各种Advice进行拦截，另一种则是采用MethodInterceptor方式进行拦截。

二、配置使用示例

Spring提供的Advice拦截方式

定义一个逻辑接口IBusinessLogic：

[java]view plaincopy
 package com.wow.asc.aop;  
   
 public interface IBusinessLogic {  
   
     public void foo();  
   
     public void bar() throws BusinessLogicException;  
       
     public long time();  
 }  

其中有一个BusinessLogicException异常，它用于后面对于ThrowsAdvice进行检验的实例，在此定义为：

[java]view plaincopy
 package com.wow.asc.aop;  
   
 public class BusinessLogicException extends Exception {  
   
 }  

对于该业务逻辑的实现BusinessLogic，如下所示：

[java]view plaincopy
 package com.wow.asc.aop;  
   
 public class BusinessLogic implements IBusinessLogic {  
     @Override  
     public void foo() {  
         System.out.println("Inside BusinessLogic.foo()");  
     }  
     @Override  
     public void bar() throws BusinessLogicException {  
         System.out.println("Inside BusinessLogic.bar()");  
         throw new BusinessLogicException();  
     }  
      /*  
      * 返回该方法执行的时间 
      */  
     @Override  
     public long time() {  
         System.out.println("Inside BusinessLogic.time()");  
         long startTime = System.currentTimeMillis();  
         for(int i = 0; i < 100000000; i++);  
         long endTime = System.currentTimeMillis();  
           
         return (endTime - startTime);  
     }  
 }  

在完成上述业务逻辑编码后，接下来将进行更多的横切插入点的设计，如在方法执行前或返回时、抛出异常时进行各种处理。对于Advice的写法如下所示：

[java]view plaincopy
 package com.wow.asc.aop;  
   
 import java.lang.reflect.Method;  
 import org.springframework.aop.MethodBeforeAdvice;  
 /* 
 * 表示一个在方法执行前进行拦截的一个Advice 
  */  
 public class TracingBeforeAdvice implements MethodBeforeAdvice {  
     @Override  
     public void before(Method method, Object[] args, Object target) throws Throwable {  
         System.out.println("execute before (by " + method.getDeclaringClass().getName() + "." + method.getName() + ")");  
     }  
 }  
   
 package com.wow.asc.aop;  
   
 import java.lang.reflect.Method;  
 import org.springframework.aop.AfterReturningAdvice;  
 /* 
  * 表示一个在方法返回时进行拦截的Advice 
 */  
 public class TracingAfterAdvice implements AfterReturningAdvice {  
     @Override  
     public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {  
         System.out.println(method.getDeclaringClass().getName() + "." + method.getName() + "spend time: " + returnValue);  
         System.out.println("execute after (by " + method.getDeclaringClass().getName() + "." + method.getName() + ")");  
     }  
 }  
   
 package com.wow.asc.aop;  
   
 import java.lang.reflect.Method;  
 import org.springframework.aop.ThrowsAdvice;  
 /* 
  * 表示一个异常抛出时进行拦截的Advice 
 */  
 public class TracingThrowsAdvice implements ThrowsAdvice {  
       
     public void afterThrowing(Method method, Object[] args, Object target, Throwable subclass) {  
          System.out.println( "Logging that a " + subclass + "Exception was thrown.");  
       }  
 }  

在设计完上述的代码及逻辑后，即可以通过applicationContext.xml将上述类进行组合，在装配过程中即可明确哪个类的哪些方法需要被拦截，及拦截前、后会做哪些事情。具体的配置示例：

[java]view plaincopy
 <?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"  
     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"  
     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  
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd  
         http://www.springframework.org/schema/context http://localhost:8080/schema/www.springframework.org/schema/context/spring-context-2.5.xsd">  
     <bean id="businessLogic" class="com.wow.asc.aop.BusinessLogic" />  
     <bean id="businessLogicBean" class="org.springframework.aop.framework.ProxyFactoryBean">  
         <property name="proxyInterfaces">  
             <value>com.wow.asc.aop.IBusinessLogic</value>  
         </property>  
         <property name="target">  
             <ref local="businessLogic"/>   
         </property>  
         <property name="interceptorNames">  
             <list>  
                 <value>theTracingBeforeAdvisor</value>  
                     <value>theTracingAfterAdvisor</value>  
                     <value>theTracingThrowsAdvisor</value>  
             </list>  
         </property>  
     </bean>  
       
     <bean id="theTracingBeforeAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">  
         <property name="advice">  
             <ref local="theTracingBeforeAdvice"/>  
         </property>  
         <property name="pattern">  
             <value>.*</value>  
         </property>  
     </bean>  
     <bean id="theTracingAfterAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">  
         <property name="advice">  
             <ref local="theTracingAfterAdvice"/>  
         </property>  
         <property name="pattern">  
             <value>.*time.*</value>  
         </property>  
     </bean>  
     <bean id="theTracingThrowsAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">  
         <property name="advice">  
             <ref local="theTracingThrowsAdvice"/>  
         </property>  
         <property name="pattern">  
             <value>.*bar.*</value>  
         </property>  
     </bean>  
     <bean id="theTracingBeforeAdvice" class="com.wow.asc.aop.TracingBeforeAdvice"/>  
     <bean id="theTracingAfterAdvice" class="com.wow.asc.aop.TracingAfterAdvice"/>  
     <bean id="theTracingThrowsAdvice" class="com.wow.asc.aop.TracingThrowsAdvice"/>  
 </beans>  

通过上述的配置，我们可以看出我们将IBusinessLogic做为代理接口，同时它的真正的目标类是BusinesssLogic。同时会对所有进入方法之前采用TracingBeforeAdvice进行拦截，进行方法前的预处理；对time方法采用TracingAfterAdvice进行拦截，进行方法返回后的处理；对于bar则采用TracingThrowsAdvice进行拦截，当方法返回BusinessLogicException时进行相应的处理。

在配置完上述类的依赖关系及需要拦截的方法后，即可以编写客户端程序来调用，查看它的运行机制。客户端调用代码：

[java]view plaincopy
 package com.wow.asc.test;  
   
 import org.springframework.context.ApplicationContext;  
 import org.springframework.context.support.ClassPathXmlApplicationContext;  
 import com.wow.asc.aop.BusinessLogicException;  
 import com.wow.asc.aop.IBusinessLogic;  
   
 public class AOPTest {  
     public static void main(String[] args) {  
         ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");  
         IBusinessLogic ibl = (IBusinessLogic)ac.getBean("businessLogicBean");  
         ibl.foo();  
         try {  
             ibl.bar();  
         } catch (BusinessLogicException e) {  
             System.out.println("Caught BusinessLogicException");  
         }  
         ibl.time();  
     }  
 }  

通过运行结果来详细的了解下，看是否真正的如上所述，会在方法前、后及异常抛出时能够拦截并进行相应处理。结果如下：

[java]view plaincopy
 1、execute before (by com.wow.asc.aop.IBusinessLogic.foo)  
 2、Inside BusinessLogic.foo()  
 3、execute before (by com.wow.asc.aop.IBusinessLogic.bar)  
 4、Inside BusinessLogic.bar()  
 5、Logging that a com.wow.asc.aop.BusinessLogicExceptionException was thrown.  
 6、Caught BusinessLogicException  
 7、execute before (by com.wow.asc.aop.IBusinessLogic.time)  
 8、Inside BusinessLogic.time()  
 9、com.wow.asc.aop.IBusinessLogic.timespend time: 46  
 10、execute after (by com.wow.asc.aop.IBusinessLogic.time)  

其实通过1、3、7行可以非常清晰的了解到，每个方法在执行前都被TracingBeforeAdvice拦截到，并执行了预处理。5、6行表示当调用的是bar方法时，会被TracingThrowsAdvice拦截，当有异常抛出时，会执行相应的处理；8、9、10行则表示当调用的是time方法，返回时会被TracingAfterAdvice拦截，对其返回值进行处理。

MethodInterceptor拦截方式

采用该种方式进行拦截，需要实现一个继承自MethodInterceptor的类，并将该类注册至spring Context中，具体如下：

[java]view plaincopy
 package com.wow.asc.aop;  
   
 import org.aopalliance.intercept.MethodInterceptor;  
 import org.aopalliance.intercept.MethodInvocation;  
   
 public class MyInterceptor implements MethodInterceptor {  
     @Override  
     public Object invoke(MethodInvocation invocation) {  
         Object result = null;  
         StringBuffer info = new StringBuffer();  
         info.append("intercept the method: ");  
         info.append(invocation.getMethod().getDeclaringClass().  
 getName());  
         info.append(".");  
         info.append(invocation.getMethod().getName());  
         System.out.println("start " + info.toString());  
         try {  
            result = invocation.proceed();  
         } catch (Throwable e) {  
             e.printStackTrace();  
         } finally {  
             System.out.println("end " + info.toString());  
         }  
         return result;  
     }  
 }  

对于类的装配，其实和上面的非常类似，示例：

[java]view plaincopy
 <bean id="testBean" class="org.springframework.aop.framework.ProxyFactoryBean">  
         <property name="proxyInterfaces">  
             <value>com.wow.asc.aop.IBusinessLogic</value>  
         </property>  
         <property name="target">  
             <ref local="businessLogic"/>   
         </property>  
         <property name="interceptorNames">  
             <list>  
                 <value>myInterceptor</value>  
             </list>  
         </property>  
 </bean>  
 <bean id="myInterceptor" class="com.wow.asc.aop.MyInterceptor"/>  

再通过客户端进行调用，可得到运行结果，从结果来分析可以看出它在方法执行的前、后均添加了相应的日志。

[java]view plaincopy
 start intercept the method: com.wow.asc.aop.IBusinessLogic.foo  
 Inside BusinessLogic.foo()  
 end intercept the method: com.wow.asc.aop.IBusinessLogic.foo  
 start intercept the method: com.wow.asc.aop.IBusinessLogic.time  
 Inside BusinessLogic.time()  
 end intercept the method: com.wow.asc.aop.IBusinessLogic.time  

至此，采用两种不同方式实现的AOP就结束了，接下去以第一种配置方式讲一下Spring Aop大概的实现原理和过程。

三、Spring Aop实现过程和原理
通过上面的示例我们可以看到通过ProxyFactoryBean产生了目标对象Target（在示例中为BusinessLogic）的代理对象，我们执行该代理对象的foo方法时，事实上方法体中并没有什么具体的逻辑，而是直接执行与其关联的InvocationHandler的invoke方法，在Spring Aop中就是执行JdkDynamicAopProxy的invoke方法（或者Cglib2AopProxy的intercept方法），在JdkDynamicAopProxy的invoke方法中如果没有拦截器的设定，那么直接调用目标对象的相应方法，反之有拦截器会调用ReflectiveMethodInvocation的proceed方法，在该方法中会遍历所有的拦截器，如果当前方法和拦截器中的PoinCut相匹配（Advisor对象里包含Advice和PoinCut对象，而拦截器对象又是由Advisor对象适配过来的），那么则调用相应拦截器的invoke方法，再在invoke方法中调用相应的Advice的方法，如before，afterReturning等，所有拦截器调用完毕之后，则调用被代理对象的方法。

现在还有两个问题代理对象是怎么创建的？拦截器又是从哪里来的？

第一个问题还是得从ProxyFactoryBean说起，IOC容易或者程序会调用该类的getObject方法，那么ProxyFactoryBean会先调用initializeAdvisorChain方法来从配置文件中读取相关的Advisor，接着调用自己的getSingletonInstance方法，在这个方法中会去调用ProxyCreatorSupport（从名字可以看出这是创建代理对象的辅助类），然后会去调用AopProxyFactory这种代理对象工厂的ctreateAopProxy方法去产生代理对象，比如DefaultAopProxyFactory的ctreateAopProxy方法，在这个方法中会去判断目标对象是不是接口的实现类，如果是的话就创建一个AopProxy的子类JdkDynamicAopProxy实例，否则通过Cglib2AopProxy的createCglibProxy方法创建一个AopProxy的子类Cglib2AopProxy实例，之后就可以通过AopProxy的实现类中的getProxy方法返回代理对象了。

第二个问题，拦截器链是在JdkDynamicAopProxy的invoke方法中去获得的，通过AdvisedSupport对象的getInterceptorsAndDynamicInterceptionAdvice方法去获得的，AdvisedSupport这个辅助类从缓存中去获得拦截器链，如果缓存中没有，那么利用DefaultAdvisorChainFactory的getInterceptorsAndDynamicInterceptionAdvice方法去获得。

这就是自己看了Spring Aop相关源码后的理解，如有不对的地方希望指出。

本文链接：https://blog.csdn.net/Mr_Tim/article/details/51890943

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

qt编写sqlite数据库_qt sqlite ide 开发__丽_的博客-程序员秘密

QSqlDatabase db=QSqlDatabase::addDatabase("QSQLITE");db.setDatabaseName("mydb");bool ok=db.open();qDebug()QSqlQuery qure(db);/*qure.exec("create table mytab4(id int PRIMARY KEY ,name text)")

配置路由器交换机常见的坑_幻紫星的博客-程序员秘密

1.思科模拟器灯是红色的，实验失败？按老师指导完成实验，都配对了但是还是不行，为什么呢？一看灯是红色的，为啥？原来是端口未打开，在配置交换机路由器常常会遇到这种问题，华三要进入端口undo shutdown，思科则是no shutdown.这是实验前的样子，可以看到灯是红色的，配置很简单，我们只要进入交换机配置界面。输入：enableconfigure terminal...

计算IP地址及子网掩码_可变长子网掩码计算_yiranblade的博客-程序员秘密

首先谈谈何为子网掩码:子网掩码——屏蔽一个IP地址的网络部分的“全1”比特模式。对于A类地址来说，默认的子网掩码是255.0.0.0；对于B类地址来说默认的子网掩码是255.255.0.0；对于C类地址来说默认的子网掩码是255.255.255.0。利用子网掩码可以把大的网络划分成子网，即VLSM（可变长子网掩码），也可以把小的网络归并成大的网络即超网。子网掩码的设定必须遵循一定的规则。与二进制I...

Python 之关键字和实例_b348382544的博客-程序员秘密

Python 之关键字和实例0.0682018.04.09 20:10:28字数 1073阅读 2671一、python关键字Screen Shot 2018-04-09 at 19.50.17.png\1. and ：表示逻辑判断【与】a = '1'b = 1if a and b: print('Hello Python')2.as ：单独没有实际意思，常与...

Unity内置资源如何打包避免冗余_contentbuildinterface.generateassetbundlebuilds_UWA的博客-程序员秘密

这是第249篇UWA技术知识分享的推送。今天我们继续为大家精选了若干和开发、优化相关的问题，建议阅读时间10分钟，认真读完必有收获。UWA 问答社区：answer.uwa4d.comUWA QQ群2：793972859（原群已满员）本期目录：Unity内置资源如何打包避免冗余 SpriteAtlas的“冗余”问题关于Mesh占用内存的问题 UGUI.Rendering.UpdateBatches耗时较高 Plugins的DLL是如何影响Package的AssetBundleQ：

Java网络编程--Netty中的责任链_baijiyuan9594的博客-程序员秘密

Netty中的责任链设计模式 - 责任链模式责任链模式(Chain of Responsibility Pattern)是一种是行为型设计模式，它为请求创建了一个处理对象的链。其链中每一个节点都看作是一个对象，每个节点处理的请求均不同，且内部自动维护一个下一节点对象。当一个请求从链式的首端发出时，会沿着链的路径依次传递给每一个节点对象，直至有对象处理这个请求为止。责任链模...