Spring AOP基础组件 Advice

相关阅读

Spring AOP基础组件 PointcutSpring AOP基础组件 AdvisorSpring AOP基础组件 Advised 简介

表示通知的标签接口，通知的实现类可以多种，比如Interceptor；

源码

public interface Advice {

}

实现子类

BeforeAdvice 简介

前置通知的标记接口；实现子类有：MethodBeforeAdvice；
Spring目前只支持方法前置通知；

AfterAdvice 简介

后置通知的标记接口，实现子类有：AfterReturningAdvice、ThrowsAdvice；

AbstractAspectJAdvice 简介

包装AspectJ切面或者AspectJ注解标注的通知方法的AOP Advice的基础类；

核心代码

public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedenceInformation, Serializable {

    // 调用增强方法
    protected Object invokeAdviceMethod(
            @Nullable JoinPointMatch jpMatch, @Nullable Object returnValue, @Nullable Throwable ex)
            throws Throwable {

        return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));
    }

    // 调用增强方法
    protected Object invokeAdviceMethod(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
            @Nullable Object returnValue, @Nullable Throwable t) throws Throwable {

        return invokeAdviceMethodWithGivenArgs(argBinding(jp, jpMatch, returnValue, t));
    }

    // 根据给定参数调用增强方法
    protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
        Object[] actualArgs = args;
        if (this.aspectJAdviceMethod.getParameterCount() == 0) {
            actualArgs = null;
        }
        try {
            // 反射调用增强方法
            ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
            return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
        }
        catch (IllegalArgumentException ex) {
            throw new AopInvocationException("Mismatch on arguments to advice method [" +
                    this.aspectJAdviceMethod + "]; pointcut expression [" +
                    this.pointcut.getPointcutexpression() + "]", ex);
        }
        catch (InvocationTargetException ex) {
            throw ex.getTargetException();
        }
    }
}

AspectJMethodBeforeAdvice 简介

包装AspectJ前置通知方法的Spring AOP Advice；

核心代码

public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements MethodBeforeAdvice, Serializable {

    @Override
    public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
        invokeAdviceMethod(getJoinPointMatch(), null, null);
    }

    @Override
    public boolean isBeforeAdvice() {
        return true;
    }

    @Override
    public boolean isAfterAdvice() {
        return false;
    }
}

AspectJAfterAdvice 简介

包装AspectJ最终通知方法的Spring AOP Advice；

核心代码

public class AspectJAfterAdvice extends AbstractAspectJAdvice
        implements MethodInterceptor, AfterAdvice, Serializable {

    @Override
    @Nullable
    public Object invoke(MethodInvocation mi) throws Throwable {
        try {
            return mi.proceed();
        }
        finally {
            // 不管是否正常返回都会执行通知
            invokeAdviceMethod(getJoinPointMatch(), null, null);
        }
    }

    @Override
    public boolean isBeforeAdvice() {
        return false;
    }

    @Override
    public boolean isAfterAdvice() {
        return true;
    }
}

AspectJAfterReturningAdvice 简介

包装AspectJ后置通知方法的Spring AOP Advice；

核心代码

public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice
        implements AfterReturningAdvice, AfterAdvice, Serializable {

    @Override
    public boolean isBeforeAdvice() {
        return false;
    }

    @Override
    public boolean isAfterAdvice() {
        return true;
    }

    @Override
    public void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable {
        // 根据返回值判断是否调用
        if (shouldInvokeOnReturnValueOf(method, returnValue)) {
            invokeAdviceMethod(getJoinPointMatch(), returnValue, null);
        }
    }

    private boolean shouldInvokeOnReturnValueOf(Method method, @Nullable Object returnValue) {
        Class type = getDiscoveredReturningType();
        Type genericType = getDiscoveredReturningGenericType();
        // If we aren't dealing with a raw type, check if generic parameters are assignable.
        // 判断返回值类型是否匹配，如果返回值类型是泛型类型，则泛型参数也要匹配
        return (matchesReturnValue(type, method, returnValue) &&
                (genericType == null || genericType == type ||
                        TypeUtils.isAssignable(genericType, method.getGenericReturnType())));
    }

    private boolean matchesReturnValue(Class type, Method method, @Nullable Object returnValue) {
        if (returnValue != null) {
            // 返回值是否是指定类型type
            return ClassUtils.isAssignablevalue(type, returnValue);
        }
        else if (Object.class == type && void.class == method.getReturnType()) {
            // 方法无返回值也会匹配Object类型
            return true;
        }
        else {
            // 方法返回值类型是否匹配指定类型type
            return ClassUtils.isAssignable(type, method.getReturnType());
        }
    }
}

AspectJAfterThrowingAdvice 简介

包装AspectJ抛出异常通知方法的Spring AOP Advice；

核心代码

public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice
        implements MethodInterceptor, AfterAdvice, Serializable {

    @Override
    public boolean isBeforeAdvice() {
        return false;
    }

    @Override
    public boolean isAfterAdvice() {
        return true;
    }

    @Override
    public void setThrowingName(String name) {
        setThrowingNameNoCheck(name);
    }

    @Override
    @Nullable
    public Object invoke(MethodInvocation mi) throws Throwable {
        try {
            return mi.proceed();
        }
        catch (Throwable ex) {
            // 根据异常类型判断是否调用
            if (shouldInvokeOnThrowing(ex)) {
                invokeAdviceMethod(getJoinPointMatch(), null, ex);
            }
            throw ex;
        }
    }

    private boolean shouldInvokeOnThrowing(Throwable ex) {
        // 当前发生的异常是否匹配指定异常类型
        return getDiscoveredThrowingType().isAssignableFrom(ex.getClass());
    }
}

AspectJAroundAdvice 简介

包装AspectJ环绕通知方法的Spring AOP Advice；

核心代码

public class AspectJAroundAdvice extends AbstractAspectJAdvice implements MethodInterceptor, Serializable {

    @Override
    public boolean isBeforeAdvice() {
        return false;
    }

    @Override
    public boolean isAfterAdvice() {
        return false;
    }

    @Override
    protected boolean supportsProceedingJoinPoint() {
        return true;
    }

    @Override
    @Nullable
    public Object invoke(MethodInvocation mi) throws Throwable {
        if (!(mi instanceof ProxyMethodInvocation)) {
            throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
        }
        ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
        ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
        JoinPointMatch jpm = getJoinPointMatch(pmi);
        return invokeAdviceMethod(pjp, jpm, null, null);
    }

    protected ProceedingJoinPoint lazyGetProceedingJoinPoint(ProxyMethodInvocation rmi) {
        return new MethodInvocationProceedingJoinPoint(rmi);
    }
}

MethodInterceptor 简介

在到达目标的途中拦截接口的调用，子类实现在接口调用之前和之后执行额外处理逻辑；

核心代码

@FunctionalInterface
public interface MethodInterceptor extends Interceptor {

    // 调用方法调用，可以在方法调用之前和之后执行额外逻辑
    @Nullable
    Object invoke(@Nonnull MethodInvocation invocation) throws Throwable;
}

ConstructorInterceptor 简介

拦截构造方法，子类实现在构造方法调用之前和之后执行额外处理逻辑；

核心方法

public interface ConstructorInterceptor extends Interceptor  {

    // 调用构造方法调用，可以在构造方法调用之前和之后执行额外逻辑
    @Nonnull
    Object construct(ConstructorInvocation invocation) throws Throwable;
}

MethodBeforeAdviceInterceptor 简介

包装MethodBeforeAdvice的Interceptor；

核心代码

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, BeforeAdvice, Serializable {

    // 前置通知
    private final MethodBeforeAdvice advice;


    public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
        // 校验前置通知
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }

    @Override
    @Nullable
    public Object invoke(MethodInvocation mi) throws Throwable {
        // 先执行前置通知逻辑
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        // 再执行方法调用
        return mi.proceed();
    }
}

AfterReturningAdviceInterceptor 简介

包装AfterReturningAdvice的Interceptor；

核心代码

public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {

    // 后置通知
    private final AfterReturningAdvice advice;


    public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
        // 校验后置通知
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }

    @Override
    @Nullable
    public Object invoke(MethodInvocation mi) throws Throwable {
        // 先执行方法调用
        Object retVal = mi.proceed();
        // 再执行后置通知逻辑
        this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
        return retVal;
    }
}

ThrowsAdviceInterceptor 简介

包装ThrowsAdvice的Interceptor；
ThrowsAdvice实现子类中的异常处理方法的签名必须是以下格式：
void afterThrowing([Method, args, target], ThrowableSubclass);
比如：

public void afterThrowing(Exception ex)
public void afterThrowing(RemoteException)
public void afterThrowing(Method method, Object[] args, Object target, Exception ex)
public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)

核心代码

public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {

    private static final String AFTER_THROWING = "afterThrowing";

    // 抛出异常增强
    private final Object throwsAdvice;

    // 缓存异常处理方法，以异常类型为KEY
    private final Map, Method> exceptionHandlerMap = new HashMap<>();


    public ThrowsAdviceInterceptor(Object throwsAdvice) {
        // 校验抛出异常增强
        Assert.notNull(throwsAdvice, "Advice must not be null");
        this.throwsAdvice = throwsAdvice;

        Method[] methods = throwsAdvice.getClass().getMethods();
        // 遍历抛出异常增强的所有方法，寻找异常处理方法
        for (Method method : methods) {
            if (method.getName().equals(AFTER_THROWING) &&
                    (method.getParameterCount() == 1 || method.getParameterCount() == 4)) {
                Class throwableParam = method.getParameterTypes()[method.getParameterCount() - 1];
                if (Throwable.class.isAssignableFrom(throwableParam)) {
                    // 缓存异常处理方法，方便直接根据异常类型直接获取异常处理方法
                    this.exceptionHandlerMap.put(throwableParam, method);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Found exception handler method on throws advice: " + method);
                    }
                }
            }
        }

        // 校验异常处理方法有效性
        if (this.exceptionHandlerMap.isEmpty()) {
            throw new IllegalArgumentException(
                    "At least one handler method must be found in class [" + throwsAdvice.getClass() + "]");
        }
    }

    @Override
    @Nullable
    public Object invoke(MethodInvocation mi) throws Throwable {
        try {
            // 执行方法调用
            return mi.proceed();
        }
        catch (Throwable ex) {
            // 发生异常，则根据异常类型获取对应的异常处理方法进行处理
            Method handlerMethod = getExceptionHandler(ex);
            if (handlerMethod != null) {
                invokeHandlerMethod(mi, ex, handlerMethod);
            }
            throw ex;
        }
    }

    @Nullable
    private Method getExceptionHandler(Throwable exception) {
        Class exceptionClass = exception.getClass();
        if (logger.isTraceEnabled()) {
            logger.trace("Trying to find handler for exception of type [" + exceptionClass.getName() + "]");
        }
        Method handler = this.exceptionHandlerMap.get(exceptionClass);
        while (handler == null && exceptionClass != Throwable.class) {
            // 当前异常类型未找到对应的异常处理方法，则继续根据其父类进行查找
            exceptionClass = exceptionClass.getSuperclass();
            handler = this.exceptionHandlerMap.get(exceptionClass);
        }
        if (handler != null && logger.isTraceEnabled()) {
            logger.trace("Found handler for exception of type [" + exceptionClass.getName() + "]: " + handler);
        }
        return handler;
    }

    private void invokeHandlerMethod(MethodInvocation mi, Throwable ex, Method method) throws Throwable {
        Object[] handlerArgs;
        // 准备方法参数
        if (method.getParameterCount() == 1) {
            handlerArgs = new Object[] {ex};
        }
        else {
            handlerArgs = new Object[] {mi.getMethod(), mi.getArguments(), mi.getThis(), ex};
        }
        try {
            // 调用异常处理方法
            method.invoke(this.throwsAdvice, handlerArgs);
        }
        catch (InvocationTargetException targetEx) {
            throw targetEx.getTargetException();
        }
    }
}

AsyncExecutionInterceptor 简介

使用AsyncTaskExecutor异步执行方法调用的AOP MethodInterceptor；

核心代码

public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport implements MethodInterceptor, Ordered {

    @Override
    @Nullable
    public Object invoke(final MethodInvocation invocation) throws Throwable {
        Class targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
        Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);
        final Method userDeclaredMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);

        // 获取方法调用对应的执行器
        AsyncTaskExecutor executor = determineAsyncExecutor(userDeclaredMethod);
        if (executor == null) {
            // 执行器必须存在，否则直接抛出异常
            throw new IllegalStateException(
                    "No executor specified and no default executor set on AsyncExecutionInterceptor either");
        }

        // 封装方法调用为异步任务
        Callable