SpringMVC Controller介绍

SpringMVC Controller 介绍

1、简介

         在SpringMVC 中，控制器Controller 负责处理由DispatcherServlet 分发的要求，它把用户要求的数据经过业务处理层处理以后封装成1个Model ，然后再把该Model 返回给对应的View 进行展现。在SpringMVC 中提供了1个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controller 标记1个类是Controller ，然后使用@RequestMapping 和@RequestParam 等1些注解用以定义URL 要求和Controller 方法之间的映照，这样的Controller 就可以被外界访问到。另外Controller 不会直接依赖于HttpServletRequest和HttpServletResponse 等HttpServlet 对象，它们可以通过Controller 的方法参数灵活的获得到。为了先对Controller 有1个初步的印象，以下先定义1个简单的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 中的属性名称 " , " 对应的属性值，它是1个对象 " );  
9.        return modelAndView;  
10.     }  
11.   
12. }   

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

2、使用 @Controller 定义1个 Controller 控制器

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

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

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 中的属性名称 " , " 对应的属性值，它是1个对象 " );  
8.        return modelAndView;  
9.     }  
10.   
11. }   

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

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

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

   第2种方式是在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 标注的类

3、使用 @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 中的属性名称 " , " 对应的属性值，它是1个对象 " );  
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 中的属性名称 " , " 对应的属性值，它是1个对象 " );  
9.        return modelAndView;  
10.     }  
11.   
12. }   

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

（1）使用 URI 模板

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

   在SpringMVC 中，我们可使用@PathVariable 来标记1个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 中的属性名称 " , " 对应的属性值，它是1个对象 " );  
10.        return modelAndView;  
11.     }  
12. }   

   在上面的代码中我们定义了两个URI 变量，1个是控制器类上的variable1 ，1个是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”) 。这二者有甚么区分呢？第1种情况就默许去URI 模板中找跟参数名相同的变量，但是这类情况只有在使用debug 模式进行编译的时候才可以，而第2种情况是明确规定使用的就是URI 模板中的variable2 变量。当不是使用debug 模式进行编译，或是所需要使用的变量名跟参数名不相同的时候，就要使用第2种方式明确指出使用的是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. }   

（2）使用 @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 1样，当你没有明确指定从request 中取哪一个参数时，Spring 在代码是debug 编译的情况下会默许取更方法参数同名的参数，如果不是debug 编译的就会报错。另外，当需要从request 中绑定的参数和方法的参数名不相同的时候，也需要在@RequestParam 中明确指出是要绑定哪一个参数。在上面的代码中如果我访问/requestParam.do?name=hello&age=1 则Spring 将会把request要求参数name 的值hello 赋给对应的处理方法参数name ，把参数age 的值1 赋给对应的处理方法参数age 。

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

（3）使用 @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 的值到方法参数上。上面1共绑定了两个参数，1个是明确指定要绑定的是名称为hello 的cookie 的值，1个是没有指定。使用没有指定的情势的规则和@PathVariable、@RequestParam 的规则是1样的，即在debug 编译模式下将自动获得跟方法参数名同名的cookie 值。

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

（5） @RequestMapping 的1些高级利用

         在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 属性指定了3个参数，这些参数都是针对要求参数而言的，它们分别表示参数param1 的值必须等于value1 ，参数param2 必须存在，值无所谓，参数param3 必须不存在，只有当要求/testParams.do 并且满足指定的3个参数条件的时候才能访问到该方法。所以当要求/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 方法。

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

1. 支持的方法参数类型

         （1 ）HttpServlet 对象，主要包括HttpServletRequest 、HttpServletResponse 和HttpSession 对象。 这些参数Spring 在调用途理器方法的时候会自动给它们赋值，所以当在处理器方法中需要使用到这些对象的时候，可以直接在方法上给定1个方法参数的申明，然后在方法体里面直接用就能够了。但是有1点需要注意的是在使用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 对象。 这两个对象参数必须紧接在需要验证

生活不易，码农辛苦
如果您觉得本网站对您的学习有所帮助,可以手机扫描二维码进行捐赠