【转载】基于注解的SpringMVC简单介绍

SpringMVC是一个基于DispatcherServlet的MVC框架，每一个请求最先访问的都是DispatcherServlet，DispatcherServlet负责转发每一个Request请求给相应的Handler，Handler处理以后再返回相应的视图(View)和模型(Model)，返回的视图和模型都可以不指定，即可以只返回Model或只返回View或都不返回。在使用注解的SpringMVC中，处理器Handler是基于@Controller和@RequestMapping这两个注解的，@Controller声明一个处理器类，@RequestMapping声明对应请求的映射关系，这样就可以提供一个非常灵活的匹配和处理方式。

DispatcherServlet是继承自HttpServlet的，既然SpringMVC是基于DispatcherServlet的，那么我们先来配置一下DispatcherServlet，好让它能够管理我们希望它管理的内容。HttpServlet是在web.xml文件中声明的。

1. <servlet>
2. <servlet-name>blog</servlet-name>
3. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
4. <load-on-startup>1</load-on-startup>
5. </servlet>
6. <servlet-mapping>
7. <servlet-name>blog</servlet-name>
8. <url-pattern>*.do</url-pattern>
9. </servlet-mapping>

上面声明了一个名为blog的DispatcherServlet，该Servlet将处理所有以“.do”结尾的请求。在初始化DispatcherServlet的时候，SpringMVC默认会到/WEB-INF目录下寻找一个叫[servlet-name]-servlet.xml的配置文件，来初始化里面的bean对象，该文件中对应的bean对象会覆盖spring配置文件中声明的同名的bean对象。如上面的就会在/WEB-INF目录下寻找一个叫blog-servlet.xml的文件；当然也可以在Servlet中声明配置文件的位置，那就是通过Servlet的初始化参数来设置contextConfigLocation参数的值。

1. <servlet>
2. <servlet-name>blog</servlet-name>
3. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
4. <init-param>
5. <param-name>contextConfigLocation</param-name>
6. <param-value>/WEB-INF/blog-servlet.xml</param-value>
7. </init-param>
8. <load-on-startup>1</load-on-startup>
9. </servlet>
10. <servlet-mapping>
11. <servlet-name>blog</servlet-name>
12. <url-pattern>*.do</url-pattern>
13. </servlet-mapping>

DispatcherServlet会利用一些特殊的bean来处理Request请求和生成相应的视图返回。

关于视图的返回，Controller只负责传回来一个值，然后到底返回的是什么视图，是由视图解析器控制的，在jsp中常用的视图解析器是InternalResourceViewResovler，它会要求一个前缀和一个后缀

1. <bean
2. class="org.springframework.web.servlet.view.InternalResourceViewResolver">
3. <property name="prefix" value="/WEB-INF/" />
4. <property name="suffix" value=".jsp" />
5. </bean>

在上述视图解析器中，如果Controller返回的是blog/index，那么通过视图解析器解析之后的视图就是/WEB-INF/blog/index.jsp。

要使用注解的SpringMVC需要在SpringMVC的配置文件中进行声明，具体方式为先引入mvc命名空间，然后利用<mvc:annotation-driven />进行声明。

1. <beans xmlns="http://www.springframework.org/schema/beans"
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
3. <span style="background-color: #00ff00;"><span style="color: #ff0000;">xmlns:mvc="http://www.springframework.org/schema/mvc"</span>
4. </span>
5. xsi:schemaLocation="http://www.springframework.org/schema/beans
6. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
7. http://www.springframework.org/schema/context
8. http://www.springframework.org/schema/context/spring-context-3.0.xsd
9. <span style="background-color: #00ff00; color: #ff0000;"> http://www.springframework.org/schema/mvc
10. http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"</span>
11. >
12. <mvc:annotation-driven />
13. </beans>

主要是说说Controller.

在SpringMVC中Controller不需要继承什么类，也不需要实现什么接口，一切使用了@Controller进行标记的类都是Controller

1. @Controller
2. public class BlogController {
3. }

有了Controller之后，那么到底是怎样请求一个Controller具体的方法的呢，那是通过@RequestMapping来标记的，@RequestMapping可以标记在类上面，也可以标记在方法上，当方法上和类上都标记了@RequestMapping的时候，那么对应的方法对应的Url就是类上的加方法上的，如下面的index方法，其对应的URL应为类上的/blog加上index方法上的/index，所以应为/blog/index，所以当请求/blog/index.do的时候就会访问BlogController的index方法。加在类上的@RequestMapping不是必须的，当Controller类上加上了@RequestMapping的时候，那么Controller方法上的@RequestMapping就是相对于类上的@RequestMapping而言的，也就是前面说的请求映射的时候是类上的地址加方法上的地址，而当Controller类上没有加@RequestMapping的时候，方法上的@RequestMapping就是绝对路径了。

1. @Controller
2. @RequestMapping("/blog")
3. public class BlogController {
4. @RequestMapping("/index")
5. public String index(Map<String, Object> map) {
6. return "blog/index";
7. }
8. }

在上面的代码中，如果index方法上没有RequestMapping注解，而只有BlogController类上有，且该类只有一个方法的时候，直接请求类上的URL就会调用里面的方法，即直接请求/blog.do的时候就会调用index方法。

在RequestMapping中还可以指定一个属性method，其主要对应的值有RequestMethod.GET和RequestMethod.POST，利用该属性可以严格的控制某一方法只能被标记的请求路径对应的请求方法才能访问，如指定method的值为GET，则表示只有通过GET方式才能访问该方法，默认是都可以访问。RequestMapping中的URL映射还支持通配符*，如：

1. @Controller
2. @RequestMapping("/blog")
3. public class BlogController {
4. @RequestMapping("/*/index")
5. public String index(Map<String, Object> map) {
6. return "blog/index";
7. }
8. }

在@RequestMapping中还有一个属性params，可以通过该属性指定请求参数中必须包含某一参数，或必须不包含某一参数，或某参数的值必须是什么，以此来缩小指定的映射范围。

1. @Controller
2. @RequestMapping("/blog")
3. public class BlogController {
4. @RequestMapping(value="/index", params="param1=value1")
5. public String index(Map<String, Object> map) {
6. return "blog/index";
7. }
8. }

在上面示例中，只有当请求/blog/index.do并且请求参数param1的值为value1的时候才能访问到对应的index方法。如果params的值为"param1"，则表示请求参数只要包含param1就可以了，至于它的值是什么无所谓；如果params的值为"!param1"，则表示请求参数必须不包含param1才可以。@RequestMapping中还可以使用header来缩小映射范围，如：

1. @Controller
2. @RequestMapping("/blog")
3. public class BlogController {
4. @RequestMapping(value="/index",headers="content-type=text/html")
5. public String index(Map<String, Object> map) {
6. return "blog/index";
7. }
8. }

在SpringMVC中常用的注解还有@PathVariable，@RequestParam，@PathVariable标记在方法的参数上，利用它标记的参数可以利用请求路径传值，看下面一个例子

1. @RequestMapping(value="/comment/{blogId}", method=RequestMethod.POST)
2. public void comment(Comment comment,@PathVariable int blogId, HttpSession session, HttpServletResponse response) throws IOException {
3. }

在该例子中，blogId是被@PathVariable标记为请求路径变量的，如果请求的是/blog/comment/1.do的时候就表示blogId的值为1，@PathVariable在进行赋值的时候如果像上面那样没有指定后面接的变量是对应URL中的哪个变量时默认是从URL中取跟后面接的变量名相同的变量，如上面示例中的@PathVariable int blogId，没有指明要获取URL中的哪个变量，这个时候就默认取URL中的blogId变量对应的值赋给方法参数中的blogId，那如果方法参数的名称跟RequestMapping中定义的访问路径中的变量名不一样，或者我要利用PathVariable明确指定后面接的方法参数是对应于URL中的哪个变量时，可以像下面这样做，在PathVariable中给定一个value="blogId"(只有一个参数的时候value是可以省略的)值明确指定方法参数中的id变量是对应请求路径定义中的blogId变量的。

1. @RequestMapping(value="/comment/{blogId}", method=RequestMethod.POST)
2. public void comment(Comment comment,@PathVariable("blogId") int id, HttpSession session, HttpServletResponse response) throws IOException {
3. }

同样@RequestParam也是用来给参数传值的，但是它是从头request的参数里面取值，相当于request.getParameter("参数名")方法。它的取值规则跟@PathVariable是一样的，当没有指定的时候，默认是从request中取名称跟后面接的变量名同名的参数值，当要明确从request中取一个参数的时候使用@RequestParam("参数名")，如下所示：

1. @RequestMapping("/show")
2. public void showParam(@RequestParam int id, @RequestParam("name") String username) {
3. //这样做进行URL请求访问这个方法的时候，就会先从request中获取参数id的值赋给参数变量id，从request中获取参数name的值赋给参数变量username
4. }

在Controller的方法中，如果需要WEB元素HttpServletRequest，HttpServletResponse和HttpSession，只需要在给方法一个对应的参数，那么在访问的时候SpringMVC就会自动给其传值，但是需要注意的是在传入Session的时候如果是第一次访问系统的时候就调用session会报错，因为这个时候session还没有生成。

接下来讨论一下方法的返回值，主要有以下情况：

• 返回一个ModelAndView，其中Model是一个Map，里面存放的是一对对的键值对，其可以直接在页面上使用，View是一个字符串，表示的是某一个View的名称
• 返回一个字符串，这个时候如果需要给页面传值，可以给方法一个Map参数，该Map就相当于一个Model，往该Model里面存入键值对就可以在页面上进行访问了
• 返回一个View对象
• 返回一个Model也就是一个Map，这个时候将解析默认生成的view name，默认情况view name就是方法名，这里之前搞错了，感谢网友的指正。默认的View Name是由RequestToViewNameTranslator来解析的，顾名思义就是把request翻译成viewName，在没有指定RequestToViewNameTranslator时，Spring将使用其自身的默认实现DefaultRequestToViewNameTranslator的默认配置，即取到当前请求的URI，去掉最前和最后的斜杠“/”，以及对应的后缀。所以当你请求“http://localhost/app/abc”的时候，对应的默认viewName就是请求URI——“/abc”去掉最前最后的斜杠和后缀之后的结果，即“abc”，请求“http://localhost/app/abc/efg”时对应的默认视图名称是“abc/efg”，“http://localhost/app/abc/efg/hi.html”——>“abc/efg/hi”。如果需要改变默认的视图名称的解析方式，可以在SpringMVC的配置文件中配置一个名称为viewNameTranslator，类型为RequestToViewNameTranslator的bean。如果该bean是DefaultRequestToViewNameTranslator，那么你可以通过prefix属性指定视图名称的前缀，通过suffix指定后缀，通过stripLeadingSlash指定是否需要去掉最前面的斜杠，更多可指定的属性请参考DefaultRequestToViewNameTranslator的实现。当然你也可以定义自己的RequestToViewNameTranslator实现类，实现RequestToViewNameTranslator接口的getViewName(HttpServletRequest request)方法，实现自己的获取默认视图名称的逻辑。
• 什么也不返回，这个时候可以在方法体中直接往HttpServletResponse写入返回内容，否则将会由RequestToViewNameTranslator来决定
• 任何其他类型的对象。这个时候就会把该方法返回类型对象当做返回Model模型的一个属性返回给视图使用，这个属性名称可以通过在方法上给定@ModelAttribute注解来指定，否则将默认使用该返回类名称作为属性名称。

下面是一个简单的实例

1. @RequestMapping("/{owner}/index")
2. public String userIndex(Map<String, Object> map,@PathVariable String owner, HttpServletRequest request) throws ParserException {
3. List<DefCategory> categories = categoryService.find(owner);
4. int offset = Util.getOffset(request);
5. Pager<Blog> pager = blogService.find(owner, 0, offset, maxResults);
6. int totalRecords = pager.getTotalRecords();
7. List<Blog> blogs = pager.getData();
8. Util.shortBlog(blogs);
9. List<Message> messages = messageService.find(owner, 0, 5).getData();
10. Util.shortMessage(messages, 20);
11. map.put("messages", messages);
12. map.put("totalRecords", totalRecords);
13. List<BlogStore> stores = storeService.find(owner, 0, 5).getData();
14. map.put("maxResults", maxResults);
15. map.put("blogs", blogs);
16. map.put("totalRecords", totalRecords);
17. map.put("owner", userService.find(owner));
18. map.put("defCategories", categories);
19. map.put("stores", stores);
20. return "blog/userIndex";
21. }

给页面传值

在Controller中把请求转发给业务逻辑层进行处理之后需要把业务逻辑层的处理结果进行展现，在展现的过程中就需要我们把处理结果传给展示层进行展示。那么处理结果是怎么进行传递的呢？前面已经说了Controller的返回结果可以是一个包含模型和视图的ModelAndView，也可以仅仅是一个视图View，当然也可以什么都不返回，还可以是仅仅返回一个Model。我们知道模型Model是用来封装数据给视图View进行展示的，那么，在SpringMVC中，如果要把我们后台的信息传递给前台进行展示的话应该怎么做呢？这主要有两种方式：     1.返回包含模型Model的ModelAndView，或者是直接返回一个Model(这个时候就需要考虑默认的视图)，这种类型的返回结果是包含Model的，这个Model对象里面的对应属性列都可以直接在视图里面使用。     2.如果是直接返回一个视图View，这个时候SpringMVC提供了一种类似于在Controller方法中获取HttpRequest对象的机制，这个时候我们只需要给定Controller方法一个Map参数，然后在方法体里面给这个Map加上需要传递到视图的键值对，这样在视图中就可以直接访问对应的键值对