public class UserService {

    public void createUser(String username) {

        // 模拟业务处理
        System.out.println("Creating user: " + username);
    }

    public void deleteUser(String username) {

        // 模拟业务处理
        System.out.println("Deleting user: " + username);
    }
}

// 定义一个前置增强
public class LoggingBeforeAdvice implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("Before method: " + method.getName());
    }
}

// 定义一个后置增强
public class LoggingAfterAdvice implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("After method: " + method.getName());
    }
}

// 定义一个 环绕增强
public class LoggingMethodInterceptor implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 方法执行前逻辑
        long startTime = System.currentTimeMillis();
        System.out.println(invocation.getMethod().getName()+ " 方法开始执行");


        // 通过反射执行目标方法
        Object result = invocation.proceed();

        // 方法执行后逻辑
        //System.out.println("After method: " + invocation.getMethod().getName());
        long endTime = System.currentTimeMillis();
        System.out.println(invocation.getMethod().getName()+ "方法执行时间: " + (endTime - startTime) + "ms");

        return result;
    }
}

public class CodingInActionApplication{
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 获取代理对象
        UserService userService = (UserService) context.getBean("userServiceProxy");

        // 调用方法，观察 AOP 切面的效果
        userService.createUser("john");
        userService.deleteUser("john");
    }
}

UserService userService = (UserService) context.getBean("userServiceProxy");

private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
	// 检查Advisor Chain是否已经初始化
	// 如果advisorChainInitialized标志已经为true，表示Advisor Chain已经初始化过了，方法直接返回，不再进行初始化。
	if (this.advisorChainInitialized) {
		return;
	}
	// 检查Interceptor名称列表是否为空。如果interceptorNames为空，则跳过初始化。
	if (!ObjectUtils.isEmpty(this.interceptorNames)) {
		if (this.beanFactory == null) {
			throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
					"- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));
		}

		// Globals can't be last unless we specified a targetSource using the property...
		// 检查interceptorNames数组的最后一个元素是否以GLOBAL_SUFFIX结尾。
		// 如果是Global类型，并且targetName为null且targetSource为EMPTY_TARGET_SOURCE，
		// 则抛出AopConfigException异常，表示在Global Interceptor之后需要一个目标。
		if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&
				this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
			throw new AopConfigException("Target required after globals");
		}

		// Materialize interceptor chain from bean names.
		for (String name : this.interceptorNames) {
			// 如果名称以GLOBAL_SUFFIX结尾：
			if (name.endsWith(GLOBAL_SUFFIX)) {
				// 检查beanFactory是否为ListableBeanFactory类型。如果不是，抛出AopConfigException异常。
				if (!(this.beanFactory instanceof ListableBeanFactory)) {
					throw new AopConfigException(
							"Can only use global advisors or interceptors with a ListableBeanFactory");
				}
				// 如果是ListableBeanFactory类型， 则将全局Advisor添加到Advisor Chain中。
				addGlobalAdvisors((ListableBeanFactory) this.beanFactory,
						name.substring(0, name.length() - GLOBAL_SUFFIX.length()));
			}

			else {
				// 如果名称不是以GLOBAL_SUFFIX结尾
				Object advice;
				// 根据名称检查Bean是单例（singleton）还是原型（prototype）。
				if (this.singleton || this.beanFactory.isSingleton(name)) {

					// 如果是单例或this.singleton为true，则从beanFactory中获取实际的advice实例
					// 注意，此时IOC 容器已经启动完成， getBean会从三层缓存中获取实例返回
					advice = this.beanFactory.getBean(name);
				}
				else {
					// 如果是原型（prototype），则创建一个对象
					advice = new PrototypePlaceholderAdvisor(name);
				}
				// 将advice添加到Advisor Chain中。
				addAdvisorOnChainCreation(advice);
			}
		}
	}

	this.advisorChainInitialized = true;
}

advice = this.beanFactory.getBean(name);

public class ProxyFactoryBean extends ProxyCreatorSupport  
implements FactoryBean<Object>, BeanClassLoaderAware, BeanFactoryAware {

  	private synchronized Object getSingletonInstance() {
			this.singletonInstance = getProxy(createAopProxy());
	
		 return this.singletonInstance;
	}
	// 根据确定的动态代理，创建target 的代理对象
	protected Object getProxy(AopProxy aopProxy) {  
		return aopProxy.getProxy(this.proxyClassLoader);  
	}
}

public class ProxyCreatorSupport extends AdvisedSupport {
  	protected final synchronized AopProxy createAopProxy() {
		if (!this.active) {
			activate();
		}
		return getAopProxyFactory().createAopProxy(this);
	}
}


// 确定动态代理的类型
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

	@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		if (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动态代理。
			// 如果是代理类，也使用JDK动态代理。
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			// 如果目标类既不是接口，也不是代理类，则使用CGLIB代理。
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
    }
  }
}

class CglibAopProxy implements AopProxy, Serializable {
  @Override
	public Object getProxy(@Nullable ClassLoader classLoader) {
		if (logger.isTraceEnabled()) {
			logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
		}

		try {
			// 获取目标类的 Class 对象， 并将其设置为代理类的父类，因为cglib代理是通过生成子类的方式实现的
			Class<?> rootClass = this.advised.getTargetClass();
			Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

			Class<?> proxySuperClass = rootClass;
			// 检查rootClass的名称是否包含CGLIB的类分隔符 "$$"，$$通常用来分隔原始类名和附加的代理类信息
			// 如果包含，说明 rootClass 还有它的父类，要把proxySuperClass 设置为这个父类
			if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
				proxySuperClass = rootClass.getSuperclass();
				Class<?>[] additionalInterfaces = rootClass.getInterfaces();
				for (Class<?> additionalInterface : additionalInterfaces) {
					// 获取目标类实现的所有接口，并将这些接口添加到advised对象中。
					this.advised.addInterface(additionalInterface);
				}
			}

			// Validate the class, writing log messages as necessary.
			// 验证代理超类是否合法
			validateClassIfNecessary(proxySuperClass, classLoader);

			// Configure CGLIB Enhancer...
			// 创建Enhancer实例，用于生成代理类。
			Enhancer enhancer = createEnhancer();
			// 如果传入了classLoader，则将其设置为Enhancer的类加载器。
			if (classLoader != null) {
				enhancer.setClassLoader(classLoader);
				// 如果类加载器是SmartClassLoader的实例，并且代理类的超类是可重载的，则禁用缓存
				if (classLoader instanceof SmartClassLoader &&
						((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
					enhancer.setUseCache(false);
				}
			}
			// 设置代理类的父类
			enhancer.setSuperclass(proxySuperClass);
			// 设置代理类实现的接口
			enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
			// 设置命名策略，确保生成的代理类有合适的名称
			enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
			// 设置生成策略，使用ClassLoaderAwareGeneratorStrategy来处理类加载器。
			enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
			// 获取用于代理的方法回调， 回调必须实现MethodInterceptor接口
			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);
		}
	}
}


class ObjenesisCglibAopProxy extends CglibAopProxy {
  
  @Override
	protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
		// 获取代理类的Class 对象
		Class<?> proxyClass = enhancer.createClass();
		Object proxyInstance = null;
		// 检查是否值得尝试使用Objenesis。
		if (objenesis.isWorthTrying()) {
			try {
				// 如果值得尝试，则尝试使用Objenesis实例化代理对象
				proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
			}
			catch (Throwable ex) {
				logger.debug("Unable to instantiate proxy using Objenesis, " +
						"falling back to regular proxy construction", ex);
			}
		}
		// 如果proxyInstance仍然是null，则使用常规方式通过默认构造函数实例化代理对象
		if (proxyInstance == null) {
			// Regular instantiation via default constructor...
			try {
				// 获取代理类的构造函数，根据是否有构造参数决定使用哪个构造函数
				Constructor<?> ctor = (this.constructorArgs != null ?
						proxyClass.getDeclaredConstructor(this.constructorArgTypes) :
						proxyClass.getDeclaredConstructor());
				// 设置构造函数可访问， private 构造函数是不可访问的
				ReflectionUtils.makeAccessible(ctor);
				// 使用构造函数实例化代理对象
				proxyInstance = (this.constructorArgs != null ?
						ctor.newInstance(this.constructorArgs) : ctor.newInstance());
			}
			catch (Throwable ex) {
				throw new AopConfigException("Unable to instantiate proxy using Objenesis, " +
						"and regular proxy instantiation via default constructor fails as well", ex);
			}
		}
		// 设置回调用
		((Factory) proxyInstance).setCallbacks(callbacks);
		return proxyInstance;
	}  
}

public class HelloWorldInterceptor implements MethodInterceptor {  
	@Override  
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {  
		System.out.println("Before method: " + method.getName());  
		Object result = proxy.invokeSuper(obj, args);  
		System.out.println("After method: " + method.getName());  
		return result;  
	}  
}

public class CglibDynamicProxyDemo {  
  
	public static void main(String[] args) {  
		Enhancer enhancer = new Enhancer();  
		enhancer.setSuperclass(HelloWorldImpl.class);  
		enhancer.setCallback(new HelloWorldInterceptor());  
		  
		HelloWorld proxy = (HelloWorld) enhancer.create();  
		proxy.sayHello();  
		proxy.sayBye();  
	}  
}

package org.springframework.cglib.proxy;    
public interface Callback {  
}

package org.springframework.cglib.proxy;
public interface MethodInterceptor extends Callback {
    Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable;
}

Callback[] callbacks = getCallbacks(rootClass);

private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
		// Parameters used for optimization choices...
		// 是否需要公开代理对象。
		boolean exposeProxy = this.advised.isExposeProxy();
		// 代理配置是否被冻结。
		boolean isFrozen = this.advised.isFrozen();
		// 目标源是否是静态的（即目标对象在创建时已经确定，不会变化）。
		boolean isStatic = this.advised.getTargetSource().isStatic();

		// Choose an "aop" interceptor (used for AOP calls).
		// 创建一个DynamicAdvisedInterceptor实例，用于处理AOP调用。这是主要的AOP拦截器。
		Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);

		// Choose a "straight to target" interceptor. (used for calls that are
		// unadvised but can return this). May be required to expose the proxy.
		Callback targetInterceptor;
		if (exposeProxy) {
			targetInterceptor = (isStatic ?
					new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
					new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource()));
		}
		else {
			targetInterceptor = (isStatic ?
					new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
					new DynamicUnadvisedInterceptor(this.advised.getTargetSource()));

		Callback targetDispatcher = (isStatic ?
				new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp());

		Callback[] mainCallbacks = new Callback[] {
				aopInterceptor,  // for normal advice 处理常规的AOP增强。
				// 优化情况下直接调用目标对象的方法。
				targetInterceptor,  // invoke target without considering advice, if optimized
				// 对于没有增强的方法，什么也不做。
				new SerializableNoOp(),  // no override for methods mapped to this
				// 直接调用静态目标的方法。
				targetDispatcher,
				// 代理配置的调度器。
				this.advisedDispatcher,
				//  处理equals方法的拦截器。
				new EqualsInterceptor(this.advised),
				// 处理equals方法的拦截器。
				new HashCodeInterceptor(this.advised)
		};

		Callback[] callbacks;
		return callbacks;
	}

userService.createUser("john");  
userService.deleteUser("john");

private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {

		private final AdvisedSupport advised;

		public DynamicAdvisedInterceptor(AdvisedSupport advised) {
			this.advised = advised;
		}

		@Override
		@Nullable
		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
			Object oldProxy = null;
			boolean setProxyContext = false;
			Object target = null;
			TargetSource targetSource = this.advised.getTargetSource();
			try {
				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...
				target = targetSource.getTarget();
				Class<?> targetClass = (target != null ? target.getClass() : null);
				// 获取适用于当前类当前方法的增强，还记得“筛选条件”吗
				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
				Object retVal;
				// 如果拦截器链为空并且方法是public的,直接通过methodProxy调用目标对象的方法。
				if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
					Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
					retVal = methodProxy.invoke(target, argsToUse);
				}
				else {
					// We need to create a method invocation...
					// 创建一个CglibMethodInvocation对象并调用其proceed方法，执行拦截器链中的所有拦截器逻辑。
					retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
				}
				retVal = processReturnType(proxy, target, method, retVal);
				return retVal;
			}
			finally {
				if (target != null && !targetSource.isStatic()) {
					targetSource.releaseTarget(target);
				}
				if (setProxyContext) {
					// Restore old proxy.
					AopContext.setCurrentProxy(oldProxy);
				}
			}
		}

		@Override
		public boolean equals(@Nullable Object other) {
			return (this == other ||
					(other instanceof DynamicAdvisedInterceptor &&
							this.advised.equals(((DynamicAdvisedInterceptor) other).advised)));
		}

		/**
		 * CGLIB uses this to drive proxy creation.
		 */
		@Override
		public int hashCode() {
			return this.advised.hashCode();
		}
	}

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {  
	MethodCacheKey cacheKey = new MethodCacheKey(method);  
	List<Object> cached = this.methodCache.get(cacheKey);  
	if (cached == null) {  
		cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(  
	this, method, targetClass);  
		this.methodCache.put(cacheKey, cached);  
	}  
	return cached;  
}

class CglibAopProxy implements AopProxy, Serializable {
	private static class CglibMethodInvocation extends ReflectiveMethodInvocation {
	@Override  
	@Nullable  
	public Object proceed() throws Throwable {
		return super.proceed();
	}
}
````
#### ReflectiveMethodInvocation
`ReflectiveMethodInvocation.proceed` 是CGLIB 动态代理处理目标方法调用 核心逻辑。

它根据`currentInterceptorIndex`来判断是执行Advice 增强逻辑，还是执行目标方法的调用
```java
public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {
	public Object proceed() throws Throwable {
		// We start with an index of -1 and increment early.
		// 检查当前拦截器索引是否已经到达拦截器链的末尾。如果是，则调用invokeJoinpoint方法，直接执行目标方法。
		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
			return invokeJoinpoint();
		}
		// 增加当前拦截器索引，并获取下一个拦截器或增强逻辑对象
		Object interceptorOrInterceptionAdvice =
				this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
		if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
			InterceptorAndDynamicMethodMatcher dm =
					(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
			Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
			if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
				return dm.interceptor.invoke(this);
			}
			else {

				return proceed();
			}
		}
		else {
			return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
		}
	}
}

public interface UserI {  
	void createUser(String username);  
	  
	void deleteUser(String username);  
}


public class UserService implements UserI {
    @Override
    public void createUser(String username) {

        // 模拟业务处理
        System.out.println("Creating user: " + username);
    }

    @Override
    public void deleteUser(String username) {
        // 模拟业务处理
        System.out.println("Deleting user: " + username);

    }
}

public class CodingInActionApplication {

    public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserI userService = (UserI) context.getBean("userServiceProxy");

        // 调用方法，观察 AOP 切面的效果
        userService.createUser("john");
        userService.deleteUser("john");
    }
}

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

	@Override
	public Object getProxy(@Nullable ClassLoader classLoader) {
		if (logger.isTraceEnabled()) {
			logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
		}
		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
	}   
}

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {}

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		
			// Get the interception chain for this method.
			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

			if (chain.isEmpty()) {

				Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
				retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
			}
			else {
				// We need to create a method invocation...
				MethodInvocation invocation =
						new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
				// Proceed to the joinpoint through the interceptor chain.
				retVal = invocation.proceed();
			}

			// Massage return value if necessary.
			Class<?> returnType = method.getReturnType();
			if (retVal != null && retVal == target &&
					returnType != Object.class && returnType.isInstance(proxy) &&
					!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {

				retVal = proxy;
			}
			else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
				throw new AopInvocationException(
						"Null return value from advice does not match primitive return type for: " + method);
			}
			return retVal;
		}
		finally {
			if (target != null && !targetSource.isStatic()) {
				// Must have come from TargetSource.
				targetSource.releaseTarget(target);
			}
			if (setProxyContext) {
				// Restore old proxy.
				AopContext.setCurrentProxy(oldProxy);
			}
		}
	}
}

package org.springframework.cglib.proxy;
public interface MethodInterceptor {
    Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable;
}

public class HelloWorldInterceptor implements MethodInterceptor {  
	@Override  
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {  
		System.out.println("Before method: " + method.getName());  
		Object result = proxy.invokeSuper(obj, args);  
		System.out.println("After method: " + method.getName());  
		return result;  
	}  
}

public interface MethodInterceptor extends Interceptor {
    Object invoke(MethodInvocation invocation) throws Throwable;
}

// 定义一个 环绕增强
public class LoggingMethodInterceptor implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 方法执行前逻辑
        long startTime = System.currentTimeMillis();
        System.out.println(invocation.getMethod().getName()+ " 方法开始执行");

        // 通过反射执行目标方法
        Object result = invocation.proceed();

        // 方法执行后逻辑
        //System.out.println("After method: " + invocation.getMethod().getName());
        long endTime = System.currentTimeMillis();
        System.out.println(invocation.getMethod().getName()+ "方法执行时间: " + (endTime - startTime) + "ms");

        return result;
    }
}