Spring IOC及AOP学习总结

一、Spring IOC体系学习总结:

Spring中有两个容器体系,一类是BeanFactory、另一类是ApplicationContext。BeanFactory提供了基础的容器功能。ApplicationContext则是基于BeanFactory建立的一套更加丰富的容器体系,基于ApplicationContext构建了Spring AOP体系(基于AOP体系又构建了声明式事务模型),I18n的支持,基于观察者模式的事件模型,多渠道的Bean资源的载入(比如从文件系统,从internet)。下面看一下两个容器体系的类结构图。
BeanFactory容器体系结构图:
Spring IOC及AOP学习总结
如上图:BeanFactory接口定义了IOC容器的最基本的方法,例如getBean,isSingleton等。子类ListableBeanFactory则是补充定义了批量获取Bean信息的一些列表方法,好多方法返回的都是数据或者列表,比如获取所有的Bean的名字等。而子类HierarchialBeanFactory则是描述了IOC容器的双亲模型,是IOC容器具备了管理双亲容器的功能,例如添加了getParentBeanFactory的功能(这里展开一下,在获取Bean的时候,是先在父容器中去获取,如果获取不到,才会在本身的容器中获取)。最后ConfigurableBeanFactory定义了IOC容器的一些配置功能,例如添加了setParentBeanFactory方法,addBeanPostProcessor配置Bean后置处理器的方法等。通过观察继承体系可以看出,DefaultListableBeanFactory辗转反侧的继承了所有的接口,由此可见DefaultListableBeanFactory是比较土豪的,是在BeanFactory容器体系下比较完善的容器模型。
(1) 看下直接通过编程式使用 BeanFactory的一个例子,顺便分析一下:

ClassPathResource res = new ClassPathResource("beans.xml");
//直接使用DefaultListableBeanFactory
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions(res);

上述代码对应了BeanFactory加载beans.xml的过程,具体对应到Spring的加载过程为:

Spring IOC及AOP学习总结

调用DefaultListBeanFactory的registerBeanDefinition方法的代码为:

BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

可以看到传入的参数有两个 一个是bdHolder这个对应的其实就是BeanDefinition的包装,另外一个就是BeanDefinitionRegistry对象。而这个BeanDefinitionRegistry对象的实例就是DefaultListBeanFactory。参考如下继承关系:

Spring IOC及AOP学习总结
所以其实调用就是 DefaultListBeanFactory 的 registerBeanDefinition 方法:

/**
 * 向BeanFactory的map容器中注册Bean
 */
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {

    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");

    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }

    synchronized (this.beanDefinitionMap) {
        Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
        if (oldBeanDefinition != null) {
            //当不允许新的Bean覆盖老的Bean时,则会抛异常出来
            if (!this.allowBeanDefinitionOverriding) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                        "Cannot register bean definition [" + beanDefinition + "] for bean ‘" + beanName +
                        "‘: There is already [" + oldBeanDefinition + "] bound.");
            }
            else {
                if (this.logger.isInfoEnabled()) {
                    this.logger.info("Overriding bean definition for bean ‘" + beanName +
                            "‘: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
                }
            }
        }
        else {
            this.beanDefinitionNames.add(beanName);
            this.frozenBeanDefinitionNames = null;
        }
        this.beanDefinitionMap.put(beanName, beanDefinition);

        resetBeanDefinition(beanName);
    }
}

支持BeanDefinition的信息都被注册到了DefaultListBeanFactory中。

(2) 以上看到了BeanDefinition注册到DefaultListBeanFactory的过程,其中BeanDefinition其实就对应了我们xml文件中配置的Bean的信息,BeanDefinition信息注册到DefaultListBeanFactory中其实并没有完成对Bean的实例化,注册的只是Bean实例的元数据信息,即还没有完成Bean依赖的关系的注入。首先看下BeanDefinition的类的继承体系:

Spring IOC及AOP学习总结这个图就看看得了,不详细分析了。

下面再看下Xml配置文件里的Bean是如何变成BeanDefinition的:
Spring IOC及AOP学习总结

BeanDefinitionParserDelegate封装了解析Xml文件的一些方法,主要有这个Delegate将Xml文件解析成BeanDefinition。

(3) 上面看到了BeanDefinition的解析以及注册到BeanFactory的过程。然后就是针对BeanDefinition的完成Bean依赖关系的注入过程。获取一个Bean的实例并完成注入的过程如下:

Spring IOC及AOP学习总结

其中 AbstractAutowireCapableBeanFactory 的 populateBean 是实际发生Bean依赖注入的地方。具体的代码如下:

//实际涉及到bean注入的方法
protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {
    PropertyValues pvs = mbd.getPropertyValues();

    if (bw == null) {
        if (!pvs.isEmpty()) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
        }
        else {
            // Skip property population phase for null instance.
            return;
        }
    }

    // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
    // state of the bean before properties are set. This can be used, for example,
    // to support styles of field injection.
    boolean continueWithPropertyPopulation = true;

    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
    }

    if (!continueWithPropertyPopulation) {
        return;
    }

    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
            mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

        // Add property values based on autowire by name if applicable.
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }

        // Add property values based on autowire by type if applicable.
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }

        pvs = newPvs;
    }

    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

    if (hasInstAwareBpps || needsDepCheck) {
        PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw);
        if (hasInstAwareBpps) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvs == null) {
                        return;
                    }
                }
            }
        }
        //检查Bean的依赖是否已经装配好
        if (needsDepCheck) {
            checkDependencies(beanName, mbd, filteredPds, pvs);
        }
    }
    //对属性进行依赖注入
    applyPropertyValues(beanName, mbd, bw, pvs);
}

(4) Spring的另一种高级的容器ApplicationContext在BeanFactory的基础上添加了更多的面向框架的功能,比如和AOP的融合,生命周期的管理,Bean处理器(BeanProcessor)添加等,上面已经说了,就不提了。下文看下ApplicationContext的类继承关系图:
Spring IOC及AOP学习总结

简述:ApplicationContext 的子类主要包含两个方面:ConfigurableApplicationContext 表示该 Context 是可修改的,也就是在构建 Context 中用户可以动态添加或修改已有的配置信息,它下面又有多个子类,其中最经常使用的是可更新的 Context,即:AbstractRefreshableApplicationContext 类。 WebApplicationContext 顾名思义,就是为 web 准备的 Context 他可以直接访问到 ServletContext,通常情况下,这个接口使用的少。 再往下分就是按照构建 Context 的文件类型,接着就是访问 Context 的方式。这样一级一级构成了完整的 Context 等级层次。 总体来说 ApplicationContext 必须要完成以下几件事:
I.标识一个应用环境
II.利用 BeanFactory 创建 Bean 对象
III.保存对象关系表
IV.能够捕获各种事件
V.Context 作为 Spring 的 Ioc 容器,基本上整合了 Spring 的大部分功能,或者说是大部分功能的基础。

ApplicationContext和BeanFactory及ResourceLoader的关系如下图:

Spring IOC及AOP学习总结
ApplicationContext继承了ResourceLoader,注定了ApplicationContext可以完成多渠道外部资源的读入,不光是可以加载配置的xml文件。还有上图也清晰的标识了ApplicationContext和BeanFactory的关系。

ApplicationContext容器初始化的过程还是可以看上面那个时序图:

Spring IOC及AOP学习总结

AbstractApplicationContext的容器初始化过程是通过调用Refresh方法完成的,具体方法的代码如下:

//整个容器启动的入口
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        // 在子类中启动RefreshBeanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            //设置post的后置处理
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            //调用Bean的后置处理器,后置处理器是在Bean定义时向容器注册的
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            //注册Bean的后置处理器,在Bean创建过程中调用
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            //对上下文的消息源进行初始化
            initMessageSource();

            // Initialize event multicaster for this context.
            //初始化上下文的事件机制
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            //初始化其他的特殊Bean
            onRefresh();

            // Check for listener beans and register them.
            //检查监听Bean并将这些Bean向容器注册
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            //实例化所有的(non-lazy-init)单件
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            //发布容器事件,结束Refresh进程
            finishRefresh();
        }

        catch (BeansException ex) {
            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // Reset ‘active‘ flag.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }
    }

上面的代码中,每一步干什么都写了注释。下面再补充扩展一下ResourceLoader和Resource的类体系结构图:
ResourceLoader的类体系结构图:

Spring IOC及AOP学习总结

Resource的类体系结构图:
Spring IOC及AOP学习总结

Resource抽象出了资源的概念,这里的资源就可以理解为Spring容器需要加载的Bean的元数据,ApplicationContext继承了ResourceLoader,使其具备了加载元数据资源的能力。

最后再附上一张BeanFactory和ApplicationContext比较完成的类体系结构图:

Spring IOC及AOP学习总结

(5) IOC容器大体的结构就说这么多,下面总结一下几个常见的问题:

Spring中的FactoryBean怎么理解:
Spring中有两种类型的Bean:一种是普通的javaBean;另一种就是工厂Bean(FactoryBean),这两种Bean对IOC容器BeanFactory来说在获取Bean的方式上有一些细微的差别。看个实例DEMO:

public class MyFactoryBean implements FactoryBean<Date>,BeanNameAware {

private String name;

@Override
public void setBeanName(String name) {
    this.name = name;
}

@Override
public Date getObject() throws Exception {
    return new Date();
}

@Override
public Class<?> getObjectType() {
    return Date.class;
}

@Override
public boolean isSingleton() {
    return false;
}

public void sayName() {
    System.out.println("My name is "+this.name);
}

public static void main(String[] args) {

    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    Resource resource = new ClassPathResource("/aop/demo/demo4/applicationContext.xml");
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
    reader.loadBeanDefinitions(resource);
    //这里获取的其实是自定义FactoryBean中getObject获取到的Value
    Date now = (Date) beanFactory.getBean("myFactoryBean");
    System.out.println(now);
    //这里获取的是FactoryBean
    MyFactoryBean factoryBean = (MyFactoryBean) beanFactory.getBean("&myFactoryBean");
    factoryBean.sayName();
}
}

执行的输出结果:

Thu May 08 09:46:43 CST 2014
My name is myFactoryBean

看代码,从BeanFactory中获取 myFactoryBean的过程中根据两种名字进行获取 分别为 myFactoryBean,&myFactoryBean,通过myFactoryBean获取到的Bean如果实现了Spring定义的FactoryBean的接口,那么将会调用该接口的getObject方法,获取真是的值。如果&myFactoryBean来获取Bean的话就直接返回 FactoryBean实例。FactoryBean这个类型的Bean其实是Spring为我们提供的一个扩展点,我们可以自行定义FactoryBean,然后对容器中真实的对象做一些包装处理,例如为了实现Spring AOP,则定义了 ProxyFactoryBean,在调用器getObject方法时,对目标对象进行了动态代理,将横切逻辑编织到目标对象的方法逻辑中,具体分析下文有讲述。

BeanFactory 和 ApplicationContext 在获取Bean方式上的区别?

BeanFactory在获取Bean的时候,是延迟加载的,既不会完成BeanDefinition的载入,也不会完成Bean的依赖注入,xml文件即使配置错了也不会检查出来,它是在获取的时候才完成了Bean的关联关系的注入的。而ApplicationContext则是在容器启动时直接调用器Refresh方法,完成整个配置文件描述的Bean的载入,但是并没有完成依赖的注入,当第一次调用getBean方法获取Bean的时候,如果Bean是单例的会完成Bean依赖关系的注入,并且缓存,如果Bean是多例的,则每次都会create一个新Bean,并完成这个Bean依赖注入。

二、Spring AOP体系学习总结:

要理解AOP整体的逻辑需要理解一下Advice,Pointcut,Advisor的概念以及他们的关系。
Advice是为Spring Bean提供增强逻辑的接口,提供了多种方法增强的方式,比如前置,后置,包裹等增强方式。看下Advice的类体系结构图:

Spring IOC及AOP学习总结

图中定义了主要有3中类型的Advice,分别是BeforeAdvice,AfterAdvice 和 Interceptor,BeforeAdvice就是定义的就是方法的前置织入逻辑,AfterAdvice就是方法的后置织入逻辑。MethodInteceptor定义的是方法的包裹逻辑。想要分析其原理,先要看看怎么用,看一个应用的DEMO:

AfterAdvice.class:
public class AfterAdvice implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable {
        System.out.println("这个是 AfterReturning 方法!");
    }
}

BeforeAdvice.class:
public class BeforeAdvice implements MethodBeforeAdvice {
    @Override
    public void before(Method arg0, Object[] arg1, Object arg2)
            throws Throwable {
        System.out.println("这是BeforeAdvice的before方法!");
    }
}

CompareInterceptor.class
public class CompareInterceptor implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
          Object result = null;
          String stu_name = invocation.getArguments()[0].toString();
          if ( stu_name.equals("dragon")){
              //如果学生是dragon时,执行目标方法,
              result= invocation.proceed();            
          } else{
              System.out.println("此学生是"+stu_name+"而不是dragon,不批准其加入.");
          }
          return result;
    }
}

以上定义的分别是目标方法的前置逻辑,后置逻辑,及包裹逻辑。

目标类接口:
public interface IStudent {
    public void addStudent(String name);
}

目标实现类:
public class StudentImpl implements IStudent {
    @Override
    public void addStudent(String name) {
        System.out.println(name);
    }
}

Bean定义的配置文件:

<beans>
 <bean id="beforeAdvice" class="aop.demo.demo1.BeforeAdvice"></bean>
 <bean id="afterAdvice" class="aop.demo.demo1.AfterAdvice"></bean>
 <bean id="compareInterceptor" class="aop.demo.demo1.CompareInterceptor"></bean>
 <bean id="studenttarget" class="aop.demo.demo1.StudentImpl"></bean>
 <bean id="student" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces">
        <value>aop.demo.demo1.IStudent</value>
    </property>
    <property name="interceptorNames">
    <list>
       <value>beforeAdvice</value>
       <value>afterAdvice</value>
       <value>compareInterceptor</value>  
    </list>
    </property>
    <property name="target">
        <ref bean="studenttarget"/>
    </property>
  </bean>
</beans>

测试驱动类:<br>
public class DriverTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ApplicationContext ctx = new FileSystemXmlApplicationContext("/src/main/java/aop/demo/applicationContext.xml");
        IStudent person = (IStudent)ctx.getBean("student");
        //person.addStudent("dragon");
        person.addStudent("javadragon");
    }
}

//执行结果:<br>
这是BeforeAdvice的before方法!
此学生是javadragon而不是dragon,不批准其加入.
这个是 AfterReturning 方法!

从上面的DEMO可以看到一共配置了 2个Advice和 1个Interceptor,然后这些配置都是作为 ProxyFactoryBean的属性存在的,上文中已经提到FactgoryBean概念,容器在获取ProxyFactoryBean的时候其实是调用其 getObject方法。正式这个调用完成了代理逻辑的编织。先看下这个ProxyFactoryBean getObjec方法的代码。

public Object getObject() throws BeansException {
    //初始化通知器链
    initializeAdvisorChain();
    if (isSingleton()) {
        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.");
        }
        return newPrototypeInstance();
    }
}

private synchronized Object newPrototypeInstance() {
    // In the case of a prototype, we need to give the proxy
    // an independent instance of the configuration.
    // In this case, no proxy will have an instance of this object‘s configuration,
    // but will have an independent copy.
    if (logger.isTraceEnabled()) {
        logger.trace("Creating copy of prototype ProxyFactoryBean config: " + this);
    }

    ProxyCreatorSupport copy = new ProxyCreatorSupport(getAopProxyFactory());
    // The copy needs a fresh advisor chain, and a fresh TargetSource.
    TargetSource targetSource = freshTargetSource();
    copy.copyConfigurationFrom(this, targetSource, freshAdvisorChain());
    if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
        // Rely on AOP infrastructure to tell us what interfaces to proxy.
        copy.setInterfaces(
                ClassUtils.getAllInterfacesForClass(targetSource.getTargetClass(), this.proxyClassLoader));
    }
    copy.setFrozen(this.freezeProxy);

    if (logger.isTraceEnabled()) {
        logger.trace("Using ProxyCreatorSupport copy: " + copy);
    }
    return getProxy(copy.createAopProxy());
}

以上两个方法就是ProxyFactoryBean获取代理对象的入口方法,具体的获取流程下面时序图表述一下:
Spring IOC及AOP学习总结通过以上时序图可以看到,具体代理类的生成是有 JDKDynamicAopProxy 和 CglibProxy来完成的。具体使用哪种动态代理的生成方式是根据目标类是否有接口 isInterface来判断的。对应DefaultAOPProxyFactory 生成代理类的方法如下:

//这里有两个分支选择,一个是选择JDK的Proxy动态代理的实现,一个使用Cglib的实现。
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.");
        }
        if (targetClass.isInterface()) {
            return new JdkDynamicAopProxy(config);
        }
        if (!cglibAvailable) {
            throw new AopConfigException(
                    "Cannot proxy target class because CGLIB2 is not available. " +
                    "Add CGLIB to the class path or specify proxy interfaces.");
        }
        //如果不是接口类要生成Proxy,那么使用CGLIB来生成
        return CglibProxyFactory.createCglibProxy(config);
    }
    else {
        return new JdkDynamicAopProxy(config);
    }
}

由上文可知Advice是定义的Bean的前后的织入逻辑,那么这个织入逻辑是什么时候融入到方法中的呢,那就需要具体分析一下JDKDynamicAopProxy和Cglib2AopProxy了。
先上两张张AopProxy的类图:

Spring IOC及AOP学习总结

AopProxy的依赖类图:
Spring IOC及AOP学习总结
由上图可见AopProxy是间接只用了Advice来完成Bean的编织强化操作,具体代码如下:

JdkDynamicAopProxy的invoke方法:
/**
 * Implementation of <code>InvocationHandler.invoke</code>.
 * <p>Callers will see exactly the exception thrown by the target,
 * unless a hook method throws an exception.
 */
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    MethodInvocation invocation;
    Object oldProxy = null;
    boolean setProxyContext = false;

    TargetSource targetSource = this.advised.targetSource;
    Class targetClass = null;
    Object target = null;

    try {
        //如果目标对象没有实现Object类的基本方法:equals
        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
            // The target does not implement the equals(Object) method itself.
            return equals(args[0]);
        }
        //如果目标对象没有实现Object类的基本方法:hashCode
        if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
            // The target does not implement the hashCode() method itself.
            return hashCode();
        }

        if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                method.getDeclaringClass().isAssignableFrom(Advised.class)) {
            // Service invocations on ProxyConfig with the proxy config...
            //根据代理对象的配置来调用服务
            return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
        }

        Object retVal;

        if (this.advised.exposeProxy) {
            // Make invocation available if necessary.
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }

        // May be null. Get as late as possible to minimize the time we "own" the target,
        // in case it comes from a pool.
        target = targetSource.getTarget();
        if (target != null) {
            targetClass = target.getClass();
        }

        // Get the interception chain for this method.
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

        // Check whether we have any advice. If we don‘t, we can fallback on direct
        // reflective invocation of the target, and avoid creating a MethodInvocation.
        //如果没有定义拦截器,那么就直接调用target对应的方法
        if (chain.isEmpty()) {
            // We can skip creating a MethodInvocation: just invoke the target directly
            // Note that the final invoker must be an InvokerInterceptor so we know it does
            // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
        }
        else {
            //如果有拦截器设定,那么需要调用拦截器之后才调用目标对象的相应方法。
            // We need to create a method invocation...
            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.
        if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) &&
                !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
            // Special case: it returned "this" and the return type of the method
            // is type-compatible. Note that we can‘t help if the target sets
            // a reference to itself in another returned object.
            retVal = proxy;
        }
        return retVal;
    }
    finally {
        if (target != null && !targetSource.isStatic()) {
            // Must have come from TargetSource.
            targetSource.releaseTarget(target);
        }
        if (setProxyContext) {
            // Restore old proxy.
            AopContext.setCurrentProxy(oldProxy);
        }
    }
}

JdkDynamicAopProxy实现了JDK定义的 InvocationHandler接口,在实现JDK的动态代理的时候时间自身传入代理逻辑完成Bean的强化,这个invoke方法就是强化Bean逻辑的核心。从代码中可以看到在具体执行被代理类的目标方法的时候,先是获取了一个连接器链:

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); 

然后再执行具体方法的时候,先会递归的调用拦截器的逻辑,我们定义的Advice逻辑和Interceptor逻辑就是封装在这些Interceptor里面的。拦截器链的调用织如逻辑可以看下ReflectiveMethodInvocation 这个类的 proceed方法:

//递归调用拦截器链
//不管是JdkDynamicAopProxy还是Cglib2Aop都是要用的这个方法执行的拦截器链
public Object proceed() throws Throwable {
    //  We start with an index of -1 and increment early.
    // 从索引-1的拦截器开始调用,并按序递增,如果拦截器链中的拦截器迭代调用完毕,这里开始调用target的函数,这个函数是通过反射机制完成的,
    // 具体实现在AopUtil.invokeJoinpointUsingReflection方法中。
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        //这步才真正的调用目标方法
        return invokeJoinpoint();
    }

    Object interceptorOrInterceptionAdvice =
        this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        // Evaluate dynamic method matcher here: static part will already have
        // been evaluated and found to match.
        InterceptorAndDynamicMethodMatcher dm =
            (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
            //这个里面也会执行Proceed方法完成,Advice行为的调用
            return dm.interceptor.invoke(this);
        }
        else {
            // Dynamic matching failed.
            // Skip this interceptor and invoke the next in the chain.
            return proceed();
        }
    }
    else {
        // It‘s an interceptor, so we just invoke it: The pointcut will have
        // been evaluated statically before this object was constructed.
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

这个方法完成了我们定义的拦截器的递归调用。具体可以看代码上的注释。至于Cglib2AopProxy的拦截方式和JDkDynamicAopProxy可以说是如出一辙的,Cglib2AopProxy的强化逻辑可以看其内部类DynamicAdvisedInterceptor定义的intercept方法:

private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {

    private AdvisedSupport advised;

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

    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;
        Class targetClass = null;
        Object target = null;
        try {
            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }
            // May be <code>null</code>. Get as late as possible to minimize the time we
            // "own" the target, in case it comes from a pool.
            target = getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
            Object retVal;
            // Check whether we only have one InvokerInterceptor: that is,
            // no real advice, but just reflective invocation of the target.
            //如果没有拦截器则直接调用目标方法
            if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
                // We can skip creating a MethodInvocation: just invoke the target directly.
                // Note that the final invoker must be an InvokerInterceptor, so we know
                // it does nothing but a reflective operation on the target, and no hot
                // swapping or fancy proxying.
                retVal = methodProxy.invoke(target, args);
            }
            else {
                // We need to create a method invocation...
                // 如果拦截器有设置则对其进行拦截
                retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
            }
            retVal = massageReturnTypeIfNecessary(proxy, target, method, retVal);
            return retVal;
        }
        finally {
            if (target != null) {
                releaseTarget(target);
            }
            if (setProxyContext) {
                // Restore old proxy.
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }

而这里定义的MethodInvocation对应的proceed方法和JDKDynamicAopProxy对应的同一个proceed方法。

至此Spring 容器中Bean的强化逻辑就看完了,细心的同学可能会发现一个问题就是上面那个DEMO里,为什么把Advice配置在了Interceptor的属性里呢?:

 <property name="interceptorNames">
    <list>
       <value>beforeAdvice</value>
       <value>afterAdvice</value>
       <value>compareInterceptor</value>  
    </list>
</property>

这样的配置无非是把Advice当做了拦截器注入,其实这里面还存在一个适配器的概念:
Spring IOC及AOP学习总结 是这些Adapter将我们定义的Advice转换成了Interceptor,然后再代理类目完成拦截调用,看个源码:
MethodBeforeAdviceAdapter的适配转换实现:

/**
 * Adapter to enable {@link org.springframework.aop.MethodBeforeAdvice}
 * to be used in the Spring AOP framework.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 */
class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

    public boolean supportsAdvice(Advice advice) {
        return (advice instanceof MethodBeforeAdvice);
    }

    public MethodInterceptor getInterceptor(Advisor advisor) {
        MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
        return new MethodBeforeAdviceInterceptor(advice);
    }
}

正是这些适配器完成了我们定义的Advice和Inteceptor的转换。由此可见Advice和Interceptor有着很强的血缘关系,下面看个Advice和Inteceptor的关系图:

Spring IOC及AOP学习总结

Advice就说到这吧,下面看下Pointcut的概念:
Pointcut(切点)决定Advice应该作用于哪个连接点,也就说通过Pointcut来定义需要增强的方法集合,这些集合的选取可以按照一定的规则来完成,说白了就是制定那些方法需要增强。下面是Pointcut的类继承体系结构:

Spring IOC及AOP学习总结

Pointcut不想多说,看个实际使用的配置文件的例子:

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="     
      http://www.springframework.org/schema/beans     
      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd     
      http://www.springframework.org/schema/context     
      http://www.springframework.org/schema/context/spring-context-3.0.xsd 
      http://www.springframework.org/schema/aop     
      http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"
default-autowire="byName">

<!-- ==============================利用spring自己的aop配置================================ -->
<!-- 声明一个业务类 -->
<bean id="baseBusiness" class="aop.demo.demo2.BaseBusiness" />

<!-- 声明通知类 -->
<bean id="baseBefore" class="aop.demo.demo2.BaseBeforeAdvice" />
<bean id="baseAfterReturn" class="aop.demo.demo2.BaseAfterReturnAdvice" />
<bean id="baseAfterThrows" class="aop.demo.demo2.BaseAfterThrowsAdvice" />
<bean id="baseAround" class="aop.demo.demo2.BaseAroundAdvice" />

<!-- 指定切点匹配类 -->
<bean id="pointcut" class="aop.demo.demo2.Pointcut" />

<!-- 包装通知,指定切点 -->
<bean id="matchBeforeAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
    <property name="pointcut">
        <ref bean="pointcut" />
    </property>
    <property name="advice">
        <ref bean="baseBefore" />
    </property>
</bean>

<!-- 使用ProxyFactoryBean 产生代理对象 -->
<bean id="businessProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
    <!-- 代理对象所实现的接口 ,如果有接口可以这样设置 -->
    <property name="proxyInterfaces">
        <value>aop.demo.demo2.IBaseBusiness</value>
    </property>

    <!-- 设置目标对象 -->
    <property name="target">
        <ref local="baseBusiness" />
    </property>
    <!-- 代理对象所使用的拦截器 -->
    <property name="interceptorNames">
        <list>
            <!-- 这个Advisor之所以可以设置在这里,是因为会有AdvisorAdapter做转换适配 -->
            <value>matchBeforeAdvisor</value>
            <value>baseAfterReturn</value>
            <value>baseAround</value>
        </list>
    </property>
</bean>
</beans>

通过配置文件可以看出来通过Advisor将 pointcut和Advice整合在了一起,然后将这些Advisor注入到ProxyFactoryBean的体系中。这样这个Advisor就变成了有条件的链接器,pointcut就是条件,Advice就是对应的执行逻辑,而Advisor就是整合这两个实体的一个关联关系。

以上学习的代码版本是: 代码版本是Spring V3.1.1 svn地址是:https://github.com/lantian0802/spring-framework.git/tags/v3.1.1.RELEASE

Spring IOC及AOP学习总结,布布扣,bubuko.com

Spring IOC及AOP学习总结

上一篇:spring scope 属性的取值


下一篇:深入理解Javascript闭包概念