首页 > 代码库 > AOP技术应用和研究--SpringAop实现原理
AOP技术应用和研究--SpringAop实现原理
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技术应用和研究
AOP技术应用和研究--SpringAop实现原理