1<plugin>
 2  <groupId>org.apache.tomcat.maven</groupId>
 3  <artifactId>tomcat7-maven-plugin</artifactId>
 4  <version>2.1</version>
 5  <configuration>
 6    <port>80</port>
 7    <path>/</path>
 8    <uriEncoding>UTF-8</uriEncoding>
 9  </configuration>
10</plugin>

 1<!-- Servlet -->
 2<dependency>
 3    <groupId>javax.servlet</groupId>
 4    <artifactId>javax.servlet-api</artifactId>
 5    <version>3.1.0</version>
 6    <!-- Servlet需要修改作用范围，否则会与Tomcat中的servlet-api包发生冲突 -->
 7    <!-- provided代表的是该包只在编译和测试的时候用 -->
 8    <scope>provided</scope>
 9</dependency>
10<!-- SpringMVC -->
11<dependency>
12    <groupId>org.springframework</groupId>
13    <artifactId>spring-webmvc</artifactId>
14    <version>5.2.10.RELEASE</version>
15</dependency>

 1<!-- Spring JDBC -->
 2<dependency>
 3  <groupId>org.springframework</groupId>
 4  <artifactId>spring-jdbc</artifactId>
 5  <version>5.2.10.RELEASE</version>
 6</dependency>
 7<!-- MySQL -->
 8<dependency>
 9  <groupId>mysql</groupId>
10  <artifactId>mysql-connector-java</artifactId>
11  <version>5.1.47</version>
12</dependency>
13<!-- MyBatis -->
14<dependency>
15  <groupId>org.mybatis</groupId>
16  <artifactId>mybatis</artifactId>
17  <version>3.5.6</version>
18</dependency>
19<!-- MyBatis Spring依赖 -->
20<dependency>
21  <groupId>org.mybatis</groupId>
22  <artifactId>mybatis-spring</artifactId>
23  <version>1.3.0</version>
24</dependency>
25<!-- Druid 数据库连接池 -->
26<dependency>
27  <groupId>com.alibaba</groupId>
28  <artifactId>druid</artifactId>
29  <version>1.1.16</version>
30</dependency>

 1<!-- Jackson -->
 2<dependency>
 3  <groupId>com.fasterxml.jackson.core</groupId>
 4  <artifactId>jackson-databind</artifactId>
 5  <version>2.9.0</version>
 6</dependency>
 7
 8<!-- 日志 -->
 9<dependency>
10  <groupId>ch.qos.logback</groupId>
11  <artifactId>logback-classic</artifactId>
12  <version>1.2.3</version>
13</dependency>
14
15<!-- Thymeleaf（不常用） -->
16<dependency>
17  <groupId>org.thymeleaf</groupId>
18  <artifactId>thymeleaf-spring5</artifactId>
19  <version>3.0.12.RELEASE</version>
20</dependency>
21
22<!-- 文件上传依赖 -->
23<dependency>
24  <groupId>commons-fileupload</groupId>
25  <artifactId>commons-fileupload</artifactId>
26  <version>1.3.1</version>
27</dependency>
28
29<!-- Test -->
30<!-- Junit 单元测试 -->
31<dependency>
32  <groupId>junit</groupId>
33  <artifactId>junit</artifactId>
34  <version>3.8.1</version>
35  <scope>test</scope>
36</dependency>

 1<!DOCTYPE web-app PUBLIC
 2 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 3 "http://java.sun.com/dtd/web-app_2_3.dtd" >
 4
 5<web-app>
 6    <servlet>
 7        <servlet-name>springMVC</servlet-name>
 8        <!-- 指定SpringMVC前端控制器： -->
 9        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
10    </servlet>
11    <servlet-mapping>
12        <servlet-name>springMVC</servlet-name>
13        <!-- 
14            配对路径
15            / 表示处理所有不包括.jsp的请求
16            因为.jsp有自己的servlet，如果在DispatcherServlet中处理.jsp，会导致找不到相应页面，从而导致渲染失败
17        -->
18        <url-pattern>/</url-pattern>
19    </servlet-mapping>
20</webapp>

 1<!-- 
 2    配置SpringMVC的前端控制器
 3    对浏览器发送的请求统一进行处理
 4 -->
 5<webapp>
 6    <servlet>
 7        <servlet-name>springMVC</servlet-name>
 8        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 9        <!-- 
10            通过初始化参数指定SpringMVC配置文件的位置和名称
11         -->
12        <init-param>
13            <!-- contextConfigLocation为固定值 -->
14            <param-name>contextConfigLocation</param-name>
15            <!-- 
16                使用 classpath: 表示从类路径查找配置文件，例如maven工程中的src/main/resources
17             -->
18            <param-value>classpath:springMVC.xml</param-value>
19        </init-param>
20        <!-- 
21            将启动控制DispatcherServlet的初始化时间提前到服务器启动时：
22        -->
23        <load-on-startup>1</load-on-startup>
24    </servlet>
25
26    <!-- ... -->
27
28</webapp>

 1<?xml version="1.0" encoding="UTF-8"?>
 2<beans xmlns="http://www.springframework.org/schema/beans"
 3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4       xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc"
 5       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
 6
 7    <!-- 自动扫描包 -->
 8    <context:component-scan base-package="com.linner.controller"/>
 9
10    <!-- 配置Thymeleaf视图解析器（不常用） -->
11    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
12        <property name="order" value="1"/>
13        <!-- 设置编码，将编码都转为 UTF-8 -->
14        <property name="characterEncoding" value="UTF-8"/>
15        <property name="templateEngine">
16            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
17                <property name="templateResolver">
18                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
19        
20                        <!-- 视图前缀 -->
21                        <property name="prefix" value="/WEB-INF/templates/"/>
22        
23                        <!-- 视图后缀 -->
24                        <property name="suffix" value=".html"/>
25                        <property name="templateMode" value="HTML5"/>
26                        <property name="characterEncoding" value="UTF-8" />
27                    </bean>
28                </property>
29            </bean>
30        </property>
31    </bean>
32
33    <!-- 静态资源访问 -->
34    <mvc:view-controller path="/" view-name="index" />
35
36    <!-- 
37        处理静态资源，例如html、js、css、jpg
38        若只设置该标签，则只能访问静态资源，其他请求则无法访问
39        此时必须设置<mvc:annotation-driven/>解决问题
40    -->
41    <mvc:default-servlet-handler/>
42
43    <!-- 开启mvc注解驱动 -->
44    <mvc:annotation-driven>
45        <mvc:message-converters>
46            <!-- 处理响应中文内容乱码 -->
47            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
48                <property name="defaultCharset" value="UTF-8" />
49                <property name="supportedMediaTypes">
50                    <list>
51                        <value>text/html</value>
52                        <value>application/json</value>
53                    </list>
54                </property>
55            </bean>
56        </mvc:message-converters>
57    </mvc:annotation-driven>
58</beans>

 1<webapp>
 2    <!-- 配置 SpringMVC 的编码过滤器 -->
 3    <filter>
 4        <filter-name>CharacterEncodingFilter</filter-name>
 5        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
 6        <init-param>
 7            <param-name>encoding</param-name>
 8            <param-value>UTF-8</param-value>
 9        </init-param>
10        <init-param>
11            <param-name>forceResponseEncoding</param-name>
12            <param-value>true</param-value>
13        </init-param>
14    </filter>
15    <filter-mapping>
16        <filter-name>CharacterEncodingFilter</filter-name>
17        <url-pattern>/*</url-pattern>
18    </filter-mapping>
19
20    <servlet>
21        <!-- ... -->
22    </servlet>
23
24    <!-- ... -->
25    
26</webapp>

 1public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
 2
 3    /**
 4     * 指定Spring的配置类
 5     */
 6    @Override
 7    protected Class<?>[] getRootConfigClasses() {
 8        return new Class[]{SpringConfig.class};
 9    }
10
11    /**
12     * 指定Spring MVC的配置类
13     */
14    @Override
15    protected Class<?>[] getServletConfigClasses() {
16        return new Class[]{SpringMvcConfig.class};
17    }
18
19    /**
20     * 指定DispatcherServlet的映射路径，即url-pattern
21     */
22    @Override
23    protected String[] getServletMappings() {
24        return new String[]{"/"};
25    }
26}

1@Configuration
2@ComponentScan({"com.linner.service"})
3@PropertySource("classpath:jdbc.properties")
4@Import({JdbcConfig.class, MyBatisConfig.class}) // 引入其它配置
5@EnableTransactionManagement    // 开启事务管理
6public class SpringConfig {
7}

 1@Configuration
 2@ComponentScan({"com.linner.controller"})
 3@EnableWebMvc   // MVC注解驱动
 4public class WebConfig implements WebMvcConfigurer {
 5
 6    /**
 7     * 相当于 default-servlet-handler
 8     */
 9    @Override
10    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
11        configurer.enable();
12    }
13
14    /**
15     * 视图控制器 view-controller
16     */
17    @Override
18    public void addViewControllers(ViewControllerRegistry registry) {
19        registry.addViewController("/hello").setViewName("hello");
20    }
21
22    /**
23     * 文件上传解析器
24     */
25    @Bean
26    public MultipartResolver getMultipartResolver() {
27        CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver();
28        return commonsMultipartResolver;
29    }
30
31    /**
32     * 异常处理解析器
33     */
34    @Override
35    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
36        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
37        Properties prop = new Properties();
38        prop.setProperty("java.lang.ArithmeticException", "error");
39        exceptionResolver.setExceptionMappings(prop);
40        // 可以不设置，默认键即为 exception
41        exceptionResolver.setExceptionAttribute("exception");
42        exceptionResolvers.add(exceptionResolver);
43    }
44
45    /**
46     * 模板解析器
47     */
48    @Bean
49    public ITemplateResolver getTemplateResolver() {
50
51        // 获取当前的 WebApplicationContext
52        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
53        // 使用WebApplicationContext获取ServletContext，并构造ServletContextTemplateResolver
54        ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(
55                webApplicationContext.getServletContext());
56
57        // 设置视图前缀
58        templateResolver.setPrefix("/WEB-INF/templates/");
59        // 设置视图后缀
60        templateResolver.setSuffix(".html");
61
62        templateResolver.setCharacterEncoding("UTF-8");
63        templateResolver.setTemplateMode(TemplateMode.HTML);
64
65        return templateResolver;
66    }
67
68    /**
69     * 模板引擎
70     * @param templateResolver 模板解析器（自动装配，@Autowired可忽略不写）
71     */
72    @Bean
73    public SpringTemplateEngine getTemplateEngine(ITemplateResolver templateResolver) {
74
75        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
76        templateEngine.setTemplateResolver(templateResolver);
77
78        return templateEngine;
79    }
80
81    /**
82     * 设置视图解析器
83     * @param templateEngine 模板引擎（自动装配）
84     */
85    @Bean
86    public ViewResolver getViewResolver(SpringTemplateEngine templateEngine) {
87
88        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
89        viewResolver.setCharacterEncoding("UTF-8");
90        viewResolver.setTemplateEngine(templateEngine);
91
92        return viewResolver;
93    }
94}

1jdbc.driver=com.mysql.jdbc.Driver
2jdbc.url=jdbc:mysql:///spring_db?useSSL=false&characterEncoding=utf-8
3jdbc.username=root
4jdbc.password=123456

 1public class JdbcConfig {
 2    
 3    @Value("${jdbc.driver}")
 4    private String driver;
 5    @Value("${jdbc.url}")
 6    private String url;
 7    @Value("${jdbc.username}")
 8    private String username;
 9    @Value("${jdbc.password}")
10    private String password;
11
12    @Bean
13    public DataSource dataSource(){
14        DruidDataSource dataSource = new DruidDataSource();
15        dataSource.setDriverClassName(driver);
16        dataSource.setUrl(url);
17        dataSource.setUsername(username);
18        dataSource.setPassword(password);
19        return dataSource;
20    }
21
22    @Bean
23    public PlatformTransactionManager transactionManager(DataSource dataSource){
24        DataSourceTransactionManager ds = new DataSourceTransactionManager();
25        ds.setDataSource(dataSource);
26        return ds;
27    }
28}

 1public class MyBatisConfig {
 2    @Bean
 3    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
 4        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
 5        factoryBean.setDataSource(dataSource);
 6        factoryBean.setTypeAliasesPackage("com.linner.domain");
 7        return factoryBean;
 8    }
 9
10    @Bean
11    public MapperScannerConfigurer mapperScannerConfigurer(){
12        MapperScannerConfigurer msc = new MapperScannerConfigurer();
13        msc.setBasePackage("com.linner.dao");
14        return msc;
15    }
16}

 1/**
 2 * 注册过滤器
 3 */
 4@Override
 5protected Filter[] getServletFilters() {
 6    
 7    // 设置编码，将编码都转为 UTF-8
 8    CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
 9    characterEncodingFilter.setEncoding("UTF-8");
10    characterEncodingFilter.setForceEncoding(true);
11
12    HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
13
14    return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
15}

 1@Controller
 2@RequestMapping("/user")
 3public class UserController {
 4    @RequestMapping(value = "/helloSpring")
 5    @ResponseBody
 6    public String helloSpring() {
 7        return "Hello Spring!";
 8    }
 9
10    @RequestMapping("/helloWorld")
11    @ResponseBody
12    public String helloWorld() {
13        return "Hello World!";
14    }
15}

1@RequestMapping({"hello", "helloWorld"})

1http://localhost/user/hello?name=张三

1@RequestMapping(value = "/save", method = RequestMethod.GET)

 1@Controller
 2@RequestMapping("/user")
 3public class UserController {
 4
 5    // 使用 [http://localhost/user/hello?name=张三] 访问
 6    // 返回响应体 Hello 张三!
 7    @RequestMapping("/hello")
 8    @ResponseBody
 9    public String hello(String name) {
10        return "Hello " + name + "!";
11    }
12
13    // 使用 [http://localhost/user/login?name=张三&password=abc] 访问
14    // 返回响应体 OK，终端输出 userName=张三; password=abc
15    @RequestMapping("/login")
16    @ResponseBody
17    public String login(@RequestParam("name") String userName, String password) {
18        System.out.println("userName=" + userName + "; password=" + password);
19        return "OK";
20    }
21
22}

1public class Address {
2    private String province;
3    private String city;
4
5    // setter、getter and toString...
6}

1public class User {
2    private Integer id;
3    private String name;
4    private String password;
5    private Address address;
6
7    // setter、getter and toString...
8}

 1@Controller
 2@RequestMapping("/user")
 3public class UserController {
 4
 5    // 访问 [http://localhost/user/login?id=123&password=abc&name=张三&address.province=广东&address.city=广州]
 6    // 返回响应体 OK，终端输出 Login: User{id=123, name='张三', password='abc', address=Address{province='广东', city='广州'}}
 7    @RequestMapping("/login")
 8    @ResponseBody
 9    public String login(User user) {
10        System.out.println("Login: " + user);
11        return "OK";
12    }
13
14}

 1@Controller
 2@RequestMapping("/user")
 3public class UserController {
 4
 5    // 访问 [http://localhost/user/setHobbies?id=123&hobbies=唱歌,跳舞,Rap,打篮球]
 6    // 返回响应体 OK，终端输出 User 123's hobbyies: [唱歌, 跳舞, Rap, 打篮球]
 7    @RequestMapping("/setHobbies")
 8    @ResponseBody
 9    public String setHobbies(Integer id, String[] hobbies) {
10        System.out.println("User " + id + "'s hobbies: " + Arrays.toString(hobbies));
11        return "OK";
12    }
13
14}

 1@Controller
 2@RequestMapping("/user")
 3public class UserController {
 4
 5    // 访问方式与数组形式相同，响应体与终端输出也相同
 6    @RequestMapping("/setHobbies")
 7    @ResponseBody
 8    public String setHobbies(Integer id, @RequestParam List<String> hobbies) {
 9        System.out.println("User " + id + "'s hobbies: " + hobbies);
10        return "OK";
11    }
12
13}

 1@Controller
 2@RequestMapping("/user")
 3public class UserController {
 4
 5    // URL: http://localhost/user/setBirthday?id=123&birthday=2023/1/1 18:23:40
 6    @RequestMapping("/setBirthday")
 7    @ResponseBody
 8    public String setBirthday(Integer id, @DateTimeFormat(pattern = "yyyy/MM/dd HH:mm:ss") Date birthday) {
 9        System.out.println("User " + id + "'s birthday is " + birthday);
10        return "OK";
11    }
12    
13}

1<dependency>
2    <groupId>com.fasterxml.jackson.core</groupId>
3    <artifactId>jackson-databind</artifactId>
4    <version>2.9.0</version>
5</dependency>

1@Configuration
2@ComponentScan("com.linner.controller")
3@EnableWebMvc // 开启JSON数据类型自动转换
4public class SpringMvcConfig {
5}

 1@Controller
 2@RequestMapping("/user")
 3public class UserController {
 4
 5    @RequestMapping("/login")
 6    @ResponseBody
 7    public String login(@RequestBody User user) {
 8        System.out.println("Login: " + user);
 9        return "OK";
10    }
11
12    @RequestMapping("/setHobbies")
13    @ResponseBody
14    public String setHobbies(Integer id, @RequestBody List<String> /* 也可以使用 String[] */ hobbies) {
15        System.out.println("User " + id + "'s hobbies: " + hobbies);
16        return "OK";
17    }
18
19}

1public class Book {
2    private Integer id;
3    private String name;
4    // constructor、setter、getter and toString ...
5}

 1@Controller
 2@RequestMapping("/books")
 3public class BookController {
 4
 5    @RequestMapping("/search")
 6    @ResponseBody
 7    public Book search(int id) {
 8        return new Book(id, "Hello SpringMVC");
 9    }
10
11    @RequestMapping("/searchName")
12    @ResponseBody
13    public List<Book> searchName(String name) {
14        System.out.println("Search the book " + name);
15        List books = new ArrayList<Book>();
16        for (int i = 0; i < 5; i++) {
17            books.add(new Book(i, name + Integer.toString(i)));
18        }
19        return books;
20    }
21
22}

 1@Controller
 2@RequestMapping("/users")
 3public class UserController {
 4
 5    /**
 6     * 添加用户
 7     */
 8    @RequestMapping(method = RequestMethod.POST)
 9    @ResponseBody
10    public String save(@RequestBody User user) {
11        return "OK";
12    }
13
14    /**
15     * 删除用户
16     */
17    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
18    @ResponseBody
19    public String delete(@PathVariable int id) {
20        return "OK";
21    }
22
23    /**
24     * 修改用户
25     */
26    @RequestMapping(method = RequestMethod.PUT)
27    @ResponseBody
28    public String update(@RequestBody User user) {
29        return "OK";
30    }
31
32    /**
33     * 根据用户id查询
34     */
35    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
36    @ResponseBody
37    public String searchById(@PathVariable int id) {
38        return "OK";
39    }
40
41    /**
42     * 查询所有用户
43     */
44    @RequestMapping(method = RequestMethod.GET)
45    @ResponseBody
46    public String searchAll() {
47        return "OK";
48    }
49}

1@RequestMapping(value = "/{id}/{name}", method = RequestMethod.GET)
2@ResponseBody
3public String searchById(@PathVariable int id, @PathVariable String name) {
4    return "OK";
5}

1@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
2@ResponseBody
3public String delete(@PathVariable("id") int userId) {
4    return "OK";
5}

 1@RestController
 2@RequestMapping("/books")
 3public class BookController {
 4
 5    /**
 6     * 搜索全部书籍
 7     */
 8    @GetMapping
 9    public String getAll() {
10        return "All Books";
11    }
12
13    /**
14     * 搜索图书
15     */
16    @GetMapping("/{id}")
17    public String getById(@PathVariable int id) {
18        return "Get by id " + id;
19    }
20
21    /**
22     * 保存图书
23     */
24    @PostMapping
25    public String save(@RequestBody Book book) {
26        return "Save " + book.toString();
27    }
28
29    /**
30     * 修改图书
31     */
32    @PutMapping
33    public String update(@RequestBody Book book) {
34        return "Update " + book.toString();
35    }
36
37    /**
38     * 删除图书
39     */
40    @DeleteMapping("/{id}")
41    public String delete(@PathVariable int id) {
42        return "Delete by id" + id;
43    }
44
45}

1@RequestMapping("/testServletAPI")
2@ResponseBody
3public String testServletAPI(HttpServletRequest request) {
4    request.setAttribute("testScope", "Hello ServletAPI!");
5    return testRequestScope;
6}

 1@RequestMapping("/testModel")
 2@ResponseBody
 3public String testModel(Model model) {
 4    // 写入
 5    model.addAttribute("testRequestScope", "Hello Model!");
 6    // 读取
 7    String testRequestScope = (String) model.getAttribute("testRequestScope");
 8    System.out.println(testRequestScope);
 9
10    return testRequestScope;
11}

 1@RequestMapping("/testMap")
 2@ResponseBody
 3public String testMap(Map<String, Object> map) {
 4    // 写入
 5    map.put("testRequestScope", "Hello Map!");
 6    // 读取
 7    String testRequestScope = (String) map.get("testRequestScope");
 8    System.out.println(testRequestScope);
 9    
10    return testRequestScope;
11}

 1@RequestMapping("/testModelMap")
 2@ResponseBody
 3public String testModelMap(ModelMap modelMap) {
 4    // 写入
 5    modelMap.addAttribute("testRequestScope", "Hello ModelMap!");
 6    // 读取
 7    String testRequestScope = (String) modelMap.getAttribute("testRequestScope");
 8    System.out.println(testRequestScope);
 9    
10    return testRequestScope;
11}

 1@RequestMapping("/testModelAndView")
 2public ModelAndView testModelAndView() {
 3    ModelAndView mav = new ModelAndView();
 4    // 处理模型数据，即向请求域request共享数据
 5    mav.addObject("testRequestScope", "Hello ModelAndView!");
 6    // 设置视图名称（返回视图需要有对应的页面）
 7    mav.setViewName("success");
 8    // 读取数据（第一次写入后可能读取失败，因为只有在方法执行完毕后才能真正写入）
 9    String testRequestScope = (String) mav.getModel().get("testRequestScope");
10    System.out.println(testRequestScope);
11
12    return mav;
13}

 1<!DOCTYPE html>
 2<html lang="zh">
 3    <head>
 4        <meta charset="UTF-8">
 5        <title>Success!</title>
 6    </head>
 7    <body>
 8        <h1>Success!</h1>
 9    </body>
10</html>

 1protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
 2
 3    /* ... */
 4
 5    try {
 6        ModelAndView mv = null;
 7        /* ... */
 8
 9        try {
10
11            /* ... */
12            
13            // Actually invoke the handler.（实际的请求处理者）
14            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
15            // 最后返回一个封装好的ModelAndView对象
16            
17            /* ... */
18            
19        }
20        
21        /* ... */
22
23        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
24
25    }/* ... */
26
27    /* ... */
28
29}

 1@RequestMapping("/testSession")
 2@ResponseBody
 3public String testSession(HttpSession session) {
 4    // 写入
 5    session.setAttribute("testSessionScope", "Hello Session!");
 6    // 读取
 7    String testSessionScope = (String) session.getAttribute("testSessionScope");
 8    System.out.println(testSessionScope);
 9    return testSessionScope;
10}

 1@RequestMapping("/testSessionInServlet")
 2@ResponseBody
 3public String testSession(HttpServletRequest request) {
 4    // 从Request域中获取Session
 5    HttpSession session = request.getSession();
 6    // 写入
 7    session.setAttribute("testSessionScope", "Hello Session In Servlet!");
 8    // 读取
 9    String testSessionScope = (String) session.getAttribute("testSessionScope");
10    System.out.println(testSessionScope);
11    return testSessionScope;
12}

 1@RequestMapping("/testApplication")
 2@ResponseBody
 3public String testApplication(HttpSession session) {
 4    // 从Session域中获取ServletContext
 5    ServletContext application = session.getServletContext();
 6    // 写入
 7    application.setAttribute("testSessionScope", "Hello Application!");
 8    // 读取
 9    String testSessionScope = (String) application.getAttribute("testSessionScope");
10    System.out.println(testSessionScope);
11
12    return testSessionScope;
13}

 1@RequestMapping("/testApplicationInServlet")
 2@ResponseBody
 3public String testApplication(HttpServletRequest request) {
 4    // 从Request域中获取ServletContext
 5    ServletContext application = request.getServletContext();
 6    // 写入
 7    application.setAttribute("testSessionScope", "Hello Application In Servlet !");
 8    // 读取
 9    String testSessionScope = (String) application.getAttribute("testSessionScope");
10    System.out.println(testSessionScope);
11
12    return testSessionScope;
13}

1@RequestMapping("/testResponse")
2public void testResponse(HttpServletResponse response) throws IOException {
3    response.getWriter().print("Hello Response!");
4}