Spring Aspect Oriented Programming

3，切片（@Pointcut）

    切片的作用是用来决定我们声明的通知在什么时候被执行。一个切片的生命有两部分组成：1）由名称和任意参数组成的切片签名，2）切片表达式。在Spring AOP 中的注解方式中，切片的签名就是该常规方法定义的签名，如上例的

@Pointcut("execution(* aop.*.save())")//切片表达式
public void notice(){}//切片签名

    注：作为切片签名的方法必须是void返回值。

    Spring AOP目前仅支持部分AspectJ中定义的切片标识符， 下面便是完整的支持列表：

execution - 切片定义的主要用法，用于匹配方法连接点的执行。
within - 将连接点的匹配限定在某个特定类型中
this - 将AOP代理的类型限定在某个特定的类型中
target - 将目标对象的类型限定在某个特定的类型中
args - 限定连接点的参数为某些特定类型
@target - 限定目标对象为具有某个注解的特定类型
@args - 限定连接点的参数类型具有特定的注解
@within - 将连接点的匹配限定在某个具有特定注解的类型中
@annotation - 限定执行该连接点的对象为某个特定的类型

    以下则是Spring AOP还未实现的标识符call, get, set, preinitialization, staticinitialization, initialization, handler, adviceexecution, withincode, cflow, cflowbelow, if, @this, and @withincode如果无意使用了这些还没支持的切片，则Spring会抛出IllegalArgumentException。

    前面曾提到Spring AOP是基于代理的实现方式，因此我们会用target表示被代理对象（也就是上例的OrderServiceImpl），用this表示代理对象（也就是上例的Spring 为拦截被代理对象所自动创建的对象，详细分析可阅读关于Java动态代理的文章）

    另外，Spring 还支持bean切片，用于将连接点的匹配限定在指定的bean内。用法如下：

bean(idOrNameOfBean)

    其中idOrNameOfBean可以是任意的Spring Bean的名字或者ID，并且支持*通配符，因此如果你的项目遵循好的命名规范，你可以很容易的写出强大的bean切片。

    再编写切片时，我们通常会用到一下几个小技巧：

    A，切片表达式支持%%, || 以及!。

    B，切片表达式支持对切片签名的引用。

    C，我们可以将常用的切片进行统一管理（参考上例）

public class Pointcuts {
        @Pointcut("execution(public * *(..))")//公共方法切片
        public void publicOperation(){}
        
	@Pointcut("within(aop.service..*)")
	public void notice(){}
	
	@Pointcut("publicOperation() && notice()")
	public void noticePublic(){}
}

    通过以上技巧，我们可以组合各种各样复杂的切片。另外需要注意，在引用切片签名时，需要遵循常规的Java方法的可见性约束，如同一个类型中可以访问private 切片定义。以下是一个Spring 提供的可能的企业开发中的切片组织方案：

package com.xyz.someapp;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class SystemArchitecture {
    //用来匹配web层的切片，匹配位于web及其子包中定义的类中的方法
    @Pointcut("within(com.xyz.someapp.web..*)")
    public void inWebLayer() {}
    //同上，用于匹配service层的切片
    @Pointcut("within(com.xyz.someapp.service..*)")
    public void inServiceLayer() {}
    //用来匹配dao层
    @Pointcut("within(com.xyz.someapp.dao..*)")
    public void inDataAccessLayer() {}
    //以下切片表达式，假设我们的包结构为
    //com.aop.app.order.service...
    //com.aop.app.pay.service...
    //该切片会匹配这些service包下的所有类的所有方法的执行
    @Pointcut("execution(* com.xyz.someapp..service.*.*(..))")
    public void businessService() {}
    //匹配dao包下的所有方法的执行
    @Pointcut("execution(* com.xyz.someapp.dao.*.*(..))")
    public void dataAccessOperation() {}

}

    这样你就可以在任意地方来引用这些切片定义了。

    Execution 表达式

    execution是最常用的一种切片标识符，我们有必要分析下该切片表达式的格式：

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

    有上述表达式可以看出，除了返回值类型(ret-type-pattern)，名字(name-pattern)，参数(param-pattern)，其他部分都是可选的。其中ret-type-pattern决定了连接点的返回值，大多数情况下我们用*通配符类匹配所有的返回值。name-pattern用来匹配方法名称，我们同样可以用*来作为方法名的全部或部分。

对于param-pattern来说：()匹配没有参数的方法，(..)匹配任意数量参数的方法，(*)匹配有一个任意参数的方法，(*, String)匹配两个参数的方法，第一个参数为任意类型，第二个参数为String类型。以下是一些常用的切片表达式：

execution(public * *(..))
execution(* set*(..))
execution(* com.xyz.service.AccountService.*(..))
execution(* com.xyz.service.*.*(..))
execution(* com.xyz.service..*.*(..))
within(com.xyz.service.*)
within(com.xyz.service..*)
this(com.xyz.service.AccountService)
target(com.xyz.service.AccountService)
args(java.io.Serializable)
@target(org.springframework.transaction.annotation.Transactional)
@within(org.springframework.transaction.annotation.Transactional)
bean(*Service)

    我们不一一分析了，相信你能理解这些表达式的意思。

@Aspect
public class BeforeAdvice{
    @Before("aop.Pointcuts.notice()")//reference to another pointcut definition.
    public void before(){
        //...
    }
    @Before("execution(* aop.OrderService.*())")
    public void before1(){
        //...
    }
}

@Aspect
public class AfterReturningExample {    
    @AfterReturning("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
    public void doAccessCheck() {        
        // ...
    }
    @AfterReturning(
        pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
        returning="retVal")
    public void doAccessCheck(Object retVal) {        
        // ...
    }
}

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

@Aspect
public class AfterFinallyExample {    
    @After("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
    public void doReleaseLock() {        
        // ...
    }
}

@Aspect
public class AroundExample {    
    @Around("com.xyz.myapp.SystemArchitecture.businessService()")
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {        
        // start stopwatch
        Object retVal = pjp.proceed();        
        // stop stopwatch
        return retVal;
    }
}

@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation() && args(user,..)")
public void validate(User user) {    // ...}

//或者
@Pointcut("com.xyz.myapp.SystemArchitecture.dataAccessOperation() && args(user,..)")
private void accountDataAccessOperation(User user) {}

@Before("accountDataAccessOperation(user)")
public void validate(User user) {    // ...}