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();
            }
        
    }
}