主要流程：

1、读取配置文件

2、实例化bean和填充bean属性

这个粗略的流程感觉更像是一个需求，有了这个需求，那么spring内部是怎么处理的呢？

我们知道spring的两个核心接口BeanFactory和ApplicationContext。BeanFactory主要定义容器的核心方法，ApplicationContext加以扩展，主要使用的还是ApplicationContext。在ApplicationContext的子类中，AbstractApplicationContext中的refresh()方法定义了容器加载配置文件及装配Bean的过程。

AbstractApplicationContext#refresh()代码如下：

// Prepare this context for refreshing.
            //1 准备刷新工作
            prepareRefresh();
            // Tell the subclass to refresh the internal bean factory.
            // 2 实例化BeanFactory，将配置文件的信息装入到容器的Bean定义的注册表（BeanDefinitionRegistry中），此时Bean还未初始化
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            // Prepare the bean factory for use in this context.
            // 3 准备BeanFactory 主要是加载一些类
            prepareBeanFactory(beanFactory);
            try {
                // Allows post-processing of the bean factory in context subclasses.
                // 4 留作子类实现
                postProcessBeanFactory(beanFactory);
                // Invoke factory processors registered as beans in the context.
                // 5 调用工厂后处理器
                invokeBeanFactoryPostProcessors(beanFactory);
                // Register bean processors that intercept bean creation.
                //6 注册bean后处理器
                registerBeanPostProcessors(beanFactory);
                // Initialize message source for this context.
                //7 初始化消息源
                initMessageSource();
                // Initialize event multicaster for this context.
                //8 初始化事件广播器
                initApplicationEventMulticaster();
                // Initialize other special beans in specific context subclasses.
                //9 钩子方法
                onRefresh();
                // Check for listener beans and register them.
                // 10 注册监听器
                registerListeners();
                // Instantiate all remaining (non-lazy-init) singletons.
                //11 完成bean实例化（除lazy-init），并放入缓存中
                finishBeanFactoryInitialization(beanFactory);
                // Last step: publish corresponding event.
                // 12 广播刷新事件
                finishRefresh();
            }

其实直接粘贴代码意义不大。重点还是要看refresh()函数的重点步骤。

一、prepareRefresh()：准备工作。

在spring代码中，很容易看到这样的逻辑：就是在一个流程动作上下包裹着前后的动作。也就是说：在刷新动作时，会包裹刷新前动作和刷新后动作。这些动作可以有操作，也可以没有。又如：在读取xml文件加载bean时的一个操作（处理xml前，处理xml后）：

preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
postProcessXml(root);

这里主要记录了一下容器开始时间，初始化了属性资源。

二、ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

作用：实例化BeanFactory，将配置文件的信息装入到容器的Bean定义的注册表（BeanDefinitionRegistry中），此时Bean还未初始化

其中，AbastractApplicationContext#obtainFreshBeanFactory()如下：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        refreshBeanFactory();
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (logger.isDebugEnabled()) {
            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
}

这里的getBeanFactory()方法用来获取实例。重点是refreshBeanFactory()方法。

AbstractRefreshableApplicationContext#refreshBeanFactory()

protected final void refreshBeanFactory() throws BeansException {
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(beanFactory);
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

如果存在BeanFacotry()，则销毁。这里要保证在BeanDefinitionRegistry中存储的是最新的xml对应的Bean映射。然后就到了loadBeanDefinitions(beanFactory)加载BeanDefinitions.中间跳过一些步骤，然后就到了XmlBeanDefinitionReader#loadBeanDefinitions(EncodedResource encodedResource)

显然是要从相应的资源（这里是XML中）读取信息。截取一段信息：

Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
        if (currentResources == null) {
            currentResources = new HashSet<EncodedResource>(4);
            this.resourcesCurrentlyBeingLoaded.set(currentResources);
        }
        if (!currentResources.add(encodedResource)) {
            throw new BeanDefinitionStoreException(
                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
        }
        try {
            InputStream inputStream = encodedResource.getResource().getInputStream();
            try {
                InputSource inputSource = new InputSource(inputStream);
                if (encodedResource.getEncoding() != null) {
                    inputSource.setEncoding(encodedResource.getEncoding());
                }
                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
            }
            finally {
                inputStream.close();
            }
        }

这里提到了doLoadBeanDefinitions(inputSource, encodedResource.getResource());方法。点进去之后跟想的一样，加载xml文件

try {
    Document doc = doLoadDocument(inputSource, resource);
    return registerBeanDefinitions(doc, resource);
}

接着跳过几步就到了把xml中的DOM节点信息转化为Bean对应属性的方法

protected void doRegisterBeanDefinitions(Element root) {
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(getReaderContext(), root, parent);
        if (this.delegate.isDefaultNamespace(root)) {
            String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
            if (StringUtils.hasText(profileSpec)) {
                String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                        profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
                if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                    return;
                }
            }
        }
        preProcessXml(root);
        parseBeanDefinitions(root, this.delegate);
        postProcessXml(root);
        this.delegate = parent;
}

这里到了parseBeanDefinitions(root, this.delegate)方法。也就是把root信息转化为BeanDefinitions。点进去发现spring处理两类节点：

• 默认元素
• 用户自定义元素

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        if (delegate.isDefaultNamespace(root)) {
            NodeList nl = root.getChildNodes();
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                if (node instanceof Element) {
                    Element ele = (Element) node;
                    if (delegate.isDefaultNamespace(ele)) {
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            delegate.parseCustomElement(root);
        }
}

 

这里就是遍历Element了。然后对每个节点判断，如果是默认命名空间（http://www.springframework.org/schema/beans）下的元素，则使用parseDefaultElement(ele, delegate)方法，否则使用delegate.parseCustomElement(ele);方法。查看默认元素的方法：parseDefaultElement(ele, delegate);

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
            importBeanDefinitionResource(ele);
        }
        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
            processAliasRegistration(ele);
        }
        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            processBeanDefinition(ele, delegate);
        }
        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
            // recurse
            doRegisterBeanDefinitions(ele);
        }
}

这里有四个节点：

• public static final String IMPORT_ELEMENT = "import";

• public static final String ALIAS_ELEMENT = "alias";

• public static final String BEAN_ELEMENT = "bean";

• public static final String NESTED_BEANS_ELEMENT = "beans";

这里再看一下DefaultBeanDefinitionDocumentReader#processBeanDefinition(ele, delegate)方法

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

里面有一个行代码跳转到registerBeanDefinition(bdHolder, getReaderContext().getRegistry())

public static void registerBeanDefinition(
            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
            throws BeanDefinitionStoreException {
        // Register bean definition under primary name.
        String beanName = definitionHolder.getBeanName();
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
        // Register aliases for bean name, if any.
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            for (String aliase : aliases) {
                registry.registerAlias(beanName, aliase);
            }
        }
}

这里有一个地方需要注意：前面提到过的BeanDefinitionRegistry，也就是把配置信息装入到BeanDefinitionRegistry中。进入 registerBeanDefinition方法中如下：

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {
        Assert.hasText(beanName, "'beanName' must not be empty");
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");
        this.beanDefinitionMap.put(beanName, beanDefinition);
}

这里我们可以看到，beanName和beanDefinition装入到了一个Map中。这个map的定义如下：

/** Map of bean definition objects, keyed by bean name */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);

其中，key位bean的名字,value为BeanDefinition。

这个时候的Bean还是没有属性的。

三、prepareBeanFactory(beanFactory)：加载一些类资源

四、postProcessBeanFactory(beanFactory):留作子类实现，这里为空

五、invokeBeanFactoryPostProcessors(beanFactory)：调用BeanFactoryPostProcessor接口处理beanFactory.

这个方法的参数是beanFactory，它包含了在xml定义的bean信息。调用这个方法，可以在读取xmlbean信息之后以及实例化bean之前修改bean定义的属性。

spring中，有内置的一些BeanFactoryPostProcessor实现类，常用的有：

• org.springframework.beans.factory.config.PropertyPlaceholderConfigurer：属性占位符（${user}）
• org.springframework.beans.factory.config.PropertyOverrideConfigurer
• org.springframework.beans.factory.config.CustomEditorConfigurer：用来注册自定义的属性编辑器

通过这几个实现类可以了解到这个接口会起到的一些作用：对占位符进行处理等

其中：BeanFactoryPostProcessor接口定义如下：

public interface BeanFactoryPostProcessor {
    /**
    *在其标准初始化后修改应用程序上下文的内部bean工厂。 所有bean定义都将被加载，但是没有bean将被实例化。
    *这允许覆盖或添加属性，即使是急切地初始化bean。
    */
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

这一步的重点是理解BeanFactoryPostProcessor接口的作用。实现这个接口，可以实现修改bean属性的功能。也就是说，Spring允许BeanFactoryPostProcessor在容器实例化任何其它bean之前读取配置元数据，并可以根据需要进行修改，例如可以把bean的scope从singleton改为prototype，也可以把property的值给修改掉。可以同时配置多个BeanFactoryPostProcessor，并通过设置'order'属性来控制各个BeanFactoryPostProcessor的执行次序。

这里摘抄一个网上的例子（原地址：http://blog.csdn.net/caihaijiang/article/details/35552859）实现一个自定义的BeanFactoryPostProcessor实现类来实现动态修改Bean属性功能。

1.在配置文件中定义一个名为MyBean的bean,这里只提供了两个简单的属性desc和mark。以及定义一个实现BeanFactoryPostProcessor接口的类MyBeanFactoryPostProcessorImpl

<bean id="myBean" class="uodut.spring3x.MyBean">
    <property name="desc" value="这里通过自定义MyBeanFactoryPostProcessorImpl来动态改变mark的值"></property>
    <property name="mark" value="initMark"></property>
</bean>
<bean id="myBeanFactoryPostProcessor" class="uodut.spring3x.MyBeanFactoryPostProcessorImpl"/>

2.MyBeanFactoryPostProcessorImpl类实现如下：

public class MyBeanFactoryPostProcessorImpl implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        BeanDefinition bd = beanFactory.getBeanDefinition("myBean");
        System.out.println("属性值:" + bd.getPropertyValues().toString());
        MutablePropertyValues propertyValues = bd.getPropertyValues();
        if (propertyValues.contains("mark")) {
            propertyValues.addPropertyValue("mark", "initMark->afterMark");
        }
    }
}

3.定义一个测试方法来测试

public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("BeanTest.xml");
        MyBean bean = (MyBean) context.getBean("myBean");
        System.out.println("描述：" + bean.getDesc());
        System.out.println("备注：" + bean.getMark());
}

运行后输出结果如下:(可以看到mark属性的值从initMark变成了initMark->afterMark)

1 属性值:PropertyValues: length=2; bean property 'desc'; bean property 'mark'
2 描述：这里通过自定义MyBeanFactoryPostProcessorImpl来动态改变mark的值
3 备注：initMark->afterMark

六、registerBeanPostProcessors(beanFactory);注册BeanPostProcessors

BeanPostProcessor，可以在spring容器实例化bean之后，在执行bean的初始化方法前后，添加一些自己的处理逻辑。这里说的初始化方法，指的是下面两种：

1）bean实现了InitializingBean接口，对应的方法为afterPropertiesSet

2）在bean定义的时候，通过init-method设置的方法

注意：BeanPostProcessor是在spring容器加载了bean的定义文件并且实例化bean之后执行的。BeanPostProcessor的执行顺序是在BeanFactoryPostProcessor之后。

这里在上面的例子基础上修改：

public class MyBean implements InitializingBean{
    public void afterPropertiesSet() throws Exception {
        System.out.println("调用afterPropertiesSet方法");
        this.desc = "在初始化方法中修改之后的描述信息";
    }
}

声明MyBeanPostProcessorImpl实现BeanPostProcessor

public class MyBeanPostProcessorImpl implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor，对象" + beanName + "调用初始化方法之前的数据： " + bean.toString());
        return bean;
    }
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor，对象" + beanName + "调用初始化方法之后的数据：" + bean.toString());
        return bean;
    }
}

运行测试用例：

属性值：PropertyValues: length=2; bean property 'desc'; bean property 'mark'
调用setDesc方法
调用setMark方法
BeanPostProcessor，对象myBean调用初始化方法之前的数据： [描述：原始描述信息， 备注：initMark->afterMark]
调用afterPropertiesSet方法
调用initMethod方法
BeanPostProcessor，对象myBean调用初始化方法之后的数据：[描述：在初始化方法中修改之后的描述信息， 备注：initMark->afterMark]
描述：在初始化方法中修改之后的描述信息
备注：initMark->afterMark

可以看到在初始化方法前后会调用BeanPostProcessor接口的两个方法。

七、initMessageSource();初始化消息源

八、initApplicationEventMulticaster();初始化应用上下文事件广播

九、onRefresh();初始化其他特殊的bean，这是一个钩子方法。

十、registerListeners();注册监听器

十一、finishBeanFactoryInitialization(beanFactory);初始化所有单实例的Bean，使用lazy-init的bean除外。初始化Bean后，将它们放入Spring容器的缓存中。

十二、finishRefresh();创建上下文刷新事件，事件广播器负责将这些事件广播到每个注册的事件监听器中。

spring容器从加载配置文件到创建出一个完整的Bean的流程

1、ResourceLoader从存储介质中加载Spring配置信息，并使用Resource表示该配置文件的资源

2、BeanDefinitionReader读取Resource所指向的配置文件资源，然后解析配置文件。配置文件中的每个<bean>解析成一个BeanDefinition对象，并保存到BeanDefinitionRegistry中。

3、容器扫描BeanDefinitionRegistry中的BeanDefinition，使用java反射机制识别出实现BeanFactoryPostProcessor接口的Bean，然后调用BeanFactoryPostProcessor的实现类对BeanDefinitionRegistry中的BeanDefinition进行加工处理。主要作以下两个工作：

1）对使用到占位符的<bean>元素标签进行解析，得到最终的配置值。这意味着对半成品式的BeanDefinition对象进行加工处理并得到成品的BeanDefinition对象。（这里用到了前文提到的PropertyPlaceholderConfigurer）

2）对BeanDefinitionRegistry中的BeanDefinition进行扫描，通过反射机制找出所有属性编辑器的Bean(实现java.beans.PropertyEditor接口的Bean),并自动将它们注册到spring容器的属性编辑器注册表中（PropertyEditorRegistry）

4、Spring容器从BeanDefinitionRegistry中取出加工后的BeanDefinition,并调用InstantiationStrategy进行Bean实例化的工作。

5、在实例化Bean时，Spring容器使用BeanWrapper对Bean进行封装，它结合该Bean的BeanDefinition以及容器中属性编辑器，完成Bean属性的设置工作。

6、BeanPostProcess对完成属性设置的Bean进行后续加工，装配出一个准备就绪的Bean。

 

参考资料：

• 《spring 3.x企业应用开发实战》
• http://blog.csdn.net/caihaijiang/article/details/35552859