SpringMVC Controller介绍

原文来自http://elim.iteye.com/blog/1753271

SpringMVC Controller 介绍

一、简介

         在SpringMVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。在SpringMVC 中提供了一个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controller 标记一个类是Controller ，然后使用@RequestMapping 和@RequestParam 等一些注解用以定义URL 请求和Controller 方法之间的映射，这样的Controller 就能被外界访问到。此外Controller 不会直接依赖于HttpServletRequest 和HttpServletResponse 等HttpServlet 对象，它们可以通过Controller 的方法参数灵活的获取到。为了先对Controller 有一个初步的印象，以下先定义一个简单的Controller ：

Java代码  

1. @Controller  
2. public class MyController {  
3.   
4.     @RequestMapping ( "/showView" )  
5.     public ModelAndView showView() {  
6.        ModelAndView modelAndView = new ModelAndView();  
7.        modelAndView.setViewName( "viewName" );  
8.        modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );  
9.        return modelAndView;  
10.     }  
11.   
12. }   

 

在上面的示例中，@Controller 是标记在类MyController 上面的，所以类MyController 就是一个SpringMVC Controller 对象了，然后使用@RequestMapping(“/showView”) 标记在Controller 方法上，表示当请求/showView.do 的时候访问的是MyController 的showView 方法，该方法返回了一个包括Model 和View 的ModelAndView 对象。这些在后续都将会详细介绍。

二、使用 @Controller 定义一个 Controller 控制器

         @Controller 用于标记在一个类上，使用它标记的类就是一个SpringMVC Controller 对象。分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping 注解。@Controller 只是定义了一个控制器类，而使用@RequestMapping 注解的方法才是真正处理请求的处理器，这个接下来就会讲到。

   单单使用@Controller 标记在一个类上还不能真正意义上的说它就是SpringMVC 的一个控制器类，因为这个时候Spring 还不认识它。那么要如何做Spring 才能认识它呢？这个时候就需要我们把这个控制器类交给Spring 来管理。拿MyController 来举一个例子

 

Java代码  

1. @Controller  
2. public class MyController {  
3.     @RequestMapping ( "/showView" )  
4.     public ModelAndView showView() {  
5.        ModelAndView modelAndView = new ModelAndView();  
6.        modelAndView.setViewName( "viewName" );  
7.        modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );  
8.        return modelAndView;  
9.     }  
10.   
11. }   

 

这个时候有两种方式可以把MyController 交给Spring 管理，好让它能够识别我们标记的@Controller 。

   第一种方式是在SpringMVC 的配置文件中定义MyController 的bean 对象。

<bean class="com.host.app.web.controller.MyController"/>

   第二种方式是在SpringMVC 的配置文件中告诉Spring 该到哪里去找标记为@Controller 的Controller 控制器。

Xml代码  

1. < context:component-scan base-package = "com.host.app.web.controller" >  
2.    < context:exclude-filter type = "annotation"  
3.        expression = "org.springframework.stereotype.Service" />  
4. </ context:component-scan >   

    注：

       上面 context:exclude-filter 标注的是不扫描 @Service 标注的类

三、使用 @RequestMapping 来映射 Request 请求与处理器

         可以使用@RequestMapping 来映射URL 到控制器类，或者是到Controller 控制器的处理方法上。当@RequestMapping 标记在Controller 类上的时候，里面使用@RequestMapping 标记的方法的请求地址都是相对于类上的@RequestMapping 而言的；当Controller 类上没有标记@RequestMapping 注解时，方法上的@RequestMapping 都是绝对路径。这种绝对路径和相对路径所组合成的最终路径都是相对于根路径“/ ”而言的。

 

Java代码  

1. @Controller  
2. public class MyController {  
3.     @RequestMapping ( "/showView" )  
4.     public ModelAndView showView() {  
5.        ModelAndView modelAndView = new ModelAndView();  
6.        modelAndView.setViewName( "viewName" );  
7.        modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );  
8.        return modelAndView;  
9.     }  
10.   
11. }   

 

在这个控制器中，因为MyController 没有被@RequestMapping 标记，所以当需要访问到里面使用了@RequestMapping 标记的showView 方法时，就是使用的绝对路径/showView.do 请求就可以了。

 

Java代码  

1. @Controller  
2. @RequestMapping ( "/test" )  
3. public class MyController {  
4.     @RequestMapping ( "/showView" )  
5.     public ModelAndView showView() {  
6.        ModelAndView modelAndView = new ModelAndView();  
7.        modelAndView.setViewName( "viewName" );  
8.        modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );  
9.        return modelAndView;  
10.     }  
11.   
12. }   

 

   这种情况是在控制器上加了@RequestMapping 注解，所以当需要访问到里面使用了@RequestMapping 标记的方法showView() 的时候就需要使用showView 方法上@RequestMapping 相对于控制器MyController上@RequestMapping 的地址，即/test/showView.do 。

（一）使用 URI 模板

   URI 模板就是在URI 中给定一个变量，然后在映射的时候动态的给该变量赋值。如URI 模板http://localhost/app/{variable1}/index.html ，这个模板里面包含一个变量variable1 ，那么当我们请求http://localhost/app/hello/index.html 的时候，该URL 就跟模板相匹配，只是把模板中的variable1 用hello 来取代。在SpringMVC 中，这种取代模板中定义的变量的值也可以给处理器方法使用，这样我们就可以非常方便的实现URL 的RestFul 风格。这个变量在SpringMVC 中是使用@PathVariable 来标记的。

   在SpringMVC 中，我们可以使用@PathVariable 来标记一个Controller 的处理方法参数，表示该参数的值将使用URI 模板中对应的变量的值来赋值。

 

Java代码  

1. @Controller  
2. @RequestMapping ( "/test/{variable1}" )  
3. public class MyController {  
4.   
5.     @RequestMapping ( "/showView/{variable2}" )  
6.     public ModelAndView showView( @PathVariable String variable1, @PathVariable ( "variable2" ) int variable2) {  
7.        ModelAndView modelAndView = new ModelAndView();  
8.        modelAndView.setViewName( "viewName" );  
9.        modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );  
10.        return modelAndView;  
11.     }  
12. }   

 

   在上面的代码中我们定义了两个URI 变量，一个是控制器类上的variable1 ，一个是showView 方法上的variable2，然后在showView 方法的参数里面使用@PathVariable 标记使用了这两个变量。所以当我们使用/test/hello/showView/2.do 来请求的时候就可以访问到MyController 的showView 方法，这个时候variable1 就被赋予值hello ，variable2 就被赋予值2 ，然后我们在showView 方法参数里面标注了参数variable1 和variable2 是来自访问路径的path 变量，这样方法参数variable1 和variable2 就被分别赋予hello 和2 。方法参数variable1 是定义为String 类型，variable2 是定义为int 类型，像这种简单类型在进行赋值的时候Spring 是会帮我们自动转换的，关于复杂类型该如何来转换在后续内容中将会讲到。

   在上面的代码中我们可以看到在标记variable1 为path 变量的时候我们使用的是@PathVariable ，而在标记variable2 的时候使用的是@PathVariable(“variable2”) 。这两者有什么区别呢？第一种情况就默认去URI 模板中找跟参数名相同的变量，但是这种情况只有在使用debug 模式进行编译的时候才可以，而第二种情况是明确规定使用的就是URI 模板中的variable2 变量。当不是使用debug 模式进行编译，或者是所需要使用的变量名跟参数名不相同的时候，就要使用第二种方式明确指出使用的是URI 模板中的哪个变量。

   除了在请求路径中使用URI 模板，定义变量之外，@RequestMapping 中还支持通配符“* ”。如下面的代码我就可以使用/myTest/whatever/wildcard.do 访问到Controller 的testWildcard 方法。

 

Java代码  

1. @Controller  
2. @RequestMapping ( "/myTest" )  
3. public class MyController {  
4.     @RequestMapping ( "*/wildcard" )  
5.     public String testWildcard() {  
6.        System. out .println( "wildcard------------" );  
7.        return "wildcard" ;  
8.     }    
9. }   

 

（二）使用 @RequestParam 绑定 HttpServletRequest 请求参数到控制器方法参数

 

Java代码  

1. @RequestMapping ( "requestParam" )  
2. ublic String testRequestParam( @RequestParam(required=false) String name, @RequestParam ( "age" ) int age) {  
3.    return "requestParam" ;  
4. }   

 

在上面代码中利用@RequestParam 从HttpServletRequest 中绑定了参数name 到控制器方法参数name ，绑定了参数age 到控制器方法参数age 。值得注意的是和@PathVariable 一样，当你没有明确指定从request 中取哪个参数时，Spring 在代码是debug 编译的情况下会默认取更方法参数同名的参数，如果不是debug 编译的就会报错。此外，当需要从request 中绑定的参数和方法的参数名不相同的时候，也需要在@RequestParam 中明确指出是要绑定哪个参数。在上面的代码中如果我访问/requestParam.do?name=hello&age=1 则Spring 将会把request请求参数name 的值hello 赋给对应的处理方法参数name ，把参数age 的值1 赋给对应的处理方法参数age 。

在@RequestParam 中除了指定绑定哪个参数的属性value 之外，还有一个属性required ，它表示所指定的参数是否必须在request 属性中存在，默认是true ，表示必须存在，当不存在时就会报错。在上面代码中我们指定了参数name 的required 的属性为false ，而没有指定age 的required 属性，这时候如果我们访问/requestParam.do而没有传递参数的时候，系统就会抛出异常，因为age 参数是必须存在的，而我们没有指定。而如果我们访问/requestParam.do?age=1 的时候就可以正常访问，因为我们传递了必须的参数age ，而参数name 是非必须的，不传递也可以。

（三）使用 @CookieValue 绑定 cookie 的值到 Controller 方法参数

 

Java代码  

1. @RequestMapping ( "cookieValue" )  
2. public String testCookieValue( @CookieValue ( "hello" ) String cookieValue, @CookieValue String hello) {  
3.    System. out .println(cookieValue + "-----------" + hello);  
4.    return "cookieValue" ;  
5. }   

 

    在上面的代码中我们使用@CookieValue 绑定了cookie 的值到方法参数上。上面一共绑定了两个参数，一个是明确指定要绑定的是名称为hello 的cookie 的值，一个是没有指定。使用没有指定的形式的规则和@PathVariable、@RequestParam 的规则是一样的，即在debug 编译模式下将自动获取跟方法参数名同名的cookie 值。

（四）使用 @RequestHeader 注解绑定 HttpServletRequest 头信息到Controller 方法参数

 

Java代码  

1. @RequestMapping ( "testRequestHeader" )  
2. public String testRequestHeader( @RequestHeader ( "Host" ) String hostAddr, @RequestHeader String Host, @RequestHeader String host ) {  
3.     System. out .println(hostAddr + "-----" + Host + "-----" + host );  
4.     return "requestHeader" ;  
5. }   

 

         在上面的代码中我们使用了 @RequestHeader 绑定了 HttpServletRequest 请求头 host 到Controller 的方法参数。上面方法的三个参数都将会赋予同一个值，由此我们可以知道在绑定请求头参数到方法参数的时候规则和 @PathVariable 、 @RequestParam 以及 @CookieValue 是一样的，即没有指定绑定哪个参数到方法参数的时候，在 debug 编译模式下将使用方法参数名作为需要绑定的参数。但是有一点 @RequestHeader 跟另外三种绑定方式是不一样的，那就是在使用 @RequestHeader 的时候是大小写不敏感的，即 @RequestHeader(“Host”) 和 @RequestHeader(“host”) 绑定的都是Host 头信息。记住在 @PathVariable 、 @RequestParam 和 @CookieValue 中都是大小写敏感的。

（五） @RequestMapping 的一些高级应用

         在RequestMapping 中除了指定请求路径value 属性外，还有其他的属性可以指定，如params 、method 和headers 。这样属性都可以用于缩小请求的映射范围。

 

1.params属性

 

   params 属性用于指定请求参数的，先看以下代码。

 

Java代码  

1. @RequestMapping (value= "testParams" , params={ "param1=value1" , "param2" , "!param3" })  
2. public String testParams() {  
3.    System. out .println( "test Params..........." );  
4.    return "testParams" ;  
5. }   

 

   在上面的代码中我们用@RequestMapping 的params 属性指定了三个参数，这些参数都是针对请求参数而言的，它们分别表示参数param1 的值必须等于value1 ，参数param2 必须存在，值无所谓，参数param3 必须不存在，只有当请求/testParams.do 并且满足指定的三个参数条件的时候才能访问到该方法。所以当请求/testParams.do?param1=value1&param2=value2 的时候能够正确访问到该testParams 方法，当请求/testParams.do?param1=value1&param2=value2&param3=value3 的时候就不能够正常的访问到该方法，因为在@RequestMapping 的params 参数里面指定了参数param3 是不能存在的。

 

2.method属性

 

   method 属性主要是用于限制能够访问的方法类型的。

 

Java代码  

1. @RequestMapping (value= "testMethod" , method={RequestMethod. GET , RequestMethod. DELETE })  
2. public String testMethod() {  
3.    return "method" ;  
4. }   

 

在上面的代码中就使用method 参数限制了以GET 或DELETE 方法请求/testMethod.do 的时候才能访问到该Controller 的testMethod 方法。

 

3.headers属性

 

         使用headers 属性可以通过请求头信息来缩小@RequestMapping 的映射范围。

 

Java代码  

1. @RequestMapping (value= "testHeaders" , headers={ "host=localhost" , "Accept" })  
2. public String testHeaders() {  
3.    return "headers" ;  
4. }   

 

   headers 属性的用法和功能与params 属性相似。在上面的代码中当请求/testHeaders.do 的时候只有当请求头包含Accept 信息，且请求的host 为localhost 的时候才能正确的访问到testHeaders 方法。

（六）以 @RequestMapping 标记的处理器方法支持的方法参数和返回类型

1. 支持的方法参数类型

         （1 ）HttpServlet 对象，主要包括HttpServletRequest 、HttpServletResponse 和HttpSession 对象。 这些参数Spring 在调用处理器方法的时候会自动给它们赋值，所以当在处理器方法中需要使用到这些对象的时候，可以直接在方法上给定一个方法参数的申明，然后在方法体里面直接用就可以了。但是有一点需要注意的是在使用HttpSession 对象的时候，如果此时HttpSession 对象还没有建立起来的话就会有问题。

   （2 ）Spring 自己的WebRequest 对象。 使用该对象可以访问到存放在HttpServletRequest 和HttpSession中的属性值。

   （3 ）InputStream 、OutputStream 、Reader 和Writer 。 InputStream 和Reader 是针对HttpServletRequest 而言的，可以从里面取数据；OutputStream 和Writer 是针对HttpServletResponse 而言的，可以往里面写数据。

   （4 ）使用@PathVariable 、@RequestParam 、@CookieValue 和@RequestHeader 标记的参数。

   （5 ）使用@ModelAttribute 标记的参数。

   （6 ）java.util.Map 、Spring 封装的Model 和ModelMap 。 这些都可以用来封装模型数据，用来给视图做展示。

   （7 ）实体类。 可以用来接收上传的参数。

   （8 ）Spring 封装的MultipartFile 。 用来接收上传文件的。

   （9 ）Spring 封装的Errors 和BindingResult 对象。 这两个对象参数必须紧接在需要验证的实体对象参数之后，它里面包含了实体对象的验证结果。

2. 支持的返回类型

         （1 ）一个包含模型和视图的ModelAndView 对象。

   （2 ）一个模型对象，这主要包括Spring 封装好的Model 和ModelMap ，以及java.util.Map ，当没有视图返回的时候视图名称将由RequestToViewNameTranslator 来决定。

   （3 ）一个View 对象。这个时候如果在渲染视图的过程中模型的话就可以给处理器方法定义一个模型参数，然后在方法体里面往模型中添加值。

   （4 ）一个String 字符串。这往往代表的是一个视图名称。这个时候如果需要在渲染视图的过程中需要模型的话就可以给处理器方法一个模型参数，然后在方法体里面往模型中添加值就可以了。

   （5 ）返回值是void 。这种情况一般是我们直接把返回结果写到HttpServletResponse 中了，如果没有写的话，那么Spring 将会利用RequestToViewNameTranslator 来返回一个对应的视图名称。如果视图中需要模型的话，处理方法与返回字符串的情况相同。

   （6 ）如果处理器方法被注解@ResponseBody 标记的话，那么处理器方法的任何返回类型都会通过HttpMessageConverters 转换之后写到HttpServletResponse 中，而不会像上面的那些情况一样当做视图或者模型来处理。

   （7 ）除以上几种情况之外的其他任何返回类型都会被当做模型中的一个属性来处理，而返回的视图还是由RequestToViewNameTranslator 来决定，添加到模型中的属性名称可以在该方法上用@ModelAttribute(“attributeName”) 来定义，否则将使用返回类型的类名称的首字母小写形式来表示。使用@ModelAttribute 标记的方法会在@RequestMapping 标记的方法执行之前执行。

（七）使用 @ModelAttribute 和 @SessionAttributes 传递和保存数据

       SpringMVC 支持使用 @ModelAttribute 和 @SessionAttributes 在不同的模型和控制器之间共享数据。 @ModelAttribute 主要有两种使用方式，一种是标注在方法上，一种是标注在 Controller方法参数上。

当 @ModelAttribute 标记在方法上的时候，该方法将在处理器方法执行之前执行，然后把返回的对象存放在 session 或模型属性中，属性名称可以使用 @ModelAttribute(“attributeName”) 在标记方法的时候指定，若未指定，则使用返回类型的类名称（首字母小写）作为属性名称。关于 @ModelAttribute 标记在方法上时对应的属性是存放在 session 中还是存放在模型中，我们来做一个实验，看下面一段代码。

 

Java代码  

1. @Controller  
2. @RequestMapping ( "/myTest" )  
3. public class MyController {  
4.   
5.     @ModelAttribute ( "hello" )  
6.     public String getModel() {  
7.        System. out .println( "-------------Hello---------" );  
8.        return "world" ;  
9.     }  
10.   
11.     @ModelAttribute ( "intValue" )  
12.     public int getInteger() {  
13.        System. out .println( "-------------intValue---------------" );  
14.        return 10;  
15.     }  
16.   
17.     @RequestMapping ( "sayHello" )  
18.     public void sayHello( @ModelAttribute ( "hello" ) String hello, @ModelAttribute ( "intValue" ) int num, @ModelAttribute ( "user2" ) User user, Writer writer, HttpSession session) throws IOException {  
19.        writer.write( "Hello " + hello + " , Hello " + user.getUsername() + num);  
20.        writer.write( "\r" );  
21.        Enumeration enume = session.getAttributeNames();  
22.        while (enume.hasMoreElements())  
23.            writer.write(enume.nextElement() + "\r" );  
24.     }  
25.   
26.     @ModelAttribute ( "user2" )  
27.     public User getUser() {  
28.        System. out .println( "---------getUser-------------" );  
29.        return new User(3, "user2" );  
30.     }  
31. }   

 

当我们请求 /myTest/sayHello.do 的时候使用 @ModelAttribute 标记的方法会先执行，然后把它们返回的对象存放到模型中。最终访问到 sayHello 方法的时候，使用 @ModelAttribute 标记的方法参数都能被正确的注入值。执行结果如下图所示：

       由执行结果我们可以看出来，此时 session 中没有包含任何属性，也就是说上面的那些对象都是存放在模型属性中，而不是存放在 session 属性中。那要如何才能存放在 session 属性中呢？这个时候我们先引入一个新的概念 @SessionAttributes ，它的用法会在讲完 @ModelAttribute 之后介绍，这里我们就先拿来用一下。我们在 MyController 类上加上 @SessionAttributes 属性标记哪些是需要存放到 session中的。看下面的代码：

 

Java代码  

1. @Controller  
2. @RequestMapping ( "/myTest" )  
3. @SessionAttributes (value={ "intValue" , "stringValue" }, types={User. class })  
4. public class MyController {  
5.   
6.     @ModelAttribute ( "hello" )  
7.     public String getModel() {  
8.        System. out .println( "-------------Hello---------" );  
9.        return "world" ;  
10.     }  
11.   
12.     @ModelAttribute ( "intValue" )  
13.     public int getInteger() {  
14.        System. out .println( "-------------intValue---------------" );  
15.        return 10;  
16.     }  
17.      
18.     @RequestMapping ( "sayHello" )  
19.     public void sayHello(Map<String, Object> map, @ModelAttribute ( "hello" ) String hello, @ModelAttribute ( "intValue" ) int num, @ModelAttribute ( "user2" ) User user, Writer writer, HttpServletRequest request) throws IOException {  
20.        map.put( "stringValue" , "String" );  
21.        writer.write( "Hello " + hello + " , Hello " + user.getUsername() + num);  
22.        writer.write( "\r" );  
23.        HttpSession session = request.getSession();  
24.        Enumeration enume = session.getAttributeNames();  
25.        while (enume.hasMoreElements())  
26.            writer.write(enume.nextElement() + "\r" );  
27.        System. out .println(session);  
28.     }  
29.   
30.     @ModelAttribute ( "user2" )  
31.     public User getUser() {  
32.        System. out .println( "---------getUser-------------" );  
33.        return new User(3, "user2" );  
34.     }  
35. }   

 

       在上面代码中我们指定了属性为 intValue 或 stringValue 或者类型为 User 的都会放到 Session中，利用上面的代码当我们访问 /myTest/sayHello.do 的时候，结果如下：

       仍然没有打印出任何 session 属性，这是怎么回事呢？怎么定义了把模型中属性名为 intValue 的对象和类型为 User 的对象存到 session 中，而实际上没有加进去呢？难道我们错啦？我们当然没有错，只是在第一次访问 /myTest/sayHello.do 的时候 @SessionAttributes 定义了需要存放到 session 中的属性，而且这个模型中也有对应的属性，但是这个时候还没有加到 session 中，所以 session 中不会有任何属性，等处理器方法执行完成后 Spring 才会把模型中对应的属性添加到 session 中。所以当请求第二次的时候就会出现如下结果：

当 @ModelAttribute 标记在处理器方法参数上的时候，表示该参数的值将从模型或者 Session 中取对应名称的属性值，该名称可以通过 @ModelAttribute(“attributeName”) 来指定，若未指定，则使用参数类型的类名称（首字母小写）作为属性名称。

 

Java代码  

1. @Controller  
2. @RequestMapping ( "/myTest" )  
3. public class MyController {  
4.   
5.     @ModelAttribute ( "hello" )  
6.     public String getModel() {  
7.        return "world" ;  
8.     }  
9.   
10.     @RequestMapping ( "sayHello" )  
11.     public void sayHello( @ModelAttribute ( "hello" ) String hello, Writer writer) throws IOException {  
12.        writer.write( "Hello " + hello);  
13.     }     
14. }   

 

在上面代码中，当我们请求/myTest/sayHello.do 的时候，由于MyController 中的方法getModel 使用了注解@ModelAttribute 进行标记，所以在执行请求方法sayHello 之前会先执行getModel 方法，这个时候getModel 方法返回一个字符串world 并把它以属性名hello 保存在模型中，接下来访问请求方法sayHello 的时候，该方法的hello参数使用@ModelAttribute(“hello”) 进行标记，这意味着将从session 或者模型中取属性名称为hello 的属性值赋给hello 参数，所以这里hello 参数将被赋予值world ，所以请求完成后将会在页面上看到Hello world 字符串。

@SessionAttributes 用于标记需要在Session 中使用到的数据，包括从Session 中取数据和存数据。@SessionAttributes 一般是标记在Controller 类上的，可以通过名称、类型或者名称加类型的形式来指定哪些属性是需要存放在session 中的。

 

Java代码  

1. @Controller  
2. @RequestMapping ( "/myTest" )  
3. @SessionAttributes (value={ "user1" , "blog1" }, types={User. class , Blog. class })  
4. public class MyController {  
5.   
6.     @RequestMapping ( "setSessionAttribute" )  
7.     public void setSessionAttribute(Map<String, Object> map, Writer writer) throws IOException {  
8.        User user = new User(1, "user" );  
9.        User user1 = new User(2, "user1" );  
10.        Blog blog = new Blog(1, "blog" );  
11.        Blog blog1 = new Blog(2, "blog1" );  
12.        map.put( "user" , user);  
13.        map.put( "user1" , user1);  
14.        map.put( "blog" , blog);  
15.        map.put( "blog1" , blog1);  
16.        writer.write( "over." );  
17.     }  
18.   
19.    
20.   
21.     @RequestMapping ( "useSessionAttribute" )  
22.     public void useSessionAttribute(Writer writer, @ModelAttribute ( "user1" ) User user1, @ModelAttribute ( "blog1" ) Blog blog1) throws IOException {  
23.        writer.write(user1.getId() + "--------" + user1.getUsername());  
24.        writer.write( "\r" );  
25.        writer.write(blog1.getId() + "--------" + blog1.getTitle());  
26.     }  
27.   
28.     @RequestMapping ( "useSessionAttribute2" )  
29.     public void useSessionAttribute(Writer writer, @ModelAttribute ( "user1" ) User user1, @ModelAttribute ( "blog1" ) Blog blog1, @ModelAttribute User user, HttpSession session) throws IOException {  
30.        writer.write(user1.getId() + "--------" + user1.getUsername());  
31.        writer.write( "\r" );  
32.        writer.write(blog1.getId() + "--------" + blog1.getTitle());  
33.        writer.write( "\r" );  
34.        writer.write(user.getId() + "---------" + user.getUsername());  
35.        writer.write( "\r" );  
36.        Enumeration enume = session.getAttributeNames();  
37.        while (enume.hasMoreElements())  
38.            writer.write(enume.nextElement() + " \r" );  
39.     }  
40.   
41.     @RequestMapping ( "useSessionAttribute3" )  
42.     public void useSessionAttribute( @ModelAttribute ( "user2" ) User user) {  
43.   
44.     }  
45. }   

 

   在上面代码中我们可以看到在MyController 上面使用了@SessionAttributes 标记了需要使用到的Session 属性。可以通过名称和类型指定需要存放到Session 中的属性，对应@SessionAttributes 注解的value 和types 属性。当使用的是types 属性的时候，那么使用的Session 属性名称将会是对应类型的名称（首字母小写）。当value 和types 两个属性都使用到了的时候，这时候取的是它们的并集，而不是交集，所以上面代码中指定要存放在Session 中的属性有名称为user1 或blog1 的对象，或类型为User 或Blog 的对象。在上面代码中我们首先访问/myTest/setSessionAttribute.do ，该请求将会请求到MyController 的setSessionAttribute 方法，在该方法中，我们往模型里面添加了user 、user1 、blog 和blog1 四个属性，因为它们或跟类上的@SessionAttributes 定义的需要存到session 中的属性名称相同或类型相同，所以在请求完成后这四个属性都将添加到session 属性中。接下来访问/myTest/useSessionAttribute.do ，该请求将会请求MyController 的useSessionAttribute(Writer writer, @ModelAttribute(“user1”) User user1, @ModelAttribute(“blog1”) Blog blog) 方法，该方法参数中用@ModelAttribute 指定了参数user1 和参数blog1 是需要从session 或模型中绑定的，恰好这个时候session 中已经有了这两个属性，所以这个时候在方法执行之前会先绑定这两个参数。执行结果如下图所示：

   接下来访问/myTest/useSessionAttribute2.do ，这个时候请求的是上面代码中对应的第二个useSessionAttribute方法，方法参数user 、user1 和blog1 用@ModelAttribute 声明了需要session 或模型属性注入，我们知道在请求/myTest/setSessionAttribute.do 的时候这些属性都已经添加到了session 中，所以该请求的结果会如下图所示：

   接下来访问/myTest/useSessionAttribute3.do ，这个时候请求的是上面代码中对应的第三个useSessionAttribute方法，我们可以看到该方法的方法参数user 使用了@ModelAttribute(“user2”) 进行标记，表示user 需要session中的user2 属性来注入，但是这个时候我们知道session 中是不存在user2 属性的，所以这个时候就会报错了。执行结果如图所示：

（八）定制自己的类型转换器

         在通过处理器方法参数接收 request 请求参数绑定数据的时候，对于一些简单的数据类型 Spring 会帮我们自动进行类型转换，而对于一些复杂的类型由于 Spring 没法识别，所以也就不能帮助我们进行自动转换了，这个时候如果我们需要 Spring 来帮我们自动转换的话就需要我们给 Spring 注册一个对特定类型的识别转换器。 Spring 允许我们提供两种类型的识别转换器，一种是注册在 Controller 中的，一种是注册在SpringMVC 的配置文件中。聪明的读者看到这里应该可以想到它们的区别了，定义在 Controller 中的是局部的，只在当前 Controller 中有效，而放在 SpringMVC 配置文件中的是全局的，所有 Controller 都可以拿来使用。

1. 在 @InitBinder 标记的方法中定义局部的类型转换器

         我们可以使用 @InitBinder 注解标注在 Controller 方法上，然后在方法体里面注册数据绑定的转换器，这主要是通过 WebDataBinder 进行的。我们可以给需要注册数据绑定的转换器的方法一个WebDataBinder 参数，然后给该方法加上 @InitBinder 注解，这样当该 Controller 中在处理请求方法时如果发现有不能解析的对象的时候，就会看该类中是否有使用 @InitBinder 标记的方法，如果有就会执行该方法，然后看里面定义的类型转换器是否与当前需要的类型匹配。

 

Java代码  

1. @Controller  
2. @RequestMapping ( "/myTest" )  
3. public class MyController {  
4.   
5.     @InitBinder  
6.     public void dataBinder(WebDataBinder binder) {  
7.        DateFormat dateFormat = new SimpleDateFormat( "yyyyMMdd" );  
8.        PropertyEditor propertyEditor = new CustomDateEditor(dateFormat, true ); // 第二个参数表示是否允许为空  
9.        binder.registerCustomEditor(Date. class , propertyEditor);  
10.     }  
11.   
12.     @RequestMapping ( "dataBinder/{date}" )  
13.     public void testDate( @PathVariable Date date, Writer writer) throws IOException {  
14.        writer.write(String.valueOf (date.getTime()));  
15.     }  
16.   
17. }   

 

       在上面的代码中当我们请求 /myTest/dataBinder/20121212.do 的时候， Spring 就会利用@InitBinder 标记的方法里面定义的类型转换器把字符串 20121212 转换为一个 Date 对象。这样定义的类型转换器是局部的类型转换器，一旦出了这个 Controller 就不会再起作用。类型转换器是通过WebDataBinder 对象的 registerCustomEditor 方法来注册的，要实现自己的类型转换器就要实现自己的 PropertyEditor 对象。 Spring 已经给我们提供了一些常用的属性编辑器，如CustomDateEditor 、 CustomBooleanEditor 等。

       PropertyEditor 是一个接口，要实现自己的 PropertyEditor 类我们可以实现这个接口，然后实现里面的方法。但是 PropertyEditor 里面定义的方法太多了，这样做比较麻烦。在 java 中有一个封装类是实现了 PropertyEditor 接口的，它是 PropertyEditorSupport 类。所以如果需要实现自己的PropertyEditor 的时候只需要继承 PropertyEditorSupport 类，然后重写其中的一些方法。一般就是重写 setAsText 和 getAsText 方法就可以了， setAsText 方法是用于把字符串类型的值转换为对应的对象的，而 getAsText 方法是用于把对象当做字符串来返回的。在 setAsText 中我们一般先把字符串类型的对象转为特定的对象，然后利用 PropertyEditor 的 setValue 方法设定转换后的值。在 getAsText 方法中一般先使用 getValue 方法取代当前的对象，然后把它转换为字符串后再返回给 getAsText 方法。下面是一个示例：

 

Java代码  

1. @InitBinder  
2. public void dataBinder(WebDataBinder binder) {  
3.    // 定义一个 User 属性编辑器  
4.    PropertyEditor userEditor = new PropertyEditorSupport() {  
5.   
6.        @Override  
7.        public String getAsText() {  
8.           // TODO Auto-generated method stub  
9.           User user = (User) getValue();  
10.           return user.getUsername();  
11.        }  
12.   
13.        @Override  
14.        public void setAsText(String userStr) throws IllegalArgumentException {  
15.           // TODO Auto-generated method stub  
16.           User user = new User(1, userStr);  
17.           setValue(user);  
18.        }  
19.    };  
20.    // 使用 WebDataBinder 注册 User 类型的属性编辑器  
21.    binder.registerCustomEditor(User. class , userEditor);  
22. }   

 

   

2. 实现 WebBindingInitializer 接口定义全局的类型转换器

       如果需要定义全局的类型转换器就需要实现自己的 WebBindingInitializer 对象，然后把该对象注入到AnnotationMethodHandlerAdapter 中，这样 Spring 在遇到自己不能解析的对象的时候就会到全局的 WebBindingInitializer 的 initBinder 方法中去找，每次遇到不认识的对象时， initBinder 方法都会被执行一遍。

 

Java代码  

1. public class MyWebBindingInitializer implements WebBindingInitializer {  
2.   
3.     @Override  
4.     public void initBinder(WebDataBinder binder, WebRequest request) {  
5.        // TODO Auto-generated method stub  
6.        DateFormat dateFormat = new SimpleDateFormat( "yyyyMMdd" );  
7.        PropertyEditor propertyEditor = new CustomDateEditor(dateFormat, true );  
8.        binder.registerCustomEditor(Date. class , propertyEditor);  
9.     }  
10.   
11. }   

 

定义了这么一个 WebBindingInitializer 对象之后 Spring 还是不能识别其中指定的对象，这是因为我们只是定义了 WebBindingInitializer 对象，还没有把它交给 Spring ， Spring 不知道该去哪里找解析器。要让 Spring 能够识别还需要我们在 SpringMVC 的配置文件中定义一个AnnotationMethodHandlerAdapter 类型的 bean 对象，然后利用自己定义的WebBindingInitializer 覆盖它的默认属性 webBindingInitializer 。

 

Xml代码  

1. < bean class = "org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" >  
2.    < property name = "webBindingInitializer" >  
3.        < bean class = "com.host.app.web.util.MyWebBindingInitializer" />  
4.    </ property >  
5. </ bean >   

 

3.触发数据绑定方法的时间

当Controller处理器方法参数使用@RequestParam、@PathVariable、@RequestHeader、@CookieValue和@ModelAttribute标记的时候都会触发initBinder方法的执行，这包括使用WebBindingInitializer定义的全局方法和在Controller中使用@InitBinder标记的局部方法。而且每个使用了这几个注解标记的参数都会触发一次initBinder方法的执行，这也意味着有几个参数使用了上述注解就会触发几次initBinder方法的执行。