SpringMVC之用注解控制器

SpringMVC之用注解控制器

在传统的Spring MVC开发方法中，必须在Bean配置文件中为每个控制器类配置实例和请求映射和让每个控制器类去实现或者扩展特定于框架的接口或者基类，不够灵活。

如果Spring MVC可以自动侦测你的控制器类和请求映射，就能减少配置所需要的工作量。

Spring2.5支持一种基于注解的控制器开发方法。

Spring可以通过@Controller注解自动发现你的控制器类以及@RequestMapping注解中的请求映射，这样就为你免去了在Bean配置文件中配置它们的麻烦。此外，如果使用注解，控制器类和处理程序方法在访问上下文资源(例如请求参数、模型属性和会话属性)时也会更加灵活。

常用到的注解

 

1、@Controller

 

2、@RequestMapping

 

3、@RequestParam,  @PathVariable,  @CookieValue

 

@Controller注解能将任意的类标注成控制器类。与传统的控制器相反， 被标注的控制器类不需要实现特定于框架的接口，也不必扩展特定于框架的基类。

在控制器类内部，可能有一个或者多个处理程序方法添加了@RequestMapping注解。

 

 

处理程序方法的签名非常灵活。你可以为处理程序方法指定任意的名称，并定义以下任意一种类型作为它的方法参数。在这里，只提到了常见的参数类型。关于有效参数类型的完整列表，请参阅有关配置基于注解的控制器的Spring文档。

 

常见的参数类型

 

1.HttpServletRequest、HttpServletResponse或HttpSession。

2.添加了@RequestParam注解的任意类型的请求参数

3.添加了@ModelAttribute注解的任意类型的模型属性

4.任意类型的命令对象，供Spring绑定请求参数

5.Map或者ModelMap，供处理程序方法向模型添加属性

6.Errors或者BindingResult,让处理程序方法访问命令对象的绑定和验证结果

7.SessionStatus，让处理程序方法发出会话处理已经完成的通知

 

 

常见的返回值类型

 

处理程序方法的返回类型可以是ModelAndView、Model、Map、String、void

 

 

在创建基于注解的控制器之前，必须构建web应用程序上下文来处理注解。

首先，为了让Spring用@Controller注解自动侦测控制器，必须通过<context:component-scan>元素启用Spring的组件扫描特性。

其次Spring MVC还能够根据@RequestMapping将请求映射到控制器类和处理程序方法。

为了使其生效，必须在web应用程序上下文中注册DefaultAnnotationHandlerMapping实例和AnnotationMethodHandlerAdapter实例。

它们分别处理在类级别和方法级别上的@RequestMapping注解。

 

 

必要的Spring MVC配置

Xml代码

[xml]  view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.         xmlns:mvc="http://www.springframework.org/schema/mvc"  
5.         xmlns:context="http://www.springframework.org/schema/context"  
6.         xsi:schemaLocation="  
7.           http://www.springframework.org/schema/beans  
8.           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
9.           http://www.springframework.org/schema/mvc/spring-mvc  
10.           http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd  
11.           http://www.springframework.org/schema/context  
12.           http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
13.   
14.     <!-- 自动扫描注解的Controller -->  
15.     <context:component-scan base-package="com.wy.controller.annotation" />  
16.       
17.     <!-- 处理在类级别上的@RequestMapping注解-->  
18.     <bean  
19.         class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />  
20.     <!-- 处理方法级别上的@RequestMapping注解-->  
21.     <bean  
22.         class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />  
23.        
24.        
25.     <!-- 视图解析器策略 和 视图解析器 -->  
26.     <!-- 对JSTL提供良好的支持 -->  
27.     <bean  
28.         class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
29.         <!-- 默认的viewClass,可以不用配置  
30.         <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceView" />  
31.          -->  
32.         <property name="prefix" value="/WEB-INF/page/" />  
33.         <property name="suffix" value=".jsp" />  
34.     </bean>  
35.           
36. </beans>  

 DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter是默认在Web应用程序上下文中预先注册好的。然而，如果你还显式地注册了其他的处理程序映射或者处理程序适配器，它们就不会自动注册了。在这种情况下，你必须亲自注册它们。

 

基于注解的控制器类可以是个任意类，不实现特殊接口，也不扩展特殊的基类。你只要用@Controller注解对它进行标注即可。还可以在控制器中定义一个或者多个处理程序方法来处理单个或者多个动作。处理程序方法的签名很灵活，足以接受一系列参数。

 

 @RequestMapping注解可以被应用到类级别或者方法级别上。

 

Controller层：代码中写了很详细的注释

Java代码

[java]  view plain copy

1. package com.wy.controller.annotation;  
2.   
3. import java.io.IOException;  
4. import java.io.PrintWriter;  
5. import java.text.SimpleDateFormat;  
6. import java.util.Date;  
7. import java.util.HashMap;  
8. import java.util.List;  
9. import java.util.Map;  
10.   
11. import javax.servlet.http.HttpServletRequest;  
12. import javax.servlet.http.HttpServletResponse;  
13.   
14. import org.springframework.beans.propertyeditors.CustomDateEditor;  
15. import org.springframework.stereotype.Controller;  
16. import org.springframework.ui.Model;  
17. import org.springframework.validation.BindingResult;  
18. import org.springframework.validation.FieldError;  
19. import org.springframework.web.bind.ServletRequestDataBinder;  
20. import org.springframework.web.bind.annotation.InitBinder;  
21. import org.springframework.web.bind.annotation.PathVariable;  
22. import org.springframework.web.bind.annotation.RequestMapping;  
23. import org.springframework.web.bind.annotation.RequestMethod;  
24. import org.springframework.web.bind.annotation.RequestParam;  
25. import org.springframework.web.bind.support.WebRequestDataBinder;  
26. import org.springframework.web.servlet.ModelAndView;  
27.   
28. import com.wy.pojo.User;  
29.   
30. /** 
31.  * @author Administrator 
32.  * @version 2011-12-3 
33.  */  
34.   
35. @Controller  
36. @RequestMapping("userManagerContoller") //指定请求路径,相对路径可以不定义  
37. public class UserManagerContoller {  
38.   
39.     /** 
40.      * 欢迎 
41.      * @return 
42.      */  
43.       
44.     /* 1.传统的获取请求的参数方式 
45.      * http://localhost:8080/SpringMVC/userManagerContoller/welcome.do?name=wy 
46.      */  
47.     @RequestMapping("/welcome")   
48.     public ModelAndView welcome(HttpServletRequest request){    
49.         ModelAndView mav = new ModelAndView();  
50.         String name = request.getParameter("name");  
51.         Date today = new Date();    
52.         String date = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(today);  
53.         mav.addObject("today", date);  
54.         mav.addObject("name", name);  
55.         mav.setViewName("welcome");  
56.         return mav;    
57.     }  
58.       
59.     /* 2.restful风格获取请求的参数方式  Spring3.0的一个重要变化(将参数放到了请求路径中) 
60.      * http://localhost:8080/SpringMVC/userManagerContoller/welcome/wy.do 
61.      *  
62.      * 注意点: JVM将Java文件编译成Class文件有两种模式 Debug 和Release 
63.      * 这两种编译方式的区别是： 
64.      *    Debug 包含额外的调试信息,可以完整的保留变量的名称 (Eclipse 使用的是Debug) 
65.      *    Release 把变量名称使用其他的一些符号代替,量名称就不可见啦 (在使用 javac命令)    
66.      */  
67.     @RequestMapping("/welcome/{param}/{sex}")  
68.     //前一个“param是防止Release编译下找不到参数名称,因此要指定;要和模板中定义的参数名称一致  
69.     //后面一个“param”可以和模板中定义的参数名称不一致,建议还是一致  
70.     public ModelAndView welcome(@PathVariable("param") String param, @PathVariable("sex") String xingbie){  
71.         ModelAndView mav = new ModelAndView();  
72.         mav.addObject("name", param);  
73.         mav.addObject("sex", xingbie);  
74.         Date today = new Date();    
75.         String date = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(today);  
76.         mav.addObject("today", date);  
77.         mav.setViewName("welcome");  
78.         return mav;  
79.     }  
80.       
81.     /** 
82.      * 3.不同请求方式(get,post),映射不同的方法 
83.      *  
84.      *   value 指定请求路径,method 指定请求方式 
85.      */  
86.     @RequestMapping(value="/welcome", method=RequestMethod.GET)  
87.     public ModelAndView requestMethodGet(){  
88.         ModelAndView mav = new ModelAndView();  
89.         mav.setViewName("welcome");  
90.         return mav;  
91.     }  
92.   
93.     @RequestMapping(value="/hello", method=RequestMethod.POST)  
94.     public ModelAndView requestMethodPost(){  
95.         ModelAndView mav = new ModelAndView();  
96.         mav.setViewName("hello");  
97.         return mav;  
98.     }  
99.       
100.     /** 
101.      * 4. @RequestParam 使用方法和@PathVariable类似(要注意Debug和Release) 
102.      *    http://localhost:8080/SpringMVC/userManagerContoller/welcomeParam.do?username=wy&password=123&age=23 
103.      */  
104.     @RequestMapping(value="/welcomeParam", method=RequestMethod.GET)  
105.     public ModelAndView welcome(@RequestParam("username") String username,  
106.             @RequestParam("password") String password, @RequestParam("age") int age) {  
107.         ModelAndView mav = new ModelAndView();  
108.         User user = new User();  
109.         user.setUsername(username);  
110.         user.setPassword(password);  
111.         user.setAge(age);  
112.         mav.addObject("user", user);  
113.         mav.setViewName("hello");  
114.         return mav;  
115.     }  
116.       
117.     /** 
118.      * 5.获取表单中的值 
119.      *   BindingResult 绑定数据过程中产生的错误注入到BindingResult中。 
120.      */  
121.     @RequestMapping(value="/welcome", method=RequestMethod.POST)  
122.     public ModelAndView commonCommod(User user, BindingResult result){  
123.         ModelAndView mav = new ModelAndView();  
124.         mav.addObject(user);  
125.         if(result.hasErrors() && result.hasFieldErrors()){  
126.             String field = null;  
127.             Object fieldValue = null;  
128.             Map<String, Object> map = new HashMap<String, Object>();  
129.             List<FieldError> fieldErrors = result.getFieldErrors();  
130.             for(FieldError fieldError : fieldErrors){  
131.                 field = fieldError.getField();  
132.                 fieldValue = fieldError.getRejectedValue();  
133.                   
134.                 map.put(field, fieldValue);  
135.             }  
136.             mav.addObject("map", map);  
137.             mav.setViewName("welcome");  
138.         }else{  
139.             mav.setViewName("hello");  
140.         }  
141.         return mav;  
142.     }  
143.       
144.     /** 
145.      * 属性编辑器 类型转换 
146.      * 典型应用: 日期转换 
147.      */  
148.     @InitBinder  
149.     public void initBinder(WebRequestDataBinder binder){  
150.         binder.registerCustomEditor(Date.class, new CustomDateEditor(  
151.                 new SimpleDateFormat("yyyy-MM-dd"),false));  
152.     }  
153.       
154.     public void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception{  
155.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");  
156.         dateFormat.setLenient(false);  
157.         binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));  
158.     }  
159.     /** 
160.      * 6.常用的参数 
161.      *   使用Session有一个前提就是session必须是可用的 
162.      */  
163. //  public ModelAndView commonArguments(HttpServletRequest request, HttpServletResponse response, HttpSession session,   
164. //          @CookieValue AnyType cookieName, @RequestHeader("user-Agent") AnyType name,   
165. //          @PathVariable AnyType variableName, @RequestParam AnyType paramName){  
166. //      ModelAndView mav = new ModelAndView();  
167. //        
168. //      return mav;  
169. //  }  
170.       
171.     /** 
172.      * 7.返回类型 
173.      *   void 、String、AnyType(任意对象)、Model、ModelAndView 
174.      *   说明：Model继承了Map,为SpringMVC定制的 
175.      */  
176.     // void  
177.     @RequestMapping  
178.     public void commonReturnType(HttpServletResponse response){  
179.         try {  
180.             PrintWriter out = response.getWriter();  
181.             out.println("向页面中输出的值");  
182.         } catch (IOException e) {  
183.             // TODO Auto-generated catch block  
184.             e.printStackTrace();  
185.         }  
186.     }  
187.       
188.     @RequestMapping  
189.     public void commonReturnType(PrintWriter out){//其实也是从HttpServletResponse 通过getWriter()得到out  
190.         out.println("向页面中输出的值");  
191.     }  
192.       
193.     @RequestMapping("/commonReturnType")  
194.     public void commonReturnType(){  
195.         //默认生成隐含的viewName(规则测略：按照请求路径${appName/userManagerContoller/commonReturnType.do   
196.         //                                   ---> userManagerContoller/commonReturnType}  
197.         //                                   ---> /WEB-INF/page/userManagerContoller/commonReturnType.jsp  
198.         //                  )  
199.     }  
200.       
201.     // String  
202.     /** 
203.      * ModelAndView中的Model 
204.      * ModelAndView中的View 
205.      */  
206.     @RequestMapping  
207.     public String commonReturnType(Map<Object, Object> model){//model  
208.         model.put("", "");  
209.         return "viewName";  
210.     }  
211.       
212.     //AnyType(任意对象)  
213.     /** 
214.      * user放到model中,model(key, value) key默认是取Bean的名称将其首字母小写 即user,value即user 
215.      * 默认生成隐含的viewName 
216.      * 在页面上可以使用request.getAttribute("user")或者${user.key} ${user.value} 
217.      * @return 
218.      */  
219.     @RequestMapping  
220.     public User commonReturnTypeUser(){//  
221.         User user = null;  
222.           
223.         return user;  
224.     }  
225.       
226.     /** 
227.      * userList放到model中,model(key, value) key默认是框架生成userList,value即user 
228.      * 默认生成隐含的viewName 
229.      * 在页面上可以使用request.getAttribute("userList")或者${userList.key} ${userList.value} 
230.      * @return 
231.      */  
232.     @RequestMapping  
233.     public List<User> commonReturnTypeUserList(){  
234.         List<User> userList = null;  
235.           
236.         return userList;  
237.     }  
238.       
239.     /** 
240.      *  
241.      * 默认生成隐含的viewName 
242.      * @return 
243.      */  
244.     @RequestMapping  
245.     public Model commonReturnTypeModel(){  
246.         Model model = null;  
247.           
248.         return model;  
249.     }  
250.       
251.     /** 
252.      *  
253.      * @return 
254.      */  
255.     @RequestMapping  
256.     public ModelAndView commonReturnTypeModelAndView(){  
257.         ModelAndView mav = new ModelAndView();  
258.           
259.         mav.addObject("", "");  
260.         mav.setViewName("");  
261.         return mav;  
262.     }  
263.       
264. }  

 

view层

  welcome.jsp

  

Html代码

[html]  view plain copy

1. <%@ page language="java" pageEncoding="UTF-8"%>  
2. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>  
3. <%  
4. String path = request.getContextPath();  
5. %>  
6. <!DOCTYPE html>  
7. <html>  
8.   <head>  
9.     <title>welcome.html</title>  
10.       
11.     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">  
12.     <meta http-equiv="description" content="this is my page">  
13.     <meta http-equiv="content-type" content="text/html; charset=UTF-8">  
14.       
15.     <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->  
16.   
17.   </head>  
18.     
19.   <body>  
20.     This is my annotation HTML page. <br/>  
21.           今天是: ${today}<br/>  
22.           参数是: ${name}&nbsp;&nbsp;&nbsp;${sex}<br/>  
23.     <hr/>       
24.     <c:forEach var="field" items="${map}">  
25.        <c:if test="${field != null}" var="param" scope="page">  
26.                           您输入的${field.key}不正确! ${field.value}<br/>  
27.     </c:if>  
28.     </c:forEach>  
29.       
30.     <form action="<%=path%>/userManagerContoller/welcome.do" method="post">  
31.                    用户名: <input type="text" id="username" name="username"  value="wy" /><br/>  
32.                    密码 : <input type="text" id="password" name="password"  value="wy" /><br/>  
33.                    年龄 : <input type="text" id="age"      name="age"       value="23wy" /><br/>            
34.        <input type="submit" value="提交" />  
35.     </form>            
36.   </body>  
37. </html>  

 

 

值得注意的点：

    1、@PathVariable("paramName") @RequestParam("paramName") 建议指定参数名称

         原因是VM将Java文件编译成Class文件有两种模式 Debug 和Release

         这两种编译方式的区别是：

               Debug 包含额外的调试信息,可以完整的保留变量的名称 (Eclipse 使用的是Debug)

                Release 把变量名称使用其他的一些符号代替,量名称就不可见啦 (在使用 javac命令)

       2、restful风格获取请求的参数方式

       3、参数类型转换

             注册属性编辑器

      4、对于无任何输出的方法

       

Java代码

[java]  view plain copy

1. @RequestMapping("/commonReturnType")  
2.     public void commonReturnType(){  
3.         //默认生成隐含的viewName(规则测略：按照请求路径${appName/userManagerContoller/commonReturnType.do   
4.         //                                   ---> userManagerContoller/commonReturnType}  
5.         //                                   ---> /WEB-INF/page/userManagerContoller/commonReturnType.jsp  
6.         //                  )  
7.     }