Spring MVC官方文档学习笔记之DispatcherServlet

Posted 2023-05-31 shame11

1.DispatcherServlet入门

(1) Spring MVC是以前端控制器模式(即围绕着一个中央的Servelt, DispatcherServlet)进行设计的,这个DispatcherServlet为请求的处理提供了一个共用的算法,即它都会将实际的请求处理工作委托给那些可配置的组件进行执行,说白了,DispatcherServlet的作用就是进行统一调度,并控制请求的处理流程,和其他的Servlet一样，DispatcherServlet需要根据Servlet规范，使用基于Java的配置或在web.xml中进行声明,与此同时,DispatcherServlet会使用Spring相关配置来发现它在请求映射、视图解析、异常处理等方面所需要的组件,而实际的工作也会交由这些组件进行执行，下面列出了注册DispatcherServlet的一些方式

@Configuration
@ComponentScan("cn.example.springmvc.boke")
public class WebConfig 


//使用基于Java的配置,注册并初始化一个DispatcherServlet
public class MyWebApplicationInitializer implements WebApplicationInitializer 

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException 
        //声明一个Spring-web容器
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(WebConfig.class);

        //创建并注册DispatcherServlet
        DispatcherServlet servlet = new DispatcherServlet(ctx);
        //动态的添加Servlet
        ServletRegistration.Dynamic registration = servletContext.addServlet("dispatcherServlet", servlet);
        registration.setLoadOnStartup(1);
        //指定由DispatcherServlet拦截所有请求(包括静态资源，但不拦截.jsp)
        registration.addMapping("/");
    

上述是基于Java的配置,我们还可以基于web.xml来配置DispatcherServlet,如下

<web-app ....>
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

(2) 现在DispatcherServlet有了,我们还需要@Controller与@RequestMapping注解,来标注某个访问应该由谁进行处理,如下,而到此为止,我们就已经完全不需要编写HttpServlet相关的内容了,可见通过DispatcherServlet帮助我们免去了冗杂的Servlet映射配置

@Controller
public class DemoController 
    @RequestMapping("/demo")
    @ResponseBody
    public String get(HttpServletRequest request) 
        return "aaa";
    

启动容器,访问 http://localhost:8080/springmvc/demo, 页面显示aaa,说明访问正常,这便是我们的第一个Spring MVC项目

2.Spring容器的层次结构

(1) 根容器与Servlet子容器

通常情况下,一个web应用中有一个唯一的WebApplicationContext容器就足够了,但Spring还允许我们配置具有父子关系的根容器和它的Servlet子容器,来形成一个层次结构,如上图所示,可以很清楚的看到,Spring将表示层相关的组件全部放到了子容器中,而将公共的与基础服务有关的组件全部放到了根容器中,这样的话,当我们需要注册多个DispatcherServlet并共享那些基础服务组件的时候，不必重复注册Service和Dao了，因为每个Servlet子容器都可以从这个根容器中获取到Service和Dao,这便是层次结构的意义

当然，Spring也支持单容器配置，如开头中的示例那样，此外我们可以通过继承AbstractAnnotationConfigDispatcherServletInitializer来配置父子容器，如下

//配置父子容器，其中容器使用基于注解的配置方式
public class IocInit extends AbstractAnnotationConfigDispatcherServletInitializer 

    //配置 DispatcherServlet 拦截的路径
    @Override
    protected String[] getServletMappings() 
        return new String[] "/";
    

    //设置根容器的配置类
    @Override
    protected Class<?>[] getRootConfigClasses() 
        return new Class[] RootConfig.class;
    

    //设置子容器的配置类
    //如果不想形成父子容器，那么只需将下面这个getServletConfigClasses()方法返回null即可
    @Override
    protected Class<?>[] getServletConfigClasses() 
        return new Class[] WebConfig.class;
    


//由于我们采用的是父子容器，因此这就要求我们编写父子容器的配置文件时，根容器的配置文件(RootConfig)配置非web组件的bean，而子容器的配置文件(WebConfig)配置web组件的bean，同时，也要防止同一组件在不同容器中分别注册初始化，从而出现两个相同bean
//根容器配置类，使用excludeFilters排除掉@Controller注解标注的类和@Configuration注解标注的类，这里之所以要排除掉@Configuration注解标注的类，是为了防止根容器扫描到子容器的配置类WebConfig
@Configuration
@ComponentScan(value = "cn.example.springmvc.boke",
                excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class),
                        @ComponentScan.Filter(type = FilterType.ANNOTATION, value = Configuration.class)
                )
public class RootConfig 


//子容器配置类，使用includeFilters指定只扫描由@Controller注解标注的类
@Configuration
@ComponentScan(value = "cn.example.springmvc.boke",
        includeFilters = @ComponentScan.Filter(value = Controller.class, type = FilterType.ANNOTATION))
public class WebConfig 

也可以基于web.xml来配置父子容器，如下

<web-app ....>
    <!-- ContextLoaderListener用于配置根容器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 设置根容器的xml配置文件路径 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springroot.xml</param-value>
    </context-param>

    <!-- DispatcherServlet用于配置子容器 -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 设置子容器的xml配置文件路径 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springweb.xml</param-value>
        </init-param>
    </servlet>
    
    <!-- 设置 DispatcherServlet 拦截的路径  -->
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3.特殊类型的bean

(1) 前面已经提过了，DispatcherServlet会将实际的请求处理过程委托给那些特殊的组件来干，而它本身起一个统一分配与调度的作用，这些特殊的组件已经由Spring提供了默认的实现，但同时Spring也允许我们自己实现替换它们，下表列出了由 DispatcherServlet检测到的这些特殊的Bean类型

Bean类型	说明
HandlerMapping	处理器映射器，主要就是将请求路径(uri)映射到能处理该请求的处理器(handler)，DispatcherServlet在接收到请求后，该请求会交由谁来处理?这个匹配查找的工作不是由DispatcherServlet来做的，而是交由HandlerMapping负责的，而至于Handler，我们可以把它理解为在@Controller注解所标注的类中的一个标注了@RequestMapping注解的方法，所谓的匹配本质上就是匹配@RequestMapping注解中所声明的值罢了。注意：HandlerMapping在查找匹配到对应的Handler后，并不是直接返回这个Handler，而是返回这个Handler的包装对象HandlerExecutionChain，而这个HandlerExecutionChain其实就是 Handler + 该请求所涉及到的拦截器 所组合而成的一个对象。 两个主要的HandlerMapping实现类分别是RequestMappingHandlerMapping（标注了@RequestMapping注解的方法）和SimpleUrlHandlerMapping（若在xml中显式的配置了请求路径与Controller的对应关系，则会使用该处理器映射器）
HandlerAdapter	帮助 DispatcherServlet 调用映射匹配到的HandlerExecutionChain，换句话说，DispatcherServlet获得HandlerExecutionChain后，它不会进行调用执行，而是交由HandlerAdapter来调用执行HandlerExecutionChain
HandlerExceptionResolver	解决异常的策略，用于定义在请求映射，参数绑定或方法执行时若发生异常，该怎么处理
ViewResolver	Handler方法执行后，将返回的逻辑视图名(通常为一个String字符串)解析为真正的视图(如.jsp 、.html等)，并进行视图渲染，渲染完成后，将视图返回给DispatcherServlet
LocaleResolver, LocaleContextResolver	用于解析客户的Locale，实现国际化功能
ThemeResolver	解析你的web应用可使用的主题(theme)，主题是一系列静态资源的集合(比如说css文件，图片等)
MultipartResolver	专门用于处理文件上传
FlashMapManager	专门用于保存和管理FlashMap，而这个FlashMap是用来在重定向时传递参数的，因为redirect重定向是不能传递参数的，此时就可以借助FlashMap

4.Web MVC配置

(1) 我们可以自定义在上一节中所列出来的那些特殊的bean，DispatcherServlet会检查它们，如果没有，那么它将会使用DispatcherServlet.properties中所列出的默认类型的bean，如下

5.Servlet 配置

(1) 在Servlet环境中，我们可以选择以编程式的方式或基于web.xml的方式来配置Servlet容器，在本篇开头的位置也提到过了，如下是一个基于编程式的例子

public class IocInit implements WebApplicationInitializer 
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException 
        //创建一个基于xml配置的容器
        XmlWebApplicationContext appContext = new XmlWebApplicationContext();
        appContext.setConfigLocation("classpath:springmvc.xml");

        ServletRegistration.Dynamic registration = servletContext.addServlet("dispatcherServlet", new DispatcherServlet(appContext));
        registration.setLoadOnStartup(1);
        registration.addMapping("/");
    

WebApplicationInitializer是由Spring MVC提供的一个接口，Spring MVC会确保该接口的实现类们会被正确调用以初始化Servlet容器，WebApplicationInitializer有一个抽象基类为AbstractDispatcherServletInitializer，通过继承该基类可以使得注册DispatcherServlet更加容易

(2) 除了上面的例子之外，还可以使用基于java的Spring配置，如下，前面也提到过了

public class IocInit extends AbstractAnnotationConfigDispatcherServletInitializer 
    @Override
    protected String[] getServletMappings() 
        return new String[] "/";
    

    @Override
    protected Class<?>[] getRootConfigClasses() 
        return null;
    

    //创建一个基于注解配置的容器
    @Override
    protected Class<?>[] getServletConfigClasses() 
        return new Class[] WebConfig.class;
    

(3) 除此之外，还可以继承AbstractDispatcherServletInitializer

public class IocInit extends AbstractDispatcherServletInitializer 
    @Override
    protected WebApplicationContext createServletApplicationContext() 
        XmlWebApplicationContext cxt = new XmlWebApplicationContext();
        cxt.setConfigLocation("classpath:springmvc.xml");
        return cxt;
    

    @Override
    protected WebApplicationContext createRootApplicationContext() 
        return null;
    

    @Override
    protected String[] getServletMappings() 
        return new String[] "/";
    

上面列出了常见的3种创建ioc容器的方式，我们可以根据自己的需要来进行选择

(4) AbstractDispatcherServletInitializer还提供了一种便捷的方式来创建Filter实例，并且这些Filter实例会被自动映射到DispatcherServlet上，如下

public class IocInit extends AbstractDispatcherServletInitializer 

    //...
    
    //这些Filter会被自动映射到DispatcherServlet上，并且会根据它们的类型来为其添加一个默认名称
    @Override
    protected Filter[] getServletFilters() 
        return new Filter[] 
                new HiddenHttpMethodFilter(), new CharacterEncodingFilter() ;
    

此外，如果我们希望需要进一步的定制DispatcherServlet，我们可以重写createDispatcherServlet方法

6.请求处理

(1) DispatcherServlet按照如下的方式来处理请求：

• 搜索WebApplicationContext并将其作为一个属性绑定到请求中，这样在请求的后续处理过程中我们就可以直接从请求中拿到ioc容器，如下

@Controller
public class DemoController 
    @RequestMapping("/demo")
    @ResponseBody
    public String get(HttpServletRequest httpServletRequest) 
        //从请求中获取到WebApplicationContext，这个ioc容器被绑定到了请求的DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE属性上
        WebApplicationContext ctx = (WebApplicationContext)httpServletRequest.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE);
        Arrays.stream(ctx.getBeanDefinitionNames()).forEach(System.out::println);
        return "aaa";
    

• Locale解析器也被绑定到了请求上，以便后续处理流程中进行使用

• Theme解析器也被绑定到了请求上，以便后续处理流程中进行使用

• 如果我们指定了multipart文件解析器，那么Spring会检查请求中是否含有multipart文件，如果有，那么该请求会被包裹在一个MultipartHttpServletRequest中，以便后续处理流程中进行进一步处理

• 针对请求搜索恰当的handler，如果搜索到的话，与该handler相关的执行链（HandlerExecutionChain）将会被执行，以准备渲染模型（model）

• 如果有模型返回，那么视图（view）就会被渲染，否则，如果没有模型返回，那么视图就不会被渲染

(2) 在WebApplicationContext中的HandlerExceptionResolver类型的bean将被用来解决请求处理过程中抛出的异常，这些异常解析器允许自定义处理异常的逻辑

(3) 我们可以在web.xml中的标签使用标签来添加Servlet初始化参数，这样就能达到定制DispatcherServlet的目的，下面列出了DispatcherServlet常见的初始化参数

参数	说明
contextClass	设置web容器，该容器必须是ConfigurableWebApplicationContext的实现类，默认为XmlWebApplicationContext
contextConfigLocation	该参数值将会被传递至由上面contextClass指定的容器，通常用于指明配置文件（xml文件，@Configuration注解标注的类）的路径，容器会到指定位置加载配置文件
namespace	容器的命名空间，默认为[servlet-name]-servlet
throwExceptionIfNoHandlerFound	决定当一个请求没有找到其对应的handler时，是否会抛出NoHandlerFoundException异常，若设置为true，则表示抛出异常，然后我们就可以用HandlerExceptionResolver来捕获该异常，并像处理其他异常一样进行该处理。在默认情况下，该值被设置为false，因此在默认情况下，如果一个请求没有找到其对应的handler，那么DispatcherServlet会将响应状态码设置为404（NOT_FOUND）而不会引发异常，因此我们会在页面上看到一个 "404 - 未找到" 页面，最后注意，如果defaultServletHandling也被配置了，那么这些不正常的请求会被转发到defaultServlet进行处理，且永远不会出现404

具体的配置例子如下

<web-app ....>

    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置容器，容器需要实现ConfigurableWebApplicationContext接口，此处我们选择了XmlWebApplicationContext，这也是Spring的默认配置 -->
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>org.springframework.web.context.support.XmlWebApplicationContext</param-value>
        </init-param>

        <!-- 因为我们上面选用的是XmlWebApplicationContext，一个基于xml配置的容器，因此通过contextConfigLocation属性来设置容器的xml配置文件路径 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springweb.xml</param-value>
        </init-param>

        <!-- 如下是配置一个基于注解的容器 -->
<!--        <init-param>-->
<!--            <param-name>contextClass</param-name>-->
<!--            <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>-->
<!--        </init-param>-->
        <!-- 因为是基于注解的容器，因此通过contextConfigLocation属性来设置Configuration配置类的路径 -->
<!--        <init-param>-->
<!--            <param-name>contextConfigLocation</param-name>-->
<!--            <param-value>cn.example.springmvc.boke.config.Config</param-value>-->
<!--        </init-param>-->

        <!-- 设置WebApplicationContext的命名空间 -->
        <init-param>
            <param-name>namespace</param-name>
            <param-value>app</param-value>
        </init-param>

        <!-- 注意，单单将这个值设置为true，并不会生效(即不会抛出NoHandlerFoundException异常)，原因是Spring会默认加上ResourceHttpRequestHandler这个handler来进行处理，也就不会出现no handler的情况了，因此我们还需要配置spring.resources.add-mappings=false，这样在发生no handler时才会抛出NoHandlerFoundException异常 -->
        <init-param>
            <param-name>throwExceptionIfNoHandlerFound</param-name>
            <param-value>true</param-value>
        </init-param>
    </servlet>

    <!-- 设置 DispatcherServlet 拦截的路径  -->
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

7.拦截器

(1) 拦截器必须实现HandlerInterceptor接口，该接口提供了3个方法，分别为

• preHandle(..): 在handler执行之前执行

• postHandle(..): 在handler执行之后执行

• afterCompletion(..): 在整个请求完成后执行

preHandle方法返回一个boolean值，通过该方法我们可以决定是继续还是中断执行链的执行，若返回true，则执行链继续执行，若返回false，则DispatcherServlet会认为拦截器本身已经处理了该请求，因此会中断执行链中其他的拦截器以及handler的执行

postHandle方法在有@ResponseBody和ResponseEntity的方法中用处不大，因为这种方法在postHandle方法执行前已经在写入response了，等待postHandle方法执行时已经太迟了，而针对这种情况，我们可以使用ResponseBodyAdvice

8.异常

(1) 如果在请求映射处理过程中发生异常，DispatcherServlet会委托一个由HandlerExceptionResolver构成的异常处理链来处理这个异常，下面列出一些可用的HandlerExceptionResolver实现类

HandlerExceptionResolver	说明
SimpleMappingExceptionResolver	提供异常类名称与异常视图名称之间的一个映射，即针对不同类型的异常响应不同的错误视图
DefaultHandlerExceptionResolver	解析由Spring MVC引发的标准异常，并将它们映射成对应的HTTP状态码，它是作为“缺省”使用的，如果其他HandlerExceptionResolver不能处理某些异常，最后会使用DefaultHandlerExceptionResolver来统一处理
ResponseStatusExceptionResolver	解析被@ResponseStatus注解标注的异常，并根据注解中的值将异常映射到对应的HTTP状态码
ExceptionHandlerExceptionResolver	通过调用@ControllerAdvice类或@Controller类中合适的@ExceptionHandler方法来解析异常

(2) 我们可以在容器中配置多个HandlerExceptionResolver类型的bean并根据需要设置它们的order属性来形成一个异常处理器链，其中order属性值越高，它在异常处理器链中的位置就越靠后，通常情况下，HandlerExceptionResolver返回

• 一个指向错误视图的ModelAndView

• 若异常在处理器中被处理，返回一个空的ModelAndView

• 若异常未被解决，则返回null，以便让后续的处理器尝试解决，如果到最后异常仍未解决，则允许将异常冒泡到Servlet容器中

使用MVC Config(通过@EnableWebMvc注解)后，会自动的向容器中添加Spring MVC异常，由@ResponseStatus注解标注的异常等异常的处理器，我们可以对它们进行替换

(3) 如果一个异常没有被任何HandlerExceptionResolver处理或者请求的http响应被设置为错误状态（即4xx，5xx），那么Servlet容器使用HTML来渲染一个默认的错误页面，而为了自定义容器的默认错误页面，我们可以在web.xml中配置错误页面映射url，如下

<error-page>
    <location>/error</location>
</error-page>

当配置好错误页面映射url后，如果此时有一个异常没有被任何HandlerExceptionResolver处理或者请求的http响应被设置为错误状态，那么Servlet容器将会请求我们所配置的这个url，此时，我们就可以返回一个自定义的错误视图或像下面这样直接返回一个字符串

@RequestMapping("/error")
@ResponseBody
public String error() 
    return "error";

9. view，locale，theme和logging这四节的内容略过，如果有需要可查看官方文档

10. Multipart解析器

(1) org.springframework.web.multipart包中的MultipartResolver可用于解析multipart类型(例如：文件上传)的请求，为了使用Multipart解析器，我们需要配置一个MultipartResolver类型的bean，并且这个bean的名称必须是multipartResolver，配置好之后，DispatcherServlet会检测到它并将其应用于后续的请求，当我们接收到一个类型为multipart/form-data的post请求时，Multipart解析器会解析请求内容并将当前这个HttpServletRequest包装成MultipartHttpServletRequest以便访问解析的内容，Spring MVC已为我们提供了两个MultipartResolver的实现类，如下

• CommonsMultipartResolver：基于Apache Commons FileUpload的MultipartResolver实现类，为了使用它，需要添加commons-fileupload依赖

• StandardServletMultipartResolver：基于Servlet 3.0 multipart请求解析的MultipartResolver实现类，为了使用它，我们需要在<web.xml/>或Servlet registration中进行一些配置:

<!-- 在web.xml的<servlet/>标签中添加<multipart-config/>标签,配置上传文件的大小等信息 -->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <multipart-config>
        <location>/</location>
        <max-file-size>2097152</max-file-size>
        <max-request-size>419304</max-request-size>
    </multipart-config>
</servlet>

也可在Servlet registration中进行配置

public class IocInit extends AbstractAnnotationConfigDispatcherServletInitializer 
    @Override
    protected String[] getServletMappings() 
        return new String[] "/";
    

    @Override
    protected Class<?>[] getRootConfigClasses() 
        return new Class[] RootConfig.class;
    

    @Override
    protected Class<?>[] getServletConfigClasses() 
        return new Class[] WebConfig.class;
    

    //使用ServletRegistration配置上传文件大小等信息
    @Override
    protected void customizeRegistration(ServletRegistration.Dynamic registration) 
        registration.setMultipartConfig(new MultipartConfigElement("/", 2097152, 419304, 0));
    

Spring IOC官方文档学习笔记（十四）之ApplicationContext的其他功能

1.使用MessageSource

(1) 有时，我们的项目可能会面临国际化需求，例如：对不同国家的人，我们需返回不同语言的消息，而java本身已经给我们提供了ResourceBundle类实现国际化的需求，如下

//在resources目录下，新建两个配置文件，分别为message_en_us.properties和message_zh_cn.properties，内容如下

//message_en_us.properties文件中配置如下
country=us

//message_zh_cn.properties文件中配置如下，注意对中文使用unicode编码
country=\\u4e2d\\u56fd

//现在，我们希望我们的项目在不同的国家返回不同的country信息，那么就可以使用ResourceBundle类了，如下
public static void main(String[] args) 
    //使用ResourceBundle加载的文件都必须放置在resources根目录下，因此我们的message_en_us.properties和message_zh_cn.properties文件都位于resources根目录，而且这些文件都必须按照$name_$language_$region的方式来命名，因为这种命名方式正好能对应ResourceBundle.getBundle()方法中的参数，例如ResourceBundle.getBundle("message", new Locale("zh", "cn"))，其中，message对应$name，zh对应$language，cn对应$region，即ResourceBundle.getBundle("message", new Locale("zh", "cn"))这个方法会读取我们的message_zh_cn.properties配置文件，这样我们就可以根据不同的参数来读取不同的文件，达到国际化的目的

    //未指定它的Locale，因此java获取它当前所在的地区，为cn
    ResourceBundle DefaultBundle = ResourceBundle.getBundle("message");
    System.out.println(DefaultBundle.getString("country"));

    //指定地区为cn
    ResourceBundle cnBundle = ResourceBundle.getBundle("message", new Locale("zh","cn"));
    System.out.println(cnBundle.getString("country"));

    //指定地区为us
    ResourceBundle uSbundle = ResourceBundle.getBundle("message", new Locale("en","us"));
    System.out.println(uSbundle.getString("country"));


//打印结果如下，通过ResourceBundle实现了国际化
中国
中国
us

(2) Spring提供了MessageSource来帮助我们实现国际化功能，具体的使用方法同jdk中的ResourceBundle，如下

//在resources目录下，新建两个配置文件，分别为message_en.properties和message_zh.properties，内容如下

//message_en.properties文件中配置如下
country=us

//message_zh.properties文件中配置如下
country=中国

<!-- 配置xml -->
<beans ....>
        <!-- 使用ReloadableResourceBundleMessageSource类，向容器中注入MessageSource用于国际化功能，注意：这个bean的名称必须为messageSource -->
        <bean id="messageSource"
              class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
            <property name="basenames">
                <list>
                    <!-- 指定消息源为message，那么spring会去寻找名称中包含message的配置文件 -->
                    <value>message</value>
                </list>
            </property>
            <!-- 避免中文乱码 -->
            <property name="defaultEncoding">
                <value>UTF-8</value>
            </property>
        </bean>
</beans>

//ApplicationContext继承了MessageSource接口
MessageSource messageSource = new ClassPathXmlApplicationContext("beans.xml");
//指定不同的语言，来获取不同消息
String zh = messageSource.getMessage("country", null, Locale.CHINESE);
System.out.println(zh);

String en = messageSource.getMessage("country", null, Locale.ENGLISH);
System.out.println(en);

//启动容器，输出如下
中国
us

(3) Spring的MessageSource还提供了占位符功能，来进行消息内容的填充，如下例所示

//向message_zh.properties中添加配置项如下，0表示第一个占位符，还有1，2等等，以此类推
argument=we need 0

//main函数
MessageSource messageSource = new ClassPathXmlApplicationContext("beans.xml");
                                                     //Object[]指定向占位符填充的内容
String argument = messageSource.getMessage("argument", new Object[]"蛋糕", Locale.CHINESE);
System.out.println(argument);

//启动后，打印如下
we need 蛋糕

2.标准和自定义事件

(1) Spring中的事件是通过ApplicationEvent类和ApplicationListener接口提供的，如果一个bean实现了ApplicationListener接口，那么每当一个ApplicationEvent发布到Spring中时，都会通知该bean

(2) Spring中内置事件

事件	说明
ContextRefreshedEvent	容器初始化或刷新时(refresh)时发布该事件
ContextStartedEvent	通过调用ConfigurationApplicationContext接口中的start()方法启动容器时发布该事件
ContextStoppedEvent	通过调用ConfigurationApplicationContext接口中的stop()方法停止容器时发布该事件
ContextClosedEvent	通过调用ConfigurationApplicationContext接口中的close()方法或jvm关闭钩子关闭容器时发布该事件
RequestHandledEvent	适用于使用了DispatcherServlet的web环境中，在请求完成后发布该事件，用于告知所有的bean已经为http请求提供了服务
ServletRequestHandledEvent	RequestHandledEvent的子类，其中添加了Servlet特定信息

(3) 示例如下

//现在假设有一个用户注册事件，每当一个用户注册后，进行相应的其他操作(如发送邮件等等)
//自定义事件,需继承ApplicationEvent
public class RegisterEvent extends ApplicationEvent 
    private String username;

    public RegisterEvent(Object source,String username) 
        super(source);
        this.username = username;
    

    public String getUsername() 
        return username;
    


//使用ApplicationEventPublisher中的publishEvent()方法来向容器中发布一个事件
@Service
public class RegisterService implements ApplicationEventPublisherAware 

    private ApplicationEventPublisher publisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) 
        this.publisher = applicationEventPublisher;
    

    //publishEvent()方法会阻塞，直到所有的监听器都完成了对事件的处理
    public void finishRegister(String username) 
        this.publisher.publishEvent(new RegisterEvent(this, username));
    


//实现ApplicationListener接口，实现某种类型事件的监听者
@Component
public class RegisterLister implements ApplicationListener<RegisterEvent> 

    //每当有一个RegisterEvent事件发布后，都会触发该回调
    @Override
    public void onApplicationEvent(RegisterEvent registerEvent) 
        System.out.println("用户:" + registerEvent.getUsername() + "完成注册...");
        //do other things，such as send emails
    


//main
ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext("cn.example.spring");
String username ="zpc";
ctx.getBean(RegisterService.class).finishRegister(username);

//启动后，容器打印如下，可见Spring使用了观察者模式，来实现了一个事件发布与订阅的功能
用户:zpc完成注册...