spring MVC学习入门笔记

SpringMVC是什么？
springmvc是一种基于mvc设计模式的轻量级web框架，属于springframework的产品。是目前最主流的mvc框架之一。
mvc:

第一个springmvc程序
新建动态web项目springmvc01
目录结构如下：

加入的包

在web.xml文件中配置springmvc

<?xmlversion="1.0"encoding="UTF-8"?>

<web-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://xmlns.jcp.org/xml/ns/javaee"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"id="WebApp_ID"version=“3.1”>
springmvc01

<servlet>
	<servlet-name>springDispatcherServlet</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>

<!-- Map all requests to the DispatcherServlet for handling -->
<servlet-mapping>
	<servlet-name>springDispatcherServlet</servlet-name>
	<url-pattern>/</url-pattern><!—需要修改，指定访问路径-->
</servlet-mapping>

注：另外一种方式配置springmvc
也可以不使用contextConfigLocation加载指定的springmvc配置文件，可以使用默认的xml，默认的xml文件在WEB-INF/你指定的-servlet.xml.
上面配置可以修改如下：

<?xmlversion="1.0"encoding="UTF-8"?>

<web-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://xmlns.jcp.org/xml/ns/javaee"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"id="WebApp_ID"version=“3.1”>
springmvc01

<servlet>
	<servlet-name>springDispatcherServlet</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

	<load-on-startup>1</load-on-startup>
</servlet>

<!-- Map all requests to the DispatcherServlet for handling -->
<servlet-mapping>
	<servlet-name>springDispatcherServlet</servlet-name>
	<url-pattern>/</url-pattern>
</servlet-mapping>

此时，需要在web-inf下增加-servlet.xml，如图：

在classpath下创建springmvc.xml
内容如下：

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns=“http://www.springframework.org/schema/beans”
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
xmlns:context=“http://www.springframework.org/schema/context”
xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd”>

<context:component-scanbase-package="com.niit"></context:component-scan>

<beanclass="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<propertyname="prefix"value="/WEB-INF/views/"></property>
	<propertyname="suffix"value=".jsp"></property>
</bean>

创建控制器
package com.niit.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**

• controller 注解：标识当前的类为控制器
• @author hussein

*/
@Controller
public class HelloWorldController {

/**
 * RequestMapping注解：
 * 将Web请求映射到特定处理程序类和/或处理程序方法，
 * 	这个注解可以用于类或者方法上，并通过属性value指定请求路径
 * 
 * 返回值会通过视图解析器解析为实际的视图，对于InternalResourceViewResolver视图解析器，
 * 最后会通过 prefix + returnVal + suffix 的方式得到实际的视图
 * 
 * @return
 */
@RequestMapping("/helloworld")
public String helloWorld() {
	return "success";
}

}

创建返回页面success.jsp
<%@pagelanguage="java"contentType=“text/html; charset=UTF-8”
pageEncoding=“UTF-8”%>

测试
在浏览器中输入：
http://localhost:8080/springmvc01/helloworld

将显示以下页面：

注解
@RequestMapping注解
RequestMapping注解：
* 将Web请求映射到特定处理程序类和/或处理程序方法，
* 这个注解可以用于类或者方法上，并通过属性value指定请求路径

DispatcherServlet截获请求后，就通过控制器上的@RequestMapping提供的映射信息确定请求所对应的处理方法。

类型
用在类上
作用：提供初步的请求映射信息，相对于应用的根目录

示例：
请求的路径为：
http://localhost:8080/springmvc01/hw/helloWorld

@Controller
@RequestMapping("/hw")
publicclassHelloWorldController {

@RequestMapping(value = "/helloWorld")
public String helloWorld() {
	return"success";
}

}
用在方法上
作用：提供进一步的细分映射信息，相对于类定义出的URL。如果类定义处没有标注@RequestMapping,则方法处标记的URL相对于项目的根目录

示例：
请求路径：
http://localhost:8080/springmvc01/helloWorld

@Controller
publicclassHelloWorldController {

@RequestMapping(value = "/helloWorld")
public String helloWorld() {
	return"success";
}

}
属性
Value
作用：用于指定映射路径，同path。可以指定多个路径
示例：

单个路径
请求路径：http://localhost:8080/springmvc01/helloWorld
@RequestMapping(value = “/helloWorld”)
public String helloWorld() {
return"success";
}
多个路径
请求路径：
访问http://localhost:8080/springmvc01/hw
或http://localhost:8080/springmvc01/helloWorld都可以
@RequestMapping(value = {"/helloWorld","/hw"})
publicStringhelloWorld() {
return"success";
}

Path
用于指定映射路径，同value。
示例：
请求路径：http://localhost:8080/springmvc01/hw
@RequestMapping(path="/hw")
public String helloWorld() {
return"success";
}
Method
作用：用于指定请求类型：GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE
可以不写，默认为get/post.

单个请求类型
设置当前的方法，只能为post请求类型。如果使用其他请求类型（如get）,则会报 405-
Method Not Allowed错误。

@RequestMapping(path="/hw",method=RequestMethod.POST)
public String helloWorld() {
	return"success";
}

多个请求类型
设置当前方法，同时可以接受多种类型的请求
@RequestMapping(path="/hw",method= {RequestMethod.POST,RequestMethod.GET})
public String helloWorld() {
return"success";
}
Params
指定请求的参数。支持简单的表达式,例如：
 param1:表示请求必须包含名为param1的请求参数
 !param1:表示请求不能包含名为param1的请求参数
 param1 != value1:表示请求包含名为param1的请求参数，但其值不能为value1
 {“param1=value1”,”param2”}:请求必须包含名为param1和param2的两个请求参数，且param1参数的值必须为value1

示例：
 param1:表示请求必须包含名为param1的请求参数
例如：请求中必须包含参数name
请求路径：http://localhost:8080/springmvc01/hw?name=amy
@RequestMapping(value="/hw",params= {“name”}) //或者也可以写成@RequestMapping(value="/hw",params= “name”)
public String helloWorld() {
return"success";
}

 !param1:表示请求不能包含名为param1的请求参数
例如：请求中不能包含参数name，此时如果参数中有name,会报错。
请求路径（错误）：http://localhost:8080/springmvc01/hw?name=amy&age=12
请求路径（正确）：http://localhost:8080/springmvc01/hw?age=12

@RequestMapping(value="/hw" , params= "!name")
public String helloWorld() {
	return"success";
}

 param1 != value1:表示请求包含名为param1的请求参数，但其值不能为value1
例如：请求中不能包含name=amy的参数
请求路径（错误）：http://localhost:8080/springmvc01/hw?name=amy
请求路径（正确）：http://localhost:8080/springmvc01/hw?name=tom
@RequestMapping(value="/hw" , params= “name!=amy”)
public String helloWorld() {
return"success";
}

 {“param1=value1”,”param2”}:请求必须包含名为param1和param2的两个请求参数，且param1参数的值必须为value1
例如：请求中要包含sign=mx和id=1
请求路径：http://localhost:8080/springmvc01/hw?sign=mx&id=1
@RequestMapping(value="/hw" , params= {“sign=mx”,“id”})
public String helloWorld() {
return"success";
}

Headers
指定请求头部，源码示例：RequestMapping(value = “/something”, headers = “content-type=text/*”)
示例：
设置请求的Accept-Language为zh-CN
@RequestMapping(value="/hw" , headers=“Accept-Language=en,zh-CN;q=0.9,zh;q=0.8”)
public String helloWorld1() {
return"success";
}

Consumes
指定处理请求提交的内容类型（Content-Type），例如application/json, text/html，只有在Content-Type匹配这些媒体类型之一时才会映射请求。
它支持否定表达式，如：!text/plain表示除了text/plain以外的其他内容类型。
可使用在方法上，也可以使用在类上。当在方法上和类上都使用时，方法级别的使用会覆盖类上的使用。

示例：仅处理Content-Type为text/html 类型的请求
@RequestMapping(value="/hw" ,consumes=MediaType.TEXT_HTML_VALUE)
// @RequestMapping(value="/hw" ,consumes=“text/html”) //也可以直接写类型
public String helloWorld2() {
return"success";
}

测试：使用postman，设置content-type

Produces
指定请求返回的内容类型例如：produces = “application/json; charset=UTF-8”
produces = “application/xml; charset=UTF-8”
必须要和@ResponseBody注解一起使用才可以，不加@ResponseBody注解相当于按照和返回String同名jsp页面解析自然就会报错。如果返过来，不加produces属性，只有@ResponseBody注解的话也是没有问题的，只是在浏览器中直接访问的时候有区别
示例：
@RequestMapping(value="/hw" , produces=“application/json”)
@ResponseBody
public String helloWorld2() {
return"success";
}

映射请求—通配符
 ? :匹配文件名中的一个字符
 * : 匹配文件名中的任意字符
 ** : 匹配多层路径

例如：/user/*/add: 匹配/user/aaa/add /user/bbb/add等
/user/**/add 匹配/user/add /user/aaa/bbb/add等
/user/add?? 匹配/user/addUs /user/addUe等

示例1
请求路径：localhost:8080/springmvc01/hw/aaa/hw3
@RequestMapping("/hw/*/hw3")
public String helloWorld3() {
return"success";
}
示例2：
请求路径：localhost:8080/springmvc01/hw/a/b/c/hw3
@RequestMapping("/hw/**/hw3")
publicString helloWorld3() {
return"success";
}
示例3：
请求路径：localhost:8080/springmvc01/hw/hwABc
@RequestMapping("/hw/hw???")//注意：三个问号，要传入3个字符，否则匹配失败
public String helloWorld3() {
return"success";
}

快捷方式变体
注意：在类级别，需要使用@RequestMapping.
以下几种mapping，使用在方法上。

• @GetMapping
作用：接受get请求。相当于@RequestMapping(method = RequestMethod.GET)
源码：
示例：
@GetMapping("/hw")
public String helloWorld3() {
return"success";
}
• @PostMapping
• @PutMapping
• @DeleteMapping
• @PatchMapping

@RestController
@RequestMapping("/persons")
classPersonController {

@GetMapping("/{id}")
public Person getPerson(@PathVariable Long id) {
// …
}

@PostMapping
@ResponseStatus(HttpStatus.CREATED)
publicvoidadd(@RequestBody Person person) {
// …
}
}

@PathVariable注解
作用
映射URL绑定的占位符。
通过@PathVariable可以将URL中占位符参数{XXX}绑定到控制器处理方法的入参中
示例
示例1：单个参数
请求路径：localhost:8080/springmvc01/sayHello/amy
@GetMapping("/sayHello/{name}")
public String sayHello(@PathVariable(“name”) String uname) {
System.out.println(uname+": sayHello");
return"success";
}
控制台打印：amy: sayHello

示例2多个参数
注：@PathVariable(“name”)可以省略括号及其中的内容，如果入参名称和URL中的参数名称一致，并且jdk8以上。
请求路径：localhost:8080/springmvc01/amy/say/hi
@GetMapping("/{name}/say/{content}")
public String saySth(@PathVariableString name,@PathVariableString content) {
System.out.println(name+",say: " + content);
return"success";
}
控制台打印：amy,say: hi

使用正则表达式
语法
语法：{varName:regex}
varName：变量名
regex ：正则表达式

示例
{name:[a-z-]+}：传入参数name,值为a-z的多个字母

示例代码1：
要求：匹配传入参数name为a-z的一个字符，后跟一个数字
请求路径：localhost:8080/springmvc01/a1/say/hi
代码：
@GetMapping("/{name:[a-z]\d}/say/{content}")
public String saySth(@PathVariable(“name”) String name,@PathVariable(“content”) String content) {
System.out.println(name+",say: " + content);
return"success";
}

示例代码2：
要求：匹配给定URL:/spring-web-3.0.5 .jar
代码：
@GetMapping("/{name:[a-z-]+}-{version:\d\.\d\.\d}{ext:\.[a-z]+}")
publicvoidhandle(@PathVariableString version, @PathVariableStringext) {
// …
}

@RequestParam注解
把请求参数传递给方法。包含三个属性：
 value:参数名
 defaultValue:默认值，如果设置了defaultValue的值，则会隐式的将required设置为false
 required:是否必须，布尔型。默认为true，表示请求参数中必须包含对应的参数。

示例：
请求路径：
localhost:8080/springmvc01/sayHello?name=amy或
localhost:8080/springmvc01/sayHello?name=amy&age=20
代码：
/**
*
* @param name 姓名
* @param age 年龄，非必传，默认为10
* @return
*/
@GetMapping("/sayHello")
public String sayHello(@RequestParam(“name”) String name,
@RequestParam(value=“age”,required=false,defaultValue=“10”) intage) {
System.out.println(name+",age: " + age);
return"success";
}

@RequestHeader注解
可以使用该注解绑定请求报头的属性值。
请求头包含了若干属性，服务器可据此获知客户端的信息，通过@RequestHeader即可将请求头中的属性值绑定到处理方法的入参中。
例如：
Host localhost:8080
Accept text/html,application/xhtml+xml,application/xml;q=0.9
Accept-Language fr,en-gb;q=0.7,en;q=0.3
Accept-Encoding gzip,deflate
Accept-Charset ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive 300

示例：
示例1：获取header中的一组值
请求路径：127.0.0.1:8080/springmvc01/sayHello
@GetMapping("/sayHello")
public String sayHello(@RequestHeader(“Host”) String header) {
System.out.println(header);
return"success";
}
输出打印：127.0.0.1:8080

示例2：获取header中的多组值
@GetMapping("/demo")
publicvoidhandle(
@RequestHeader(“Accept-Encoding”) String encoding,
@RequestHeader(“Keep-Alive”) longkeepAlive) {
//…
}

示例3：获取header中的全部值
可以使用Map<String,String>, MultiValueMap<String,String>或 HttpHeaders配合@RequestHeader注解获取全部的header值。

请求路径：127.0.0.1:8080/springmvc01/sayHello
@GetMapping("/sayHello")
public String sayHello(@RequestHeader Map<String,String>map) {
for(String key:map.keySet()) {
System.out.println("header: “+key +” , value : “+ map.get(key));
}
return"success”;
}
打印：
header: cache-control , value : no-cache
header: postman-token , value : 6504e6cd-56c4-4c07-a598-50f0f2581036
header: user-agent , value : PostmanRuntime/7.1.5
header: accept , value : /
header: host , value : 127.0.0.1:8080
header: cookie , value : JSESSIONID=44E86F58C4F8EAE8D1567699A30ACFFB
header: accept-encoding , value : gzip, deflate
header: connection , value : keep-alive

示例4：参数也可以使用集合或数组获取
文档：
Built-in support is available for converting a comma-separated string into an array or collection of strings or other types known to the type conversion system. For example, a method parameter annotated with @RequestHeader(“Accept”) can be of type String but also String[] or List.

@GetMapping("/sayHello")
public String sayHello(@RequestHeader("accept-encoding") String[] str) {
	for(String s:str) {
		System.out.println(s);
	}
	System.out.println(str);
	return"success";
}

@CookieValue
获取cookie中的值

示例：获取cookie中的JSESSIONID的值
请求地址：127.0.0.1:8080/springmvc01/sayHello
@GetMapping("/sayHello")
public String sayHello(@CookieValue(“JSESSIONID”) String value) {
System.out.println(“value”+value);
return"success";
}

@SessionAttributes
作用
用于在session中存放数据。只可以标注于类上。

共有三个属性：
-Value：字符串数组，写需要存储到session中数据的名称。例如：value={“name”,”age”,”phone”}
-Name:同value。
-Types: 根据指定参数的类型，将模型中对应类型的参数存储到session中。例如：types= {String.class,Integer.class}, model或map或modelmap中绑定的参数如果有String或Integer类型，将会被放入到session中。
示例：
示例：
@SessionAttributes(“name”)
//也可以@SessionAttributes(types=String.class)
@Controller
publicclassHelloWorldController {
@GetMapping("/sayHello")
public String sayHello(Model model) {
model.addAttribute(“name”, “amy”);
return"success";
}

@RequestMapping(value="/hw")
public String helloWorld(SessionStatusstatus) {
	status.setComplete();//这个方法会清空SessionAttributes里的所有数据
	return"success";
}

}

@SessionAttribute
作用
获取存储在session中的数据，并作用在方法上。只能标注在参数上.
示例
@RequestMapping("/demo")
public String method2(@SessionAttribute(“age”)intage) {
System.out.println(“age====”+age);
return"success";
}

@ModelAttribute
作用
在方法上使用该注解：
SpringMVC在调用目标处理方法之前，会先逐个调用在方法上标注了@ModelAttribute的方法。
在方法的入参前使用@ModelAttribute注解：

• 可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数绑定到对象中，再传入参数
• 将方法入参对象添加到模型中

示例
示例1：在方法上使用
在方法上使用@ModelAttribute注解，如果方法有多个，会依次执行标注有该注解的方法。
请求路径：http://localhost:8080/springmvc01/sayHello
@ModelAttribute
publicvoidtestModelAttribute() {
System.out.println(“先执行这个方法1”);
}
/**
* 这个返回值User，会被自动的放入Model中，绑定名为首字母小写user，相当于model.addAttribute(“user”, new User(“kelly2”,“30”));
* @return
*/
@ModelAttribute
publicUser testModelAttribute2() {
System.out.println(“先执行这个方法2”);
returnnew User(“kelly2”,“30”);
}

/**
 * @ModelAttribute("userKelly") = @ModelAttribute(value="userKelly")
 * 显式的指定绑定名称。默认为User类名首字母小写
注意：在目标方法中取值时，需要使用@ModelAttribute("userKelly")方式，否则取不到。
		例如
			publicString  updateUser(@ModelAttribute("userKelly")User user){
				return SUCCESS;
			}
 * @return
 */
@ModelAttribute("userKelly")
public User testModelAttribute3() {
	System.out.println("先执行这个方法2");
	returnnew User("kelly3","20");
}

@GetMapping("/sayHello")
public String sayHello(Model model) {
	System.out.println("执行了sayHello方法");
	return"success";
}

结果打印：

示例：和XXXMapping一起使用
访问路径：http://localhost:8080/工程名/ testModelAttribute4

/**
 * 这两个注解一起使用，返回的return "success" 并不是返回视图的名称，而是把success放入了model中，
 * 返回的视图名称是@RequestMapping中的value值，即：testModelAttribute4
 * @return
 */
@RequestMapping("testModelAttribute4")//这个是值是返回的视图名称
@ModelAttribute("returnVal")
public String testModelAttribute4() {
	System.out.println("先执行这个方法4");
	return"success";//此处为放入model中绑定的值，即model.addAttribute(“returnVal”,”success”)
}

下列这种写法效果相同：
@RequestMapping(“testModelAttribute4”)
public@ModelAttribute(“returnVal”)String testModelAttribute4() {
System.out.println(“先执行这个方法4”);
return"success";
}

示例：使用在入参中
/**
* 这个返回值User，会被自动的放入Model中，绑定名为首字母小写user，相当于model.addAttribute(“user”, new User(“kelly2”,“30”));
* @return
*/
@ModelAttribute
public User testModelAttribute2() {
System.out.println(“先执行这个方法2”);
returnnew User(“kelly2”,“30”);
}

/**
 * 这个方法中的入参User user 的值，来自方法testModelAttribute2中。并且也会存在于model中。
 * @param user
 * @return
 */
@GetMapping("/sayHello5")
public String sayHello5(@ModelAttribute("user") User user) {
	System.out.println("执行了sayHello5方法");
	System.out.println(user);
	return"success";
}

@RequestAttribute
获取request中的值。
示例
@ModelAttribute
publicvoidbefore(HttpServletRequestrequest) {
request.setAttribute(“na2”, “shanghai”);
request.setAttribute(“na1”, “guangzhou”);
}

@RequestMapping("/testme")
public String testme(@RequestAttribute("na1") String na) {//这里的na1会取到上面方法中request的值
	System.out.println(na);
	return"success";
}

测试路径：http://localhost:8080/工程名/testme
测试结果：控制台打印：guangzhou

@ResponseBody
作用
将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML。
使用此注解之后不会再走试图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。

1. 使用时需要加入以下三个jar包

2. springmvc配置文件中加入<mvc:annotation-driven />。该注解启用后，Spring会默认帮我们注册处理请求，参数和返回值的类

示例
@GetMapping("/demo1")
@ResponseBody
public Map<String,Object> demo1() {
Map<String,Object>map = new HashMap<>();
map.put(“date”, new Date());
map.put(“name”, “罗小黑”);
map.put(“age”, 20);
returnmap;
}

输出：

处理方法
入参
使用POJO对象绑定请求参数值
SpringMVC会按照请求名和POJO属性名进行自动匹配，自动为该对象填充属性值。支持级联属性，如：user.address.province, cart.product.pname

示例：
控制器：
@PostMapping("/sayHello")
public String sayHello(User user) {//此处直接写要接收的对象即可
System.out.println(user);
return"success";
}

类：
User.java
publicclass User {
private String uname;
private String age;
private Address address;

getter/setter…
toString()…..

}

Address.java
publicclassAddress {
private String province;
private String city;

getter/setter……

}

测试请求：

打印结果：

servlet API
可以接收以下方法的入参：
javax.servlet.ServletRequest,
javax.servlet.ServletResponse
javax.servlet.http.HttpSession
javax.servlet.http.PushBuilder
java.io.OutputStream,
java.io.Writer
java.io.InputStream,
java.io.Reader
java.util.Locale
java.security.Principal

示例
使用HttpServletRequest
@RequestMapping("/demo")
public String method2(HttpServletRequestrequest) {
System.out.println(request.getRequestURI());
return"success";
}

使用Write
@RequestMapping("/me")
publicvoid method2(Writer writer) {
try {
writer.write(“spring mvc”);
} catch (IOExceptione) {
e.printStackTrace();
}

Map（java.util.Map）
使用map作为传入参数，处理模型数据。
示例
示例1：
-请求路径：（GET）127.0.0.1:8080/springmvc01/sayHello
-代码：
–类：
@GetMapping("/sayHello")
public String sayHello(Map<String ,Object>map) {//此处的传入参数为map类型
map.put(“name”,“zhangsan”); //绑定参数
return"success";
}
–页面：
<!DOCTYPEhtml>


<metacharset=“UTF-8”>

SUCCESS

${name }

-返回结果：

Model
同map。作为传入参数使用。
示例
示例：
-请求路径：
-代码：
–类：
@GetMapping("/sayHello")
public String sayHello(Model model) {//此处的传入参数为Model类型
System.out.println(model.getClass().getName());
model.addAttribute(“name”,“zhangsan”);//绑定参数
return"success";
}
–页面：
<!DOCTYPEhtml>


<metacharset=“UTF-8”>

SUCCESS

${name }

-返回结果：

ModelMap
同map和model. 在方法的传入参数处使用。
示例
示例1：
-请求路径：
-代码：
-类：
@GetMapping("/sayHello")
public String sayHello(ModelMapmodelmap) {//此处的传入参数为ModelMap类型
System.out.println(modelmap.getClass().getName());
modelmap.addAttribute(“name”,“zhangsan”);//绑定参数
modelmap.put(“age”,20);//绑定参数
return"success";
}
-页面:
<!DOCTYPEhtml>


<metacharset=“UTF-8”>

SUCCESS

$name</h2><h2>${age }

-返回结果：

返回值
ModelAndView
控制器处理方法的返回值如果为ModelAndView,则其既包含视图信息，也包含模型数据信息。
相关API:
添加：

ModelAndView
addObject(String attributeName, Object attributeValue)
Add an attribute to the model.

ModelAndView
addAllObjects(Map<String,?> modelMap)
Add all attributes contained in the provided Map to the model.

设置视图
void setView(View view)
Set a View object for this ModelAndView.
void setViewName(String viewName)
Set a view name for this ModelAndView, to be resolved by the DispatcherServlet via a ViewResolver.

示例
示例1：
请求路径：（get）127.0.0.1:8080/springmvc01/sayHello
代码：
类：
@GetMapping("/sayHello")
publicModelAndViewsayHello() {
ModelAndViewmav = newModelAndView();
mav.addObject(“name”, “amy”);//携带的数据
mav.setViewName(“success”);//返回的视图名称
returnmav;
}
页面：
<!DOCTYPEhtml>


<metacharset=“UTF-8”>

SUCCESS

${name }

返回结果：

转发/重定向
方法返回的字符串中带forward: 或 redirect: 前缀时，springmvc会对他们进行特殊处理，将forward 和redirect当成指示符，后面的字符串作为url处理。
例如：redirect:index.jsp会重定向到index.jsp
forward:index.jsp会转发到index.jsp

示例
重定向，转发类似。
@GetMapping("/demo")
public String demo() {
// return “redirect:/index.jsp”;//重定向到页面
return"redirect:/me";//重定向到下面这个请求
}

@GetMapping("/me")
public String method2(ModelMapmap) {
	map.addAttribute("date", new Date());
	return"success"; 
}

自定义类型转换器
spring提供了很多内置类型转换器，但是有些时候也并不能满足实际需求，所以可以使用自定义类型转换器来实现。

步骤

1. 新建自定义转换器类，并实现org.springframework.core.convert.converter.Converter接口
   importorg.springframework.core.convert.converter.Converter;
   publicclassXXXimplements Converter<S, T>{

   @Override
   publicTconvert(Ssource) {
   //这里写逻辑
   returnt;
   }
   }

2. 配置xml文件
   <beanid=“conversionService”
   class=“org.springframework.context.support.ConversionServiceFactoryBean”>
   <propertyname=“converters”>
   
   
   <beanclass=“XXX”>
   
   
   

<mvc:annotation-driven
	conversion-service="conversionService" />

示例
有代码如下：
@RequestMapping("/testCustomConverter")
public String testCustomConverter(Date date) {
System.out.println(date);
return"success";
}
此时如果请求为testCustomConverter?date=2018-10-01，则会转换出错。

解决方案：增加字符串到Date类型的转换器

1. 新建自定义转换器类，并实现org.springframework.core.convert.converter.Converter接口

importjava.text.ParseException;
importjava.text.SimpleDateFormat;
importjava.util.Date;

importorg.springframework.core.convert.converter.Converter;

/**

• 两个泛型：
• 第一个:Source 表示想要对什么类型做处理
• 第二个：Target表示想要转换成什么类型

*/
publicclassDateResolverimplements Converter<String, Date>{

@Override
public Date convert(String source) {
	SimpleDateFormatsdf = newSimpleDateFormat("yyyy-MM-dd");
	Date date = null;
	try {
		date = sdf.parse(source);
	} catch (ParseExceptione) {
		e.printStackTrace();
	}
	returndate;
}

}

2. 配置xml文件
   <beanid=“conversionService” class=“org.springframework.context.support.ConversionServiceFactoryBean”>
   <propertyname=“converters”>
   

   		<beanclass="com.niit.springmvc.util.DateResolver"></bean>
   	</set>
   </property>
   

   <mvc:annotation-drivenconversion-service=“conversionService” />

controller不需要做修改，此时发送请求testCustomConverter?date=2018-10-01，则可以正常访问。
标签
<mvc:view-controller
如果发送的请求不想通过controller，只想直接地跳转到目标页面，这时候就可以使用mvc:view-controller标签 .

使用

1. 在配置文件中增加如下配置：
   mvc:view-controllerpath="/success"view-name="/WEB-INF/views/success.jsp"/

其中：
 path 访问的路径（相当于RequestMapping(“/hello”)）
 view-name返回的视图（如hello.jsp,相当于return “hello”） 配置了这个后对于/hello请求,就会直接交给dispatcherServlet,然后使用ViewResolver进行解析。

2. 加入 mvc:annotation-driven/

示例

1. 在spring-mvc.xml中配置：
   mvc:annotation-driven/
   mvc:view-controllerpath="/success"view-name=“success.jsp”/

2. 控制器
   @RequestMapping("/testViewController")
   public String testViewController() {
   return"success";
   }

3. 对应请求
   http://localhost:8080/springmvc01-exer/success
   或
   http://localhost:8080/springmvc01-exer/testViewController

<mvc:annotation-driven />
该注解启用后，Spring会默认帮我们注册处理请求，参数和返回值的类。
 会默认创建并注 RequestMappingHandlerMapping，RequestMappingHandlerAdapter
和 ExceptionHandlerExceptionResolver。
 支持使用 ConversionService 进行数据格式转换
 支持使用 NumberFormatAnnotation 与 DateTimeFormat 进行数据格式化
 支持使用 RequestBody 与 ResponseBody 注解
 忽略静态资源

<mvc:resources
作用：当DispatcherServlet请求映射配置为"/"，则Spring MVC将捕获Web容器所有的请求，包括静态资源的请求，Spring MVC会将它们当成一个普通请求处理，因此找不到对应处理器将导致错误。该标签即为处理静态资源的方式之一。
DispatcherServlet不会拦截以/static开头的所有请求路径，并当作静态资源交由Servlet处理.

属性：
 location静态文件存放的位置
 mapping请求路径，如/static/a 或者/static/a/b；

示例：
mvc:resourceslocation="/static/“mapping=”/static/**"</mvc:resources>

如果拦截器中拦截了静态资源，还需要对静态资源进行不拦截处理。

${pageContext.request.contextPath}

h2{
background-color:blue;
}
<linkhref="${pageContext.request.contextPath }/static/index.css"rel="stylesheet"type=“text/css”>

mvc:default-servlet-handler/
作用：当DispatcherServlet请求映射配置为"/"，则Spring MVC将捕获Web容器所有的请求，包括静态资源的请求，Spring MVC会将它们当成一个普通请求处理，因此找不到对应处理器将导致错误。该标签即为处理静态资源的方式之一。

拦截器
Spring MVC中的拦截器（Interceptor）类似于Servlet中的过滤器（Filter），主要用于拦截用户请求并作相应的处理。

两种实现方式：
 通过实现HandlerInterceptor接口，或继承HandlerInterceptor接口的实现类（如HandlerInterceptorAdapter）来定义。

1. preHandler():该方法会在控制器方法前执行，其返回值表示是否中断后续操作。
   返回值为true时，表示继续向下执行；
   返回值为false时，会中断后续的所有操作（包括调用下一个拦截器和控制器类中的方法执行等）。
2. postHandler():该方法会在控制器方法调用之后，且解析视图之前执行。可以通过此方法对请求域中的模型和视图做出进一步的修改。
3. afterCompletion():该方法会在整个请求完成，即视图渲染结束之后执行。可以通过此方法实现一些资源清理、记录日志信息等工作。

 通过实现WebRequestInterceptor接口，或继承WebRequestInterceptor接口的实现类来定义。

1. void preHandle(WebRequest request) throws Exception;
2. void postHandle(WebRequest request, ModelMap model) throws Exception;
3. void afterCompletion(WebRequest request, Exception ex) throws Exception;

实现HandlerInterceptor接口

1. 创建拦截器类并实现HandlerInterceptor接口
   importjavax.servlet.http.HttpServletRequest;
   importjavax.servlet.http.HttpServletResponse;

importorg.springframework.web.servlet.HandlerInterceptor;
importorg.springframework.web.servlet.ModelAndView;

publicclassTestInterceptorimplementsHandlerInterceptor {

/**
 * 在目标方法调用前被调用
 */
@Override
publicbooleanpreHandle(HttpServletRequestrequest, HttpServletResponseresponse, Object handler)
		throws Exception {
	System.out.println("preHandle()");
	returnHandlerInterceptor.super.preHandle(request, response, handler);
}


/**
 * 在目标方法调用之后，视图渲染之前调用
 */
@Override
publicvoidpostHandle(HttpServletRequestrequest, HttpServletResponseresponse, Object handler,
		ModelAndViewmodelAndView) throws Exception {
	System.out.println("postHandle()");
}


/**
 * 在视图渲染之后调用
 */
@Override
publicvoidafterCompletion(HttpServletRequestrequest, HttpServletResponseresponse, Object handler, Exception ex)
		throws Exception {
	HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
	System.out.println("afterCompletion()");
}

}

2. 配置spring-mvc.xml

<mvc:interceptors>
	<mvc:interceptor>

		<mvc:mappingpath="/**"/>

		<mvc:exclude-mappingpath="/testCustomConverter"/>

		<beanclass="com.niit.springmvc.interceptor.TestInterceptor"></bean>
	</mvc:interceptor>

	<mvc:interceptor>
		<mvc:mappingpath="/XXX"/>
		<beanclass="XXX"></bean>
	</mvc:interceptor>
	
</mvc:interceptors>

path匹配规则：

1. path必须以/开头进行匹配，因为默认的是匹配URI。
2. path匹配目录使用**，如/**代表匹配多级，/*匹配一级
3. path匹配文件使用*，如/**/*.htm代表匹配所有一级目录下的所有htm文件。
4. path可以匹配以指定文字开头或者结尾或者中间包含的URI,如：
   /twov**/twov*.htm
   /wov/two*.htm
   /*wovv/*wovv.htm

实现WebRequestInterceptor接口

1. 创建拦截器类并实现HandlerInterceptor接口
   importorg.springframework.ui.ModelMap;
   importorg.springframework.web.context.request.WebRequest;
   importorg.springframework.web.context.request.WebRequestInterceptor;

publicclassTestWebRequestInterceptorimplementsWebRequestInterceptor{

@Override
publicvoidpreHandle(WebRequestrequest) throws Exception {
	// TODO Auto-generated method stub
	System.out.println("WebRequestInterceptor---preHandle");
	
}

@Override
publicvoidpostHandle(WebRequestrequest, ModelMapmodel) throws Exception {
	// TODO Auto-generated method stub
	System.out.println("WebRequestInterceptor---postHandle");
}

@Override
publicvoidafterCompletion(WebRequestrequest, Exception ex) throws Exception {
	// TODO Auto-generated method stub
	System.out.println("WebRequestInterceptor---afterCompletion");
}

}

2. 配置spring-mvc.xml
   mvc:interceptor
   mvc:mappingpath="/**"/
   
   </mvc:interceptor>

异常处理
springmvc通过HandlerExceptionResolver处理程序的异常，包括Handler映射，数据绑定以及目标方法执行时发生的异常。

HandlerExceptionResolver
步骤：

1. 新建异常处理类并实现HandlerExceptionResolver接口
   importjavax.servlet.http.HttpServletRequest;
   importjavax.servlet.http.HttpServletResponse;

importorg.springframework.stereotype.Component;
importorg.springframework.web.servlet.HandlerExceptionResolver;
importorg.springframework.web.servlet.ModelAndView;

publicclassTestHandlerExceptionimplementsHandlerExceptionResolver{

@Override
publicModelAndViewresolveException(HttpServletRequestrequest, HttpServletResponseresponse, Object handler,
		Exception ex) {
	ModelAndViewmav = newModelAndView("error");
mav.addObject("msg", ex.getMessage());
	returnmav;
}

}

2. xml配置或注解配置注入spring
   使用@Component注解或者在spring-mvc.xml中配置即可

3. 测试
   请求路径:http://localhost:8080/XXX/testExceptionHandler
   页面跳转至错误页面error.jsp
   @RequestMapping("/testExceptionHandler")
   public String testExceptionHandler() {
   System.out.println(2/0);
   return"success";
   }

使用@ExceptionHandler

1. 在控制器中加入如下方法
   @ExceptionHandler
   publicModelAndViewhandleException(Exception e) {
   ModelAndViewmav= newModelAndView(“error”);
   mav.addObject(“error”, e.getMessage());
   returnmav;
   }

如果需要缩小异常范围，也可以写成：
@ExceptionHandler({NullPointerException.class,NumberFormatException.class})
publicModelAndViewhandleException(Exception e) {
ModelAndViewmav= newModelAndView(“error”);
mav.addObject(“error”, e.getMessage());
returnmav;
}
注意：无需配置xml文件。在使用了@ExceptionHandler的控制器中,会进行异常处理，其他不包含这个注解的控制器，不会进行异常处理。

对于404等的处理
上面的所述的异常处理方式，并不能解决404等错误页面的出现。
解决方案如下：

1. 在web.xml中配置
   
   404
   /404.jsp
   

2. 增加404.jsp
   <%@pagelanguage=“java” contentType=“text/html; charset=UTF-8”
   pageEncoding=“UTF-8”%>

Controller
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;

import com.niit.eneity.Product;
import com.niit.service.ProductService;

@Controller
public class ProductController {

@Autowired
private ProductServiceproductService;


/**
 * 列表
 */
@GetMapping("/products")
public String productList(Model model) {
	List<Product> list = productService.productList();
	model.addAttribute("list", list);
	return "list";
}     

/**
 * 跳转新增
 */
@GetMapping("/product")
public String toAddProduct() {
	return "addProduct";
}

/**
 * 跳转修改
 */
@GetMapping("/product/{index}")
public String tomodifyProduct(@PathVariable("index")Integerindex,Model model) {
	Product product = productService.findPro(index);
	model.addAttribute("product", product);
	model.addAttribute("index", index);
	return "addProduct";
}

/**
 * 新增
 */
@PostMapping("/product")
public String addProduct(Product product) {
	productService.addProduct(product);
	return "redirect:/products";
}

/**
 * 删除
 */
@DeleteMapping("/product/{index}")
public String delProduct(@PathVariable("index")Integer index) {
	productService.delProduct(index);
	return "redirect:/products";
}


/**
 * 修改
 */
@PutMapping("/product/{index}")
public String modifyProduct(@PathVariable("index")Integerindex,Product product) {
	productService.updateProduct(index,product);
	return "redirect:/products";
}

}

Service
importjava.util.ArrayList;
importjava.util.List;

importorg.springframework.stereotype.Service;

importcom.niit.eneity.Product;
importcom.niit.service.ProductService;

@Service
publicclassProductServiceImplimplementsProductService{

privatestatic List<Product>plist ;

static {
	plist = newArrayList<>();
	plist.add(new Product("马克杯", "好看的喝水杯",10));
	plist.add(new Product("猫爪杯", "更好看的喝水杯",20));
	plist.add(new Product("保温杯", "实用",30));
}



@Override
public List<Product>productList() {
	returnplist;
}



@Override
publicvoidaddProduct(Product product) {
	plist.add(product);
	
}



@Override
publicvoiddelProduct(Integer index) {
	plist.remove(plist.get(index));
}



@Override
public Product findPro(Integer index) {
	Product pro  =plist.get(index);
	returnpro;
}



@Override
publicvoidupdateProduct(Integer index, Product product) {
	plist.set(index, product);
}

}

web.xml

<?xml version="1.0" encoding="UTF-8"?>

<web-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://xmlns.jcp.org/xml/ns/javaee"xsi:schemaLocation=“http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd” id=“WebApp_ID” version=“3.1”>

<!-- The front controller of this Spring Web application, responsible for handling all application requests -->
<servlet>
	<servlet-name>springDispatcherServlet</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

	<load-on-startup>1</load-on-startup>
</servlet>

<!-- Map all requests to the DispatcherServlet for handling -->
<servlet-mapping>
	<servlet-name>springDispatcherServlet</servlet-name>
	<url-pattern>/</url-pattern>
</servlet-mapping>
<filter>
	<filter-name>characterEncodingFilter</filter-name>
	<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
	<init-param>

encoding
UTF-8


forceEncoding
true



characterEncodingFilter
/*

<filter>
	<filter-name>hiddenHttpMethodFilter</filter-name>
	<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>

<filter-mapping>
	<filter-name>hiddenHttpMethodFilter</filter-name>
	<url-pattern>/*</url-pattern>
</filter-mapping>

mvc.xml

<?xml version="1.0" encoding="UTF-8"?>

<beansxmlns=“http://www.springframework.org/schema/beans”
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
xmlns:context=“http://www.springframework.org/schema/context”
xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd”>

<context:component-scan base-package="com.niit"></context:component-scan>


<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="prefix" value="/WEB-INF/views/"></property>
	<property name="suffix"  value=".jsp"></property>
</bean>

页面
list.jsp
<%@pagelanguage=“java” contentType=“text/html; charset=UTF-8”
pageEncoding=“UTF-8”%>
<%@taglibprefix=“c” uri=“http://java.sun.com/jsp/jstl/core” %>

					<formaction="'" method="POST" id="delForm">
							<inputtype="hidden" name="_method" value="DELETE">
					</form>

<ahref=“product”>新增

<tableborder=“1”>

商品名称
描述
库存
操作

<c:forEachitems="$list"var="p"varStatus="status"><tr><td>${p.pname }
$p.pdescribe</td><td>${p.pnum }

<ahref=“javascript:void(0)” οnclick=“delForm($status.index)">删除</a><ahref="product/${status.index }”>修改


</c:forEach>

	</table>

addProduct.jsp
<%@pagelanguage=“java” contentType=“text/html; charset=UTF-8”
pageEncoding=“UTF-8”%>
<%@taglibprefix=“c” uri=“http://java.sun.com/jsp/jstl/core” %>

文件上传
springmvc通过MultipartResovler提供了对文件上传的直接支持。默认情况下没有装配MultipartResovler,所以不能处理上传文件的功能，需要在上下文中配置MultipartResovler后才能使用。

步骤

1. 加入以下jar包

2. 修改上下文配置文件。注意：<bean的id不能省略，否则不生效
   <beanid=“multipartResolver” class=“org.springframework.web.multipart.commons.CommonsMultipartResolver”>
   
   <propertyname="defaultEncoding"value=“utf-8”>
   
   <propertyname="maxUploadSize"value=“1024”>
   

3. 使用
   @RequestMapping("/uploadFile")
   publicStringuploadFile(MultipartFilefile) {

示例
单个文件上传
控制器
importjava.io.File;
importjava.io.IOException;

importorg.springframework.stereotype.Controller;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RequestParam;
importorg.springframework.web.multipart.MultipartFile;

@Controller
publicclassUploadController {

@RequestMapping("/uploadFile")
public String uploadFile(@RequestParam("file") MultipartFilefile) {
	File f = new File("C:\\Users\\hussein\\Desktop\\"+file.getOriginalFilename());

//获取tomcat下的路径,打印路径为：.metadata.plugins\org.eclipse.wst.server.core\tmp1\wtpwebapps\spring-//springmvc\upload
//request.getServletContext().getRealPath("/upload")+"\"+System.currentTim//eMillis()+".jpg";
try {
file.transferTo(f);
} catch (Exception e) {
e.printStackTrace();
}
return"success";
}

}

页面：
<%@pagelanguage=“java” contentType=“text/html; charset=UTF-8”
pageEncoding=“UTF-8”%>

多个文件上传
控制器
使用数组接收
@RequestMapping("/uploadFile")
public String uploadFile(@RequestParam(“file”)MultipartFile[]files) {
for(MultipartFilefile : files ) {
File f = new File(“C:\Users\hussein\Desktop\”+file.getOriginalFilename());
try {
file.transferTo(f);
} catch (Exception e) {
e.printStackTrace();
}
}
return"success";
}

页面
<%@pagelanguage=“java” contentType=“text/html; charset=UTF-8”
pageEncoding=“UTF-8”%>

文件大小超出限制的处理
如果在上下文的配置文件中，配置了上传文件的最大值（<property name=“maxUploadSize”）,如果用户上传的文件超过了设定的最大值，则会出现 org.springframework.web.multipart.MaxUploadSizeExceededException异常。
可以使用异常处理解决

使用异常处理
上下文文件，需要配置上传文件的最大值。
<beanid=“multipartResolver” class=“org.springframework.web.multipart.commons.CommonsMultipartResolver”>

<propertyname="defaultEncoding"value=“utf-8”>

<propertyname="maxUploadSize"value=“1024”>

异常处理类
importjava.io.IOException;

importjavax.servlet.ServletException;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;

importorg.springframework.stereotype.Component;
importorg.springframework.web.multipart.MaxUploadSizeExceededException;
importorg.springframework.web.servlet.HandlerExceptionResolver;
importorg.springframework.web.servlet.ModelAndView;

@Component
publicclassHandleExceptionUtilimplementsHandlerExceptionResolver{

@Override
publicModelAndViewresolveException(HttpServletRequestrequest, HttpServletResponseresponse, Object arg2,
		Exception e) {
	ModelAndViewmav = newModelAndView();
	if(einstanceofMaxUploadSizeExceededException) {
		mav.addObject("errormsg","文件不能超过1Kb");
		mav.setViewName("/index");//这里可以传入request中动态获取请求的路径
	}
	returnmav;
}

}

页面index.jsp，加入${errormsg}
<%@pagelanguage=“java” contentType=“text/html; charset=UTF-8”
pageEncoding=“UTF-8”%>

国际化
作用：不同国家的用户展示不同语言的内容。

1. 添加资源束文件，放在根目录下。

2. 配置spring-mvc.xml
   <beanid=“messageSource” class=“org.springframework.context.support.ResourceBundleMessageSource”>
   
   <propertyname="basename"value=“msg”>
   

示例
修改浏览器默认语言实现中英文切换

1. 新建资源束文件

1. language_zh_CN.properties
   uname=\u7528\u6237\u540D
   password=\u5BC6\u7801
   submit=\u63D0\u4EA4

2. language_en_US.properties
   uname=UserName
   password=Password
   submit=submit

2. 修改上下文配置文件
   注意：bean的id不能省略，并且必须为messageSource
   <beanid=“messageSource” class=“org.springframework.context.support.ResourceBundleMessageSource”>
   <propertyname="basename"value=“language”>
   

3. 页面
   <%@pagelanguage=“java” contentType=“text/html; charset=UTF-8”
   pageEncoding=“UTF-8”%>
   <%@taglibprefix=“fmt” uri=“http://java.sun.com/jsp/jstl/fmt” %>
   <%@taglibprefix=“spring” uri=“http://www.springframework.org/tags” %>

4. 测试

1. 浏览器默认语言为中文简体

2. 浏览器默认语言为英文（美国）

注意：测试语言类型时，需要将语言类型移动到顶部，然后刷新测试页面即可。

点击超链接实现中英文切换

1. 新建资源束文件

1. language_zh_CN.properties
   uname=\u7528\u6237\u540D
   password=\u5BC6\u7801
   submit=\u63D0\u4EA4

2. language _en_US.properties
   uname=UserName
   password=Password
   submit=submit

2. 修改上下文配置文件

   mvc:interceptors
   
   <property name="paramName"value=“message”>
   
   </mvc:interceptors>

   <bean  id="messageSource"class="org.springframework.context.support.ResourceBundleMessageSource">
   

			<property name="basename"value="language"></property>
	</bean>
	
	<bean id="localeResolver"class="org.springframework.web.servlet.i18n.SessionLocaleResolver">
	</bean>

3. 页面
   <%@pagelanguage=“java” contentType=“text/html; charset=UTF-8”
   pageEncoding=“UTF-8”%>
   <%@taglibprefix=“fmt” uri=“http://java.sun.com/jsp/jstl/fmt” %>
   <%@taglibprefix=“spring” uri=“http://www.springframework.org/tags” %>

4. 测试
   点击中文：

点击英文：

spring整合springmvc
整合：
一般情况下，数据员，事务，service，dao等都是放在spring的配置文件中，不是放在springmvc的配置文件中。
如果全都放在springmvc配置文件中也可以，比较好的做法是区分配置文件，使用import导入或者使用通配符加载配置文件。

示例
分成spring和springmvc配置文件。

• 项目结构：

• web.xml

<?xml version="1.0" encoding="UTF-8"?>

<web-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://xmlns.jcp.org/xml/ns/javaee"xsi:schemaLocation=“http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd” id=“WebApp_ID” version=“3.1”>
spring-springmvc

<!-- needed for ContextLoaderListener -->
<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>

<!-- Bootstraps the root web application context before servlet initialization -->
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<servlet>
	<servlet-name>springDispatcherServlet</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<load-on-startup>1</load-on-startup>
</servlet>

<!-- Map all requests to the DispatcherServlet for handling -->
<servlet-mapping>
	<servlet-name>springDispatcherServlet</servlet-name>
	<url-pattern>/</url-pattern>
</servlet-mapping>

• applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<beansxmlns=“http://www.springframework.org/schema/beans”
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
xmlns:context=“http://www.springframework.org/schema/context”
xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd”>

<context:component-scan base-package="com.niit">
	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

• springDispatcherServlet-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>

<beansxmlns=“http://www.springframework.org/schema/beans”
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
xmlns:context=“http://www.springframework.org/schema/context”
xmlns:mvc=“http://www.springframework.org/schema/mvc”
xsi:schemaLocation=“http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd”>

<context:component-scan base-package="com.niit"  use-default-filters="false">
	<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="suffix" value=".jsp"></property>
	<property name="prefix" value="/WEB-INF/views/"></property>
</bean>

<mvc:annotation-driven></mvc:annotation-driven>
<mvc:default-servlet-handler/>