spring aop api

　　

* POINTCUT

一，concepts　　

　　spring's pointcut model enables pointcut reuse independent of advise type。so ，you can target different advice with the same pointcut。

　1.　the org.springframework.aop.Pointcut interface is the central interface，used to connection advices to classes and methods。

public interface Pointcut {
    Pointcut TRUE = TruePointcut.INSTANCE;

    ClassFilter getClassFilter();

    MethodMatcher getMethodMatcher();
}

　2.　the ClassFilter  interface use matches method to decide those class or method will be adviced。

@FunctionalInterface
public interface ClassFilter {
    ClassFilter TRUE = TrueClassFilter.INSTANCE;

    boolean matches(Class<?> var1);
}

 　3.   the MethodMatcher interface is normally more important。

public interface MethodMatcher {
    MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;

    boolean matches(Method var1, Class<?> var2);

    boolean isRuntime();

    boolean matches(Method var1, Class<?> var2, Object... var3);
}

　The matches(Method, Class) method is used to test whether this pointcut ever matches a given method on a target class.　

二，　Operations on Pointcuts

　　spring supports opertaions（notably，union and intersection）on pointcuts。i dont understand the three points。

　　Union means the methods that either pointcut matches. Intersection means the methods that both pointcuts match. Union is usually more useful. 

　　 You can compose pointcuts by using the static methods in the org.springframework.aop.support.Pointcuts class or by using the ComposablePointcut class in the same package. However, using AspectJ pointcut expressions is usually a simpler approach.

三，　Since 2.0, the most important type of pointcut used by Spring is org.springframework.aop.aspectj.AspectJExpressionPointcut. This is a pointcut that uses an AspectJ-supplied library to parse an AspectJ pointcut expression string.

四，Pointcut Superclasses

　　spring provides useful pointcut superclasses to help you to implement your own pointcuts。the superclasses is ‘ org.springframework.aop.support.StaticMethodMatcherPointcut’。

public abstract class StaticMethodMatcherPointcut extends StaticMethodMatcher implements Pointcut 

public abstract class StaticMethodMatcher implements MethodMatcher {
    public StaticMethodMatcher() {
    }

    public final boolean isRuntime() {
        return false;
    }

    public final boolean matches(Method method, Class<?> targetClass, Object... args) {
        throw new UnsupportedOperationException("Illegal MethodMatcher usage");
    }
}

override matches(Method method, Class<?> targetClass, Object... args)   is ok，and you can override other methods to customize behavior。

五，Custom Pointcuts

　　Because pointcuts in Spring AOP are Java classes rather than language features (as in AspectJ), you can declare custom pointcuts, whether static or dynamic. Custom pointcuts in Spring can be arbitrarily complex. However, we recommend using the AspectJ pointcut expression language, if you can.

* Advice 

一 ，Lifecycles

　　Each advice is a Spring bean. An advice instance can be shared across all advised objects or be unique to each advised object. 

二，advice type in spring

　　The most fundamental advice type in Spring is interception around advice.

　　Spring is compliant with the AOP Alliance interface for around advice that uses method interception. Classes that implement MethodInterceptor。

@FunctionalInterface
public interface MethodInterceptor extends Interceptor {
    Object invoke(MethodInvocation var1) throws Throwable;
}

　　The MethodInvocation argument to the invoke() method exposes the method being invoked, the target join point, the AOP proxy, and the arguments to the method.The invoke() method should return the invocation’s result: the return value of the join point.

public interface MethodInvocation extends Invocation {
    Method getMethod();
}

public interface Invocation extends Joinpoint {
    Object[] getArguments();
}

public class DebugInterceptor implements MethodInterceptor {

    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("Before: invocation=[" + invocation + "]");
        Object rval = invocation.proceed();
        System.out.println("Invocation returned");
        return rval;
    }
}

1. Before Advice

public interface MethodBeforeAdvice extends BeforeAdvice {
    void before(Method var1, Object[] var2, @Nullable Object var3) throws Throwable;
}

　　Note that the return type is void. Before advice can insert custom behavior before the join point executes but cannot change the return value. If a before advice throws an exception, it aborts further execution of the interceptor chain. The exception propagates back up the interceptor chain. If it is unchecked or on the signature of the invoked method, it is passed directly to the client. Otherwise, it is wrapped in an unchecked exception by the AOP proxy.

2. Throws Advice

　　it‘s a tag interface，afterThrowing([Method, args, target], subclassOfThrowable)，Only the last argument is required. 

　　The following advice is invoked if a RemoteException is thrown (including from subclasses):

public class RemoteThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(RemoteException ex) throws Throwable {
        // Do something with remote exception
    }
}

　　The final example illustrates how these two methods could be used in a single class that handles both RemoteException and ServletException. Any number of throws advice methods can be combined in a single class. The following listing shows the final example:

public static class CombinedThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(RemoteException ex) throws Throwable {
        // Do something with remote exception
    }

    public void afterThrowing(Method m, Object[] args, Object target, ServletException ex) {
        // Do something with all arguments
    }
}

3. After Returning Advice

　　An after returning advice has access to the return value (which it cannot modify), the invoked method, the method’s arguments, and the target.

public interface AfterReturningAdvice extends AfterAdvice {
    void afterReturning(@Nullable Object var1, Method var2, Object[] var3, @Nullable Object var4) throws Throwable;
}

4. introduction Advice

　　Spring treats introduction advice as a special kind of interception advice。

　　Introduction requires an IntroductionAdvisor and an IntroductionInterceptor that implement the following interface:　　

　　public interface IntroductionInterceptor extends MethodInterceptor, DynamicIntroductionAdvice {
　　}
　　public interface DynamicIntroductionAdvice extends Advice {
   　　 boolean implementsInterface(Class<?> var1);
　　}

　　The invoke() method inherited from the AOP Alliance MethodInterceptor interface must implement the introduction. That is, if the invoked method is on an introduced interface, the introduction interceptor is responsible for handling the method call — it cannot invoke proceed().

　　Introduction advice cannot be used with any pointcut, as it applies only at the class, rather than the method, level. You can only use introduction advice with the IntroductionAdvisor, which has the following methods:

public interface IntroductionAdvisor extends Advisor, IntroductionInfo {
    ClassFilter getClassFilter();

    void validateInterfaces() throws IllegalArgumentException;
}

public interface IntroductionInfo {
    Class<?>[] getInterfaces();
}

* ADVISOR 　

　　In Spring, an Advisor is an aspect that contains only a single advice object associated with a pointcut expression.

　　Apart from the special case of introductions, any advisor can be used with any advice. org.springframework.aop.support.DefaultPointcutAdvisor is the most commonly used advisor class. It can be used with a MethodInterceptor, BeforeAdvice, or ThrowsAdvice.

It is possible to mix advisor and advice types in Spring in the same AOP proxy. For example, you could use an interception around advice, throws advice, and before advice in one proxy configuration. Spring automatically creates the necessary interceptor chain.

*  Using the ProxyFactoryBean to Create AOP Proxies

 　　The basic way to create an AOP proxy in Spring is to use the org.springframework.aop.framework.ProxyFactoryBean. This gives complete control over the pointcuts, any advice that applies, and their ordering. 

* Creating AOP Proxies Programmatically with the ProxyFactory

 　　It is easy to create AOP proxies programmatically with Spring. This lets you use Spring AOP without dependency on Spring IoC.

ProxyFactory factory = new ProxyFactory(myBusinessInterfaceImpl);
factory.addAdvice(myMethodInterceptor);
factory.addAdvisor(myAdvisor);
MyBusinessInterface tb = (MyBusinessInterface) factory.getProxy();

* Manipulating Advised Objects

　　you can manipulate them BY using the org.springframework.aop.framework.Advised interface. Any AOP proxy can be cast to this interface, no matter which other interfaces it implements. This interface includes the following methods:

　　

ok https://docs.spring.io/spring/docs/5.2.4.RELEASE/spring-framework-reference/core.html#aop-targetsource