Spring学习笔记－初始化XmlWebApplicationContext

在Spring中，所有的bean都由其提供的容器进行管理，包括：

• AnnotationConfigApplicationContext
• AnnotationConfigWebApplicationContext
• ClassPathXmlApplicationContext
• FileSystemXmlApplicationContext
• XmlWebApplicationContext

在实际的Web程序中使用到的是AnnotationConfigWebApplicationContext和XmlWebApplicationContext，接下来我主要分析后者的初始化代码部分。

public static final Class<?> DEFAULT_CONTEXT_CLASS = XmlWebApplicationContext.class;
private Class<?> contextClass = DEFAULT_CONTEXT_CLASS;

protected WebApplicationContext createWebApplicationContext(ApplicationContext parent) {
        //...
        ConfigurableWebApplicationContext wac =
                (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

        wac.setEnvironment(getEnvironment());
        wac.setParent(parent);
        wac.setConfigLocation(getContextConfigLocation());

        configureAndRefreshWebApplicationContext(wac);

        return wac;
    }

首先是WebApplicationContext的创建，XmlWebApplicationContext是FrameworkServlet的默认容器。BeanUtils是一个工具类，提供了实例化类的简单接口，同时使用Class变量来表明XmlWebApplicationContext的具体类型使得在实例化的时候非常灵活，同时也保证所有的XmlWebApplicationContext都仅由FrameworkServlet来管理。

有了容器之后，就需要知道容器里应该有哪些bean了。

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            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.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                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;
            }
        }

在这里我们首先为beans创建了一个工厂类ConfigurableListableBeanFactory。顾名思义，这个工厂将负责之后所有bean的创建及维护。而obtainFreshBeanFactory()函数在创建工厂之后立即初始化了所有bean的信息。

@Override
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // Create a new XmlBeanDefinitionReader for the given BeanFactory.
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        // Configure the bean definition reader with this context's
        // resource loading environment.
        beanDefinitionReader.setEnvironment(getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

        // Allow a subclass to provide custom initialization of the reader,
        // then proceed with actually loading the bean definitions.
        initBeanDefinitionReader(beanDefinitionReader);
        loadBeanDefinitions(beanDefinitionReader);
    }

这里封装了一个XmlBeanDefinitionReader，用于具体的读取所有bean。对于Xml来说，读取bean定义实际上就是解析xml文件。XmlBeanDefinitionReader将文件转为Document对象并实例化
DefaultBeanDefinitionDocumentReader用于解析。

    protected void doRegisterBeanDefinitions(Element root) {
        // Any nested <beans> elements will cause recursion in this method. In
        // order to propagate and preserve <beans> default-* attributes correctly,
        // keep track of the current (parent) delegate, which may be null. Create
        // the new (child) delegate with a reference to the parent for fallback purposes,
        // then ultimately reset this.delegate back to its original (parent) reference.
        // this behavior emulates a stack of delegates without actually necessitating one.
        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;
    }

这段代码有两点值得注意

• 这里使用了Delegation pattern，将具体的解析Document操作放在BeanDefinitionParserDelegate中。
• 正如注释中所说，由于每当读取到”beans”标签都会进入该段代码，为了保留递归之前的现场，用临时变量parent进行暂时存储。这也是为什么要使用Delegation patter的原因之一。

因为XML中的element会有很多，同时也为了扩展性，spring中为每一个namespace设计了一个handler，并使用HashMap进行存储。但是为了不在一开始就一次性实例化所有的handler，spring使用了一个非常巧妙的设计。

    @Override
    public NamespaceHandler resolve(String namespaceUri) {
        Map<String, Object> handlerMappings = getHandlerMappings();
        Object handlerOrClassName = handlerMappings.get(namespaceUri);
        if (handlerOrClassName == null) {
            return null;
        }
        else if (handlerOrClassName instanceof NamespaceHandler) {
            return (NamespaceHandler) handlerOrClassName;
        }
        else {
            String className = (String) handlerOrClassName;
            try {
                Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
                if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
                    throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
                            "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
                }
                NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
                namespaceHandler.init();
                handlerMappings.put(namespaceUri, namespaceHandler);
                return namespaceHandler;
            }
            catch (ClassNotFoundException ex) {
                throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +
                        namespaceUri + "] not found", ex);
            }
            catch (LinkageError err) {
                throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +
                        namespaceUri + "]: problem with handler class file or dependent class", err);
            }
        }
    }

handlerMappings中的value有两种情况，初始化后为相应handler的class name。而在运行时需要用到的时候再更新为handler实例，并更新handlerMappings。

虽然每个handler的具体处理逻辑可能不同，但注册bean的代码都是一致的。

//BeanDefinition candidate
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    registerBeanDefinition(definitionHolder, this.registry);

从代码中可以很清楚的看到，handler首先获得所有bean的定义，存储在BeanDefinition中，其中最主要的是ClassName。之后再使用BeanDefinitionHolder与之关联起来，而BeanDefinitionHolder主要保存了BeanName，同时包含一个与之对应的BeanDefinition。之后将BeanDefinitionHolder注册到registry中。这里的registry时间上是一个BeanFactory，是利用构造函数一步步传下来的。
至此，registerBeanDefinitions基本就完成了。