spring扩展容器-ApplicationContext

ApplicationContext和BeanFactory两者都是用于加载bean的，但是相比之下ApplicationContext提供更多的扩展功能。ApplicationContext包含了BeanFactory的所有功能。
使用两个不同的类去加载配置文件在写法上的不同。
使用BeanFactory方式加载配置文件
XmlBeanFactory f=new XmlBeanFactory(new ClassPathResource(“spring-context.xml”));
使用ApplicationContext方式加载配置文件
ApplicationContext ctx=new ClassPathXmlApplicationContext(“spring-context.xml”);

下面看一下 ClassPathXmlApplicationContext的构造方法:

    public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
            throws BeansException {

        super(parent);
        setConfigLocations(configLocations);
        if (refresh) {
            refresh();//这个方法几乎包含了ApplicationContext中提供的所有功能
        }
    }

refresh() 方法的结构很清晰，很容易分析对应的层次和逻辑

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // 准备刷新的上下文环境
            prepareRefresh();

            // 初始化beanFactory,并进行xml文件读取
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();//1.下面做详细介绍

            //对beanFactory进行各种功能填充 
            //2.下面做详细介绍
            prepareBeanFactory(beanFactory);

            try {
                //子类覆盖方法做额外的处理
                postProcessBeanFactory(beanFactory);

                // 激活各种BeanFactory处理器
                invokeBeanFactoryPostProcessors(beanFactory);

                // 注册拦截bean创建的bean处理器，这里只是注册，真正调用的是在getBean
                registerBeanPostProcessors(beanFactory);

                // 为上下文初始化message源，国际化处理
                initMessageSource();

                // 初始化应用消息广播器
                initApplicationEventMulticaster();

                // 留给子类初始化其他的bean
                onRefresh();

                // 在所有的注册bean中查找Listener Bean,注册到广播消息器中
                registerListeners();

                //初始化剩下的单实例(非惰性)
                finishBeanFactoryInitialization(beanFactory);

                //完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshedEvent通知别人
                finishRefresh();
            }

            catch (BeansException ex) {
                logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

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

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

1.obtainFreshBeanFactory ,经过这个方法的处理ApplicationContext 就已经获取了BeanFactory的全部功能。就可以进行bean的创建和获取。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        refreshBeanFactory();//初始化BeanFactory()，并且进行xml文件读取，将得到的beanFactroy记录到当前实体的属性中
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (logger.isDebugEnabled()) {
            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
    }

@Override
    protected final void refreshBeanFactory() throws BeansException {
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(beanFactory);//定制beanFactory
            loadBeanDefinitions(beanFactory);//加载beanDefinitions
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;//使用全局变量记录BeanFactory实例
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

2.prepareBeanFactory
ApplicationContext的扩展功能由此展开

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Tell the internal bean factory to use the context's class loader etc.
        beanFactory.setBeanClassLoader(getClassLoader());
        //设置表达式语言处理器
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
        //增加一个默认的PropertyEditor
        //这里有2条线
//(1).doCreateBean-->createBeanInstance-->instantiateBean-->
//initBeanWrapper-->(ResourceEditorRegistrar实例的)registerCustomEditors
//(2).在这里注册ResourceEditorRegistrar实例
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
       //添加BeanPostProcessor 
       //2.1下面做详细介绍
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//设置忽略几个自动装配的接口
        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);

        // BeanFactory interface not registered as resolvable type in a plain factory.
        // MessageSource registered (and found for autowiring) as a bean.
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);

        // 增加AspectJ支持
        if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            // Set a temporary ClassLoader for type matching.
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

        // Register default environment beans.
        if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
            beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
        }
        if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
            beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
        }
        if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
            beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
        }
    }

这里用一个例子来展示一下自定义属性编辑器

public class DatePropertyEditorRegistrar implements PropertyEditorRegistrar {

    @Override
    public void registerCustomEditors(PropertyEditorRegistry registry) {
//      registry.registerCustomEditor(Date.class, new DatePropertyEditor());
        registry.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),true));
    }

}

<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
        <property name="propertyEditorRegistrars">
            <list>
                <bean
                    class="com.eroadsf.springdemo.propertEditor.DatePropertyEditorRegistrar"></bean>
            </list>
        </property>
    </bean>

2.1beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));其目的就是注册beanPostProcessor。

ApplicationContextAwareProcessor实现了BeanPostProcessor，之前讲过bean的实例化会调用BeanPostProcessor的postProcessBeforeInitialization和
postProcessAfterInitialization方法。
看看ApplicationContextAwareProcessor是如何实现这两个方法的。

@Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }

@Override
    public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
        AccessControlContext acc = null;

        if (System.getSecurityManager() != null &&
                (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                        bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                        bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }

        if (acc != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>() {
                @Override
                public Object run() {
                    invokeAwareInterfaces(bean);
                    return null;
                }
            }, acc);
        }
        else {
            invokeAwareInterfaces(bean);
        }

        return bean;
    }
//实现这些Aware接口的bean在初始化之后，可以取得一些对应的资源
    private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof EnvironmentAware) {
                ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
            }
            if (bean instanceof EmbeddedValueResolverAware) {
                ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(
                        new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
            }
            if (bean instanceof ResourceLoaderAware) {
                ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
            }
            if (bean instanceof ApplicationEventPublisherAware) {
                ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
            }
            if (bean instanceof MessageSourceAware) {
                ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
            }
            if (bean instanceof ApplicationContextAware) {
                ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
            }
        }
    }

这里就有一个例子实现ApplicationContextAware 接口

public class AppUtil implements ApplicationContextAware {
    private static ApplicationContext appContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        appContext = applicationContext;
    }

    public static Object getBean(String paramString) {
        return appContext.getBean(paramString);
    }
}

    <bean id="appUtil" class="com.eroadsf.springdemo.applicationAware.AppUtil"/>

ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-context.xml");
        ServiceA serviceA=(ServiceA) AppUtil.getBean("serviceA");
        System.out.println(serviceA.getName());

AppUtil实现了这个接口（ApplicationContextAware）之后，这个类就可以方便获得ApplicationContext中的所有bean。换句话说，就是这个类可以直接获取spring配置文件中，所有有引用到的bean对象。

在回到refresh主线的 invokeBeanFactoryPostProcessors(beanFactory); 下一篇了解一下