SpringMVC Controller 介绍

如何实现chrome谷歌浏览器多开(独立环境 独立cookie) 由于各种各样的原因,你可能需要在一个电脑登录某个平台,比如一个电脑登录3个公众号,或者3个知乎等等。最简单的方案是,直接安装3个不同的浏览器,比如一个谷歌浏览器,一个火狐浏览器,一个 Edge 浏览器。这个方案也能解决,但如果想多开10个呢?安装10个不同的浏览器也能解决,但感觉这样比较复杂,另外一方面安装太多的应用,会导致电脑卡顿。这里给大家介绍,我在 Win 和 Mac 系统下的躲开解决方案。Win 系统下的解决方案最为简单,原理就是给不同的谷歌浏览器,指向不同的用户存储路径即可。 阅读详情

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

一、简介

         在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方法的执行。

若依框架二次开发——RuoYi-AI 本地部署流程 阅读详情

相关推荐

FPGA篮球计分器:从需求分析到模块化实现的实战指南

本文详细介绍了FPGA篮球计分器的设计与实现,涵盖需求分析、模块化设计及实战调试。重点解析了24秒精确倒计时、12分钟比赛计时、比分统计和数码管显示等核心模块的Verilog实现,提供了按键消抖、状态机设计和BCD码处理等关键技术细节,帮助开发者掌握FPGA数字系统设计方法。

sql99的博客 220

SpringMVC之控制器(二)

SpringMVC之控制器1.控制器Controller2.实现Controller接口3.使用注解@Controller 1.控制器Controller 控制器复杂提供访问应用程序的行为,通常通过接口定义或注解定义两种方法实现。 控制器负责解析用户的请求并将其转换为一个模型。 在Spring MVC中一个控制器类可以包含多个方法 在Spring MVC中,对于Controller的配置方式有很多种 2.实现Controller接口 Controller是一个接口,在org.sprin

qq_50231389的博客 3162

无人机航拍实战:如何用Python代码精准计算目标地理坐标(附完整代码)

本文详细介绍了如何利用Python代码实现无人机航拍图像中目标点的精准地理位置计算。通过解析从像素坐标系到WGS84大地坐标系的完整转换链条,结合相机内参、无人机姿态与地球曲率处理,提供了可直接运行的实战代码,并重点分析了地理位置计算中的常见误差来源与应对策略,助力开发者解决实际项目中的定位漂移问题。

hh234的博客 359

SpringMVC之六:Controller详细介绍

一、简介 在SpringMVC中,控制器Controller负责处理由DispatcherServlet分发的请求,它把用户请求的数据经过业务处理层处理之后封装成一个Model,然后再把该Model返回给对应的View进行展示。在SpringMVC中提供了一个非常简便的定义Controller的方法,你无需继承特定的类或实现特定的接口,只需使用@Controller标记一个类是Controller,然后使用@RequestMapping和@RequestParam...

weixin_42073629的博客 2453

基于Java+SpringBoot+Vue的中小企业设备管理系统的设计与开发(源码+lw+部署文档+讲解等)

💗博主介绍:✌新人博主,工作经验两年+、专注于Java、小程序技术领域和毕业项目实战✌💗🌟文末获取源码+数据库🌟

2301_76502068的博客 1385

Vivado2019.1 ZYNQ7020无Uart SDK调试打印调试信息xil_printf

Vivado2019.1 ZYNQ7020无Uart SDK调试打印调试信息xil_printf

泛红尘的博客 2998

SpringMVC Controller介绍

SpringMVC Controller介绍     来自 http://haohaoxuexi.iteye.com/blog/1753271   博客分类:  SpringMVC SpringMVCModelAttributeSessionAttributesControllerRequestMapping    SpringMVC Controller...

Hi, Sun 825

1、硬件工程师笔面试真题汇总(2025版本)

答:按照使用习惯,电源指示灯用红色,信号指示灯用绿色这两种颜色的LED 灯技术最成熟,价格最便宜通孔是贯穿整个PCB 的过孔盲孔是从PCB 表层连接到内层的过孔埋孔是埋在PCB 内层的过孔。大多数PCB厂家的加工能力是这样的:大于等于8mil 的过孔可以做机械孔小于等于6mil 的过孔需要做激光孔对小于等于6mil 的微型孔,在钻孔空间不够时,允许一部分过打在PCB 焊盘上。

XU157303764的博客 2万+

spring mvc controller实现原理

讲解spring mvc controller实现原理,以及如果自定义不同注解来简化写各种配置

大鸡腿的博客 2042

HyperLynx(十九)DDR(二)DDR的地址仿真

(5)设置水平标尺为2ns/div,垂直标尺为500mV/div,如果有必要,可以通过多次仿真,得到一个更加理想的结果。此外,还可以看到信号在高低电平切换时,反射波形基本趋于平缓,许多大的反射切换边缘已减小,这给了我们更大的定时裕量。如果这些DIMM是缓冲过的,则4个DIMM通道是可行的,但因为这是一个无缓冲DIMM,(20)在编辑传输线对话框中,选择“Values”选项卡,改变传输线长度为3in,具体设置如图所示,单击“确定”按钮。(17)为了增加电压摆幅,选择一个比原来的47Ω小的电阻。

小幽余生不加糖 4260

Modbus测试工具ModbusPoll与Modbus Slave使用方法 小白实操记录

Modbus 下面介绍modbus标准协议从站、主站仿真工具;可用于指令下发,数据采集等;是学习、现场运维的好工具。 1 介绍 Modbus Poll :Modbus主机仿真器,用于测试和调试Modbus从设备。该软件支持ModbusRTU、ASCII、TCP/IP。用来帮助开发人员测试Modbus从设备,或者其它Modbus协议的测试和仿真。它支持多文档接口,即,可以同时监视多个从设备/数据域。每个窗口简单地设定从设备ID,功能,地址,大小和轮询间隔。你可以从任意一个窗口读写寄存器和线圈。如果你想改

码灵的博客 1万+

Controller类:一篇文章带你入门,直接会写接口

SpringBoot接口类常用注解解释,controller类常用注解。@Controller ,@RestController 区别。请求-相应模式。设置请求映射规则@RequestMapping,POST 请求,GET 请求。获取请求参数,获取路径参数@PathVariable,获取请求体中的Json格式参数@RequestBody,获取QueryString格式参数@RequestParam;@RequestBody与@RequestParam()可以同时使用。响应体响应数据@ResponseBody

那仰望的人,心底的孤独和叹息 3124

仿真学习系列(四十三):Sigrity仿真之平面谐振分析

在 SIGRITY 中,平面谐振分析(Plane Resonance Analysis)是一种用于分析信号完整性(SI)问题的高级仿真方法,尤其关注于层间电磁波的传播、谐振现象和信号衰减等问题。平面谐振分析通常用于电源分配网络(PDN)、信号线和参考平面之间的相互作用。本文将详细介绍如何在 SIGRITY 中进行平面谐振分析,并提供一些实用的分析方法与步骤,帮助工程师们识别和优化可能存在的设计问题。

案例文章,高速信号 483

SpringMVC Controller 介绍

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_33726943的博客 105

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

SpringMVC Controller介绍及常用注解

一、简介          在SpringMVC 中,控制器Controller 负责处理由DispatcherServlet 分发的请求,它把用户请求的数据经过业务处理层处理之后封装成一个Model ,然后再把该Model 返回给对应的View 进行展示。在SpringMVC 中提供了一个非常简便的定义Controller 的方法,你无需继承特定的类或实现特定的接口,只需使用@Contro

gh670011677的博客 271

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

springmvc Controller介绍

一、简介            在SpringMVC 中,控制器Controller 负责处理由DispatcherServlet 分发的请求,它把用户请求的数据经过业务处理层处理之后封装成一个Model ,然后再把该Model 返回给对应的View 进行展示。在SpringMVC 中提供了一个非常简便的定义Controller 的方法,你无需继承特定的类或实现特定的接口,只需使用@Contro

teroris的博客 488

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

上一篇: springMVC拦截器
下一篇: SpringMVC视图解析器
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值