[转载] spring aop 环绕通知around和其他通知的区别

前言：

spring 的环绕通知和前置通知，后置通知有着很大的区别，主要有两个重要的区别：

1） 目标方法的调用由环绕通知决定，即你可以决定是否调用目标方法，而前置和后置通知   是不能决定的，他们只是在方法的调用前后执行通知而已，即目标方法肯定是要执行的。

2）  环绕通知可以控制返回对象，即你可以返回一个与目标对象完全不同的返回值，虽然这很危险，但是你却可以办到。而后置方法是无法办到的，因为他是在目标方法返回值后调用

这里是经过我自己测试的过的例子，使用面向切面来处理一些问公共的问题，比如，权限管理，事务的委托

下面的例子就是使用环绕通知，当程序发生异常时，重复提交请求，重复的次数是可以设定的

当我们开发企业级应用时，通常会想要从几个切面来引用模块化的应用和特定操作的集合，下面是一个典型的通用切面，看起来可能像下面这样（这也是Spring文档里的）

package test.prefer.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class SystemArchitecture {

/**
   * A join point is in the web layer if the method is defined
   * in a type in the com.xyz.someapp.web package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.web..*)")
  public void inWebLayer() {}

/**
   * A join point is in the service layer if the method is defined
   * in a type in the com.xyz.someapp.service package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.service..*)")
  public void inServiceLayer(){}

/**
   * A join point is in the data access layer if the method is defined
   * in a type in the com.xyz.someapp.dao package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.dao..*)")
  public void inDataAccessLayer(){}

/**
   * A business service is the execution of any method defined on a service
   * interface. This definition assumes that interfaces are placed in the
   * "service" package, and that implementation types are in sub-packages.
   * 
   * If you group service interfaces by functional area （for example, 
   * in packages com.xyz.someapp.abc.service and com.xyz.def.service） then
   * the pointcut expression "execution（* com.xyz.someapp..service.*.*（..））"
   * could be used instead.
   *
   * Alternatively, you can write the expression using the 'bean'
   * PCD, like so "bean（*Service）". （This assumes that you have
   * named your Spring service beans in a consistent fashion.）
   */
  @Pointcut("execution(* test.prefer.aspect.*.*(..))")
  public void businessService(){}
  
  /**
   * A data access operation is the execution of any method defined on a 
   * dao interface. This definition assumes that interfaces are placed in the
   * "dao" package, and that implementation types are in sub-packages.
   */
  @Pointcut("execution(* com.xyz.someapp.dao.*.*(..))")
  public void dataAccessOperation(){}

}

 一、定义自己的一个切面

/*
*文件名:ConcurrentOperationExecutor.Java
*描述：<描述>
*修改人：Administrator
*/

package test.prefer.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.Ordered;

/**
 * @author 
 *@date 2010-6-1
 */
@Aspect
public class ConcurrentOperationExecutor implements Ordered {
   
   private static final int DEFAULT_MAX_RETRIES = 2;

private int maxRetries = DEFAULT_MAX_RETRIES;
   private int order = 1;

public void setMaxRetries(int maxRetries) {
      this.maxRetries = maxRetries;
   }
   
   public int getOrder(){
      return this.order;
   }
   public void setOrder(int order){
      this.order = order;
   }
   
   @Around("test.prefer.aspect.SystemArchitecture.businessService()")
   public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable { 
    //环绕通知处理方法
      int numAttempts = 0;
      Exception lockFailureException;
      do {
         numAttempts++;
         try { 
          System.out.println("环绕通知方法［ doConcurrentOperation(ProceedingJoinPoint pjp) ］.............");
            return pjp.proceed();
         }
         catch(Exception ex) {
            lockFailureException = ex;
         }
      }
      while(numAttempts <= this.maxRetries);
      throw lockFailureException;
   }

}

说明：

请注意切面实现了 Ordered 接口，这样我们就可以把切面的优先级设定为高于事务通知 （我们每次重试的时候都想要在一个全新的事务中进行）。maxRetries和order 属性都可以在Spring中配置。主要的动作在doConcurrentOperation这个环绕通知方法中发生。 请注意这个时候我们所有的businessService()方法都会使用这个重试策略。 我们首先会尝试处理，如果得到一个Exception异常， 我们仅仅重试直到耗尽所有预设的重试次数（spring开发文档）

二、在配置文件里配置这个切面

<aop:aspectj-autoproxy/>

<bean id="concurrentOperationExecutor"
  class="test.prefer.aspect.ConcurrentOperationExecutor">
     <property name="maxRetries" value="3"/>
     <property name="order" value="100"/>  
</bean>

好了，下面我们就试一下效果吧

三、测试效果

1）新建一个测试的bean： MyTestAspect,代码如下：

package test.prefer.aspect;
/**
 * 这是一个切面类
 */
import org.aspectj.lang.annotation.Aspect;

public class MyTestAspect {
 int k=0;
 public void test(String args) throws Exception{
  System.out.println("这里是［ 目标 ］方法test()"+ ++k);
  if(k<2){
   throw new Exception();
  }
  
 }

}

这个类必须在连接点的包或者子包下面，

在SystemArchitecture里有定义

@Pointcut("execution(* test.prefer.aspect.*.*(..))")
  public void businessService(){}

2）applicationContext.xml里配置 MyTestAspect

<bean id="test" class="test.prefer.aspect.MyTestAspect"/>

3）好了，看看效果吧

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import test.prefer.aspect.MyTestAspect;

public class example {
 
 public static void main(String args[]){
  
  ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  MyTestAspect t =(MyTestAspect)ctx.getBean("test");
  try{
  t.test("");
  }catch(Exception e){
   System.out.println("main()中处理异常"+e);
  }
 }

}

输出结果是：

环绕通知方法［ doConcurrentOperation(ProceedingJoinPoint pjp) ］.............
这里是［ 目标 ］方法test()1
环绕通知方法［ doConcurrentOperation(ProceedingJoinPoint pjp) ］.............
这里是［ 目标 ］方法test()