Struts2中properties文件参数定义在XML中通过Constant节点定义的原理

       在Struts2中提供了两种类型的框架级配置文件，XML格式和.properties,其中系统提供的

dafault.properties文件是struts2默认的框架级参数配置，struts.properties是struts2默认的应用级的参数配

置，包含所有的应用级的参数对框架级的参数的覆盖，XML中配置properties文件的格式如下：

    <constant name="struts.devMode" value="false" />

    本文将从内部的实现原理，来告诉读者，Struts2是如何实现将struts2的XML文件的constant节点中中定义

的参数值读取出来，并覆盖了struts.properties定义的框架级的参数。

 我们首先要从Dispatcher的init()方法来讲：下面是init方法的定义，

 /**
     * Load configurations, including both XML and zero-configuration strategies,
     * and update optional settings, including whether to reload configurations and resource files.
     */
    public void init() {

        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);
        }
    }

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

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

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

[3]：初始化的properties文件加载器（struts.properties）

[4]：初始化用户自定义配置加载器

[5]：初始化由web.xml传入的运行参数

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

     下面我们来查看读取XML配置文件的加载器（XmlConfigurationProvider）的register方法：我只摘取了读

取constant节点变量值的一段

　　　　　　　　　　　else if ("constant".equals(nodeName)) {
                        String name = child.getAttribute("name");
                        String value = child.getAttribute("value");
                        props.setProperty(name, value, childNode);
                   }

最终将值读取到props中，register方法 register(ContainerBuilder containerBuilder,

LocatableProperties props)，中props变量，是专门存储properties变量的，其中props.setProperty(name,

value, childNode);将会覆盖，之前定义的框架级别运行参数，下面介绍下读取default.properties和

struts.properties参数用到的两个Provider，以及它们读取参数的不同之处。default.properties：

DefaultPropertiesProvider类，它的register方法定义，

public void register(ContainerBuilder builder, LocatableProperties props)
            throws ConfigurationException {
        
        Settings defaultSettings = null;
        try {
            defaultSettings = new PropertiesSettings("org/apache/struts2/default");
        } catch (Exception e) {
            throw new ConfigurationException("Could not find or error in org/apache/struts2/default.properties", e);
        }
        
        loadSettings(props, defaultSettings);
    }

其中defaultSettings = new PropertiesSettings("org/apache/struts2/default");是将配置文件中的值解析

出来，也就是properties文件的解析器（PropertiesReader），下面是解析器的构造方法；

  /**
     * Creates a new properties config given the name of a properties file. The name is expected to NOT have
     * the ".properties" file extension.  So when <tt>new PropertiesSettings("foo")</tt> is called
     * this class will look in the classpath for the <tt>foo.properties</tt> file.
     *
     * @param name the name of the properties file, excluding the ".properties" extension.
     */
    public PropertiesSettings(String name) {
        
        URL settingsUrl = ClassLoaderUtils.getResource(name + ".properties", getClass());
        
        if (settingsUrl == null) {
            LOG.debug(name + ".properties missing");
            settings = new LocatableProperties();
            return;
        }
        
        settings = new LocatableProperties(new LocationImpl(null, settingsUrl.toString()));

        // Load settings
        InputStream in = null;
        try {
            in = settingsUrl.openStream();
            settings.load(in);
        } catch (IOException e) {
            throw new StrutsException("Could not load " + name + ".properties:" + e, e);
        } finally {
            if(in != null) {
                try {
                    in.close();
                } catch(IOException io) {
                    LOG.warn("Unable to close input stream", io);
                }
            }
        }
    }

其中 settings.load(in);是读取真正的properties文件；

    @Override
    public void load(InputStream in) throws IOException {
        Reader reader = new InputStreamReader(in);
        PropertiesReader pr = new PropertiesReader(reader);
        while (pr.nextProperty()) {
            String name = pr.getPropertyName();--读取参数名称
            String val = pr.getPropertyValue();--读取参数值
            int line = pr.getLineNumber();     --读取参数的行
            String desc = convertCommentsToString(pr.getCommentLines());
            　　　　　　　　　　　　　　　　　　　　 --读取参数的注释信息
            Location loc = new LocationImpl(desc, location.getURI(), line, 0);
            setProperty(name, val, loc);
        }
    }

 下面来观察DefaultPropertiesProvider类中的loadSettings()方法，该方法是将从配置文件中读取出来的键值映

射对保存到LocatableProperties这个类中，这个类是贯穿Struts2初始化主线的。下面来具体的分析该方法，该方

法在register方法中调用：

 public void register(ContainerBuilder builder, LocatableProperties props)
            throws ConfigurationException {
        
        Settings defaultSettings = null;
        try {
            defaultSettings = new PropertiesSettings("org/apache/struts2/default");
        } catch (Exception e) {
            throw new ConfigurationException("Could not find or error in org/apache/struts2/default.properties", e);
        }
        
        loadSettings(props, defaultSettings);--将从default.properties文件中读取出来的值放到prop中
    }

        loadSettings(props, defaultSettings)方法，DefaultPropertiesProvider类继承自

LegacyPropertiesConfigurationProvider类，它调用了父类中的loadSettings方法：

 /**
     * @param props
     * @param settings
     */
    protected void loadSettings(LocatableProperties props, final Settings settings) {
        // We are calling the impl methods to get around the single instance of Settings that is expected
        for (Iterator i = settings.listImpl(); i.hasNext(); ) {
            String name = (String) i.next();
            props.setProperty(name, settings.getImpl(name), settings.getLocationImpl(name));
        }
    }

上面的方法，将从配置文件读取到properties文件中的值全部的放到LocatableProperties类中。其中

在PropertiesSettings类中已经封装了LocatableProperties类，现在只不过是将PropertiesSetting变量中的值

拿出来放到loadSettings的那个全局的LocatableProperties类（prop）参数。相当与转移了下位置。下面是

PropertiesSettings构造方法，他包含了LocatableProperties类的一个变量setting

 /**
     * Creates a new properties config given the name of a properties file. The name is expected to NOT have
     * the ".properties" file extension.  So when <tt>new PropertiesSettings("foo")</tt> is called
     * this class will look in the classpath for the <tt>foo.properties</tt> file.
     *
     * @param name the name of the properties file, excluding the ".properties" extension.
     */
    public PropertiesSettings(String name) {
        
        URL settingsUrl = ClassLoaderUtils.getResource(name + ".properties", getClass());
        
        if (settingsUrl == null) {
            LOG.debug(name + ".properties missing");
            settings = new LocatableProperties();
            return;
        }
        --实例化LocatableProperties类
        settings = new LocatableProperties(new LocationImpl(null, settingsUrl.toString()));

        // Load settings
        InputStream in = null;
        try {
            in = settingsUrl.openStream();
            settings.load(in);--读取配置文件中的参数值和名称
        } catch (IOException e) {
            throw new StrutsException("Could not load " + name + ".properties:" + e, e);
        } finally {
            if(in != null) {
                try {
                    in.close();
                } catch(IOException io) {
                    LOG.warn("Unable to close input stream", io);
                }
            }
        }
    }

settings.load(in);--读取配置文件中的参数值和名称

@Override
    public void load(InputStream in) throws IOException {
        Reader reader = new InputStreamReader(in);
        PropertiesReader pr = new PropertiesReader(reader);--properties文件加载器
        while (pr.nextProperty()) {--pr.nextProperty文件
            String name = pr.getPropertyName();--名字
 7             String val = pr.getPropertyValue();--值
 8             int line = pr.getLineNumber();--行号
 9             String desc = convertCommentsToString(pr.getCommentLines());--描述信息
10             --具体位置信息
11             Location loc = new LocationImpl(desc, location.getURI(), line, 0);
            setProperty(name, val, loc);
        }
    }

下面观察下方法：setProperty()方法，它将key和他的位置信息存到propLocations中。

    public Object setProperty(String key, String value, Object locationObj) {
        Object obj = super.setProperty(key, value);
        if (location != null) {
            Location loc = LocationUtils.getLocation(locationObj);
5             propLocations.put(key, loc);
        }
        return obj;
    }

这时候，我们可以返回去看loadSetting方法：

  /**
     * @param props
     * @param settings
     */
    protected void loadSettings(LocatableProperties props, final Settings settings) {
        // We are calling the impl methods to get around the single instance of Settings that is expected
        for (Iterator i = settings.listImpl(); i.hasNext(); ) {
            String name = (String) i.next();
            props.setProperty(name, settings.getImpl(name), settings.getLocationImpl(name));
        }
    }

它用到了上面的三个方法；可以在DefaultSettings类中查看上述三个方法是如何定义的。

----------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------

下面介绍下在DefaultPropertiesProvider和LegacyPropertiesConfigurationProvider读取配置文件的

不同方式，在LegacyPropertiesConfigurationProvider使用了代理模式；下面来进行讲解：

DefaultPropertiesProvider的register方法：

 public void register(ContainerBuilder builder, LocatableProperties props)
            throws ConfigurationException {
        
        Settings defaultSettings = null;
        try {
            defaultSettings = new PropertiesSettings("org/apache/struts2/default");
               --直接新建了PropertiesSettings类，该构造
        } catch (Exception e) {
            throw new ConfigurationException("Could not find or error in org/apache/struts2/default.properties", e);
        }
        
        loadSettings(props, defaultSettings);
    }

 它直接defaultSettings = new PropertiesSettings("org/apache/struts2/default");从指定的位置读取数据。

而LegacyPropertiesConfigurationProvider的register的方法：

 public void register(ContainerBuilder builder, LocatableProperties props)
            throws ConfigurationException {
        
        final Settings settings = Settings.getInstance();通过Setting.getInstance()方法加载配置文件
        
        loadSettings(props, settings);
        
        // Set default locale by lazily resolving the locale property as needed into a Locale object
        builder.factory(Locale.class, new Factory() {
            private Locale locale;

            public synchronized Object create(Context context) throws Exception {
                if (locale == null) {
                    String loc = context.getContainer().getInstance(String.class, StrutsConstants                        .STRUTS_LOCALE);
                    if (loc != null) {
                        StringTokenizer localeTokens = new StringTokenizer(loc, "_");
                        String lang = null;
                        String country = null;

                        if (localeTokens.hasMoreTokens()) {
                            lang = localeTokens.nextToken();
                        }

                        if (localeTokens.hasMoreTokens()) {
                            country = localeTokens.nextToken();
                        }
                        locale = new Locale(lang, country);
                    } else {
                        LOG.info("No locale define, substituting the default VM locale");
                        locale = Locale.getDefault();
                    }
                }
                return locale;
            }
        });
    }

下面来观察Settings.getInstance()方法，

 /**
     * Provides the Settings object.
     * <p>
     * This method will substitute the default instance if another instance is not registered.
     * 当默认的实例没有被注册，则使用该方法代替，获取默认的实例对象
     * @return the Settings object.
     */
    public static Settings getInstance() {
        return (settingsImpl == null) ? getDefaultInstance() : settingsImpl;
    }

下面我们来观察getDefaultInstance()方法

 /**
     * Creates a default Settings object.
     * <p>
     * A default implementation may be specified by the <code>struts.configuration</code> setting;
     * otherwise, this method instantiates {@link DefaultSettings} as the default implementation.
     *
     * @return A default Settings object.
     */
    private static Settings getDefaultInstance() {
        if (defaultImpl == null) {
            // Create bootstrap implementation
         defaultImpl = new DefaultSettings();--新建一个默认的Setting,但是，上面的是propertiesSetting
             下面我们观察DefaultSettings是如何初始化的
            // Create default implementation
            try {
                String className = get(StrutsConstants.STRUTS_CONFIGURATION);

                if (!className.equals(defaultImpl.getClass().getName())) {
                    try {
                        // singleton instances shouldn't be built accessing request or session-specific context data
                        defaultImpl = (Settings) ObjectFactory.getObjectFactory().buildBean(Thread.currentThread().getContextClassLoader().loadClass(className), null);
                    } catch (Exception e) {
                        LOG.error("Settings: Could not instantiate the struts.configuration object, substituting the default implementation.", e);
                    }
                }
            } catch (IllegalArgumentException ex) {
                // ignore
            }
        }

        return defaultImpl;
    }

 DefaultSetting的构造方法：

    /**
     * Constructs an instance by loading the standard property files, 
     * any custom property files (<code>struts.custom.properties</code>), 
     * and any custom message resources ().
     * <p>
     * Since this constructor  combines Settings from multiple resources,
     * it utilizes a {@link DelegatingSettings} instance,
     * and all API calls are handled by that instance.
     */
    public DefaultSettings() {

        ArrayList<Settings> list = new ArrayList<Settings>();

        // stuts.properties, default.properties
        try {这里用了一个list
            list.add(new PropertiesSettings("struts"));--开始读取用户配置的struts.properties
        } catch (Exception e) {
            log.warn("DefaultSettings: Could not find or error in struts.properties", e);
        }

        Settings[] settings = new Settings[list.size()];
        delegate = new DelegatingSettings(list.toArray(settings));--实际上是PropertiesSettings

        // struts.custom.properties
        try {
            StringTokenizer customProperties = new StringTokenizer(delegate.getImpl(StrutsConstants.STRUTS_CUSTOM_PROPERTIES), ",");

            while (customProperties.hasMoreTokens()) {
                String name = customProperties.nextToken();

                try {
                    list.add(new PropertiesSettings(name));--如果配置了struts.custom.properties
                } catch (Exception e) {
                    log.error("DefaultSettings: Could not find " + name + ".properties. Skipping.");
                }
            }

            settings = new Settings[list.size()];
            delegate = new DelegatingSettings(list.toArray(settings));--代理
        } catch (IllegalArgumentException e) {
            // Assume it's OK, since IllegalArgumentException is thrown  
            // when Settings is unable to find a certain setting,
            // like the struts.custom.properties, which is commented out
        }

    }

下面来观察代理的两个方法：

    // See superclass for Javadoc
    public void setImpl(String name, String value) throws IllegalArgumentException, UnsupportedOperationException {
        delegate.setImpl(name, value);
    }

    // See superclass for Javadoc
    public String getImpl(String aName) throws IllegalArgumentException {
        return delegate.getImpl(aName);
    }

实际上，上述两个方法，最终会调用：

  // See superclass for Javadoc
    public void setImpl(String name, String value) throws IllegalArgumentException, UnsupportedOperationException {
        IllegalArgumentException e = null;

        for (Settings delegate : delegates) {
            try {
                delegate.getImpl(name); // Throws exception if not found
                delegate.setImpl(name, value); // Found it
                return; // Done
            } catch (IllegalArgumentException ex) {
                e = ex;

                // Try next delegate：执行下一个代理的类
            }
        }

        throw e;--如果最终未找到，则抛出异常，否则在循环中就return了。
    }

    // See superclass for Javadoc
    public String getImpl(String name) throws IllegalArgumentException {

        IllegalArgumentException e = null;

        for (Settings delegate : delegates) {
            try {
                return delegate.getImpl(name);  // Throws exception if not found
            } catch (IllegalArgumentException ex) {
                e = ex;

                // Try next delegate：执行下一个代理的类
            }
        }

        throw e;--如果，最终未找到，则抛出异常，否则在循环中就return
    }

对应在register方法中引用的loadSettings(props, settings);方法；

 /**
     * @param props
     * @param settings
     */
    protected void loadSettings(LocatableProperties props, final Settings settings) {
        // We are calling the impl methods to get around the single instance of Settings that is expected
        for (Iterator i = settings.listImpl(); i.hasNext(); ) {
            String name = (String) i.next();
            props.setProperty(name, settings.getImpl(name), settings.getLocationImpl(name));
        }
    }

这时候，settings.listImpl()方法，实际上最终调用的是DelegatingSettings的listImpl()方法，这个方法会把

代理类的list中读取的参数值的放到一个list中，然后统一返回settingList.iterator();

 // See superclass for Javadoc
    public Iterator listImpl() {
        boolean workedAtAll = false;

        Set<Object> settingList = new HashSet<Object>();
        UnsupportedOperationException e = null;

        for (Settings delegate : delegates) {
            try {
                Iterator list = delegate.listImpl();

                while (list.hasNext()) {
                    settingList.add(list.next());--循环迭代，加入到一个新的list中
                }

                workedAtAll = true;
            } catch (UnsupportedOperationException ex) {
                e = ex;

                // Try next delegate--循环迭代下一个代理的类
            }
        }

        if (!workedAtAll) {
            throw (e == null) ? new UnsupportedOperationException() : e;
        } else {
            return settingList.iterator();
        }

 --end