【小家Spring】探索Spring AOP中aopalliance的Joinpoint、MethodInvocation、Interceptor、MethodInterceptor...

// 此接口表示运行时的连接点（AOP术语）  （和aspectj里的连接点意思有点像）
public interface Joinpoint {

	// 执行此拦截点，并进入到下一个连接点
	Object proceed() throws Throwable;
	// 返回保存当前连接点静态部分【的对象】。  这里一般指的target
	Object getThis();
	// 返回此静态连接点  一般就为当前的Method(至少目前的唯一实现是MethodInvocation,所以连接点得静态部分肯定就是本方法喽)
	AccessibleObject getStaticPart();
}

// 此接口表示程序中的调用~
// 该调用是一个可以被拦截器拦截的连接点
public interface Invocation extends Joinpoint {
	// 获得参数们。比如方法的入参们
	Object[] getArguments();
}

// 方法调用时，对这部分进行描述
public interface MethodInvocation extends Invocation {
	// 返回正在被调用得方法~~~  返回的是当前Method对象。
	// 此时，效果同父类的AccessibleObject getStaticPart() 这个方法
	Method getMethod();
}

// 这是Spring提供的对MethodInvocation 的一个扩展。
// 它允许访问  方法被调用的代理对象以及其它相关信息
public interface ProxyMethodInvocation extends MethodInvocation {
	
	// 返回代理对象
	Object getProxy();
	
	// 克隆一个，使用的Object得clone方法
	MethodInvocation invocableClone();
	MethodInvocation invocableClone(Object... arguments);

	// 设置参数  增强器、通知们执行的时候可能会用到
	void setArguments(Object... arguments);
	// 添加一些属性kv。这些kv并不会用于AOP框架内，而是保存下来给特殊的一些拦截器实用
	void setUserAttribute(String key, @Nullable Object value);
	@Nullable
	Object getUserAttribute(String key);
}

public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {

	protected final Object proxy; // 代理对象
	@Nullable
	protected final Object target; // 目标对象
	protected final Method method; // 被拦截的方法

	protected Object[] arguments = new Object[0];
	@Nullable
	private final Class<?> targetClass;

	@Nullable
	private Map<String, Object> userAttributes;
	protected final List<?> interceptorsAndDynamicMethodMatchers;
	
	// currentInterceptorIndex初始值为 -1 
	private int currentInterceptorIndex = -1;

	// 唯一的构造函数。注意是protected  相当于只能本包内、以及子类可以调用。外部是不能直接初始化的此对象的（显然就是Spring内部使用的类了嘛）
	//invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
	// proxy：代理对象
	// target：目标对象
	// method：被代理的方法
	// args：方法的参数们
	// targetClass：目标方法的Class (target != null ? target.getClass() : null)
	// interceptorsAndDynamicMethodMatchers：拦截链。  this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)这个方法找出来的
	protected ReflectiveMethodInvocation(
			Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments,
			@Nullable Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {

		this.proxy = proxy;
		this.target = target;
		this.targetClass = targetClass;
		// 找到桥接方法，作为最后执行的方法。至于什么是桥接方法，自行百度关键字：bridge method
		// 桥接方法是 JDK 1.5 引入泛型后，为了使Java的泛型方法生成的字节码和 1.5 版本前的字节码相兼容，由编译器自动生成的方法（子类实现父类的泛型方法时会生成桥接方法）
		this.method = BridgeMethodResolver.findBridgedMethod(method);
		// 对参数进行适配
		this.arguments = AopProxyUtils.adaptArgumentsIfNecessary(method, arguments);
		this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
	}

	@Override
	public final Object getProxy() {
		return this.proxy;
	}
	@Override
	@Nullable
	public final Object getThis() {
		return this.target;
	}
	// 此处：getStaticPart返回的就是当前得method
	@Override
	public final AccessibleObject getStaticPart() {
		return this.method;
	}
	// 注意：这里返回的可能是桥接方法哦
	@Override
	public final Method getMethod() {
		return this.method;
	}
	@Override
	public final Object[] getArguments() {
		return this.arguments;
	}
	@Override
	public void setArguments(Object... arguments) {
		this.arguments = arguments;
	}


	// 这里就是核心了，要执行方法、执行通知、都是在此处搞定的
	// 这里面运用 递归调用 的方式，非常具有技巧性
	@Override
	@Nullable
	public Object proceed() throws Throwable {
		//	currentInterceptorIndex初始值为 -1  如果执行到链条的末尾 则直接调用连接点方法 即 直接调用目标方法
		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
			// 这个方法相当于调用了目标方法~~~下面会分析
			return invokeJoinpoint();
		}

		// 获取集合中的 MethodInterceptor（并且currentInterceptorIndex + 1了哦）
		Object interceptorOrInterceptionAdvice =
				this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

		//InterceptorAndDynamicMethodMatcher它是Spring内部使用的一个类。很简单，就是把MethodInterceptor实例和MethodMatcher放在了一起。看看在advisor chain里面是否能够匹配上
		if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
			InterceptorAndDynamicMethodMatcher dm =
					(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
			
			// 去匹配这个拦截器是否适用于这个目标方法  试用就执行拦截器得invoke方法
			if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
				return dm.interceptor.invoke(this);
			}
			else {
				// 如果不匹配。就跳过此拦截器，而继续执行下一个拦截器
				// 注意：这里是递归调用  并不是循环调用
				return proceed();
			}
		}
		else {
			// 直接执行此拦截器。说明之前已经匹配好了，只有匹配上的方法才会被拦截进来的
			// 这里传入this就是传入了ReflectiveMethodInvocation，从而形成了一个链条了
			return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
		}
	}
	

	// 其实就是简单的一个：method.invoke(target, args);
	// 子类可以复写此方法，去执行。比如它的唯一子类CglibAopProxy内部类  CglibMethodInvocation就复写了这个方法  它对public的方法做了一个处理（public方法调用MethodProxy.invoke）
	@Nullable
	protected Object invokeJoinpoint() throws Throwable {
		// 此处传入的是target，而不能是proxy，否则进入死循环
		return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
	}

	@Override
	public MethodInvocation invocableClone() {
		Object[] cloneArguments = this.arguments;
		if (this.arguments.length > 0) {
			// Build an independent copy of the arguments array.
			cloneArguments = new Object[this.arguments.length];
			System.arraycopy(this.arguments, 0, cloneArguments, 0, this.arguments.length);
		}
		return invocableClone(cloneArguments);
	}
	@Override
	public MethodInvocation invocableClone(Object... arguments) {
		if (this.userAttributes == null) {
			this.userAttributes = new HashMap<>();
		}
		try {
			ReflectiveMethodInvocation clone = (ReflectiveMethodInvocation) clone();
			clone.arguments = arguments;
			return clone;
		} catch (CloneNotSupportedException ex) {
			throw new IllegalStateException(
					"Should be able to clone object of type [" + getClass() + "]: " + ex);
		}
	}
	@Override
	public void setUserAttribute(String key, @Nullable Object value) {
		if (value != null) {
			if (this.userAttributes == null) {
				this.userAttributes = new HashMap<>();
			}
			this.userAttributes.put(key, value);
		}
		else {
			if (this.userAttributes != null) {
				this.userAttributes.remove(key);
			}
		}
	}
	@Override
	@Nullable
	public Object getUserAttribute(String key) {
		return (this.userAttributes != null ? this.userAttributes.get(key) : null);
	}
	public Map<String, Object> getUserAttributes() {
		if (this.userAttributes == null) {
			this.userAttributes = new HashMap<>();
		}
		return this.userAttributes;
	}

	@Override
	public String toString() {
		// Don't do toString on target, it may be proxied.
		StringBuilder sb = new StringBuilder("ReflectiveMethodInvocation: ");
		sb.append(this.method).append("; ");
		if (this.target == null) {
			sb.append("target is null");
		}
		else {
			sb.append("target is of class [").append(this.target.getClass().getName()).append(']');
		}
		return sb.toString();
	}

}

	private static class CglibMethodInvocation extends ReflectiveMethodInvocation {

		private final MethodProxy methodProxy;

		private final boolean publicMethod;

		public CglibMethodInvocation(Object proxy, @Nullable Object target, Method method,
				Object[] arguments, @Nullable Class<?> targetClass,
				List<Object> interceptorsAndDynamicMethodMatchers, MethodProxy methodProxy) {
			
			// 调用父类的构造  完成基本参数得初始化
			super(proxy, target, method, arguments, targetClass, interceptorsAndDynamicMethodMatchers);
			
			// 自己的个性化参数：
			
			// 这个参数是子类多传的，表示：它是CGLIb拦截的时候的类MethodProxy
			//MethodProxy为生成的代理类对方法的代理引用。cglib生成用来代替Method对象的一个对象，使用MethodProxy比调用JDK自身的Method直接执行方法效率会有提升
			// 它有两个重要的方法：invoke和invokeSuper
			this.methodProxy = methodProxy;
			// 方法是否是public的  对应下面的invoke方法的处理 见下面
			this.publicMethod = Modifier.isPublic(method.getModifiers());
		}

		@Override
		protected Object invokeJoinpoint() throws Throwable {
			// 如果是public的方法，调用methodProxy去执行目标方法
			// 否则直接执行method即可
			if (this.publicMethod) {
				// 此处务必注意的是，传入的是target，而不能是proxy，否则进入死循环
				return this.methodProxy.invoke(this.target, this.arguments);
			} else {
				return super.invokeJoinpoint();
			}
		}
	}

// 从名字里都能看出来，它是通过拦截方法的执行来实现通知得效果的~~~~
@FunctionalInterface
public interface MethodInterceptor extends Interceptor {
	// 可议在此方法里  在方法执行之前、之后做对应的处理。
	// 需要执行的时候，调用invocation.proceed()方法即可
	Object invoke(MethodInvocation invocation) throws Throwable;
}

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {

	private MethodBeforeAdvice advice;
	
	public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
		Assert.notNull(advice, "Advice must not be null");
		this.advice = advice;
	}
	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		// 在目标方法执行之前，先执行advice得before方法~~~
		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
		
		// 注意此处继续调用了 mi.proceed()。相当于去执行下一个增强器。类似于递归执行了，这样就行程了一个链式得调用执行
		return mi.proceed();
	}
}

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
	public Object invoke(MethodInvocation mi) throws Throwable {
		Object retVal = mi.proceed();
		// 嗲用afterReturning，它是能够享受到返回值的
		this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
		return retVal;
	}

}

public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {
	...
}

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {
	...
	public DefaultAdvisorAdapterRegistry() {
		registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
		registerAdvisorAdapter(new AfterReturningAdviceAdapter());
		registerAdvisorAdapter(new ThrowsAdviceAdapter());
	}	 
	...
}