Struts2源码浅析初始化（转载）

本文参考自：http://blog.csdn.net/java2000_wl/article/details/7572828

如果有侵犯您知识产权的地方，烦请通知本人，本人将即刻停止侵权行为

--------begin

   在web.xml中配置的StrutsPrepareAndExecuteFilter类是struts2的入口类，它实现了Filter接口 ，它的init

方法为初始化入口，下面是它的init方法：

    public void init(FilterConfig filterConfig) throws ServletException {
        InitOperations init = new InitOperations();
        try {
            filterHostConfig类对FilterConfig类进行了封装，使用了装饰模式
            FilterHostConfig config = new FilterHostConfig(filterConfig);
            初始化日志工厂：如果在web.xml中没有配置logFactory参数，则使用
            com.opensymphony.xwork2.util.logging.commons.CommonsLoggerFactory()
            如果没有该类，则使用JdkLoggerFactory，详情请参考LoggerFactory类
            init.initLogging(config);
            创建DisPatcher，初始化DisPatcher，注册加载各种配置文件的加载器，执行加载器，
            创建容器，解析XML文件
            Dispatcher dispatcher = init.initDispatcher(config);
            init.initStaticContentLoader(config, dispatcher);
            预处理类 请求处理时才会真正用到  
            1.主要负责在每次请求 创建ActionContext 清除ActionContext  
            2.当接收到一个请求时 通过uri查找 ActionConfig 创建ActionMapping  
            prepare = new PrepareOperations(filterConfig.getServletContext(), dispatcher);
            处理请求            
            execute = new ExecuteOperations(filterConfig.getServletContext(), dispatcher);
            this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);

            postInit(dispatcher, filterConfig);
        } finally {
            init.cleanup();
        }

    }

      InitOperations 类似与一个Delegate（代理） 主要负责实例化Dispatcher ，再把初始化操作转交给

Dispatcher自己的init方法处理：初始化Dispatcher类：

 /**
     * Creates and initializes the dispatcher
     */
    public Dispatcher initDispatcher( HostConfig filterConfig ) {
        Dispatcher dispatcher = createDispatcher(filterConfig);创建dispacher类
        dispatcher.init();dispatcher的初始化，在这里运行转移到dispatcher类，进行注册xml文件的加载器和运行加载器
        return dispatcher;
    }

创建Dispatcher类：

将web.xml文件中配置的启动参数独取出来，其中参数已经被初始化到HostConfig类中，将启动参数封装到

dispather类的一个属性中：params中，便于统一管理

  /**
     * Create a {@link Dispatcher}
     */
    private Dispatcher createDispatcher( HostConfig filterConfig ) {
        Map<String, String> params = new HashMap<String, String>();
        for ( Iterator e = filterConfig.getInitParameterNames(); e.hasNext(); ) {
            String name = (String) e.next();
            String value = filterConfig.getInitParameter(name);
            params.put(name, value);
        }
        return new Dispatcher(filterConfig.getServletContext(), params);
    }

Dispatcher的init方法，主要完成了以下几个方面的功能：

1、注册各种struts2配置文件的加载器

2、执行加载器

3、解析各种配置文件：主要包括XML和properties两种配置，struts2向用户预留了加载其他种类配置文件的类的接

口，在后面我们将会进行介绍

4、创建容器，实现容器的依赖注入功能

 /**
     * Load configurations, including both XML and zero-configuration strategies,
     * and update optional settings, including whether to reload configurations and resource files.
     */
    public void init() {
        如果当前的configurationManager对象为空，则创建一个默认的ConfigurationManager对象
        if (configurationManager == null) {
            configurationManager = new ConfigurationManager(BeanSelectionProvider.DEFAULT_BEAN_NAME);
        }

        try {
            init_DefaultProperties(); // [1]
            init_TraditionalXmlConfigurations(); // [2]
            init_LegacyStrutsProperties(); // [3]
            init_CustomConfigurationProviders(); // [5]用户自定义的加载器的实现
            init_FilterInitParameters() ; // [6]
            init_AliasStandardObjects() ; // [7]

            Container container = init_PreloadConfiguration();
            container.inject(this);
            init_CheckConfigurationReloading(container);
            init_CheckWebLogicWorkaround(container);

            if (!dispatcherListeners.isEmpty()) {
                for (DispatcherListener l : dispatcherListeners) {
                    l.dispatcherInitialized(this);
                }
            }
        } catch (Exception ex) {
            if (LOG.isErrorEnabled())
                LOG.error("Dispatcher initialization failed", ex);
            throw new StrutsException(ex);
        }
    }

初始化各种形式加载器,保存到ConfigurationManager#containerProviders Map集合中 没有真正执行加载 解析逻辑

对上述几个步骤初始化的文件进行介绍：

[1]：初始化stuts2默认的properties文件加载器（default.properties）

[2]：初始化XML文件文件加载器

[3]：初始化的properties文件加载器（struts.properties），该文件是用户自定义的文件

[4]：初始化用户自定义配置加载器，将我们自定义的加载器  保存到containerProviders集合中 ，web.xml中的

configProviders参数  多个用","分开  配置器必须是ConfigurationProvider接口的实例

[5]：初始化由web.xml传入的运行参数，最终保存到Container中

[6]：初始化默认容器内置对象加载器

      ConfigurationManager和Configuration是Struts2的初始化元素，它们两者之间的关系，好比是xwork中 

ActionProxy和ActionInvocation直接的关系，其中ConfigurationManager是整个配置元素进行操作的代理接口类，

而真  正进行所有配置元素初始化进行调度的是Configuration对象。

 1、default.properties文件，属性加载器

 private void init_DefaultProperties() {
        configurationManager.addConfigurationProvider(new DefaultPropertiesProvider());
    }

2、struts相关文件加载器，主要包括三种文件"struts-default.xml,struts-plugin.xml,struts.xml

 private void init_TraditionalXmlConfigurations() {
        String configPaths = initParams.get("config");从webx.xml中的配置的启动参数config读取文件，如果           没有配置，则使用的DAFAULT_CONFIGURATIO_PATHS静态常量配置的值。
        if (configPaths == null) {
            configPaths = DEFAULT_CONFIGURATION_PATHS;
        }文件名称使用,隔开，\s是java正则表达式的，表示匹配空白符号，匹配所有的空白符号，包括tab符
        String[] files = configPaths.split("\\s*[,]\\s*");
        for (String file : files) {
            if (file.endsWith(".xml")) {
                if ("xwork.xml".equals(file)) {
                    configurationManager.addConfigurationProvider(new XmlConfigurationProvider(file, false));
                } else {
                    configurationManager.addConfigurationProvider(new StrutsXmlConfigurationProvider(file, false, servletContext));
                }
            } else {
                throw new IllegalArgumentException("Invalid configuration file name");
            }
        }
    }

3、用户自定义的properties文件加载器：default.properties文件，详细情况参考DefaultSettings类的构造器

 private void init_LegacyStrutsProperties() {
        configurationManager.addConfigurationProvider(new LegacyPropertiesConfigurationProvider());
    }

4、用户自定义的文件加载器，主要是用户可能扩充读取其他配置文件的类，用户需要实现自定义的加载器，但该加载器

必须要实现ConfigurationProvider接口，并在web.xml的启动参数进行配置，并且配置的名称必须是configProviders

如果有多个，使用逗号(,)隔开。

 private void init_CustomConfigurationProviders() {
        String configProvs = initParams.get("configProviders");
        if (configProvs != null) {
            String[] classes = configProvs.split("\\s*[,]\\s*");
            for (String cname : classes) {
                try {
                    Class cls = ClassLoaderUtils.loadClass(cname, this.getClass());类加载器
                    ConfigurationProvider prov = (ConfigurationProvider)cls.newInstance();实例化
                    configurationManager.addConfigurationProvider(prov);
                } catch (InstantiationException e) {
                    throw new ConfigurationException("Unable to instantiate provider: "+cname, e);
                } catch (IllegalAccessException e) {
                    throw new ConfigurationException("Unable to access provider: "+cname, e);
                } catch (ClassNotFoundException e) {
                    throw new ConfigurationException("Unable to locate provider class: "+cname, e);
                }
            }
        }
    }

5、初始化web.xml中配置的启动参数，配置的主要是在properties文件中配置的参数，或者，在struts2的xml文件中

constant节点配置的属性和值，在这里使用了动态接口编程的思想，而没有单独的为初始化参数写加载器，只是实现了

ConfigurationProvider类的匿名接口类。

    private void init_FilterInitParameters() {动态接口编程
        configurationManager.addConfigurationProvider(new ConfigurationProvider() {
 3             public void destroy() {}
 4             public void init(Configuration configuration) throws ConfigurationException {}
 5             public void loadPackages() throws ConfigurationException {}
 6             public boolean needsReload() { return false; }
 7 
 8             public void register(ContainerBuilder builder, LocatableProperties props) throws ConfigurationException {
 9                 props.putAll(initParams);
10             }
        });
    }

6、初始化默认容器的内置对象：在这里，之前通过加载struts2配置文件中，可能用户在自定义的xml配置文件中对

系统的bean节点进行了重新配置，在这里可能需要重新的初始化，在这里主要是初始化系统的内置对象。

private void init_AliasStandardObjects() {
        configurationManager.addConfigurationProvider(new BeanSelectionProvider());
    }

加载器初始化已经完成

init_PreloadConfiguration 方法中调用了  ConfigurationManager的getConfiguration 方法

 private Container init_PreloadConfiguration() {
        Configuration config = configurationManager.getConfiguration();
        Container container = config.getContainer();

        boolean reloadi18n = Boolean.valueOf(container.getInstance(String.class, StrutsConstants.S          TRUTS_I18N_RELOAD));
        LocalizedTextUtil.setReloadBundles(reloadi18n);

        return container;
    }

getConfiguration方法：在这里，关键的方法在于reloadContainer方法它是我们初始化进行操作的地方

    /**
     * Get the current XWork configuration object.  By default an instance of DefaultConfiguration will be returned
     *
     * @see com.opensymphony.xwork2.config.impl.DefaultConfiguration
     */
    public synchronized Configuration getConfiguration() {
        if (configuration == null) {
            setConfiguration(new DefaultConfiguration(defaultFrameworkBeanName));
            try {
                configuration.reloadContainer(getContainerProviders());
            } catch (ConfigurationException e) {
                setConfiguration(null);
                throw new ConfigurationException("Unable to load configuration.", e);
            }
        } else {
            conditionalReload();
        }

        return configuration;
    }

reloadContainer方法

    /**
     * Calls the ConfigurationProviderFactory.getConfig() to tell it to reload the configuration and then calls
     * buildRuntimeConfiguration().
     *
     * @throws ConfigurationException
     */
    public synchronized List<PackageProvider> reloadContainer(List<ContainerProvider> providers) throws ConfigurationException {
        packageContexts.clear();
        loadedFileNames.clear();配置文件加载器
        List<PackageProvider> packageProviders = new ArrayList<PackageProvider>();
        props是用来保存struts2的常量信息，主要是在properties文件中配置的，和在xml的constant节点配置的
        ContainerProperties props = new ContainerProperties();
        ContainerBuilder builder = new ContainerBuilder();容器构建器
        for (final ContainerProvider containerProvider : providers)
        {
            containerProvider.init(this);//初始化配置文件加载器
            containerProvider.register(builder, props);注册配置文件加载器，进行各种文件的读取，并
        }   保存到builder和props两个变量中
        props.setConstants(builder);进行constant常量的注册，将常量保存到ContainerBuilder#
        factorys中，
        builder.factory(Configuration.class, new Factory<Configuration>() {
            public Configuration create(Context context) throws Exception {
                return DefaultConfiguration.this;
            }将自身放入到factorys中
        });

        ActionContext oldContext = ActionContext.getContext();
        try {创建容器，并创建struts2的一些核心类
            // Set the bootstrap container for the purposes of factory creation
            Container bootstrap = createBootstrapContainer();
            setContext(bootstrap);
            container = builder.create(false);创建容器
            setContext(container);
            objectFactory = container.getInstance(ObjectFactory.class);
            解析struts2的配置文件，解析package节点下的信息，并把不到
            // Process the configuration providers first
            for (final ContainerProvider containerProvider : providers)
            {
                if (containerProvider instanceof PackageProvider) {
                    container.inject(containerProvider);依赖注入
                    ((PackageProvider)containerProvider).loadPackages();
                    packageProviders.add((PackageProvider)containerProvider);
                }
            }
            解析XML的package节点，保存到packageContexts的MAP中
            // Then process any package providers from the plugins
            Set<String> packageProviderNames = container.getInstanceNames(PackageProvider.class);
            if (packageProviderNames != null) {
                for (String name : packageProviderNames) {
                    PackageProvider provider = container.getInstance(PackageProvider.class, name);
                    provider.init(this);
                    provider.loadPackages();
                    packageProviders.add(provider);
                }
            }

            rebuildRuntimeConfiguration();
        } finally {
            if (oldContext == null) {
                ActionContext.setContext(null);
            }
        }
        return packageProviders;
    }

 StrutsXmlConfigurationProvider的init方法 具体在父类XmlConfigurationProvider中实现，

 特别需要注意StrutsXmlConfigurationProvider的构造器

 /**
     * Constructs the configuration provider
     *
     * @param filename The filename to look for
     * @param errorIfMissing If we should throw an exception if the file can't be found
     * @param ctx Our ServletContext
     */
    public StrutsXmlConfigurationProvider(String filename, boolean errorIfMissing, ServletContext ctx) {
        super(filename, errorIfMissing);特别需要注意这句话，它还调用了父亲的构造器
        this.servletContext = ctx;
        this.filename = filename;
        reloadKey = "configurationReload-"+filename;
        Map<String,String> dtdMappings = new HashMap<String,String>(getDtdMappings());
        dtdMappings.put("-//Apache Software Foundation//DTD Struts Configuration 2.0//EN", "struts-2.0.dtd");
        dtdMappings.put("-//Apache Software Foundation//DTD Struts Configuration 2.1//EN", "struts-2.1.dtd");
        dtdMappings.put("-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN", "struts-2.1.7.dtd");
        setDtdMappings(dtdMappings);
        File file = new File(filename);
        if (file.getParent() != null) {
            this.baseDir = file.getParentFile();
        }
    }

init方法主要有下面三个功能：

configFileName ->struts.xml
递归处理include节点
生成Document 集合

public void init(Configuration configuration) {
        this.configuration = configuration;
        this.includedFileNames = configuration.getLoadedFileNames();
        loadDocuments(configFileName);
}

loadConfigurationFiles方法递归处理include节点 最终生成Document集合，注意在这里使用的递归方法，在struts2

的初始化操作中，大量的使用了递归方法的调用

    private List<Document> loadConfigurationFiles(String fileName, Element includeElement) {
        List<Document> docs = new ArrayList<Document>();
        List<Document> finalDocs = new ArrayList<Document>();
        if (!includedFileNames.contains(fileName)) {放置include的中引用的文件重复插入
            if (LOG.isDebugEnabled()) {
                LOG.debug("Loading action configurations from: " + fileName);
            }

            includedFileNames.add(fileName);

            Iterator<URL> urls = null;
            InputStream is = null;

            IOException ioException = null;
            try {
                urls = getConfigurationUrls(fileName);
            } catch (IOException ex) {
                ioException = ex;
            }

            if (urls == null || !urls.hasNext()) {
                if (errorIfMissing) {
                    throw new ConfigurationException("Could not open files of the name " + fileName, ioException);
                } else {
                    LOG.info("Unable to locate configuration files of the name "
                            + fileName + ", skipping");
                    return docs;
                }
            }

            URL url = null;
            while (urls.hasNext()) {
                try {
                    url = urls.next();
                    is = FileManager.loadFile(url);

                    InputSource in = new InputSource(is);

                    in.setSystemId(url.toString());
                    生成document文件
                    docs.add(DomHelper.parse(in, dtdMappings));
                } catch (XWorkException e) {
                    if (includeElement != null) {
                        throw new ConfigurationException("Unable to load " + url, e, includeElement);
                    } else {
                        throw new ConfigurationException("Unable to load " + url, e);
                    }
                } catch (Exception e) {
                    final String s = "Caught exception while loading file " + fileName;
                    throw new ConfigurationException(s, e, includeElement);
                } finally {
                    if (is != null) {
                        try {
                            is.close();
                        } catch (IOException e) {
                            LOG.error("Unable to close input stream", e);
                        }
                    }
                }
            }

            //sort the documents, according to the "order" attribute
            Collections.sort(docs, new Comparator<Document>() {
                public int compare(Document doc1, Document doc2) {
                    return XmlHelper.getLoadOrder(doc1).compareTo(XmlHelper.getLoadOrder(doc2));
                }
            });

            for (Document doc : docs) {
                Element rootElement = doc.getDocumentElement();
                NodeList children = rootElement.getChildNodes();
                int childSize = children.getLength();

                for (int i = 0; i < childSize; i++) {
                    Node childNode = children.item(i);

                    if (childNode instanceof Element) {
                        Element child = (Element) childNode;

                        final String nodeName = child.getNodeName();
                        处理include节点的内容，可以使用通配符
                        if ("include".equals(nodeName)) {
                            String includeFileName = child.getAttribute("file");
                            if (includeFileName.indexOf('*') != -1) {
                                // handleWildCardIncludes(includeFileName, docs, child);
                                ClassPathFinder wildcardFinder = new ClassPathFinder();
                                wildcardFinder.setPattern(includeFileName);
                                Vector<String> wildcardMatches = wildcardFinder.findMatches();
                                for (String match : wildcardMatches) {
                                    finalDocs.addAll(loadConfigurationFiles(match, child));
                                }   递归调用
                            } else {
                               finalDocs.addAll(loadConfigurationFiles(includeFileName, child));                                         递归调用
                            }
                        }
                    }
                }
                finalDocs.add(doc);
                loadedFileUrls.add(url.toString());
            }

            if (LOG.isDebugEnabled()) {
                LOG.debug("Loaded action configuration from: " + fileName);
            }
        }
        return finalDocs;
    }

StrutsXmlConfigurationProvider的register方法 主要在父类 XmlConfigurationProvider中实现

1.遍历init方法中生成的Document 集合  解析xml文件中定义的bean,constant常量节点 不会处理package节点

2.解析bean节点的值 包装成LocatableFactory对象  注册到ContainerBuilder中factories map集合中

3.解析constant节点的值 保存到ContainerProperties 对象中 

XmlConfigurationProvider 的register  这里只解析 bean , constant节点

 public void register(ContainerBuilder containerBuilder, LocatableProperties props) throws ConfigurationException {
        LOG.info("Parsing configuration file [" + configFileName + "]");
        Map<String, Node> loadedBeans = new HashMap<String, Node>();
        for (Document doc : documents) {
            Element rootElement = doc.getDocumentElement();
            NodeList children = rootElement.getChildNodes();
            int childSize = children.getLength();

            for (int i = 0; i < childSize; i++) {
                Node childNode = children.item(i);

                if (childNode instanceof Element) {
                    Element child = (Element) childNode;

                    final String nodeName = child.getNodeName();
                    解析bean节点
                    if ("bean".equals(nodeName)) {
                        String type = child.getAttribute("type");
                        String name = child.getAttribute("name");
                        String impl = child.getAttribute("class");
                        String onlyStatic = child.getAttribute("static");
                        String scopeStr = child.getAttribute("scope");
                        boolean optional = "true".equals(child.getAttribute("optional"));
                        Scope scope = Scope.SINGLETON;
                        if ("default".equals(scopeStr)) {
                            scope = Scope.DEFAULT;
                        } else if ("request".equals(scopeStr)) {
                            scope = Scope.REQUEST;
                        } else if ("session".equals(scopeStr)) {
                            scope = Scope.SESSION;
                        } else if ("singleton".equals(scopeStr)) {
                            scope = Scope.SINGLETON;
                        } else if ("thread".equals(scopeStr)) {
                            scope = Scope.THREAD;
                        }

                        if (StringUtils.isEmpty(name)) {
                            name = Container.DEFAULT_NAME;
                        }

                        try {
                            Class cimpl = ClassLoaderUtil.loadClass(impl, getClass());
                            Class ctype = cimpl;在开发程序的过程，应该多使用公共类，是代码简洁易懂
                            if (StringUtils.isNotEmpty(type)) {
                                ctype = ClassLoaderUtil.loadClass(type, getClass());
                            }
                            if ("true".equals(onlyStatic)) {
                                // Force loading of class to detect no class def found exceptions
                                cimpl.getDeclaredClasses();
                                containerBuilder.injectStatics(cimpl);
                            } else {beanName + class构成唯一性约束
                                if (containerBuilder.contains(ctype, name)) {使用loadedBeans检测使用重复配置bean节点信息
                                    Location loc = LocationUtils.getLocation(loadedBeans.get(ctype.getName() + name));
                                    if (throwExceptionOnDuplicateBeans) {
                                        throw new ConfigurationException("Bean type " + ctype + " with the name " +
                                                name + " has already been loaded by " + loc, child);
                                    }
                                }

                                // Force loading of class to detect no class def found exceptions
                                cimpl.getDeclaredConstructors();

                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("Loaded type:" + type + " name:" + name + " impl:" + impl);
                                }

                                   将bean定义保存到containerBuilder#factorys中，此刻，并未真正的实现bean
                                   节点
66                                 containerBuilder.factory(ctype, name, new LocatableFactory(name, ctype, cimpl, scope, childNode), scope);
                            }
                            loadedBeans.put(ctype.getName() + name, child);向loadedBeans中插入数据
                        } catch (Throwable ex) {
                            if (!optional) {
                                throw new ConfigurationException("Unable to load bean: type:" + type + " class:" + impl, ex, childNode);
                            } else {
                                LOG.debug("Unable to load optional class: " + ex);
                            }
                        }
                    } else if ("constant".equals(nodeName)) {加载constant节点，保存到props变量中
                        String name = child.getAttribute("name");
                        String value = child.getAttribute("value");
                        props.setProperty(name, value, childNode);
                    } else if (nodeName.equals("unknown-handler-stack")) {
                        List<UnknownHandlerConfig> unknownHandlerStack = new ArrayList<UnknownHandlerConfig>();
                        NodeList unknownHandlers = child.getElementsByTagName("unknown-handler-ref");
                        int unknownHandlersSize = unknownHandlers.getLength();

                        for (int k = 0; k < unknownHandlersSize; k++) {
                            Element unknownHandler = (Element) unknownHandlers.item(k);
                            unknownHandlerStack.add(new UnknownHandlerConfig(unknownHandler.getAttribute("name")));
                        }

                        if (!unknownHandlerStack.isEmpty())
                            configuration.setUnknownHandlerStack(unknownHandlerStack);
                    }
                }
            }
        }
    }

XmlConfigurationProvider的loadPackages方法  解析package节点下的所有子节点interceptor ,ResultType

等保存到DefaultConfiguration packageContexts map集合中，

关于loadPackages方法，可以参考之前的一篇文章：

Struts源码学习-XmlConfigurationProvider的loadPackages()方法递归调用

    public void loadPackages() throws ConfigurationException {
        List<Element> reloads = new ArrayList<Element>();
        for (Document doc : documents) {
            Element rootElement = doc.getDocumentElement();
            NodeList children = rootElement.getChildNodes();
            int childSize = children.getLength();

            for (int i = 0; i < childSize; i++) {
                Node childNode = children.item(i);
 
                if (childNode instanceof Element) {
                    Element child = (Element) childNode;

                    final String nodeName = child.getNodeName();
                    解析package节点，包装成PackageConfig对象
                    if ("package".equals(nodeName)) {
17                         PackageConfig cfg = addPackage(child);
18                         if (cfg.isNeedsRefresh()) {
19                             reloads.add(child);将所有要重新加载的放置到reloads这个list中，因为在初始化
20                         }   package的时候，它extends的包可能还没有加载出来，需要reload，重新最终去构建
                    }       它们的父子关系，详细情况请敞开上面的链接
                } 
            }
            loadExtraConfiguration(doc);空实现no op
        }

        if (reloads.size() > 0) {
            reloadRequiredPackages(reloads);
        }

        for (Document doc : documents) {
            loadExtraConfiguration(doc);no op空实现，便于以后的扩展
        }

        documents.clear();
        configuration = null;
    }

 addPackage(),解析package节点下的所有子节点；

  /**
     * Create a PackageConfig from an XML element representing it.
     */
    protected PackageConfig addPackage(Element packageElement) throws ConfigurationException {
        PackageConfig.Builder newPackage = buildPackageContext(packageElement);

        if (newPackage.isNeedsRefresh()) {
            return newPackage.build();
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Loaded " + newPackage);
        }
        处理所有的resultType，包括自定义的和在struts-default.xml文件中定义的，这就是为什么我们建立xml文件的
        // add result types (and default result) to this package时候一般需要继承struts-default.xml
        addResultTypes(newPackage, packageElement);
        interceptors节点
        // load the interceptors and interceptor stacks for this package
        loadInterceptors(newPackage, packageElement);
        默认的拦截器节点
        // load the default interceptor reference for this package
        loadDefaultInterceptorRef(newPackage, packageElement);
        假如没有发现对应的action，在dafault-class-ref节点
        // load the default class ref for this package
        loadDefaultClassRef(newPackage, packageElement);
        全局的result节点，在这里，我们将找到，如果不配置result的name，那么它的名字将是Action.SUCCESS,
        // load the global result list for this package也就是success
        loadGlobalResults(newPackage, packageElement);
        全局的异常处理
        // load the global exception handler list for this package
        loadGobalExceptionMappings(newPackage, packageElement);

        // get actions
        NodeList actionList = packageElement.getElementsByTagName("action");
        处理action节点的信息
        for (int i = 0; i < actionList.getLength(); i++) {
            Element actionElement = (Element) actionList.item(i);
            addAction(actionElement, newPackage);
        }
        默认的本包内部的action
        // load the default action reference for this package
        loadDefaultActionRef(newPackage, packageElement);
        构建packkage
        PackageConfig cfg = newPackage.build();
        configuration.addPackageConfig(cfg.getName(), cfg);保存到Map<String,PackageConfig>即
        return cfg; packageContexts中，
    }

这里我们看下：result-type，我们平时使用的result-type，默认为分发即dispatcher，我们在这里看看这是为什么

<result-types>
            <result-type name="chain" class="com.opensymphony.xwork2.ActionChainResult"/>
            <result-type name="dispatcher" class="org.apache.struts2.dispatcher.ServletDispatcherResult" default="true"/>
            <result-type name="freemarker" class="org.apache.struts2.views.freemarker.FreemarkerResult"/>
            <result-type name="httpheader" class="org.apache.struts2.dispatcher.HttpHeaderResult"/>
            <result-type name="redirect" class="org.apache.struts2.dispatcher.ServletRedirectResult"/>
            <result-type name="redirectAction" class="org.apache.struts2.dispatcher.ServletActionRedirectResult"/>
            <result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>
            <result-type name="velocity" class="org.apache.struts2.dispatcher.VelocityResult"/>
            <result-type name="xslt" class="org.apache.struts2.views.xslt.XSLTResult"/>
            <result-type name="plainText" class="org.apache.struts2.dispatcher.PlainTextResult" />
        </result-types>

addResultType()，所在，在我们使用在action中配置result节点的时候，不执行name，则为succcess，不指定

type，则为dispatcher.

 protected void addResultTypes(PackageConfig.Builder packageContext, Element element) {
        NodeList resultTypeList = element.getElementsByTagName("result-type");

        for (int i = 0; i < resultTypeList.getLength(); i++) {
            Element resultTypeElement = (Element) resultTypeList.item(i);
            String name = resultTypeElement.getAttribute("name");
            String className = resultTypeElement.getAttribute("class");
            String def = resultTypeElement.getAttribute("default");

            Location loc = DomHelper.getLocationObject(resultTypeElement);

            Class clazz = verifyResultType(className, loc);
            if (clazz != null) {
                String paramName = null;
                try {
                    paramName = (String) clazz.getField("DEFAULT_PARAM").get(null);
                }
                catch (Throwable t) {
                    // if we get here, the result type doesn't have a default param defined.
                }
                ResultTypeConfig.Builder resultType = new ResultTypeConfig.Builder(name, className).defaultResultParam(paramName)
                        .location(DomHelper.getLocationObject(resultTypeElement));

                Map<String, String> params = XmlHelper.getParams(resultTypeElement);

                if (!params.isEmpty()) {
                    resultType.addParams(params);
                }
                packageContext.addResultTypeConfig(resultType.build());

                // set the default result type
                if ("true".equals(def)) {设置默认的result-type，在这里为dispatcher
33                     packageContext.defaultResultType(name);
34                 }
            }
        }
    }

      最后整理解析的ActionConfig Map集合[DefaultConfiguration#packageContexts]  最终已Map<nameSpace,Map<actionName, ActionConfig>>形式存储

 /**
     * This builds the internal runtime configuration used by Xwork for finding and configuring Actions from the
     * programmatic configuration data structures. All of the old runtime configuration will be discarded and rebuilt.
     *
     * <p>
     * It basically flattens the data structures to make the information easier to access.  It will take
     * an {@link ActionConfig} and combine its data with all inherited dast.  For example, if the {@link ActionConfig}
     * is in a package that contains a global result and it also contains a result, the resulting {@link ActionConfig}
     * will have two results.
     */
    protected synchronized RuntimeConfiguration buildRuntimeConfiguration() throws ConfigurationException {
        Map<String, Map<String, ActionConfig>> namespaceActionConfigs = new LinkedHashMap<String, Map<String, ActionConfig>>();
        Map<String, String> namespaceConfigs = new LinkedHashMap<String, String>();

        for (PackageConfig packageConfig : packageContexts.values()) {

            if (!packageConfig.isAbstract()) {
                String namespace = packageConfig.getNamespace();
                Map<String, ActionConfig> configs = namespaceActionConfigs.get(namespace);

                if (configs == null) {
                    configs = new LinkedHashMap<String, ActionConfig>();
                }

                Map<String, ActionConfig> actionConfigs = packageConfig.getAllActionConfigs();

                for (Object o : actionConfigs.keySet()) {
                    String actionName = (String) o;
                    ActionConfig baseConfig = actionConfigs.get(actionName);这里设置action的默认拦截                       器
                    configs.put(actionName, buildFullActionConfig(packageConfig, baseConfig));
                }



                namespaceActionConfigs.put(namespace, configs);
                if (packageConfig.getFullDefaultActionRef() != null) {
                    namespaceConfigs.put(namespace, packageConfig.getFullDefaultActionRef());
                }
            }
        }

        return new RuntimeConfigurationImpl(namespaceActionConfigs, namespaceConfigs);
    }

请参考文章：Struts2源码学习-DefaultConfiguration的RuntimeConfigurationImpl方法（运行期改造）

解析完成后,  最终会保存到DefaultConfiguration  runtimeConfiguration变量中。