在讲述Spring国际化中遇到的问题之前，首先看下Spring MVC容器和Spring IOC容器，双容器的相关背景知识。
双容器
通常所说的spring 容器，只的是IOC容器。容器的主要作用是在程序启动时把所需的bean提前加载到内存（本质上是存储在一个ConcurrentHashMap里，DefaultListableBeanFactory
类的beanDefinitionMap字段），恰好如果web层使用的是Spring MVC，这时会产生另一个新的容—Spring MVC容器。这两个容器的启动入口都是在web.xml配置：
<!-- step1 Spring 容器启动监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- spring IOC 容器配置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-config.xml</param-value>
</context-param>
<!-- step2 Spring mvc 容器配置 -->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:spring-mvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup> <!-- 程序启动时装在该servlet -->
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
这份web.xml配置指出：Spring IOC容器是通过ContextLoaderListener启动，并根据spring-config.xml的配置读取对应的bean列表加载到容器；Spring MVC容器是通过DispatcherServlet启动，并根据spring-mvc.xml的配置读取对应的bean列表加载到容器。
两个容器的初始化过程
两个容器的初始化顺序为: Spring IOC容器àSpring mvc容器。首先看Spring IOC容器，通过阅读ContextLoaderListener的源码，可以得知其通过initWebApplicationContext方法创建容器，类型为XmlWebApplicationContext。创建完成后，调用容器自身的refresh()方法加载到容器，实际调用的是XmlWebApplicationContext的父类AbstractApplicationContext的refresh()方法,容器的加载过程是该方法再通过调用refreshBeanFactory()创建容器自己的beanFactory，并读取配置文件把bean加载到容器：
protected final void refreshBeanFactory() throws BeansException {
if(this.hasBeanFactory()) {//如果容器已有beanFactory，先销毁
this.destroyBeans();
this.closeBeanFactory();
}
try {
//创建一个DefaultListableBeanFactory类型的BeanFactory
DefaultListableBeanFactory ex = this.createBeanFactory();
ex.setSerializationId(this.getId());
this.customizeBeanFactory(ex);
//通过该方法读取配置文件spring-config.xml中所有的bean加载到容器
this.loadBeanDefinitions(ex);
Object var2 = this.beanFactoryMonitor;
synchronized(this.beanFactoryMonitor) {
//把刚创建的DefaultListableBeanFactory赋值给容器
this.beanFactory = ex;
}
} catch (IOException var5) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
}
}
AbstractApplicationContext的refresh()方法执行完成后，标志着Spring IOC容器 加载完成。
Spring IOC容器 加载完成后，才开始Spring mvc容器的初始化。上面已经提到Spring mvc容器是通过DispatcherServlet加载的，DispatcherServlet本质上是一个Servlet，容器的初始化过程是在FrameworkServlet的initWebApplicationContext()方法中完成：
protected WebApplicationContext initWebApplicationContext() {
//获取父容器---spring ioc容器，通过ContextLoaderListener已经创建完毕
WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
WebApplicationContext wac = null;
//省略部分代码
if(wac == null) {
//创建spring mvc容器类型为XmlWebApplicationContext，父容器为spring ioc容器
wac = this.createWebApplicationContext(rootContext);
}
if(!this.refreshEventReceived) {
this.onRefresh(wac);
}
//省略部分代码
return wac;
}
该方法通过调用createWebApplicationContext方法是创建容器，通过onRefresh方法把bean加载到容器。首先来看createWebApplicationContext方法：
protected WebApplicationContext createWebApplicationContext(ApplicationContext parent) {
//获取容器类型，这里还是XmlWebApplicationContext
Class contextClass = this.getContextClass();
if(this.logger.isDebugEnabled()) {
this.logger.debug("Servlet with name \'" + this.getServletName() + "\' will try to create custom WebApplicationContext context of class \'" + contextClass.getName() + "\'" + ", using parent context [" + parent + "]");
}
if(!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
throw new ApplicationContextException("Fatal initialization error in servlet with name \'" + this.getServletName() + "\': custom WebApplicationContext class [" + contextClass.getName() + "] is not of type ConfigurableWebApplicationContext");
} else {
//根据contextClass 创建容器
ConfigurableWebApplicationContext wac = (ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
wac.setEnvironment(this.getEnvironment());
//设置父容器，这里是Spring IOC容器
wac.setParent(parent);
wac.setConfigLocation(this.getContextConfigLocation());
//调用AbstractApplicationContext的refresh()方法，加载bean到容器
this.configureAndRefreshWebApplicationContext(wac);
return wac;
}
}
这里contextClass是容器的类型，为XmlWebApplicationContext。然后根据contextClass创建Spring MVC容器，并设置之前已经创建好的Spring IOC容器为其父容器，也就是说Spring MVC容器和Spring IOC容器虽然是独立的，但也存在父子关系。最后的configureAndRefreshWebApplicationContext方法会调用容器自身的refresh()方法，加载bean到容器完成初始化，refresh()方法的主要执行过程在Spring Ioc容器加载过程中已有描述，这里不再累述。
两个容器的父子关系
再说下Spring MVC容器和Spring IOC容器的父子关系：子容器对父容器是可见的，但父容器对子容器不可见，这有点类似java类的父子关系。所谓可以见，就是在调用容器的getBean方法时，子容器会在自己的容器里先查找有没有对应的bean，如果没有就会到父容器中查找，具体代码实现参考AbstractBeanFactory类的doGetBean方法：
protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = this.transformedBeanName(name);
//首先在自己的容器中查找
Object sharedInstance = this.getSingleton(beanName);
Object bean;
if (sharedInstance != null && args == null) {
if (this.logger.isDebugEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.debug("Returning eagerly cached instance of singleton bean \'" + beanName + "\' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.debug("Returning cached instance of singleton bean \'" + beanName + "\'");
}
}
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition) null);
} else {
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//如果自己的容器中没找到，在到父容器中查找
BeanFactory ex = this.getParentBeanFactory();
if (ex != null && !this.containsBeanDefinition(beanName)) {
String var24 = this.originalBeanName(name);
if (args != null) {
return ex.getBean(var24, args);
}
return ex.getBean(var24, requiredType);
}
//省略其他代码
}
//省略其他代码
}
换句话说，Spring MVC容器可以使用Spring IOC容器中的bean，反之则不行。通常spring mvc项目中分为 Controller层、Service层、Dao层，一般Controller层使用Spring MVC容器，其他的放到Spring IOC容器，Controller层对Servvice、Dao层可见，但反之则不行，这也就是事务处理在Controller层失效的原因。
Spring的双容器有时，会引发一些问题，比如 下面讲到的“国际化”资源 可见性问题。
Spring国际化中遇到的问题
最近做的项目需要满足国际化需求，直接使用Spring MVC视图渲染技术做页面国际化处理。但对于有些ajax的异步数据接口里的文字信息，由于没有视图页面，只能在接口数据返回时自行处理。处理方式为：
1、首先在xml中配置国际化资源文件，为了方便在Service层和Dao层使用，下列配置会配置到Spring IOC容器对应的spring-config.xml配置文件。
<!-- 国际化资源文件 -->
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames" >
<list>
<value>test</value>
</list>
</property>
<property name="defaultEncoding" value="UTF-8"/>
</bean>
该配置会自动读取test开头的国际化资源文件列表，这里有三个：
为了测试，配置文件内容均为：my.name=lilei
2、在需要使用国际化的地方，直接从容器中获取messageSource，调用其getMessage方法。这里就发现一个奇怪的问题，在Service层、Dao层使用没有问题，但在Controller层使用却报异常：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'xxxxController': Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.BeanNotOfRequiredTypeException: Bean named 'messageSource' must be of type [org.springframework.context.support.ResourceBundleMessageSource], but was actually of type [org.springframework.context.support.DelegatingMessageSource]
在Controller中的代码为：
@Resource
private ResourceBundleMessageSource messageSource;
@ResponseBody
@RequestMapping("/i18n")
public String Testi18n(Locale locale){ // Locale 入参
String val = messageSource.getMessage("my.name", null, locale);
System.out.println(val);
return val;
}
通过分析异常日志可以发现，其大概意思是在通过容器的getBean方法获取messageSource bean时，期望messageSource的类型为ResourceBundleMessageSource类型，但得到的是DelegatingMessageSource类型。
由于上述配置在Spring IOC容器中的类型为ResourceBundleMessageSource，DelegatingMessageSource肯定不是我们期望。再深入分析，messageSource是在Controller层使用，Controller属于Spring MVC容器，其依赖的bean优先从Spring MVC容器中查找，如果找不到再到Spring IOC容器中查找。
根据异常信息发现找到的是messageSource是DelegatingMessageSource类型，可以推测下，应该是在Spring MVC容器中有一个messageSource类型为DelegatingMessageSource，首先被找到后就返回了，没有继续到父容器中查找。带着这样个想法，又读了一遍容器初始化的源码，在AbstractApplicationContext的refresh()方法中，发现其调用this.initMessageSource()方法进行资源文件加载，方法内容为：
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
//判断容器中是否已经包含名称为messageSource 的资源对象
if(beanFactory.containsLocalBean("messageSource")) {
this.messageSource = (MessageSource)beanFactory.getBean("messageSource", MessageSource.class);
if(this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource dms = (HierarchicalMessageSource)this.messageSource;
if(dms.getParentMessageSource() == null) {
dms.setParentMessageSource(this.getInternalParentMessageSource());
}
}
if(this.logger.isDebugEnabled()) {
this.logger.debug("Using MessageSource [" + this.messageSource + "]");
}
} else {
//如果容器中不包含名为messageSource的资源对象，就新建一个DelegatingMessageSource类型的资源对象放入容器
DelegatingMessageSource dms1 = new DelegatingMessageSource();
dms1.setParentMessageSource(this.getInternalParentMessageSource());
this.messageSource = dms1;
beanFactory.registerSingleton("messageSource", this.messageSource);
if(this.logger.isDebugEnabled()) {
this.logger.debug("Unable to locate MessageSource with name \'messageSource\': using default [" + this.messageSource + "]");
}
}
}
果然在容器中如果没有名称为messageSource的资源对象，会自动创建一个名称为messageSource 类型为DelegatingMessageSource的资源对象，并放入容器。
这就是上述异常发生的根本原因。
解决办法
方法一：把下列资源对象配置从Spring IOC容器对应的spring-config.xml中 迁移到Spring MVC容器对应的
spring-mvc.xml中，即：
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames" >
<list>
<value>test</value>
</list>
</property>
<property name="defaultEncoding" value="UTF-8"/>
</bean>
通过refresh()方法的源码发现，如果容器中已经存在名称为messageSource的资源对象，就不会再去创建DelegatingMessageSource类型的资源对象。
缺点：通过配置迁移，可以在Controller层中使用messageSource资源对象。但由于Sping IOC容器对该messageSource资源对象不可见，在Service层或Dao层就无法使用该对象获取国际化消息了。
方法二：资源对象配置还是Spring IOC容器对应的spring-config.xml中，只是把bean名称改下，不使用messageSource即可。
<bean id="messageSourceIoc"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames" >
<list>
<value>test</value>
</list>
</property>
<property name="defaultEncoding" value="UTF-8"/>
</bean>
这种方式Controller层、Service层、Dao层都可以使用，只是bean的名称看起来不雅观。
方法三：把资源文件拆分成两份：testMVC和testIOC，Controller层使用的资源文件为testMVC，其他层使用的资源文件为testIOC， 分别在spring-mvc.xml和spring-config.xml中配置资源对象：
spring-mvc.xml中配置为：
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames" >
<list>
<value>testMVC</value>
</list>
</property>
<property name="defaultEncoding" value="UTF-8"/>
</bean>
spring-config.xml中配置为：
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames" >
<list>
<value>testIOC</value>
</list>
</property>
<property name="defaultEncoding" value="UTF-8"/>
</bean>
Bean的名称都是messageSource，但不会报错，也不会覆盖。因为他们分别属于两个独立的容器，在使用时也不会互相干扰。这种方式的缺点是：两个文件中有可能有重复配置，比如在Controller层、Service层都会使用同样的配置值。
这三种方式，可以根据实际项目情况进行选择。
转载请注明出处：