[spring源码学习]八、IOC源码-messageSource

一、代码实例

　　我们在第八章可以看到，spring的context在初始化的时候，会默认调用系统中的各种约定好的bean，其中第一个bean就是id为messageSource的bean，我们了解这应该是一个读取properties的，并支持国际化的bean

1、首先我们定义这个bean，spring中默认提供了一些类，查了下主要是ResourceBundleMessageSource和ReloadableResourceBundleMessageSource，我们这里采用ResourceBundleMessageSource

        <bean id="messageSource"
            class="org.springframework.context.support.ResourceBundleMessageSource">
            <property name="basenames">
                <list>
                    <value>messages</value>
                </list>
            </property>
        </bean>

2、定义两个messages文件，分别是messages_zh_CN.properties、messages_en.properties和messages.properties，中文环境的配置文件，英文环境和全局配置，内容分别为

info={0}去上学    //messages_zh_CN.properties
info={0} go to school //messages_en.properties

info={0} hehe //messages.properties

3、测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        String info1=context.getMessage("info", new String[]{"张三"}, Locale.getDefault());
        String info2=context.getMessage("info", new String[]{"张三"}, Locale.ENGLISH);
        String info3=context.getMessage("info", new String[]{"张三"}, Locale.JAPAN);
        
        System.out.println("info1="+info1);
        System.out.println("info2="+info2);
        System.out.println("info3="+info3);
    }
}

4、测试结果

info1=张三去上学
info2=张三 go to school
info3=张三去上学

可以看到，我们定义了中文和英文环境顺利的找到了对应的文件，可是日文环境没有定义，也没有找到默认的环境，而是使用了系统环境，也就是中文环境

二、代码分析

1、先回到上一章的第5部分，context的解析中,将messageSource放到context中

protected void initMessageSource() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        //查找是否包含了名为messageSource的bean，如果没有，创建一个默认的
        if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
            this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
            // Make MessageSource aware of parent MessageSource.
            //判断是否有父类且是一个分层级的messageSource，如果是将父容器的的messageSource设置到里边
            if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
                HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
                if (hms.getParentMessageSource() == null) {
                    // Only set parent context as parent MessageSource if no parent MessageSource
                    // registered already.
                    hms.setParentMessageSource(getInternalParentMessageSource());
                }
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Using MessageSource [" + this.messageSource + "]");
            }
        }
        else {
            // Use empty MessageSource to be able to accept getMessage calls.
            //初始化一个空的messagesource到context中
            DelegatingMessageSource dms = new DelegatingMessageSource();
            dms.setParentMessageSource(getInternalParentMessageSource());
            this.messageSource = dms;
            beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
                        "': using default [" + this.messageSource + "]");
            }
        }
    }

2、开始通过context.getMessage("info", new String[]{"张三"}, Locale.getDefault());获得信息，其实就是调用了bean-messageSource的getMessage方法

    public String getMessage(String code, Object args[], Locale locale) throws NoSuchMessageException {
        return getMessageSource().getMessage(code, args, locale);
    }

3、分为两步：在messageSource中查找和查找系统默认的

    public final String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException {
        //到messageSource内查找
        String msg = getMessageInternal(code, args, locale);
        if (msg != null) {
            return msg;
        }
        //查找默认的Message
        String fallback = getDefaultMessage(code);
        if (fallback != null) {
            return fallback;
        }
        throw new NoSuchMessageException(code, locale);
    }

4、对整个文字的处理，我们可以看到分为有参数和无参数两种，如果无参数，直接解析为最终结果，如果有参数首先解析配置文件，得到messageFormat，然后替换参数

    protected String getMessageInternal(String code, Object[] args, Locale locale) {
        if (code == null) {
            return null;
        }
        if (locale == null) {
            locale = Locale.getDefault();
        }
        Object[] argsToUse = args;
        //是否每次都要重新创建message args是否为空
        //此参数可以配置，可见如果是false且参数为空的话，可以使用缓存
        if (!isAlwaysUseMessageFormat() && ObjectUtils.isEmpty(args)) {
            // Optimized resolution: no arguments to apply,
            // therefore no MessageFormat needs to be involved.
            // Note that the default implementation still uses MessageFormat;
            // this can be overridden in specific subclasses.
            String message = resolveCodeWithoutArguments(code, locale);
            if (message != null) {
                return message;
            }
        }

        else {
            // Resolve arguments eagerly, for the case where the message
            // is defined in a parent MessageSource but resolvable arguments
            // are defined in the child MessageSource.
            //处理参数
            argsToUse = resolveArguments(args, locale);

            MessageFormat messageFormat = resolveCode(code, locale);
            if (messageFormat != null) {
                synchronized (messageFormat) {
                    return messageFormat.format(argsToUse);
                }
            }
        }

        // Check locale-independent common messages for the given message code.
        Properties commonMessages = getCommonMessages();
        if (commonMessages != null) {
            String commonMessage = commonMessages.getProperty(code);
            if (commonMessage != null) {
                return formatMessage(commonMessage, args, locale);
            }
        }

        // Not found -> check parent, if any.
        return getMessageFromParent(code, argsToUse, locale);
    }

 

5、对参数的处理，参数如果是MessageSourceResolvable类型，可以继续获取真实的参数，然后直接组成数组

    protected Object[] resolveArguments(Object[] args, Locale locale) {
        if (args == null) {
            return new Object[0];
        }
        List<Object> resolvedArgs = new ArrayList<Object>(args.length);
        //查找参数是否为MessageSourceResolvable的实例，如果是，继续获取，如果不是，直接组成数组
        for (Object arg : args) {
            if (arg instanceof MessageSourceResolvable) {
                resolvedArgs.add(getMessage((MessageSourceResolvable) arg, locale));
            }
            else {
                resolvedArgs.add(arg);
            }
        }
        return resolvedArgs.toArray(new Object[resolvedArgs.size()]);
    }

6、配置文件解析过程为：

　　a)从baseNames的set中获取数据，

　　b)然后依次调用java的ResourceBundle进行解析

　　c)从解析的结果获取对应code的值

注：此处我们可以在AbstractResourceBasedMessageSource中找到此bean的注入参数主要有以下几个：basenameSet（文件列表set）、defaultEncoding（文件默认编码）、fallbackToSystemLocale（是否使用系统默认的编码）、cacheMillis（cache时间），

    protected MessageFormat resolveCode(String code, Locale locale) {
        Set<String> basenames = getBasenameSet();
        for (String basename : basenames) {
            ResourceBundle bundle = getResourceBundle(basename, locale);
            if (bundle != null) {
                MessageFormat messageFormat = getMessageFormat(bundle, code, locale);
                if (messageFormat != null) {
                    return messageFormat;
                }
            }
        }
        return null;
    }

7、调用getResourceBundle方法，生成ResourceBundle，这里有一个和预想不同的设置，如果缓存时间没有设置，默认为永久保存，如果设置了反而直接要重新获取

protected ResourceBundle getResourceBundle(String basename, Locale locale) {
        //判断是否设定了缓存时间，默认-1为永久保存，如果大于0，直接冲洗获取？
        if (getCacheMillis() >= 0) {
            // Fresh ResourceBundle.getBundle call in order to let ResourceBundle
            // do its native caching, at the expense of more extensive lookup steps.
            return doGetBundle(basename, locale);
        }
        else {
            // Cache forever: prefer locale cache over repeated getBundle calls.
            synchronized (this.cachedResourceBundles) {
                //缓存所在的cachedResourceBundles
                Map<Locale, ResourceBundle> localeMap = this.cachedResourceBundles.get(basename);
                if (localeMap != null) {
                    ResourceBundle bundle = localeMap.get(locale);
                    if (bundle != null) {
                        return bundle;
                    }
                }
                try {
                    ResourceBundle bundle = doGetBundle(basename, locale);
                    if (localeMap == null) {
                        localeMap = new HashMap<Locale, ResourceBundle>();
                        this.cachedResourceBundles.put(basename, localeMap);
                    }
                    localeMap.put(locale, bundle);
                    return bundle;
                }
                catch (MissingResourceException ex) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("ResourceBundle [" + basename + "] not found for MessageSource: " + ex.getMessage());
                    }
                    // Assume bundle not found
                    // -> do NOT throw the exception to allow for checking parent message source.
                    return null;
                }
            }
        }
    }

8、调用java的方法，获取ResourceBundle，需要写入自定义的MessageSourceControl

    protected ResourceBundle doGetBundle(String basename, Locale locale) throws MissingResourceException {
        return ResourceBundle.getBundle(basename, locale, getBundleClassLoader(), new MessageSourceControl());
    }

9、MessageSourceControl中判断是format是java.properties还是java.class，我们的程序是java.class,但是调用了newBundle，再次会回调回来，此时又变成了java.properties.

a)根据basename和local拼装propoties文件拼装文件名称

b)如果生成的文件名称不存在，此时或根据FallbackToSystemLocale决定是否使用系统字符集，也就是zh_CN

public Locale getFallbackLocale(String baseName, Locale locale) {
return (isFallbackToSystemLocale() ? super.getFallbackLocale(baseName, locale) : null);
}

b)生成流文件

c)根据默认的defaultEncoding，解析流

注：

此处可以看到，如果缓存时间大于0，使用的jdk自带缓存

10、生成MessageFormat

protected MessageFormat getMessageFormat(ResourceBundle bundle, String code, Locale locale)
            throws MissingResourceException {

        synchronized (this.cachedBundleMessageFormats) {
            //判断缓存中是否有MessageFormat，如果有，直接读取，没有重新获取
            Map<String, Map<Locale, MessageFormat>> codeMap = this.cachedBundleMessageFormats.get(bundle);
            Map<Locale, MessageFormat> localeMap = null;
            if (codeMap != null) {
                localeMap = codeMap.get(code);
                if (localeMap != null) {
                    MessageFormat result = localeMap.get(locale);
                    if (result != null) {
                        return result;
                    }
                }
            }

            String msg = getStringOrNull(bundle, code);
            if (msg != null) {
                if (codeMap == null) {
                    codeMap = new HashMap<String, Map<Locale, MessageFormat>>();
                    this.cachedBundleMessageFormats.put(bundle, codeMap);
                }
                if (localeMap == null) {
                    localeMap = new HashMap<Locale, MessageFormat>();
                    codeMap.put(code, localeMap);
                }
                MessageFormat result = createMessageFormat(msg, locale);
                localeMap.put(locale, result);
                return result;
            }

            return null;
        }
    }

11、跳转回第四步，我们已经完成了整个返回信息的生成

三、总结

看完了源码，许多问题我们可以解决掉：

1、messageSource使用的默认配置文件通过一个baseNames的set进行注入

2、通常教程中说的中文乱码问题，spring提供了defaultEncoding设置，在解析流的时候可以按照设置的字符集进行解析

3、我们设置了日语，却采用zh_CN进行解析，是因为默认使用了fallbackToSystemLocale

4、messageSource默认使用自身的永久缓存，也可以设置，使用jdk的缓存

5、如果没有参数，会默认执行resolveCodeWithoutArguments，不需要先转化为MessageFormat

6、参数类型可以为MessageSourceResolvable类型

 

修改bean的配置

        <bean id="messageSource"
            class="org.springframework.context.support.ResourceBundleMessageSource">
            <property name="basenames">
                <list>
                    <value>messages</value>
                </list>
            </property>
            <property name="defaultEncoding" value="utf-8" />
            <property name="fallbackToSystemLocale" value="false" />
            <property name="cacheMillis" value="3600" />
        </bean>

2、将messages.zh_CN.properties改为如下

info={0}去上学
name=zhangsan

3.修改测试程序，我们将参数改为MessageSourceResolvable类型，这个可以从高配置文件读取，如果没读取到可以使用默认

public class Test {
    public static void main(String[] args) {

        MessageSourceResolvable resolvable=new DefaultMessageSourceResolvable(new String[]{"name"},"lisi");
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        String info1=context.getMessage("info", new MessageSourceResolvable[]{resolvable}, Locale.getDefault());
        String info2=context.getMessage("info", new String[]{"张三"}, Locale.ENGLISH);
        
        String info3=context.getMessage("info", new MessageSourceResolvable[]{resolvable}, Locale.JAPAN);

        System.out.println("info1="+info1);
        System.out.println("info2="+info2);
        System.out.println("info3="+info3);
    }
}

4、然后执行测试程序，结果为

info1=zhangsan去上学
info2=张三 go to school
info3=lisi hehehe

可以看到：

日文的已经转向系统默认设置

参数为MessageSourceResolvable可以从配置文件读取，也可以使用默认值（此方法用处不明，很少看到这么用的）