Spring 的AOP实现遵守了AOP联盟的约定。同时 Spring 又扩展了它，增加了如 Pointcut、Advisor 等一些接口使得更加灵活。在Spring的AOP模块中，包括AOP的基本概念，通知，切入点等，以及最核心的AopProxy代理对象生成和Spring AOP拦截器调用的实现。

     1，Spring Aop的基本概念

我们在前面 AOP基本概念对AOP基本概念进行了理论上的定义，现在我们将Spring AOP基本概念作为例子来说明AOP的基本概念，这样可以更好的理解AOP基本概念。并且将简单介绍Spring AOP相关的具体实现。

l  切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。3.3.2中的事务处理类（Transaction）就是一个切面。

l  连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。3.3.2中proxy.updatePerson();就是连接点

l  通知（Advice）：定义在连接点做什么，为切面增强提供织入接口。在上面动态代理的例子中切面Transaction的方法beginTransaction（）和commit()分别是前置通知和后置通知。其实在这里通知就是切面中的方法。在Spring AOP中，它主要描述Spring AOP围绕方法调用而注入的切面行为。Advice 是AOP联盟定义的一个接口，具体的接口定义在org.aopalliance.aop.Advice中。在Spring AOP的实现中，使用了这个统一的接口，并通过这个接口，为AOP切面增强的织入功能做了更多的细化和扩展，比如提供了更具体的通知类型，如BeforeAdvice，AfterAdvice，ThrowsAdvice等。

作为Spring AOP定义的接口类，具体的切面增强可以通过这些接口集成到AOP框架中去发挥作用。对于这些接口类，我们将以BeforeAdvice为例来说明。首先了解它的类层次关系，如图3.8, BeforeAdvice类层次图

在BeforeAdvice的继承关系中，定义了为待增强的目标方法设置的前置通知的接口MethodBeforeAdvice，使用这个前置接口需要实现一个回调函数：void before(Method method, Object[] args, Object target) throwsThrowable作为回调函数，before()方法的实现在Advice中被配置到目标方法后，会在目标方法时被回调。具体的调用参数有Mehod对象，这个参数是目标方法的反射对象；Object[]对象数组，这个对象数组中包括目标对象方法的输入参数。

切入点（Pointcut）：决定Advice通知应该作用于哪个连接点。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。在动态代理中if（”saveUser”.equals(methodName)||”updateUser”.equals(methodName)||……)就是切入点。当方法名为符合切入点saveUser，updateUser时就执行相应的通知。Spring AOP提供了具体的切点供用户使用，切入点在Spring AOP类继承体系如图3.9所示：

    在Spring AOP如有针对注解配置的AnnotationMatchingPointcut、针对正则表达式的JdkRegexpMethodPointcut等等。实际的调用过程就是

l  目标对象（Target Object）：既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。也就是UserDaoImpl target = newUserDaoImpl(); target就是目标对象。

l  目标对象（Target Object）：既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。也就是UserDaoImpl target = newUserDaoImpl(); target就是目标对象。

l  AOP代理（AOP Proxy）：在Spring AOP中，AOP代理可以是JDK动态代理或者CGLIB代理。3.3.2中示例中proxy就是代理对象。我们容易发现代理对象的方法=目标对象的目标方法+通知。

l  织入（Weaving）：SpringAOP和其他纯Java AOP框架一样，在运行时完成织入。织入其实就是形成代理的方法的过程。

l  通知器（Advisor）:Advisor属于Spring AOP扩展的内容。Advisor完成对目标方法的通知（Advice）和切入点（Pointcut）设计以后，需要一个对象将它们结合起来，完成这个作用的就是Advisor。通过Advisor，可以定义应该使用哪个通知并在哪个关注点使用它，也就是说通过Advisor，把Advice和Pointcut结合起来，这个结合为使用IoC容器配置AOP应用。在Spring AOP中，Advisor的实现类都有两个属性，分别为advice和pointcut。通过这两个属性，可以分别配置Advice和Pointcut。

2，生成代理对象

由上文中动态代理中可以知道AOP首要任务就是生成代理对象，对于Spring的应用，可以看到，是通过配置和调用Spring的ProxyFactoryBean来完成这个任务的。在这个生成过程中，可以使用JDK的Proxy和cglib两种方式生成。

以ProxyFactory的设计中心，可以看到相关的类继承关系如图3.10所示：

分析Spring AOP的底层实现首先要从ProxyConfig类开始，ProxyConfig是所有产生Spring AOP代理对象的基类，它是一个数据类，主要为其AOP代理对象工厂实现类提供配置属性。根据ProxyConfig的继承体系分析创建AOP代理常用类的作用：

l AdvisedSupport是ProxyConfig的子类，它封装了AOP中对通知(Advice)和通知器(Advisor)的相关操作，这些操作对于不同的AOP的代理对象的生成都是一样的，但对于具体的AOP代理对象的创建，AdvisedSupport把它交给子类去实现。

l  ProxyCreatorSupport是AdvisedSupport的子类，它是其子类创建AOP代理对象的一个辅助类，提供不同AOP代理对象生成的通用操作，具体的AOP代理对象生成，由ProxyCreatorSupport的子类完成。

l 创建AOP代理对象的类：

ProxyCreatorSupport有3个子类，分别创建不同的AOP代理对象，具体如下：

AspectJProxyFactory：主要用于创建AspectJ的AOP应用，起到集成Spring和AspectJ的作用。ProxyFactory：创建编程式的Spring AOP应用。

ProxyFactoryBean：创建声明式的Spring AOP应用。

       由于ProxyFactoryBean是在Spring IoC环境中创建AOP应用的底层方法，也是最灵活的方法，Spring通过它完成了对AOP使用的封装。将在下文以ProxyFactoryBean的实现为入口介绍AopProxy代理对象的实现。

       在ProxyFactoryBean中，通过target目标对象生成Proxy代理对象，从而为AOP横切面的编织工作做好准备工作。具体的代理对象生成工作是通过jdk的Proxy或cglib来完成的。具体的AopProxy生成过程如图3.11所示：

public class ProxyFactoryBean extends ProxyCreatorSupport
		implements FactoryBean<Object>, BeanClassLoaderAware, BeanFactoryAware {
//标注通知器器为全局通用通知器
public static final String GLOBAL_SUFFIX = "*";
//标志通知器链是否已经完成初始化
private boolean advisorChainInitialized = false;
//单态模式对象
private Object singletonInstance;
……
//ProxyFactoryBean创建AOPProxy代理的入口方法
public Object getObject() throws BeansException {
		//初始化通知器链
		initializeAdvisorChain();
		//如果目标对象是单态模式
		if (isSingleton()) {
			//调用获取单态模式对象的方法产生AOPProxy代理
			return getSingletonInstance();
		}
		//如果目标对象是原型模式
		else {
			if (this.targetName == null) {
				logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
						"Enable prototype proxies by setting the 'targetName' property.");
			}
			//调用原型模式对象方法每次创建一个新的AOPProxy代理对象
			return newPrototypeInstance();
		}
	}

通过源码分析，我们了解到ProxyFactoryBean实现了FactoryBean接口，所以本身也是一个Spring的工厂Bean，AOP代理工厂的主要功能概况为：

a.初始化通知器链，将配置的通知器链添加到容器存放通知/通知器的集合中。

b.根据单态模式/原型模式，获取AopProxy产生AopProxy代理对象。

如下是ProxyFactoryBean的getSingletonInstance()方法的源代码：

private synchronized Object getSingletonInstance() {
		if (this.singletonInstance == null) {
			…//省略
			this.singletonInstance = getProxy(createAopProxy());
		}
		return this.singletonInstance;
}
红色部分getProxy()的源代码：
protected Object getProxy(AopProxy aopProxy) {
		return aopProxy.getProxy(this.proxyClassLoader);
}

由上面可知ProxyFactoryBean是通过createAopProxy（）方法创建的AopProxy对象来创建AopProxy代理对象（AopProxy对象和AopProxy代理对象不是同一个概念，AopProxy代理对象是由AopProxy对象创建的，AopProxy是一个接口，声明了了创建AopProxy代理对象的方法getProxy()）。在ProxyFactoryBean的getObjet的getSingletonInstance()和newPrototypeInstance()方法均通过调用ProxyCreatorSupport的createAopProxy()方法获取AopProxy对象（ProxyFactoryBean通过继承ProxyCreatorSupport来获得了createAopProxy()方法），ProxyCreatorSupport的createAopProxy（）方法的源码如下：

protected final synchronized AopProxy createAopProxy() {
		if (!this.active) {
			activate();
		}
		return getAopProxyFactory().createAopProxy(this);
}

如上面的源代码所示，这里使用的了AopProxyFactory来创建AopProxy对象。

public AopProxyFactory getAopProxyFactory() {
		return this.aopProxyFactory;
}
public ProxyCreatorSupport() {
		this.aopProxyFactory = new DefaultAopProxyFactory();
}

显然这个AopProxyFactory是DefaultAopProxyFactory。下面我们看DefaultAopProxyFactory是如何生成AopProxy代理对象即可。

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
	if(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
		…//非核心部分省略
 	//如果配置的AOP目标类是接口，则使用JDK动态代理机制来生成AOP代理
			if (targetClass.isInterface()) {
				return new JdkDynamicAopProxy(config);
			}
			 //如果AOP配置的目标类不是接口，则使用CGLIB的方式来生成AOP代理
			if (!cglibAvailable) {
				throw new AopCongifgException(
						"Cannot proxy target class because CGLIB2 is not available. " +
						"Add CGLIB to the class path or specify proxy interfaces.");
			}
			return CglibProxyFactory.createCglibProxy(config);
		}
		else {
			//默认生成的是JdkDynamicAopProxy对象
			return new JdkDynamicAopProxy(config);
		}
	}

我们通过上面的分析知道AopProxy代理对象是由AopProxy对象生成，AopProxy代理对象可以由jdk或cglib来生成，而JdkDynamicAopProxy和Cglib2AopProxy实现的都是AopProxy接口，如图3.12。其中jdk对应JdkDynamicAopProxy，cglib对应Cglib2AopProxy。

     jdk生成AopProxy代理对象

JdkDynamicAopProxy生成代理对象过程的代理清单如下：
public Object getProxy(ClassLoader classLoader) {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
		}
		Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
	}

显然它是调用Proxy的newProxyInstance()方法来生成AopProxy代理对象，

由前面jdk动态代理可知，这就是使用的jdk动态代理。而Proxy在生成代理对象时，需要指明三个参数，一个是类加载器，一个是代理接口，另外一个是Proxy回调方法所在的对象，这个对象需要实现InvocationHandler接口。而JdkDynamicAopProxy本身实现了InvocationHandler接口和invoke()方法。这就是Spring AOP利用jdk动态代理生成AopProxy代理对象的整个过程。

     cglib生成AopProxy代理对象

jdk的动态代理只能针对接口生成代理对象，对于没有实现接口的目标对象，必须通过第3方的CGLIB来生成代理对象，CglibProxyFactory创建AopProxy代理的主要源码如下：
//通过CGLIB方式创建AOP代理对象
public Object getProxy(ClassLoader classLoader) {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating CGLIB2 proxy: target source is " + this.advised.getTargetSource());
		}
		try {
			//从代理创建辅助类中获取在IoC容器中配置的目标对象
			Class rootClass = this.advised.getTargetClass();
			Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
			//将目标对象本身做为自己的基类
			Class proxySuperClass = rootClass;
			//检查获取到的目标类是否是CGLIB产生的
			if (AopUtils.isCglibProxyClass(rootClass)) {
				//如果目标类是有CGLIB产生的，获取目标类的基类
				proxySuperClass = rootClass.getSuperclass();
				//获取目标类的接口
				Class[] additionalInterfaces = rootClass.getInterfaces();
				//将目标类的接口添加到容器AOP代理创建辅助类的配置中
				for (Class additionalInterface : additionalInterfaces) {
					this.advised.addInterface(additionalInterface);
				}
			}
			//校验代理基类
			validateClassIfNecessary(proxySuperClass);
			//配置CGLIB的Enhancer类，Enhancer是CGLIB中的主要操作类
			Enhancer enhancer = createEnhancer();
			if (classLoader != null) {
				enhancer.setClassLoader(classLoader);
				if (classLoader instanceof SmartClassLoader &&
						((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
					enhancer.setUseCache(false);
				}
			}
			//设置enhancer的基类
			enhancer.setSuperclass(proxySuperClass);
			enhancer.setStrategy(new UndeclaredThrowableStrategy(UndeclaredThrowableException.class));
	//设置enhancer的接口	enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
			enhancer.setInterceptDuringConstruction(false);
			//设置enhancer的回调方法
			Callback[] callbacks = getCallbacks(rootClass);
			enhancer.setCallbacks(callbacks);
			//将通知器中配置作为enhancer的方法过滤
			enhancer.setCallbackFilter(new ProxyCallbackFilter(
					this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
			Class[] types = new Class[callbacks.length];
			for (int x = 0; x < types.length; x++) {
				types[x] = callbacks[x].getClass();
			}
			//设置enhancer的回调类型
			enhancer.setCallbackTypes(types);
			//创建代理对象
			Object proxy;
			if (this.constructorArgs != null) {
				proxy = enhancer.create(this.constructorArgTypes, this.constructorArgs);
			}
			else {
				proxy = enhancer.create();
			}
			return proxy;
		}
		catch (CodeGenerationException ex) {
			throw new AopConfigException("Could not generate CGLIB subclass of class [" +
					this.advised.getTargetClass() + "]: " +
					"Common causes of this problem include using a final class or a non-visible class",
					ex);
		}
		catch (IllegalArgumentException ex) {
			throw new AopConfigException("Could not generate CGLIB subclass of class [" +
					this.advised.getTargetClass() + "]: " +
					"Common causes of this problem include using a final class or a non-visible class",
					ex);
		}
		catch (Exception ex) {
			// TargetSource.getTarget() failed
			throw new AopConfigException("Unexpected AOP exception", ex);
		}
	}
//获取给定类的回调通知
 private Callback[] getCallbacks(Class rootClass) throws Exception {
		//优化参数
		boolean exposeProxy = this.advised.isExposeProxy();
		boolean isFrozen = this.advised.isFrozen();
		boolean isStatic = this.advised.getTargetSource().isStatic();
		//根据AOP配置创建一个动态通知拦截器，CGLIB创建的动态代理会自动调用
		//DynamicAdvisedInterceptor类的intercept方法对目标对象进行拦截处理
		Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
		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, //普通通知
			targetInterceptor, // 如果优化则不考虑配置的通知
			new SerializableNoOp(), //没有被覆盖的方法
			targetDispatcher, this.advisedDispatcher,
			new EqualsInterceptor(this.advised),
			new HashCodeInterceptor(this.advised)
		};
		Callback[] callbacks;
		//如果目标是静态的，并且通知链被冻结，则使用优化AOP调用，直接对方法使用
//固定的通知链
		if (isStatic && isFrozen) {
			Method[] methods = rootClass.getMethods();
			Callback[] fixedCallbacks = new Callback[methods.length];
			this.fixedInterceptorMap = new HashMap<String, Integer>(methods.length);
			for (int x = 0; x < methods.length; x++) {
				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(methods[x], rootClass);
				fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
						chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
				this.fixedInterceptorMap.put(methods[x].toString(), x);
			}
			//将固定回调和主要回调拷贝到回调数组中
			callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
			System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
			System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
			this.fixedInterceptorOffset = mainCallbacks.length;
		}
		//如果目标不是静态的，或者通知链不被冻结，则使用AOP主要的通知
		else {
			callbacks = mainCallbacks;
		}
		return callbacks;
	}

从上面的代码清单我们可以看到具体的cglib的使用，比如Enhancer对象的配置，以及Enhancer对象生成代理对象的过程。在这个生成代理对象的过程中，需要注意的是Enhancer对象callback回调的设置，正是这些回调封装了Spring AOP的实现，就像前面介绍jdkproxy对象的invoke回调方法一样。在Enhancer的callback回调设置中，实际上是通过设置DynamicAdvisedInterceptor拦截器来完成AOP功能的。我们可以再getCallBacks()方法中看到回调DynamicAdvisedInterceptor的设置。

CallBack aopInterceptor =new DynamicAdvisedInterceptor(this.advised);

DynamicAdvisedInterceptor实现了MethodInterceptor类。这样通过AopProxy对象封装target目标对象之后，ProxyFactoryBean的getObject（）方法得到对象就不是一个普通的对象了，而是一个AopProxy代理对象。在ProxyFactoryBean配置的target目标对象，这时已经不会让应用直接调用其方法实现，而是作为AOP实现的一部分。对target目标对象的方法调用会首先被AopProxy代理对象拦截，对于不同的AopProxy代理对象生成方式，会使用不同的拦截回调入口。例如，对于jdk的AopProxy代理对象，使用的是InvocationHandler的invoke回调入口；而对于cglib的AopProxy代理对象，使用的是设置好的callback回调，这是有对cglib的使用来决定的。在这些callback回调中，对于AOP实现，是通过DynamicAdvisedInterceptor来完成的。而DynamicAdvisedInterceptor的回调入口是intecepr()方法。通过这一系列的准备，已经为实现AOP横切机制尊定了基础，在这个基础上，AOP的advisor已经可以通过AopProxy代理对象的拦截机制，对需要它进行增强的target目标对象发挥切面的强大威力了。

    3，Spring AOP拦截器调用的实现

DynamicAdvisedInterceptor来完成回调。关于两种方式的拦截过程，下面将进行详细分析。

   3.1， JdkDynamicAopProxy的invoke拦截

我们回顾下JdkDynamicAopProxy中生成Proxy对象时，是newProxyInstance(classLoader,proxiedInterface,this);这里的this参数对应的是InvocationHandler对象，InvocationHandler是jdk定义的反射类的一个接口。在JdkDynamicAopProxy中实现了InvocationHandler接口，也就是说当Proxy对象代理方法被调用时，JdkDynamicAopProxy的invoke方法作为Proxy对象的回调函数被触发，从而通过invoke的具体实现，来完成对目标对象方法调用的拦截的工作。JdkDynamicAopProxy的invoke完成了对Proxy对象的设置，这些设置包括获取目标对象，拦截器链，同时把这些对象作为输入，创建ReflectiveMethodInvocation对象，通过ReflectiveMethodInvocation对象完成对AOP功能实现的封装。具体运行的时序图：

3.2 Cglib2AopProxy的intercept拦截

在分析Cglib2AopProxy的AopProxy代理对象生成的时候，我们了解到对于AOP的拦截调用，其回调是在DynamicAdvisedInterceptor对象中实现，这个回调的实现在intercept方法中。Cglib2AopProxy的intercept回调方法的实现和JdkDynamicAopProxy的回调实现是非常相似的，只是Cglib2AopProxy中构造CglibMethodInvocation对象来完成拦截器链的调用，而在JdkDynamicAopProxy中是通过ReflectiveMethodInvocation对象完成这个功能的。

AOP技术应用和研究系列博客
AOP技术应用和研究