一、创建项目，lib下导入包
commons-logging-1.1.1.jar
jstl.jar
spring-aop-4.0.0.RELEASE.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar
spring-web-4.0.0.RELEASE.jar
spring-webmvc-4.0.0.RELEASE.jar
standard.jar
web.xml:
<servlet>
<servlet-name>dispatchServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置 DispatcherServlet 的一个初始化参数: 配置 SpringMVC 配置文件的位置和名称 -->
<!--
实际上也可以不通过 contextConfigLocation 来配置 SpringMVC 的配置文件, 而使用默认的.
默认的配置文件为: /WEB-INF/<servlet-name>-servlet.xml
-->
<!--
<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>dispatchServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/dispatchServlet-servlet.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
dispatchServlet-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="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/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
<!-- 配置自定扫描的包,扫描com.xxlong.springmvc下的@Controller@RequestMapping等 -->
<context:component-scan base-package="com.xxlong"></context:component-scan>
<!-- 配置视图解析器: 如何把 handler 方法返回值解析为实际的物理视图 -->
<!-- SpringMVC 为逻辑视图名的解析提供了不同的策略,可以在 Spring WEB 上下文中配置一种或多种解析策略,并指定他们之间的先后顺序。每一种映射策略对应一个具体的视图解析器实现类。
视图解析器的作用比较单一:将逻辑视图解析为一个具体的视图对象。 所有的视图解析器都必须实现 ViewResolver 接口
常用的视图解析器实现类：
一、解析为URL文件：1、InternalResourceViewResolver:将视图名解析为一个URL文件,一般使用该解析器将视图名映射为一个保存在WEB-INF目录下的程序文件（如jsp）
2、JasperReportsViewResolver:JasperReports是一个基于Java的开源报表工具，该解析器将视图名解析为报表文件对应的URL
二、解析为Bean的名字：BeanNameViewResolver：将逻辑视图名字解析为bean的Name属性，从而根据name属性，找定义View的bean
三、模板文件视图：1、FreeMarkerViewResolver:解析为基于FreeMarker模板技术的模板文件
2、VelocityViewResolver：解析为基于Velocity模板技术的模板文件
3、VelocityLayoutViewResolver：解析为基于Velocity模板技术的模板文件
程序员可以选择一种视图解析器或混用多种视图解析器， 每个视图解析器都实现了 Ordered 接口并开放出一个 order 属性,可以通过 order 属性指定解析器的优先顺序,order 越小优先级越高。
SpringMVC 会按视图解析器顺序的优先顺序对逻辑视图名进行解析,直到解析成功并返回视图对象,否则将抛出 ServletException 异常
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
</beans>
1、Controller:
package com.xxlong.springmvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class Springmvc_test {
@RequestMapping("/testRequestMapping")
public String testRequestMapping(){
/**
* 1. 使用 @RequestMapping 注解来映射请求的 URL
* 2. 返回值会通过视图解析器解析为实际的物理视图, 对于 InternalResourceViewResolver 视图解析器, 会做如下的解析:
* 通过 prefix + returnVal + 后缀 这样的方式得到实际的物理视图, 然会做转发操作
*
* /WEB-INF/views/success.jsp
*/
return "success";
}
}
view：
请求页面index.jsp:<a href="testRequestMapping">Test RequestMapping</a>
响应页面success.jsp:hello world！
2、Controller：
@Controller @RequestMapping("/springmvc") public class Springmvc_test { /** * 1. @RequestMapping 除了修饰方法, 还可来修饰类 2. 1). 类定义处: 提供初步的请求映射信息。相对于 WEB 应用的根目录 * 2). 方法处: 提供进一步的细分映射信息。 相对于类定义处的 URL。若类定义处未标注 @RequestMapping，则方法处标记的 URL * 相对于 WEB 应用的根目录 *@RequestMapping 除了可以使用请求 URL 映射请求外,还可以使用请求方法、请求参数及请求头映射请求 *@RequestMapping 的 value、method、params 及 heads分别表示请求 URL、请求方法、请求参数及请求头的映射条件,他们之间是与的关系,联合使用多个条件可让请求映射 *更加精确化。 */ @RequestMapping("/testRequestMapping") public String testRequestMapping2(){ return "success"; } }
view：
请求页面index.jsp:<a href="spingmvc/testRequestMapping">Test RequestMapping</a>
响应页面success.jsp:hello world！
3、Controller:@RequestMapping(method={})
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
/**
* 常用: 使用 method 属性来指定请求方式，请求必须是post类型
*/
@RequestMapping(value="/testMethod",method=RequestMethod.POST)
public String testMethod(){
return "success";
}
}
view：
请求页面index.jsp:
<form action="springmvc/testMethod" method="post">
<input type="submit" value="testMethod"/>
</form>
响应页面success.jsp:hello world！
4、Controller:@RequestMapping(params={})
@Controller @RequestMapping("/springmvc") public class Springmvc_test { @RequestMapping(value="/testParams",params={"username","age=10"}) public String testParams(){ /*param1: 表示请求必须包含名为 param1 的请求参数 !param1: 表示请求不能包含名为 param1 的请求参数 param1 != value1: 表示请求包含名为 param1 的请求参数,但其值不能为 value1 {“param1=value1”, “param2”}: 请求必须包含名为 param1 和param2 的两个请求参数,且 param1 参数的值必须为 value1 */ return "success"; } }
view：
请求页面index.jsp:
<form action="springmvc/testParams" method="get"> username:<input type="text" name="username"/><br> age:<input type="text" name="age"><br> <input type="submit" value="testParams"></input> </form>
响应页面success.jsp:hello world！
5、Controller:@RequestMapping(headers={})
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping(value="/testHeaders",headers={"Accept-Language=zh-CN,zh;q=0.8,en-US;q=0.6,en;q=0.4","Connection=keep-alive"})
public String testHeaders(){
return "success";
}
}
view：
请求页面index.jsp:<a href="springmvc/testHeaders">test Headers</a>
响应页面success.jsp:hello world！
6、Controller:@PathVariable的使用
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping(value="/testPathVariable/{id}")
public String testPathVariable(@PathVariable("id") Integer id){
System.out.println("id="+id);
return "success";
}
}
view：
请求页面index.jsp:<a href="springmvc/testPathVariable/100">test PathVariable</a>
响应页面success.jsp:hello world！
7、Controller:@RequestMapping的Ant风格匹配
@Controller @RequestMapping("/springmvc") public class Springmvc_test { /*Ant 风格资源地址支持 3 种匹配符: ?:匹配文件名中的一个字符 *:匹配文件名中的任意字符 **: 匹配多层路径 @RequestMapping 还支持 Ant 风格的 URL: /user/*/createUser: 匹配/user/aaa/createUser、/user/bbb/createUser 等 URL /user/**/createUser: 匹配/user/createUser、/user/aaa/bbb/createUser 等 URL /user/createUser??: 匹配/user/createUseraa、/user/createUserbb 等 URL */ @RequestMapping("/testAnt/**/abc") public String testAnt(){ return "success"; } }
view：
请求页面index.jsp:<a href="springmvc/testAnt/aaa/bbb/abc">test Ant</a>
响应页面success.jsp:hello world！
8、Controller:@RequestParam的使用
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping("/testRequestParam")
/**在处理方法入参处使用 @RequestParam 可以把请求参数传递给请求方法value:参数名,required:是否必须。默认为 true, 表示请求参数中必须包含对应
*的参数,若不存在,将抛出异常
*/
public String testRequestParam(@RequestParam(value="username") String un,@RequestParam(value="age",required=true,defaultValue="0")
Integer age){
System.out.println("username="+un+" age="+age);
return "success";
}
}
view：
请求页面index.jsp:
<form action="springmvc/testRequestParam" > username:<input type="text" name="username"/><br> age:<input type="text" name="age"><br> <input type="submit" value="testRequestParam"></input> </form>
响应页面success.jsp:hello world！
控制台输出：username=xxlong age=30
9、Controller:@RequestHeader的使用
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping("/testRequestHeader")
/**
*请求头包含了若干个属性,服务器可据此获知客户端的信息,通过 @RequestHeader 即可将请求头中的属性值绑定到处理方法的入参中
*/
public String testRequestHeader(@RequestHeader("Accept-Encoding") String cl){
System.out.println("Accept-Encoding="+cl);
return "success";
}
}
view：
请求页面index.jsp:<a href="springmvc/testRequestHeader">test RequestHeader</a>
响应页面success.jsp:hello world！
控制台输出：Accept-Encoding=gzip, deflate, sdch
10、Controller:@CookieValue使用
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping("/testCookieValue")
/**
* @CookieValue 可让处理方法入参绑定某个 Cookie 值
*/
public String testCookieValue(@CookieValue("JSESSIONID") String sessionId){
System.out.println("JESSIONID="+sessionId);
return "success";
}
}
view：
请求页面index.jsp:<a href="springmvc/testCookieValue">test CookieValue</a>
响应页面success.jsp:hello world！
控制台输出：JESSIONID=F0367E562E477813201CDFF41C8F4EEE
11、Controller：表单参数赋给目标方法的POJO类型参数
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping("/testPojo")
/**
* Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配， 自动为该对象填充属性值。支持级联属性。
* 如：dept.deptId、dept.address.tel 等
*/
public String testPojo(User user){
return "success";
}
}
view:
请求页面index.jsp:
<form action="springmvc/testPojo" >
username: <input type="text" name="username"/>
<br>
password: <input type="password" name="password"/>
<br>
age: <input type="text" name="age"/>
<br>
city: <input type="text" name="address.city"/>
<br>
province: <input type="text" name="address.province"/>
<br>
<input type="submit" value="Submit"/>
</form>
响应页面success.jsp:user:${requestScope.user }<br>
页面输出：user:User [username=xxlong, password=, age=20, address=Address [city=芜湖, province=安徽]]
12、Controller:目标方法的ServletAPI类型参数的使用
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping("/testServletAPI")
/**
* 可以使用 Serlvet 原生的 API 作为目标方法的参数 具体支持以下类型
* HttpServletRequest
* HttpServletResponse
* HttpSession
* java.security.Principal
* Locale
* InputStream
* OutputStream
* Reader
* Writer
*/
public void testServletAPI(HttpServletRequest request,HttpServletResponse response,Writer out) throws IOException{
System.out.println("request="+request+" response="+response);
out.write("Hello!");
}
}
view：
请求页面index.jsp:<a href="springmvc/testServletAPI">Test ServletAPI</a>
响应页面Hello!
控制台输出：request=org.apache.catalina.connector.RequestFacade@48f18d99 response=org.apache.catalina.connector.ResponseFacade@2ec2ae64
13、Controller:ModelAndView的使用
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping("/testModelAndView")
/**
* 控制器处理方法的返回值如果为 ModelAndView, 则其既包含视图信息,也包含模型数据信息。
* 添加模型数据:
* MoelAndView addObject(String attributeName, Object attributeValue)
* ModelAndView addAllObject(Map<String, ?> modelMap)
* 设置视图:
* void setView(View view)
* void setViewName(String viewName)
* SpringMVC 会把 ModelAndView 的 model 中数据放入到 request 域对象中.
*/
public ModelAndView testModelAndView(){
//ModelAndView modelAndView = new ModelAndView("success");
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("success");
HashMap<String, Object> map = new HashMap<String, Object>();
map.put("first", "value1");
map.put("second", "value2");
modelAndView.addObject("time", new Date());
modelAndView.addAllObjects(map);
return modelAndView;
}
}
view：
请求页面index.jsp:<a href="springmvc/testModelAndView">Test ModelAndView</a>
响应页面success.jsp:
time:${requestScope.time }<br>
first:${requestScope.first }<br>
second:${requestScope.second }<br>
页面输出：
time:Thu Aug 13 09:36:02 CST 2015
first:value1
second:value2
14、Controller:目标方法的Map类型参数的使用
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping("/testMap")
/**
* 目标方法可以添加 Map 类型(实际上也可以是 Model 类型或 ModelMap 类型)的参数.
* Spring MVC 在调用方法前会创建一个隐含的模型对象作为模型数据的存储容器。
* 如果方法的入参为 Map 或 Model 类型,Spring MVC 会将隐含模型的引用传递给这些入参。在方法体内,开发者可以通过这个入参对象访问到模型中的所有数
* 据,也可以向模型中添加新的属性数据,最后map中数据放入到 request 域对象中
*/
public String testMap(Map<String,Object> map){
map.put("names", Arrays.asList("Tom","Kate","Bill"));
return "success";
}
}
view：
请求页面index.jsp:<a href="springmvc/testMap">Test Map</a>
响应页面success.jsp:
names:${requestScope.names }
页面输出：names:[Tom, Kate, Bill]
15、Controller:@SessionAttributes使用
@Controller
@SessionAttributes(value="user",types=String.class)
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping("/testSessionAttributes")
/**
* @SessionAttributes: 将模型中的某个属性暂存到HttpSession 中,以便多个请求之间可以共享这个属性
* @SessionAttributes 除了可以通过属性名指定需要放到会话中的属性外(实际上使用的是 value 属性值),
* 还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中(实际上使用的是 types 属性值)
* @SessionAttributes(types=User.class) 会将隐含模型中所有类型为 User.class 的属性添加到会话中。
* @SessionAttributes(value={“user1”, “user2”})会将隐含模型中所有key为user1，user2的属性添加到会话中。
* @SessionAttributes(types={User.class, String.class})
* @SessionAttributes(value={“user1”, “user2”},types={String.class})
*
* 注意: 该注解只能放在类的上面. 而不能修饰放方法.
*/
public String testSessionAttributes(Map<String,Object> map){
User user = new User("xxlong","311",100);
map.put("user", user);
map.put("hello", "world");
return "success";
}
}
view：
请求页面index.jsp:<a href="springmvc/testSessionAttributes">Test SessionAttributes</a>
响应页面success.jsp:
request user:${requestScope.user }<br>
request hello:${requestScope.hello }<br>
session user:${sessionScope.user }<br>
session hello:${sessionScope.hello }<br>
页面输出：
request user:User [username=xxlong, password=311, age=100, address=null]
request hello:world
session user:User [username=xxlong, password=311, age=100, address=null]
session hello:world
16、Controller:目标方法POJO类型入参过程
@Controller
//@SessionAttributes(value="user",types=String.class)
@RequestMapping("/springmvc")
public class Springmvc_test {
/**
* 1. 有 @ModelAttribute 标记的方法, 会在每个目标方法执行之前被 SpringMVC 调用!
* 2. @ModelAttribute 注解也可以来修饰目标方法 POJO 类型的入参, 其 value 属性值有如下的作用:
* 1). SpringMVC 会使用 value 属性值在 implicitModel 中查找对应的对象, 若存在则会直接传入到目标方法的入参中.
* 2). SpringMVC 会把 value 为 key, POJO 类型的对象为 value, 存入到 request 中.
*/
@ModelAttribute
public void getUser(@RequestParam(value="username",required=false) String un,Map<String,Object> map){
//模拟从数据库中获取对象
User user = new User(un,"123",120);
map.put("user", user);
}
@RequestMapping("/testModelAttribute")
/**
* 运行流程:
* 1. 执行 @ModelAttribute 注解修饰的方法: 从数据库中取出对象, 把对象放入到了 Map 中. 键为: user
* 2. SpringMVC 从 Map 中取出 User 对象, 并把表单的请求参数赋给该 User 对象的对应属性.
* 3. SpringMVC 把上述对象传入目标方法的参数.
*
* 注意: 在 @ModelAttribute 修饰的方法中, 放入到 Map 时的键需要和目标方法入参类型的第一个字母小写的字符串一致!
*如果不一致则在目标方法中需要使用@ModelAttribute来获得对象，不能使用默认的POJO来获得
*
* SpringMVC 确定目标方法 POJO 类型入参的过程
* 1. 确定一个 key:
* 1). 若目标方法的 POJO 类型的参数没有使用 @ModelAttribute 作为修饰（public String testModelAttribute(User usera)
{map.put("user",User)}）, 则 key 为 POJO 类名第一个字母的小写(usera=map.get("user"))
* 2). 若使用了@ModelAttribute 来修饰（public String testModelAttribute(@ModelAttribute("user2") User userb)
{map.put("abc",User)}）, 则 key 为 @ModelAttribute 注解的 value 属性值(userb=map.get("abc")).
* 2. 在 implicitModel 中查找 key 对应的对象, 若存在, 则作为入参传入
* 1). 若在 @ModelAttribute 标记的方法中在 Map 中保存过, 且 key 和 1 确定的 key 一致, 则会获取到.
* 3. 若 implicitModel 中不存在 key 对应的对象, 则检查当前的 Handler 是否使用 @SessionAttributes 注解修饰,
* 若使用了该注解, 且 @SessionAttributes 注解的 value 属性值中包含了 key, 则会从 HttpSession 中来获取 key 所
* 对应的 value 值, 若存在则直接传入到目标方法的入参中. 若不存在则将抛出异常.
* 4. 若 Handler 没有标识 @SessionAttributes 注解或 @SessionAttributes 注解的 value 值中不包含 key, 则
* 会通过反射来创建 POJO 类型的参数, 传入为目标方法的参数（参数为表单提交的值）
* 5. SpringMVC 会把 key 和 POJO 类型的对象保存到 implicitModel 中, 进而会保存到 request 中.
*
* 源代码分析的流程
* 1. 调用 @ModelAttribute 注解修饰的方法. 实际上把 @ModelAttribute 方法中 Map 中的数据放在了 implicitModel 中.
* 2. 解析请求处理器的目标参数, 实际上该目标参数来自于 WebDataBinder 对象的 target 属性
* 1). 创建 WebDataBinder 对象:
* ①. 确定 objectName 属性: 若传入的 attrName 属性值为 "", 则 objectName 为类名第一个字母小写(user).
* *注意: attrName. 若目标方法(testModelAttribute)的 POJO 属性使用了 @ModelAttribute 来修饰, 则 attrName 值即为 @ModelAttribute
* 的 value 属性值
*
* ②. 确定 target 属性:
* > 在 implicitModel 中查找 attrName 对应的属性值. 若存在, ok
* > 若不存在: 则验证当前 Handler 是否使用了 @SessionAttributes 进行修饰, 若使用了, 则尝试从 Session 中
* 获取 attrName 所对应的属性值. 若 session 中没有对应的属性值, 则抛出了异常.
* > 若 Handler 没有使用 @SessionAttributes 进行修饰, 或 @SessionAttributes 中没有使用 value 值指定的 key
* 和 attrName 相匹配, 则通过反射创建了 POJO 对象
*
* 2). SpringMVC 把表单的请求参数赋给了 WebDataBinder 的 target 对应的属性.
* 3). *SpringMVC 会把 WebDataBinder 的 attrName 和 target 给到 implicitModel. 近而传到 request 域对象中.
* 4). 把 WebDataBinder 的 target 作为参数传递给目标方法的入参.
*/
public String testModelAttribute(User user){
return "success";
}
}
view：
请求页面index.jsp:<a href="springmvc/testModelAttribute?username=xxl">Test ModelAttribute</a>
响应页面success.jsp:user:${requestScope.user }<br>
页面输出：user:User [username=xxl, password=123, age=120, address=null]
17、Controller:@ModelAttribute的使用
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@ModelAttribute
public void getUser(@RequestParam(value="username",required=false) String un,Map<String,Object> map){
User user = new User(un,"123",120);
map.put("abc", user);
}
@RequestMapping("/testModelAttribute")
public String testModelAttribute(@ModelAttribute("abc") User user){
return "success";
}
}
view：
请求页面index.jsp:<a href="springmvc/testModelAttribute?username=xxl">Test ModelAttribute</a>
响应页面success.jsp:user:${requestScope.abc }<br>
页面输出：user:User [username=xxl, password=123, age=120, address=null]
18、 Controller:自定义视图解析器BeanNameViewResolver
@Controller @RequestMapping("/springmvc") public class Springmvc_test { @RequestMapping("/testView") public String testView(){ //去找HelloView这个类对象 return "helloView"; } }
HelloView:
@Component//把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="" class=""/>
public class HelloView implements View{
@Override
public String getContentType() {
return "text/html";
}
@Override
public void render(Map<String, ?> model, HttpServletRequest request,HttpServletResponse response) throws Exception {
response.getWriter().print("helloview time:"+new Date());
//可以是excel或是别的格式的输出
}
}
dispatchServlet-servlet.xml中添加:
<!-- 通过 order 属性来定义视图解析器的优先级, order 值越小优先级越高，InternalResourceViewResolver的order为最大值，所以定义了BeanNameViewResolver，
优先级就比InternalResourceViewResolver高-->
<bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
<property name="order" value="100"></property>
</bean>
view：
请求页面index.jsp:<a href="springmvc/testView">Test view</a>
页面输出：helloview time:Thu Aug 13 13:27:44 CST 2015
19、Controller:国际化
1、在页面上能够根据浏览器语言设置的情况对文本，时间，数值进行本地化处理
2、可以在bean中获得国际化资源文件Locale对应的消息
3、可以通过超链接切换Locale，而不在依赖于浏览器的语言设置情况
解决：1、使用JSTL的fmt标签
2、在bean中注入ResouceBundleMessageSource的示例，使用其对应的getMessageResource方法即可
3、配置LocalResolver和LocaleChangeInterceptor
@Controller @RequestMapping("/springmvc") public class Springmvc_test { @RequestMapping("/testRequestMapping") public String testView(){ return "success"; }
/*或不用在dispatchServlet-servlet.xml中添加ResourceBundleMessageSource
@Autowired
private ResourceBundleMessageSource messageSource
@RequestMapping("/testRequestMapping")
public String testView(Locale locale){
val=messageSource.getMessage("xxlong.username",null,locale)
System.out.println(val);
return "success";
}*/
}
src文件夹下添加：
1、xxlong_i18n_en_US:xxlong.username=username xxlong.password=password
2、xxlong_i18n_zh_CN:xxlong.username=用户名 xxlong.password=密码
dispatchServlet-servlet.xml中添加：
<!-- 配置国际化资源文件 如果JSP文件中使用了JSTL国际化标签的功能，则需要使用JSTLView视图类，
lib包下导入jstljar包就会使项目中的view自动变为jstlview -->
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basename" value="xxlong_i18n"></property>
</bean>
view：
请求页面index.jsp:<a href="springmvc/testRequestMapping=xxl">Test RequestMapping</a>
响应页面success.jsp:
导入jstljar包
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<fmt:message key="xxlong.username"></fmt:message><br>
<fmt:message key="xxlong.password"></fmt:message><br>
页面输出：浏览器设置为中文：用户名 密码
浏览器设置为英文：username password
不依赖浏览器语言设置的国际化
Controller：
@Controller
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping("/testHref")
public String testHref(){
return "success";
}
}
dispatchServer-servlet.xml中添加：
<!-- 默认情况下,SpringMVC 根据 Accept-Language 参数判断客户端的本地化类型。当接受到请求时,SpringMVC 会在上下文中查找一个本
地化解析器(LocalResolver),找到后使用它获取请求所对应的本地化类型信息
AcceptHeaderLocaleResolver:根据 HTTP 请求头的Accept-Language 参数确定本地化类型,如果没有显式定义本地化解析器, SpringMVC 使用该解析器。
CookieLocaleResolver:根据指定的 Cookie 值确定本地化类型
SessionLocaleResolver:根据 Session 中特定的属性确定本地化类型。在Controller中将提交上来的locale字段信息生成真正的Locale对象，然后将对象保存在
Session中，默认保存的ID是SessionLocaleResolver.LOCALE_SESSION_ATTRIBUTE_NAME
-->
<bean id="localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver"></bean>
<mvc:interceptors>
<!-- LocaleChangeInterceptor:从请求参数中获取本次请求对应的本地化类型。不论请求级别的国际化，还是Cookie级别的国际化，再或者Session级别的国际化，都 必须配置这个拦截器-->
<bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"></bean>
</mvc:interceptors>
views:
请求页面index.jsp:
<a href="springmvc/testHref?locale=zh_CN">Test 中文</a>===>页面显示中文
<a href="springmvc/testHref?locale=en_US">Test 英文</a>===>页面显示英文
20、Controller:不经过handler处理的请求
无
dispatchServlet-servlet.xml
<!-- 配置直接转发的页面 可以直接相应转发的页面, 而无需再经过 Handler 的方法.success转为/WEB-INF/views/success.jsp-->
<mvc:view-controller path="xxlong_success" view-name="success"/>
<!-- 在实际开发中通常都需配置 mvc:annotation-driven 标签,否则mvc:view-controller使得经过Handler的处理的请求出错
<mvc:annotation-driven /> 会自动注册RequestMappingHandlerMapping、RequestMappingHandlerAdapter 与ExceptionHandlerExceptionResolver 三个bean。
还将提供以下支持:
支持使用 ConversionService 实例对表单参数进行类型转换
支持使用 @NumberFormat annotation、@DateTimeFormat注解完成数据类型的格式化
支持使用 @Valid 注解对 JavaBean 实例进行 JSR 303 验证
支持使用 @RequestBody 和 @ResponseBody 注解
-->
<mvc:annotation-driven></mvc:annotation-driven>
浏览器地址：http://localhost:8080/springmvc_test/xxlong_success
返回success.jsp页面内容
21、Controller:重定向
@Controller
@SessionAttributes(value="user",types=String.class)
@RequestMapping("/springmvc")
public class Springmvc_test {
@RequestMapping("/testRedirect")
public String testRedirect(@RequestParam(value="username",required=false) String un,Map<String,Object> map){
map.put("username", un);
return "redirect:/xxlong_redirect";//==>http://localhost:8080/springmvc_test/xxlong_redirect
}
}
dispatchServlet-servlet.xml中添加：<mvc:view-controller path="xxlong_redirect" view-name="redirect" //==>/WEB-INF/views/redirect.jsp/>
view：
请求页面index.jsp:<a href="springmvc/testRedirect?username=xxlong">Test Redirect</a>
响应页面redirect.jsp:
request username:${requestScope.username }<br>
session username:${sessionScope.username }<br>
页面输出:
request username:
session username:xxlong