spring aop配置及用例说明（2）

欢迎交流转载：http://www.cnblogs.com/shizhongtao/p/3473362.html

这里先介绍下几个annotation的含义，

• @Before：表示在切入点之前执行。
• @AfterReturning：表示返回之后执行。
• @AfterThrowing：表示在切入点，如果抛出异常就执行这个方法。
• @After:表示在找到该方法执行后，它是在切入点方法返回前执行。通常用于释放资源。

接上篇介绍，在使用“AfterReturning建议”时候，如果想要得到返回参数可以这样写：其中retVal是代表返回的参数对象。我这里直接打印出来了toString方法。

 @AfterReturning(pointcut="execution(public * com.bing.test..*.*(..))",returning="retVal")
     public void afterReturning(Object retVal) {
         if(retVal!=null)
         System.out.println("参数是："+retVal);
         System.out.println("afterReturning Method");
     }

同样，如果你希望对方法抛出的异常进行处理的话你也可以去捕获。spring声明式事务管理就是这个原理。

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

 @Aspect
 public class AfterThrowingExample {

   @AfterThrowing(
     pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
     throwing="ex")
   public void doRecoveryActions(DataAccessException ex) {
     // ...
   }

 }

关于pointcut表达式说明：

• the execution of any public method:匹配所有public的方法

  execution(public * *(..))

• the execution of any method with a name beginning with "set":匹配一set开头的所有方法

  execution(* set*(..))

• the execution of any method defined by the AccountService interface:匹配类com.xyz.service.AccountService下所有方法

  execution(* com.xyz.service.AccountService.*(..))

• the execution of any method defined in the service package:匹配com.xyz.service包下的所有类的方法，不包含子包

  execution(* com.xyz.service.*.*(..))

• the execution of any method defined in the service package or a sub-package:匹配com.xyz.service包以及子包下的所有类的方法，包含子包

  execution(* com.xyz.service..*.*(..))

• any join point (method execution only in Spring AOP) within the service package:匹配在com.xyz.service包下类的所有方法

  within(com.xyz.service.*)

• any join point (method execution only in Spring AOP) within the service package or a sub-package:

  within(com.xyz.service..*)

• any join point (method execution only in Spring AOP) where the proxy implements the AccountService interface:实现AccountService接口的所有类

  this(com.xyz.service.AccountService)

  'this' is more commonly used in a binding form :- see the following section on advice for how to make the proxy object available in the advice body.

• any join point (method execution only in Spring AOP) where the target object implements the AccountService interface:

  target(com.xyz.service.AccountService)

  'target' is more commonly used in a binding form :- see the following section on advice for how to make the target object available in the advice body.

• any join point (method execution only in Spring AOP) which takes a single parameter, and where the argument passed at runtime is Serializable:

  args(java.io.Serializable)

  'args' is more commonly used in a binding form :- see the following section on advice for how to make the method arguments available in the advice body.

  Note that the pointcut given in this example is different to execution(* *(java.io.Serializable)): the args version matches if the argument passed at runtime is Serializable, the execution version matches if the method signature declares a single parameter of type Serializable.

• any join point (method execution only in Spring AOP) where the target object has an @Transactional annotation:

  @target(org.springframework.transaction.annotation.Transactional)

  '@target' can also be used in a binding form :- see the following section on advice for how to make the annotation object available in the advice body.

• any join point (method execution only in Spring AOP) where the declared type of the target object has an @Transactional annotation:

  @within(org.springframework.transaction.annotation.Transactional)

  '@within' can also be used in a binding form :- see the following section on advice for how to make the annotation object available in the advice body.

• any join point (method execution only in Spring AOP) where the executing method has an @Transactional annotation:

  @annotation(org.springframework.transaction.annotation.Transactional)

  '@annotation' can also be used in a binding form :- see the following section on advice for how to make the annotation object available in the advice body.

• any join point (method execution only in Spring AOP) which takes a single parameter, and where the runtime type of the argument passed has the @Classified annotation:

  @args(com.xyz.security.Classified)

  '@args' can also be used in a binding form :- see the following section on advice for how to make the annotation object(s) available in the advice body.

• any join point (method execution only in Spring AOP) on a Spring bean named 'tradeService':

  bean(tradeService)

• any join point (method execution only in Spring AOP) on Spring beans having names that match the wildcard expression '*Service':

  bean(*Service)

这里贴上我用于测试的代码：

manager类，相当于service层

 package com.bing.test;

 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;

 @Component("manager")
 public class Manager {
     @Value("${user.name}")
     private String myName;
     @Value("${user.description}")
     private String description;

     public void sayHello() {
         System.out.println("Hello " + myName);
     }

     public void getDes() {
         System.out.println(description);

     }
     public String getName(){
         System.out.println("执行getName");
         return myName;
     }
     public String throwTest() throws Exception {
             if (true) {

                 throw new Exception("new throwing test!");
             }
         return "sdf";
     }
 }

切面类：

 package com.bing.test;

 import org.aspectj.lang.annotation.After;
 import org.aspectj.lang.annotation.AfterReturning;
 import org.aspectj.lang.annotation.AfterThrowing;
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Before;
 import org.aspectj.lang.annotation.Pointcut;
 import org.springframework.stereotype.Component;

 @Aspect
 // 定义切面类
 @Component
 // 把类装载到容器，与@service等作用一样
 public class NotVeryUsefulAspect {
     //配置切入点集合，这样在下面可以直接引入
      @Pointcut("execution(public * com.bing.test..*.sayHello(..))")
       public void inManager() {}
      @Pointcut("within(com.bing.test..*)")
      public void excutionManager() {}
     // 表示在方法前面执行
     @Before("com.bing.test.NotVeryUsefulAspect.inManager()")
     public void before() {

         System.out.println("before Method");
     }
     @AfterReturning(pointcut="execution(public * com.bing.test..*.*(..))",returning="retVal")
     public void afterReturning(Object retVal) {
         if(retVal!=null)
         System.out.println("参数是："+retVal);
         System.out.println("afterReturning Method");
     }
     //@After("execution(public * com.bing.test..*.*(..))")
     @After("within(com.bing.test.Manager)")
     public void after() {

         System.out.println("after Method");
     }
     @AfterThrowing(pointcut="execution(* com.bing.test.*.throwTest(..))",throwing="ex")
     public void afterThrow(Exception ex){

         System.out.println(ex.getMessage());

         System.out.println("AfterThrowing Method!");
     }
 }

junit测试类：

 package com.bing.jtest;

 import javax.annotation.Resource;

 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

 import com.bing.test.Manager;

 @ContextConfiguration(locations = { "classpath:applicationContext.xml" })
 @RunWith(SpringJUnit4ClassRunner.class)
 public class Testr {

     @Resource(name="manager")
     private Manager manager;

     @Test
     public void test() {
         manager.sayHello();
         //manager.getDes();
     }
     @Test
     public void TestAfterReturning(){

         manager.getName();
     }
     @Test
     public void TestAfterThrow(){

             try {
                 manager.throwTest();
             } catch (Exception e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

     }
 }