webx3.0-容器初始化

概念介绍

Contexts

WebxComponentsContext

----类介绍：所有组件的共有上下文，即父容器，对应的默认spring配置文件为“webx.xml”

----成员变量

WebxComponentsLoader：因为beanFactory的行为均定义在WebxComponentsLoader中，故持有此变量

----成员函数

getWebxComponents：从加载器中取得webxComponents

postProcessBeanFactory：拓展点之一，使用该拓展点旨在合理的时间内创建components和component

finishRefresh：拓展点之一，使用该拓展点旨在合理的时间内refresh组件的beanFactory

WebxComponentContext

---类介绍：组件的上下文，对应的默认spring配置文件为"webx*.xml"

----成员变量

WebxComponent：组件

Components

WebxComponentsImpl

----成员变量

parentConfiguration：父容器的配置，对应于“webx.xml”中"name"为"webx_configuration"的bean,这是一个VO

parentContext：即父容器

components：一个map，保存所有的component的映射

rootComponent：根组件，对应的context即parentContext

defaultComponentName：默认组件名，根据"webx_configuration"得出

rootController：父组件的控制器

RootComponent

TODO

WebxComponent

----成员变量

components：持有所属的conponents

name：组件名

componentPath：组件路径

controller：组件的控制器

webxConfiurationName：为了获取各组件configuration的bean的name

context：顾名思义，即各个组件的上下文

Controllers

TODO

Configurations

TODO

初始化概述

1、servlet容器启动

web.xml:

<?xml version="1.0" encoding="GBK"?>
<web-app version="2.4" xmlns="<a href="http://java.sun.com/xml/ns/j2ee" 
    xmlns:xsi="<a href="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="
        http://java.sun.com/xml/ns/j2ee  http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd
    ">
 
    <context-param>
        <param-name>loggingRoot</param-name>
        <param-value>/Users/apple/workspace/3.0/petstore/logs</param-value>
    </context-param>
    <context-param>
        <param-name>loggingLevel</param-name>
        <param-value>warn</param-value>
    </context-param>
    <context-param>
        <param-name>loggingCharset</param-name>
        <param-value>UTF-8</param-value>
    </context-param>
 
    <listener>
        <listener-class>com.alibaba.citrus.logconfig.LogConfiguratorListener</listener-class>
    </listener>
 
    <!-- װ��/WEB-INF/webx.xml, /WEB-INF/webx-*.xml -->
    <listener>
        <listener-class>com.alibaba.citrus.webx.context.WebxContextLoaderListener</listener-class>
    </listener>
 
    <filter>
        <filter-name>mdc</filter-name>
        <filter-class>com.alibaba.citrus.webx.servlet.SetLoggingContextFilter</filter-class>
    </filter>
 
    <filter>
        <filter-name>webx</filter-name>
        <filter-class>com.alibaba.citrus.webx.servlet.WebxFrameworkFilter</filter-class>
    </filter>
 
    <filter-mapping>
        <filter-name>mdc</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
 
    <filter-mapping>
        <filter-name>webx</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
 
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
 
</web-app>

在这里，WebxContextLoaderListener负责框架的初始化，而WebxFrameworkFilter则是框架的入口

2、实例化加载器ContextLoader

重写了spring提供的加载器，应用WebxComponentsLoader,充血模型，定义了大多数的行为

3、加载ComponentsContext

对应的配置文件为"webx.xml"，为所有组件context的父容器

4、加载Components,Component,ComponentsController,ComponentController

通过spring的拓展点postProcessBeanFactory植入了创建components的bean，在后续的invoke中执行该bean的post方法

5、初始化单例Bean

ApplicationContext的特点之一

6、初始化ComponentsController

通过spring的事件监听机制，注册Components观察者，实现成员变量ComponetsController的初始化

7、初始化Component

通过spring容器的finishRefresh拓展实现组件的初始化

8、初始化ComponentController

依旧通过观察者模式利用spring的事件监听机制实现pipeline等的初始化

9、初始化FilterChain

至此bean容器初始化完成，接下来初始化FilterChain的每个filter，这里将从servletContext取出上一步骤生成的Components等参数来初始化filter

初始化详解

从initWebApplicationContext入口点开始

【ContextLoader】
public WebApplicationContext initWebApplicationContext(ServletContext servletContext)
            throws IllegalStateException, BeansException {
 
        if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
            throw new IllegalStateException(
                    "Cannot initialize context because there is already a root application context present - " +
                    "check whether you have multiple ContextLoader* definitions in your web.xml!");
        }
 
        servletContext.log("Initializing Spring root WebApplicationContext");
        if (logger.isInfoEnabled()) {
            logger.info("Root WebApplicationContext: initialization started");
        }
        long startTime = System.currentTimeMillis();
 
        try {
            // Determine parent for root web application context, if any.
            ApplicationContext parent = loadParentContext(servletContext);
 
            // Store context in local instance variable, to guarantee that
            // it is available on ServletContext shutdown.
            this.context = createWebApplicationContext(servletContext, parent);
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
            currentContextPerThread.put(Thread.currentThread().getContextClassLoader(), this.context);
 
            ......

接下来看下CreateWebApplicationContext,这里有个拓展点

【ContextLoader】
protected WebApplicationContext createWebApplicationContext(
            ServletContext servletContext, ApplicationContext parent) throws BeansException {
 
        Class contextClass = determineContextClass(servletContext);
        if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
            throw new ApplicationContextException("Custom context class [" + contextClass.getName() +
                    "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
        }
 
        ConfigurableWebApplicationContext wac =
                (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
        wac.setParent(parent);
        wac.setServletContext(servletContext);
        wac.setConfigLocation(servletContext.getInitParameter(CONFIG_LOCATION_PARAM));
        customizeContext(servletContext, wac);
        wac.refresh();
 
        return wac;
    }

【WebxComponentsLoader】
protected void customizeContext(ServletContext servletContext, ConfigurableWebApplicationContext componentsContext) {
        this.componentsContext = componentsContext;
 
        if (componentsContext instanceof WebxComponentsContext) {
            ((WebxComponentsContext) componentsContext).setLoader(this);
        }
    }

了解下refresh做了哪些事

【AbstractContextApplication】
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) {
                // Destroy already created singletons to avoid dangling resources.
                beanFactory.destroySingletons();
 
                // Reset 'active' flag.
                cancelRefresh(ex);
 
                // Propagate exception to caller.
                throw ex;
            }
        }
    }

有几个步骤比较重要依次介绍下，先看postProcessBeanFactory这一步

【WebxComponentsContext】
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.postProcessBeanFactory(beanFactory);
        getLoader().postProcessBeanFactory(beanFactory);
    }

这里已经可以看到webxComponentsContext持有loader是为了调用loader的行为；

【WebxComponentsLoader】
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 由于初始化components依赖于webxConfiguration，而webxConfiguration可能需要由PropertyPlaceholderConfigurer来处理，
        // 此外，其它有一些BeanFactoryPostProcessors会用到components，
        // 因此components必须在PropertyPlaceholderConfigurer之后初始化，并在其它BeanFactoryPostProcessors之前初始化。
        //
        // 下面创建的WebxComponentsCreator辅助类就是用来确保这个初始化顺序：
        // 1. PriorityOrdered - PropertyPlaceholderConfigurer
        // 2. Ordered - WebxComponentsCreator
        // 3. 普通 - 其它BeanFactoryPostProcessors
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(WebxComponentsCreator.class);
        builder.addConstructorArgValue(this);
        BeanDefinition componentsCreator = builder.getBeanDefinition();
        componentsCreator.setAutowireCandidate(false);
 
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        String name = SpringExtUtil.generateBeanName(WebxComponentsCreator.class.getName(), registry);
 
        registry.registerBeanDefinition(name, componentsCreator);
    }

接下来就是执行这些BeanFactoryProcessor,个人觉得这个需要深入研究下

【AbstractApplicationContext】
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        // Invoke factory processors registered with the context instance.
        for (Iterator it = getBeanFactoryPostProcessors().iterator(); it.hasNext();) {
            BeanFactoryPostProcessor factoryProcessor = (BeanFactoryPostProcessor) it.next();
            factoryProcessor.postProcessBeanFactory(beanFactory);
        }
 
        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
 
        // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
        // Ordered, and the rest.
        List priorityOrderedPostProcessors = new ArrayList();
        List orderedPostProcessorNames = new ArrayList();
        List nonOrderedPostProcessorNames = new ArrayList();
        for (int i = 0; i < postProcessorNames.length; i++) {
            if (isTypeMatch(postProcessorNames[i], PriorityOrdered.class)) {
                priorityOrderedPostProcessors.add(beanFactory.getBean(postProcessorNames[i]));
            }
            else if (isTypeMatch(postProcessorNames[i], Ordered.class)) {
                orderedPostProcessorNames.add(postProcessorNames[i]);
            }
            else {
                nonOrderedPostProcessorNames.add(postProcessorNames[i]);
            }
        }
 
        // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
        Collections.sort(priorityOrderedPostProcessors, new OrderComparator());
        invokeBeanFactoryPostProcessors(beanFactory, priorityOrderedPostProcessors);
 
        ......

这里有两个看点：1、BeanFactory第一次初始化Bean貌似就是这里,当然这个是题外话；2、一共有3个Bean需要被post，第一个是占位符（在webx.xml配置了该bean），第二个是RequestContextBeanFactoryPostProcessor,第三个是WebxComponentsCreator。主要分析后面两个，第一个是现存的，不做分析。

WebxComponentsCreator

【WebxComponentsLoader】
public static class WebxComponentsCreator implements BeanFactoryPostProcessor, Ordered {
        private final WebxComponentsLoader loader;
 
        public WebxComponentsCreator(WebxComponentsLoader loader) {
            this.loader = assertNotNull(loader, "WebxComponentsLoader");
        }
 
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            if (loader.components == null) {
        //loader.getParentConfiguration()为第一次执行getBean操作，configuration是什么，下面有分析
                WebxComponentsImpl components = loader.createComponents(loader.getParentConfiguration(), beanFactory);
                AbstractApplicationContext wcc = (AbstractApplicationContext) components.getParentApplicationContext();
                wcc.addApplicationListener(new SourceFilteringListener(wcc, components));
                loader.components = components;
            }
        }
 
 
private WebxComponentsImpl createComponents(WebxConfiguration parentConfiguration,
                                                ConfigurableListableBeanFactory beanFactory) {
    //从VO中取出Bean
        ComponentsConfig componentsConfig = getComponentsConfig(parentConfiguration);
 
        // 假如isAutoDiscoverComponents==true，试图自动发现components
        Map<String, String> componentNamesAndLocations = findComponents(componentsConfig, getServletContext());
 
        // 取得特别指定的components
        Map<String, ComponentConfig> specifiedComponents = componentsConfig.getComponents();
 
        // 实际要初始化的comonents，为上述两种来源的并集
        Set<String> componentNames = createTreeSet();
 
        componentNames.addAll(componentNamesAndLocations.keySet());
        componentNames.addAll(specifiedComponents.keySet());
 
        // 创建root controller
        WebxRootController rootController = componentsConfig.getRootController();
 
        if (rootController == null) {
            rootController = (WebxRootController) BeanUtils.instantiateClass(componentsConfig.getRootControllerClass());
        }
 
        // 创建并将components对象置入resolvable dependencies，以便注入到需要的bean中
        WebxComponentsImpl components = new WebxComponentsImpl(componentsContext,
                componentsConfig.getDefaultComponent(), rootController, parentConfiguration);
 
        beanFactory.registerResolvableDependency(WebxComponents.class, components);
 
        // 初始化每个component
        for (String componentName : componentNames) {
            ComponentConfig componentConfig = specifiedComponents.get(componentName);
 
            String componentPath = null;
            WebxController controller = null;
 
            if (componentConfig != null) {
                componentPath = componentConfig.getPath();
                controller = componentConfig.getController();
            }
 
            if (controller == null) {
                controller = (WebxController) BeanUtils.instantiateClass(componentsConfig.getDefaultControllerClass());
            }
 
            WebxComponentImpl component = new WebxComponentImpl(components, componentName, componentPath,
                    componentName.equals(componentsConfig.getDefaultComponent()), controller,
                    getWebxConfigurationName());
 
            components.addComponent(component);
 
            prepareComponent(component, componentNamesAndLocations.get(componentName));
        }
 
        return components;
    }
 
    private void prepareComponent(WebxComponentImpl component, String componentLocation) {
        String componentName = component.getName();
        WebxComponentContext wcc = new WebxComponentContext(component);
 
        wcc.setServletContext(getServletContext());
        wcc.setNamespace(componentName);
        wcc.addApplicationListener(new SourceFilteringListener(wcc, component));
 
        if (componentLocation != null) {
            wcc.setConfigLocation(componentLocation);
        }
 
        component.setApplicationContext(wcc);
 
        // 将context保存在servletContext中
        String attrName = getComponentContextAttributeName(componentName);
        getServletContext().setAttribute(attrName, wcc);
 
        log.debug("Published WebApplicationContext of component {} as ServletContext attribute with name [{}]",
                componentName, attrName);
    }

RequestContextBeanFactoryPostProcessor

【RequestContextBeanFactoryPostProcessor】
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 先注册request/response/session，再从beanFactory中取得requestContexts。
 
        // 创建全局的request实例。
        register(beanFactory, ServletRequest.class,
                createProxy(HttpServletRequest.class, beanFactory.getBeanClassLoader(), new RequestObjectFactory()));
 
        // 创建全局的session实例。
        register(beanFactory, HttpSession.class,
                createProxy(HttpSession.class, beanFactory.getBeanClassLoader(), new SessionObjectFactory()));
 
        // 创建全局的response实例。
        register(beanFactory, ServletResponse.class,
                createProxy(HttpServletResponse.class, beanFactory.getBeanClassLoader(), new ResponseObjectFactory()));
 
        // 取得requestContexts时会激活requestContexts的初始化。
        // 由于request/response/session已经被注册，因此已经可被注入到requestContexts的子对象中。
        RequestContextChainingService requestContexts = (RequestContextChainingService) beanFactory.getBean(
                requestContextsName, RequestContextChainingService.class);
 
        // 创建全局的request context实例。
        for (RequestContextInfo<?> info : requestContexts.getRequestContextInfos()) {
            Class<? extends RequestContext> requestContextInterface = info.getRequestContextInterface();
            Class<? extends RequestContext> requestContextProxyInterface = info.getRequestContextProxyInterface();
 
            register(
                    beanFactory,
                    requestContextInterface,
                    createProxy(requestContextProxyInterface, beanFactory.getBeanClassLoader(),
                            new RequestContextObjectFactory(requestContextProxyInterface)));
        }
    }

【RequestContextBeanFactoryPostProcessor&RequestObjectFactory】
private static class RequestObjectFactory implements ObjectFactory {
        public Object getObject() {
            RequestAttributes requestAttrs = RequestContextHolder.currentRequestAttributes();
 
            if (!(requestAttrs instanceof ServletRequestAttributes)) {
                throw new IllegalStateException("Current request is not a servlet request");
            }
 
            HttpServletRequest request = ((ServletRequestAttributes) requestAttrs).getRequest();
 
            if (request == null) {
                throw new IllegalStateException("Current request is not a servlet request");
            }
 
            return request;
        }
    }

【RequestContextHolder】
public abstract class RequestContextHolder  {
 
    private static final boolean jsfPresent =
            ClassUtils.isPresent("javax.faces.context.FacesContext", RequestContextHolder.class.getClassLoader());
 
    private static final ThreadLocal requestAttributesHolder = new NamedThreadLocal("Request attributes");
 
    private static final ThreadLocal inheritableRequestAttributesHolder =
            new NamedInheritableThreadLocal("Request context");
 
public static RequestAttributes getRequestAttributes() {
        RequestAttributes attributes = (RequestAttributes) requestAttributesHolder.get();
        if (attributes == null) {
            attributes = (RequestAttributes) inheritableRequestAttributesHolder.get();
        }
        return attributes;
    }
 
public static RequestAttributes currentRequestAttributes() throws IllegalStateException {
        RequestAttributes attributes = getRequestAttributes();
        if (attributes == null) {
            if (jsfPresent) {
                attributes = FacesRequestAttributesFactory.getFacesRequestAttributes();
            }
            if (attributes == null) {
                throw new IllegalStateException("No thread-bound request found: " +
                        "Are you referring to request attributes outside of an actual web request, " +
                        "or processing a request outside of the originally receiving thread? " +
                        "If you are actually operating within a web request and still receive this message, " +
                        "your code is probably running outside of DispatcherServlet/DispatcherPortlet: " +
                        "In this case, use RequestContextListener or RequestContextFilter to expose the current request.");
            }
        }
        return attributes;
    }

BeanFactoryPostProcessor终于结束了，看下finishRefresh，这也是个拓展点，主要是用来初始化controller和componentContext

【WebxComponentsContext】
protected void finishRefresh() {
        super.finishRefresh();
        getLoader().finishRefresh();
    }

【WebxComponentsLoader】
public void finishRefresh() {
        components.getWebxRootController().onFinishedProcessContext();
 
        for (WebxComponent component : components) {
            logInBothServletAndLoggingSystem("Initializing Spring sub WebApplicationContext: " + component.getName());
 
            WebxComponentContext wcc = (WebxComponentContext) component.getApplicationContext();
            WebxController controller = component.getWebxController();
 
            wcc.refresh();
        //留了拓展点，啥也没做
            controller.onFinishedProcessContext();
        }
 
        logInBothServletAndLoggingSystem("WebxComponents: initialization completed");
    }

容器初始化至此结束了，最后介绍下filter的初始化