Joinpoint继承体系-笔记
Joinpoint继承层次图：
由上图可以知道的所有的接口的实现都在ReflectiveMethodInvocation这个类中。ConstructorInvocation接口只有一个方法，这个方法的实现好像是由ReflectMethodInvocation的getStaticPart()方法来实现的，具体请看源码。
现在把上面的接口和类的源码的看看，顺便做下笔记。
一、Joinpoint
这个接口表示一个一般的运行时连接点。一个运行时连接点是一个事件，这个事件发生在一个静态连接点（也就是在程序中的某一个位置）。例如：
接口的方法:
/** * Proceed to the next interceptor in the chain. * <p>The implementation and the semantics of this method depends * on the actual joinpoint type (see the children interfaces). * @return see the children interfaces' proceed definition * @throws Throwable if the joinpoint throws an exception */ Object proceed() throws Throwable;
开始拦截器链条中的下一个的拦截器。
/** * Return the object that holds the current joinpoint's static part. * <p>For instance, the target object for an invocation. * @return the object (can be null if the accessible object is static) */ Object getThis();
返回目标对象。
/** * Return the static part of this joinpoint. * <p>The static part is an accessible object on which a chain of * interceptors are installed. */ AccessibleObject getStaticPart();
返回连接点的静态部分，其实应该就是目标方法吧。（返回连接点的静态部分，静态部分就是的已经安装在拦截器链条上的可以访问的方法对象。）
二、Invocation
这个接口表示程序当中的一个调用。一个调用就是一个连接点而且可以被一个拦截器拦截。
这个接口只有一个方法：
/** * This interface represents an invocation in the program. * * <p>An invocation is a joinpoint and can be intercepted by an * interceptor. * * @author Rod Johnson */ public interface Invocation extends Joinpoint { /** * Get the arguments as an array object. * It is possible to change element values within this * array to change the arguments. * @return the argument of the invocation */ Object[] getArguments(); }
方法返回的是目标方法的参数。如果目标方法是无参方法，那么会返回一个Object[] 类型的长度为0的数组。
三、MethodInvocation
/** * Description of an invocation to a method, given to an interceptor * upon method-call. * * <p>A method invocation is a joinpoint and can be intercepted by a * method interceptor. * * @author Rod Johnson * @see MethodInterceptor */ public interface MethodInvocation extends Invocation { /** * Get the method being called. * <p>This method is a frienly implementation of the * {@link Joinpoint#getStaticPart()} method (same result). * @return the method being called *///返回一个已经被调用的方法，其实是目标方法。 Method getMethod(); }
getMethod()方法返回的是目标方法对应的Method对象。
四、ProxyMethodInvocation
这个接口扩展了MethodInvocation接口。
接口的方法：
/** * Return the proxy that this method invocation was made through. * @return the original proxy object */ Object getProxy();
返回原始的对象，也就是目标对象。
/** * Create a clone of this object. If cloning is done before {@code proceed()} * is invoked on this object, {@code proceed()} can be invoked once per clone * to invoke the joinpoint (and the rest of the advice chain) more than once. * @return an invocable clone of this invocation. * {@code proceed()} can be called once per clone. */ MethodInvocation invocableClone();
浅复制
/** * Set the arguments to be used on subsequent invocations in the any advice * in this chain. * @param arguments the argument array */ void setArguments(Object... arguments);
设置目标方法的参数值。
/** * Add the specified user attribute with the given value to this invocation. * <p>Such attributes are not used within the AOP framework itself. They are * just kept as part of the invocation object, for use in special interceptors. * @param key the name of the attribute * @param value the value of the attribute, or {@code null} to reset it */ void setUserAttribute(String key, Object value);
设置用户属性
五、ReflectiveMethodInvocation
使用反射类调用目标对象。子类可以覆盖invokeJoinpoint()方法。可以通过使用invocableClone()方法浅克隆一个调用（an invocation）来重复调用proceed()方法。而且还可以使用setUserAttribute(...)方法添加上自定义的属性到这个调用上。
这个类的属性：
protected final Object proxy;//代理对象。 protected final Object target;//目标对象。 protected final Method method;//目标方法对应的Method对象。 protected Object[] arguments;//目标方法参数。 private final Class<?> targetClass;//目标对象的类型 /** * Lazily initialized map of user-specific attributes for this invocation. */ private Map<String, Object> userAttributes; /** * List of MethodInterceptor and InterceptorAndDynamicMethodMatcher * that need dynamic checks. */ protected final List<?> interceptorsAndDynamicMethodMatchers; /** * Index from 0 of the current interceptor we're invoking. * -1 until we invoke: then the current interceptor. */ private int currentInterceptorIndex = -1;
这个类的方法：
这个类方法也不少，挑重要的讲。
①、构造器。
/** * Construct a new ReflectiveMethodInvocation with the given arguments. * @param proxy the proxy object that the invocation was made on * @param target the target object to invoke * @param method the method to invoke * @param arguments the arguments to invoke the method with * @param targetClass the target class, for MethodMatcher invocations * @param interceptorsAndDynamicMethodMatchers interceptors that should be applied, * along with any InterceptorAndDynamicMethodMatchers that need evaluation at runtime. * MethodMatchers included in this struct must already have been found to have matched * as far as was possibly statically. Passing an array might be about 10% faster, * but would complicate the code. And it would work only for static pointcuts. */ protected ReflectiveMethodInvocation( Object proxy, Object target, Method method, Object[] arguments, Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) { this.proxy = proxy; this.target = target; this.targetClass = targetClass; this.method = BridgeMethodResolver.findBridgedMethod(method); this.arguments = AopProxyUtils.adaptArgumentsIfNecessary(method, arguments); this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers; }
这个构造器在初始化对象时，设置了代理对象、目标对象、目标对象所属的类Calss对象、目标方法对应的Method对象、目标方法的参数、以及MethodInterceptor和InterceptorAndDynamicMethodMatcher组成的链条。
②、这是方法最重要。不管是通知方法还是目标方法，都是通过的这个方法来调用的。所以，连接点起到了一个调度的作用。
@Override public Object proceed() throws Throwable { // We start with an index of -1 and increment early.
//currentInterceptorIndex的值等于拦截器链的长度的时候说明每个拦截器都被调用了。此时可以调用目标方法了。 if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) { return invokeJoinpoint();//调用目标方法，不知道这里的方法名为什么叫invokeJoinpoint，明明是调用的目标方法嘛，还没参透。 } //currentInterceptorIndex的初始值为-1,所以它是从拦截器链条的第一个拦截器开始调用拦截器的。先++。
Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex); if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) { // Evaluate dynamic method matcher here: static part will already have // been evaluated and found to match. InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice; if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) { return dm.interceptor.invoke(this); } else { // Dynamic matching failed. // Skip this interceptor and invoke the next in the chain. //跳过当前的拦截器并且调用链条中的下一个拦截器.
return proceed(); } } else { // It's an interceptor, so we just invoke it: The pointcut will have // been evaluated statically before this object was constructed.
//调用拦截器。注意：这个对象把自己作为参数。这就是为什么拦截器中又可以调用这个proceed()方法的原因。
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); } }
现在用一张图来解释上面的代码。
浅色小框表示连接点。深色大框表示拦截器（第一个深色框和最后一个深色框除外）。
箭头标表示程序的执行方向。我画的箭头的起始位置是非常严格的，比如后置通知的那个方框，箭头进来不是直接指向mi.proceed()那行代码的，意思是表示它之前可能还有代码。需要执行mi.proceed()那行代码之前的代码，然后才执行mi.proceed()这行，执行mi.proceed()的时候程序跳转到了连接点。在连接点中将取出下一个拦截器，调用它的invoke方法程序进入到下一个拦截器。当程序返回时，箭头并不是直接指向mi.proceed()这行代码的，说明这行代码已经执行完，现在执行mi.proceed()后面的代码。每个方法的底部都会有一个箭头指向上一个方框，箭头在方框的底部说明方法执行完毕并且return了。
根据上面的图，可以看出无论拦截器链中各个拦截器的顺序是什么样的，前置通知总是能够在调用目标方法之前执行，因为前置通知总是在mi.proceed()之前执行。而后置通知总是在目标方法之后执行，因为后置通知总是在mi.proceed()之后。但是返回通知和后置通知谁先执行呢？？？这个就跟它们在链条的顺序有关了。如上图，应该是返回通知先执行然后才到后置通知。
