Spring AOP原理及拦截器

LittleMatches

2011-08-19

原理

AOP(Aspect Oriented Programming)，也就是面向方面编程的技术。AOP基于IoC基础，是对OOP的有益补充。

AOP将应用系统分为两部分，核心业务逻辑（Core business concerns）及横向的通用逻辑，也就是所谓的方面Crosscutting enterprise concerns，例如，所有大中型应用都要涉及到的持久化管理（Persistent）、事务管理（Transaction Management）、安全管理（Security）、日志管理（Logging）和调试管理（Debugging）等。

AOP正在成为软件开发的下一个光环。使用AOP，你可以将处理aspect的代码注入主程序，通常主程序的主要目的并不在于处理这些aspect。AOP可以防止代码混乱。

Spring framework是很有前途的AOP技术。作为一种非侵略性的、轻型的AOP framework，你无需使用预编译器或其他的元标签，便可以在Java程序中使用它。这意味着开发团队里只需一人要对付AOP framework，其他人还是像往常一样编程。

AOP概念

让我们从定义一些重要的AOP概念开始。

— 方面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的Advisor或拦截器实现。

— 连接点（Joinpoint）：程序执行过程中明确的点，如方法的调用或特定的异常被抛出。

— 通知（Advice）：在特定的连接点，AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。

— 切入点（Pointcut）：指定一个通知将被引发的一系列连接点的集合。AOP框架必须允许开发者指定切入点，例如，使用正则表达式。

— 引入（Introduction）：添加方法或字段到被通知的类。Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现IsModified接口，来简化缓存。

— 目标对象（Target Object）：包含连接点的对象，也被称作被通知或被代理对象。

— AOP代理（AOP Proxy）：AOP框架创建的对象，包含通知。在Spring中，AOP代理可以是JDK动态代理或CGLIB代理。

— 编织（Weaving）：组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

各种通知类型包括：

— Around通知：包围一个连接点的通知，如方法调用。这是最强大的通知。Aroud通知在方法调用前后完成自定义的行为，它们负责选择继续执行连接点或通过返回它们自己的返回值或抛出异常来短路执行。

— Before通知：在一个连接点之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。

— Throws通知：在方法抛出异常时执行的通知。Spring提供强制类型的Throws通知，因此你可以书写代码捕获感兴趣的异常（和它的子类），不需要从Throwable或Exception强制类型转换。

— After returning通知：在连接点正常完成后执行的通知，例如，一个方法正常返回，没有抛出异常。

Around通知是最通用的通知类型。大部分基于拦截的AOP框架（如Nanning和Jboss 4）只提供Around通知。

如同AspectJ，Spring提供所有类型的通知，我们推荐你使用最为合适的通知类型来实现需要的行为。例如，如果只是需要用一个方法的返回值来更新缓存，你最好实现一个after returning通知，而不是around通知，虽然around通知也能完成同样的事情。使用最合适的通知类型使编程模型变得简单，并能减少潜在错误。例如，你不需要调用在around通知中所需使用的MethodInvocation的proceed()方法，因此就调用失败。

切入点的概念是AOP的关键，它使AOP区别于其他使用拦截的技术。切入点使通知独立于OO的层次选定目标。例如，提供声明式事务管理的around通知可以被应用到跨越多个对象的一组方法上。因此切入点构成了AOP的结构要素。

拦截器（也称拦截机）

拦截机 (Interceptor), 是 AOP (Aspect-Oriented Programming) 的另一种叫法。AOP本身是一门语言，只不过我们使用的是基于JAVA的集成到Spring 中的 SpringAOP。同样，我们将通过我们的例子来理解陌生的概念。

接口类

<span style="font-size: medium;">package com.test.TestSpring3;  
  
public interface UserService // 被拦截的接口  
...{  
    public void printUser(String user);  
}  
</span>

实现类

<span style="font-size: medium;">package com.test.TestSpring3;  
  
public class UserServiceImp implements UserService // 实现UserService接口  
...{  
    public void printUser(String user) ...{  
        System.out.println("printUser user:" + user);// 显示user  
    }  
}  
  
</span>

AOP拦截器

<span style="font-size: medium;">package com.test.TestSpring3;  
  
import org.aopalliance.intercept.MethodInterceptor;  
import org.aopalliance.intercept.MethodInvocation;  
  
public class UserInterceptor implements MethodInterceptor  
// AOP方法拦截器  
...{  
  
    public Object invoke(MethodInvocation arg0) throws Throwable ...{  
  
        try ...{  
  
            if (arg0.getMethod().getName().equals("printUser"))  
            // 拦截方法是否是UserService接口的printUser方法  
            ...{  
                Object[] args = arg0.getArguments();// 被拦截的参数  
                System.out.println("user:" + args[0]);  
                arg0.getArguments()[0] = "hello!";// 修改被拦截的参数  
  
            }  
  
            System.out.println(arg0.getMethod().getName() + "---!");  
            return arg0.proceed();// 运行UserService接口的printUser方法  
  
        } catch (Exception e) ...{  
            throw e;  
        }  
    }  
}  
</span><span style="font-size: medium;">  
</span>

测试类

<span style="font-size: medium;">package com.test.TestSpring3;  
  
import org.springframework.beans.factory.BeanFactory;  
  
import org.springframework.beans.factory.xml.XmlBeanFactory;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
import org.springframework.context.support.FileSystemXmlApplicationContext;  
import org.springframework.core.io.ClassPathResource;  
import org.springframework.core.io.Resource;  
import org.springframework.web.context.support.WebApplicationContextUtils;  
  
public class TestInterceptor ...{  
  
    public static void main(String[] args) ...{  
        ApplicationContext ctx = new FileSystemXmlApplicationContext(  
                "classpath:applicationContext.xml");  
//        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");      
          
        UserService us = (UserService) ctx.getBean("userService");  
        us.printUser("shawn");  
  
    }  
}</span><span style="font-size: medium;">  
</span>

配置文件

<span style="font-size: medium;">try {      
 // 在获得连接后，立即通过调用　setAutoCommit(false) 将事务处理置为非自动提交模式  // Prepare Query to fetch the user Information         
     pst = conn.prepareStatement(findByName);                   
       // ...            conn.commit();         
 }  catch(Exception ex) {         
     conn.rollback();        
      throw ex;         
 }finally {     
         try {      
           // Close Result Set and Statement    
          if (rset != null) rset.close();                 
         if (pst != null) pst.close();                          
    } catch (Exception ex) {                 
       ex.printStackTrace();                  
       throw new Exception("SQL Error while closing objects = " + ex.toString());              
}    
}  
</span>

这样代码在AOP的倡导者看来是“肮脏”的代码。他们认为，所有的与事务有关的方法都应当可以集中配置（见声明性事务控制），并自动拦截，程序应当关心他们的主要任务，即商业逻辑，而不应和事务处理的代码搅和在一起。

我先看看Spring是怎么做到拦截的：

Spring 内置支持的事务处理拦截机

这里因为要用到JpetStore项目中的代码，我们将 applicationContext.xml 全部内容列出:

<?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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">

<list>

<value>WEB-INF/mail.properties</value>

<value>WEB-INF/jdbc.properties</value>

</list>

</property>

</bean>

</bean>

<aop:config>

<aop:advisor pointcut="execution(* *..PetStoreFacade.*(..))" advice-ref="txAdvice"/>

<aop:advisor pointcut="execution(* *..PetStoreFacade.insertOrder(*..Order))" advice-ref="emailAdvice"/>

</aop:config>

<tx:advice id="txAdvice">

<tx:attributes>

<tx:method name="insert*"/>

<tx:method name="update*"/>

<tx:method name="*" read-only="true"/>

</tx:attributes>

</tx:advice>

</beans>

这个配置比想象的要简单的多：

Xml代码   
<span style="font-size: medium;"><aop:config>         
 <!-- This definition creates auto-proxy infrastructure based on the given pointcut, expressed in AspectJ pointcut language.   
Here: applying the advice named        "txAdvice" to all methods on classes named PetStoreImpl. 指出在 PetStoreFacade   
的所有方法都将采用 txAdvice(在紧接着的元素中定义了）事务方针，注意，我们这里虽然指定的是接口 PetStoreFacace,          
 但其暗示着其所有的实现类也将同样具有这种性质，因为本身就是实现类的方法在执行的，接口是没有方法体的。    -->     
       <aop:advisor pointcut="execution(* *..PetStoreFacade.*(..))" advice-ref="txAdvice"/>                 
 <!-- 其它拦截机-->    
</aop:config>  
</span>  

1. 所有的拦截机配置都放在 <aop:config> 配置元素中.

2.下面还是需要理解一下几个有关AOP的专用名词，不过，是挺抽象的，最好能会意出其的用意

pointcut 切入点，比如：updateAccount 方法需要进行事务管理，则这个切入点就是“执行方法体”(execution)。Spring 所有支持的切入点类型在都在 Spring reference: 6.2.3.1. Supported Pointcut Designators 中列出了。
advice 要对这个切入点进行什么操作，比如事务控制
advisor Spring 特有的概念，将上两个概念合到一个概念中来，即一个 advisor 包含了一个切入点及对这个切入点所实施的操作。

因为方法执行切入点 execution 为最常见的切入点类型，我们着重介绍一下，execution 的完全形式为：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

这是一个正则表达式，其中由 '?' 结尾的部分是可选的。翻译过来就是：

执行(方法访问修饰符? 方法返回类型声明类型? 方法名(方法参数类型) 抛出异常?)

所有的这些都是用来定义执行切入点，即那些方法应该被侯选为切入点：

方法访问修饰符即 public, private 等等
方法返回类型即方法返回的类型，如 void, String 等等
声明类型 1.5的语法，现在可以先忽略它
方法名方法的名字
方法参数类型方法的参数类型
抛出异常方法声明的抛出的异常

例如，所有dao代码被定义在包com.xyz.dao　及子包com.xyz.dao.hibernate,或者其它，如果还有的话，子包中,里面定义的是提供DAO功能的接口或类，那么表达式：

execution(* com.xyz.dao..*.*(..))

表示切入点为：执行定义在包 com.xyz.dao 及其子包（因为 .. 所致) 中的任何方法

详细情况可以参见Springrefernce:6.2.3.4.Examples

因此这个表达式为执行定义在类 PetStoreFacade　及其实现类中的所有方法，采取的动作定义在 txAdvice 中. 关于该 advice 的定义，（见声明性事务控制）一节

<aop:advisor pointcut="execution(* *..PetStoreFacade.*(..))" advice-ref="txAdvice"/>

Spring 自定拦截机

来为了进行事务控制，我们只需简单地配置几下，所有的工作都由 Spring 来做。这样固然很好，但有时我们需要有我们特有的控制逻辑。因为Spring 不可能包含所有人需要的所有拦截机。所以它提供了通过程序的方式加以定制的方式。我们的项目中就有这么一个拦截机，在用户确认付款后，将定单信息通过 email 的方式发送给注册用户的邮箱中。

<aop:config> ...  <aop:advisor pointcut="execution(* *..PetStoreFacade.insertOrder(*..Order))" advice-ref="emailAdvice"/> </aop:config>

红色的注释已经说的很清楚这个 Advisor 了，它的切入点(pointcut) 为 PetStoreFacade 的 void insertOrder(Order order) 方法，采取的动作为引用的 emailAdvice, 下面我们就来看看 emailAdvice:

它给了这个 advice 的实现类为 logic 包中 SendOrderConfirmationEmailAdvice, 该Bean 引用了我们前面定义的邮件发送器（一个 Spring 内置的邮件发送器）.

下面看看这个实现类：

public class SendOrderConfirmationEmailAdvice implements AfterReturningAdvice, InitializingBean { // user jes on localhost private static final String DEFAULT_MAIL_FROM = "[email protected]"; private static final String DEFAULT_SUBJECT = "Thank you for your order!"; private final Log logger = LogFactory.getLog(getClass()); private MailSender mailSender; private String mailFrom = DEFAULT_MAIL_FROM; private String subject = DEFAULT_SUBJECT; public void setMailSender(MailSender mailSender) {

this.mailSender=mailSender;

}publicvoidsetMailFrom(StringmailFrom){this.mailFrom=mailFrom;}publicvoidsetSubject(Stringsubject){this.subject=subject;}publicvoidthrowsException{if(this.mailSender==null){thrownewIllegalStateException("mailSenderisrequired");}}/**

*@paramreturnValue被拦截的方法的返回值

*@paramm被拦截的方法的所有信息（Method类封装了这些信息）

*@paramargs被拦截的方法的所有参数组成的数组

*@paramtarget目标对象，对于方法执行来说，即是方法所在的类的实例（与this同，批当前对象）

*@throwsjava.lang.Throwable

*/ public void afterReturning(Object returnValue, Method m, Object[] args, Object target) throws Throwable { // 我们被拦截的方法为 void insertOrder(Order order)，方法只有一个参数，所以可知数据的第1个元素即是被传进的　order 对象 // 得到了order 对象，就可以将 order 对应的帐户名及帐单号发送到邮件中，以便确认无误。 Order order = (Order) args[0]; Account account = ((PetStoreFacade) target).getAccount(order.getUser().getUsername()); // don't do anything if email address is not set if (account.getEmail() == null || account.getEmail().length() == 0) { return; } StringBuffer text = new StringBuffer(); text.append("Dear ").append(account.getFirstname()). append(' ').append(account.getLastname()); text.append(", thank your for your order from JPetStore. " + "Please note that your order number is "); text.append(order.getId()); SimpleMailMessage mailMessage = new SimpleMailMessage(); mailMessage.setTo(account.getEmail()); mailMessage.setFrom(this.mailFrom); mailMessage.setSubject(this.subject); mailMessage.setText(text.toString()); try { this.mailSender.send(mailMessage); } catch (MailException ex) { // just log it and go on logger.warn("An exception occured when trying to send email", ex); } } }

1. 红色的内容即为反向注入的 mailSender 属性

2.蓝色的内容为SpringBean的一个通用的接口InitializingBean，实现类需要实现该接口定义的方法afterPropertiesSet()，该方法中一般是在Bean被初始化后并设置了所有的setter注入后调用的。所以这里是保证邮件发送器配置正确。因为如果没有配置正确，下面的工作是无法进行的，所以与其等那时抛出异常，还不如早早地在部署时就告知（通过抛出IllegalStateException来提示）

3.绿色的内容为这个Advise的核心，即在切入点被切入后将采用的动作。因为Advise也同样有多种类型，比如我们这里的“方法正常返回”，“方法执行前”，“方法执行后”，“环绕在方法执行前后”，“方法抛出异常时”等等(详情参见SpringReference:6.2.4.Declaringadvice)。但是我们的逻辑为在用户确认定单并且执行成功（所谓的成功是指将这一定单插入到了表Order中了）后，将发送一确认信。所以”方法正常返回“完全符合我们的要求。

接口AfterReturningAdvice即是Spring中表示”方法正常返回“这一语义的Advice,所以我们实现这个接口及其必须的方法afterReturning.

方法代码的工作其实并不重要，只要我们理解这些“魔法”一样的技术后，实现代码是很简单的。值得提及的是这个方法的参数，这些参数是封装了切入点的所有信息，请见上面的注释。在我们的实现中只使用了被拦截方法的参数，在复杂的Advice实现中可能会用到切入点所有信息。

aop spring aop原理 spring框架 spring拦截器

安科网

Spring AOP原理及拦截器

LittleMatches

Spring 内置支持的事务处理拦截机

Spring 自定拦截机

LittleMatches

相关推荐

Spring入门到进阶 - Spring AOP

Spring基础之AOP

AOP的定义和原理

Spring中的AOP底层原理探讨

【Spring框架学习】AOP机制详解

coding++：Spring 中的 AOP 原理

spring——AOP原理及源码（一）

什么是AOP面向切面编程思想

aop声明式事务不起作用的原因

在Spring中使用AOP切面编程

Spring AOP 实现原理

Spring AOP 实现写事件日志功能

spring aop

【Spring】Spring相关知识点总结

浅析Spring AOP术语

个人技术总结

你敢信？面试官竟然让我现场搭建一个AOP测试环境！

声明式事务

利用Spring AOP切面对用户访问进行监控

Spring AOP

LittleMatches