AOP简单介绍

• 本文源码基于spring-framework-5.3.10。
• AOP表示面向切面编程，是一种编程思想。

AOP中的一些概念

• Aspect：表示切面，比如被@Aspect注解的类就是切面，可以在切面中去定义Pointcut、Advice等等。
• Join point：表示连接点，表示一个程序在执行过程中的一个点，比如一个方法的执行，比如一个异常的处理，在Spring AOP中，一个连接点通常表示一个方法的执行。
• Advice：表示通知，表示在一个特定连接点上所采取的动作。Advice分为不同的类型，在很多AOP框架中，包括Spring，会用Interceptor拦截器来实现Advice，并且在连接点周围维护一个Interceptor链。
• Pointcut：表示切点，用来匹配一个或多个连接点，Advice与切点表达式是关联在一起的，Advice将会执行在和切点表达式所匹配的连接点上。
• Introduction：可以使用@DeclareParents来给所匹配的类添加一个接口，并指定一个默认实现。
• Target object：目标对象，被代理对象。
• AOP proxy：表示代理工厂，用来创建代理对象的，在Spring Framework中，要么是JDK动态代理，要么是CGLIB代理。
• Weaving：表示织入，表示创建代理对象的动作，这个动作可以发生在编译时期（比如Aspejctj），或者运行时，比如Spring AOP。

Advice在Spring AOP中对应API

• @Before：AspectJMethodBeforeAdvice，实际上就是一个MethodBeforeAdvice。
• @AfterReturning：AspectJAfterReturningAdvice，实际上就是一个AfterReturningAdvice。
• @AfterThrowing：AspectJAfterThrowingAdvice，实际上就是一个MethodInterceptor。
• @After：AspectJAfterAdvice，实际上就是一个MethodInterceptor。
• @Around：AspectJAroundAdvice，实际上就是一个MethodInterceptor。

AOP整体流程

• 实例化前，会判断是否对当前beanName设置了TargetSource，可以通过CustomTargetSourceCreators来设置，如果设置了则直接针对所设置的TargetSource进行AOP，得到代理对象后直接返回，不会经过后续的生命周期了。
• 实例化，得到原始对象。
• 给原始对象填充属性。
• 初始化前。
• 初始化。
• 初始化后，这里会开始进行AOP。
• 先判断当前Bean是不是要进行AOP,比如当前Bean的类型是PointCut、Advice、Advisor等就不需要进行AOP。
• 筛选出和当前Bean所匹配的Advice、Advisor。
• 基本Bean的原始对象和所匹配的Advice、Advisor创建代理对象，并返回。

创建代理对象的流程。

• 构造一个ProxyFactory。
• 配置ProxyFactory。
• 将commonInterceptors和specificInterceptors整合再一起。

生成代理对象流程

• 构造Enhancer对象。
• 设置DynamicAdvisedInterceptor为Callback。
• 所以代理对象执行方法时就会经过DynamicAdvisedInterceptor。

代理对象执行方法的流程

• 根据当前所调用的方法和对应的类筛选对应的Advisor。
• 获取Advisor中的Advice，并封装为MethodInterceptor。
• 将得到的所有匹配的MethodInterceptor组合成List
• 将代理对象、被代理对象、当前正在执行的被代理类中的方法对象、方法参数、被代理的类、chain、当前正在执行的代理类中的方法对象整合成一个CglibMethodInvocation对象。
• 调用CglibMethodInvocation对象的proceed()方法。
• 开始执行MethodInterceptor，不同类型的MethodInterceptor执行逻辑会有差异。
• MethodInterceptor执行完了之后（调用链的总结，所有调用链加载完成的时候），会执行被代理对象的对应的方法对象，也就是执行被代理对象中对应的方法，也就是业务方法。

ProxyFactory选择cglib或jdk动态代理原理

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

	/**
	 * 如果ProxyFactory的isOptimize为true，Spring认为cglib比jdk动态代理要快。
	 * 或者isProxyTargetClass为true，
	 * 或者被代理对象没有实现接口，
	 * 或者只实现了SpringProxy这个接口，
	 * 那么则利用Cglib进行动态代理，但如果被代理类是接口，或者被代理类已经是进行过JDK动态代理而生成的代理类了则只能进行JDK动态代理
	 * 其他情况都会进行JDK动态代理，比如被代理类实现了除SpringProxy接口之外的其他接口
	 */
	@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {

		// 是不是在GraalVM虚拟机上运行
		// config.isOptimize()：使用proxyFactory.setOptimize(true)进行设置，默认为false。
		// config.isProxyTargetClass():使用proxyFactory.setProxyTargetClass(true)进行设置，默认为false。
		// hasNoUserSuppliedProxyInterfaces(config)：使用proxyFactory.addInterface（）便会返回false。
		if (!NativeDetector.inNativeImage() &&
				(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {

			// 获取被代理的对象
			Class<?> targetClass = config.getTargetClass();
			// 被代理的对象为空，抛异常
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}

			// 被代理的对象是个接口或者是个jdk动态代理产生的代理对象
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				// 使用jdk的动态代理
				return new JdkDynamicAopProxy(config);
			}

			// 使用cglib动态代理
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			// 使用jdk的动态代理
			return new JdkDynamicAopProxy(config);
		}
	}
	
	......
}

cglib动态代理的实现逻辑

/**
 * cglib动态代理实现逻辑
 */
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
	if (logger.isTraceEnabled()) {
		logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
	}

	try {
		// 被代理的类
		Class<?> rootClass = this.advised.getTargetClass();
		Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

		Class<?> proxySuperClass = rootClass;
		// 如果被代理类本身就已经是Cglib所生成的代理类了
		if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
			// 获取真正的被代理类
			proxySuperClass = rootClass.getSuperclass();
			// 获取被代理类所实现的接口
			Class<?>[] additionalInterfaces = rootClass.getInterfaces();
			for (Class<?> additionalInterface : additionalInterfaces) {
				this.advised.addInterface(additionalInterface);
			}
		}

		// Validate the class, writing log messages as necessary.
		validateClassIfNecessary(proxySuperClass, classLoader);

		// Configure CGLIB Enhancer...
		Enhancer enhancer = createEnhancer();
		if (classLoader != null) {
			enhancer.setClassLoader(classLoader);
			if (classLoader instanceof SmartClassLoader &&
					((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
				enhancer.setUseCache(false);
			}
		}

		// 被代理类，代理类的父类。可以进行强转
		enhancer.setSuperclass(proxySuperClass);
		// 代理类额外要实现的接口。可以进行强转enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
		enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
		enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));

		// 获取和被代理类所匹配的Advisor
		Callback[] callbacks = getCallbacks(rootClass);
		Class<?>[] types = new Class<?>[callbacks.length];
		for (int x = 0; x < types.length; x++) {
			types[x] = callbacks[x].getClass();
		}
		// fixedInterceptorMap only populated at this point, after getCallbacks call above
		enhancer.setCallbackFilter(new ProxyCallbackFilter(
				this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
		enhancer.setCallbackTypes(types);

		// Generate the proxy class and create a proxy instance.
		return createProxyClassAndInstance(enhancer, callbacks);
	}
	catch (CodeGenerationException | IllegalArgumentException ex) {
		throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() +
				": Common causes of this problem include using a final class or a non-visible class",
				ex);
	}
	catch (Throwable ex) {
		// TargetSource.getTarget() failed
		throw new AopConfigException("Unexpected AOP exception", ex);
	}
}

JDK动态代理的实现逻辑

/**
 * JDK动态代理实现逻辑
 */
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
	if (logger.isTraceEnabled()) {
		logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
	}
	// this实现了InvocationHandler
	return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
}

/**
 * JDK动态代理的具体执行逻辑
 */
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	Object oldProxy = null;
	boolean setProxyContext = false;

	// 拿到被代理对象
	TargetSource targetSource = this.advised.targetSource;
	Object target = null;

	try {
		// equals()方法直接执行。如果接口中没有定义equals()方法，那么则直接调用，不走代理
		if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
			// The target does not implement the equals(Object) method itself.
			return equals(args[0]);
		}
		// HashCode()方法直接执行。如果接口中没有定义HashCode()方法，那么则直接调用，不走代理
		else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
			// The target does not implement the hashCode() method itself.
			return hashCode();
		}
		else if (method.getDeclaringClass() == DecoratingProxy.class) {
			// There is only getDecoratedClass() declared -> dispatch to proxy config.
			// 得到代理对象的类型，而不是所实现的接口
			return AopProxyUtils.ultimateTargetClass(this.advised);
		}
		else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
				method.getDeclaringClass().isAssignableFrom(Advised.class)) {
			// Service invocations on ProxyConfig with the proxy config...
			// 也是直接调用Advised接口中的方法，不走代理逻辑
			// 其实就是利用代理对象获取ProxyFactory中的信息
			return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
		}

		Object retVal;

		// 如果ProxyFactory的exposeProxy为true,则将代理对象设置到currentProxy这个ThreadLocal中去。
		// 可以通过AopContext.currentProxy()来获取当前的代理对象
		if (this.advised.exposeProxy) {
			// Make invocation available if necessary.
			oldProxy = AopContext.setCurrentProxy(proxy);
			setProxyContext = true;
		}

		// Get as late as possible to minimize the time we "own" the target,
		// in case it comes from a pool.
		// 调用getTarget得到被代理对象
		target = targetSource.getTarget();
		// 得到代理类
		Class<?> targetClass = (target != null ? target.getClass() : null);

		// Get the interception chain for this method.
		// 代理对象在执行某个方法时，根据方法筛选出匹配的Advisor,并适配成Interceptor
		// this.advised是ProxyFactory对象
		List