Spring AOP 中@Pointcut的用法

格式：

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

括号中各个pattern分别表示：

修饰符匹配（modifier-pattern?）
返回值匹配（ret-type-pattern）可以为*表示任何返回值,全路径的类名等
类路径匹配（declaring-type-pattern?）
方法名匹配（name-pattern）可以指定方法名或者 *代表所有, set* 代表以set开头的所有方法
参数匹配（(param-pattern)）可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用“*”来表示匹配任意类型的参数，如(String)表示匹配一个String参数的方法；(*,String) 表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；可以用(..)表示零个或多个任意参数
异常类型匹配（throws-pattern?）
其中后面跟着“?”的是可选项

现在来看看几个例子：

1）execution(* *(..))  
//表示匹配所有方法  
2）execution(public * com. savage.service.UserService.*(..))  
//表示匹配com.savage.server.UserService中所有的公有方法  
3）execution(* com.savage.server..*.*(..))  
//表示匹配com.savage.server包及其子包下的所有方法

在Spring 2.0中，Pointcut的定义包括两个部分：Pointcut表示式(expression)和Pointcut签名(signature)

//Pointcut表示式
@Pointcut("execution(* com.savage.aop.MessageSender.*(..))")
//Point签名
private void log(){}

然后要使用所定义的Pointcut时，可以指定Pointcut签名
如下：

@Before("log()")

这种使用方式等同于以下方式，直接定义execution表达式使用

@Before("execution(* com.savage.aop.MessageSender.*(..))")

Pointcut定义时，还可以使用&&、||、! 这三个运算

@Pointcut("execution(* com.savage.aop.MessageSender.*(..))")
private void logSender(){}

@Pointcut("execution(* com.savage.aop.MessageReceiver.*(..))")
private void logReceiver(){}

@Pointcut("logSender() || logReceiver()")
private void logMessage(){}

这个例子中，logMessage()将匹配任何MessageSender和MessageReceiver中的任何方法。

pointcutexp包里的任意类.
within(com.test.spring.aop.pointcutexp.*)
pointcutexp包和所有子包里的任意类.
within(com.test.spring.aop.pointcutexp..*)
实现了Intf接口的所有类,如果Intf不是接口,限定Intf单个类.
this(com.test.spring.aop.pointcutexp.Intf)
***> 当一个实现了接口的类被AOP的时候,用getBean方法必须cast为接口类型,不能为该类的类型.

带有@Transactional标注的所有类的任意方法.
@within(org.springframework.transaction.annotation.Transactional)
@target(org.springframework.transaction.annotation.Transactional)
带有@Transactional标注的任意方法.
@annotation(org.springframework.transaction.annotation.Transactional)
***> @within和@target针对类的注解,@annotation是针对方法的注解，为自定义注解
如：

/** * 选取切入点为自定义注解 */

@Pointcut("@annotation(com.honeywen.credit.annotation.PermissionCheck)")

要想把一个类变成切面类，需要两步:

① 在类上使用 @Component 注解把切面类加入到IOC容器中
② 在类上使用 @Aspect 注解使之成为切面类

用@Aspect注解方式来实现前置通知、返回通知、后置通知、异常通知、环绕通知。

package com.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * @author wanjiadong
 * @description
 * @date Create in 15:09 2019/1/3
 */
@Aspect
@Component
public class AspectTest {

    @Pointcut("execution(* com.service..*.*(..))")
    public void pointcut(){

    }

    @Pointcut("@annotation(Override) || @within(Override)")
    public void pointcutAnnotation(){}

    /**
     * 前置通知：目标方法执行之前执行以下方法体的内容
     *
     * @param joinPoint
     */
    @Before("pointcut()")
    public void before(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println(joinPoint.getArgs()[0].getClass());
        System.out.println(joinPoint.getArgs()[0].getClass().getGenericSuperclass());
        System.out.println(joinPoint.getArgs()[0].getClass().getSuperclass());
        System.out.println(joinPoint.getArgs()[0].getClass().getSuperclass().getSuperclass());
        System.out.println("【前置通知】the method 【" + methodName + "】 begins with " + Arrays.asList(joinPoint.getArgs()));
    }

    /**
     * 环绕通知：目标方法执行前后分别执行一些代码，发生异常的时候执行另外一些代码
     *
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        String methodName = proceedingJoinPoint.getSignature().getName();
        Object result = null;
        //目标参数
        Object args = proceedingJoinPoint.getArgs();
        //获取方法
        Method method = ((MethodSignature) proceedingJoinPoint.getSignature()).getMethod();
        //获取方法上的注解
        Override override = method.getAnnotation(Override.class);
        try {
            System.out.println("【环绕通知中的--->前置通知】：the method 【" + methodName + "】 begins with " + Arrays.asList(proceedingJoinPoint.getArgs()));
            //执行目标方法
            result = proceedingJoinPoint.proceed();
            System.out.println("【环绕通知中的--->返回通知】：the method 【" + methodName + "】 ends with " + result);
        } catch (Throwable e) {
            System.out.println("【环绕通知中的--->异常通知】：the method 【" + methodName + "】 occurs exception " + e);
        }
        System.out.println("【环绕通知中的--->后置通知】：-----------------end.----------------------");
        return result;
    }

    /**
     * 返回通知：目标方法正常执行完毕时执行以下代码
     *
     * @param joinPoint
     * @param result
     */
    @AfterReturning(value = "pointcut()", returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        result = "hahah";
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【返回通知】the method 【" + methodName + "】 ends with 【" + result + "】");
    }

    /**
     * 异常通知：目标方法发生异常的时候执行以下代码
     *
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(value = "pointcut()", throwing = "e")
    public void throwing(JoinPoint joinPoint, Exception e) {
        e = new NullPointerException();
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【异常通知】the method 【" + methodName + "】 occurs exception: " + e);
    }

    /**
     * 后置通知：目标方法执行之后执行以下方法体的内容，不管是否发生异常。
     *
     * @param joinPoint
     */
    @After("pointcut()")
    public void after(JoinPoint joinPoint) {
        System.out.println("【后置通知】this is a afterMethod advice...");
    }
}

@Aspect 切面AOP

Spring AOP 中@Pointcut的用法

要想把一个类变成切面类，需要两步:

猜你喜欢