Spring mvc

SpringMvc简单介绍

Spring MVC是一个基于MVC(Model view Controller)模式的WEB框架，它解决WEB开发中常见的问题(参数接收、文件上传、表单验证、国际化、等等)，使用非常简单，SpringMvc作为Spring中的一个模块,可以与Spring无缝集成。

SpringMvc以Spring框架为核心，为应用程序中的Web层（表现层）提出的一套优秀的解决方案。

spring-webmvc-4.1.2.RELEASE.jar SpringMVC的jar文件。

spring-web-4.1.2.RELEASE.jar Spring对Web项目运行的支持。

1.1.1. MVC框架思想-核心控制器（前端控制器）

顾名思义核心控制器用于Web层核心功能的处理以及在所有控制器执行的。所有的WebMvc框架都采用了这种方式。

在Struts2中我们使用的是StrutsPrepareAndExecuteFilter作为核心控制器，在SpringMVC中使用的是DispatcherServlet为核心控制器.

DispatcherServlet核心控制器会拦截匹配的请求，把拦截下来的请求，依据相应的规则分发到目标Controller来处理。

创建项目确保Spring可用

导入jar包

com.springsource.org.apache.commons.logging-1.1.1.jar(版本三)

spring-beans-4.1.2.RELEASE.jar

spring-context-4.1.2.RELEASE.jar

spring-core-4.1.2.RELEASE.jar

spring-expression-4.1.2.RELEASE.jar

spring aop、orm、jdbc、tx相关jar根据项目使用自行添加;

准备配置文件配置 applicationContext.xml

1.1.1. 加入相关Spring mvc相关jar包。

spring-web-4.1.2.RELEASE.jar spring 对web项目的支持。

spring-webmvc-4.1.2.RELEASE.jar SpringMVC核心包。

配置核心控制器

Webmvc框架的心脏就是核心控制器，负责所有请求的公共功能，然后再分发给具体的控制器（我们编写的控制器），完成业务逻辑，响应视图。

配置：

<servlet-name>springmvc</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>springmvc</servlet-name>

<!-- / 拦截所有的请求,拦截Controller的地址

/*拦截所有的请求,会拦截*.jsp类似请求

*.do *.action 拦截.do .action结尾的请求

-->

<url-pattern>/</url-pattern>

</servlet-mapping>

1.1.1. 准备SpringMVC映射文件

规范要求

说明

实现Controller接口或子接口。

注意：子接口很多已经过时了。

核心方法为handleRequest(req,resp),处理用户请求

普通的类(常用的哦)

使用一个普通的类作为我们的控制器，每一个方法就是一个处理器，这种方式需要配合注解标签才能使用。

SpringMVC是Spring的一个模块，它的配置文件就是Spring的配置差不多，复制一份applicationContext.xml修改为applicationContext-mvc.xml。

SpringMVC中的控制器有一定规范，要么实现接口，要么使用POJO对象与注解配合使用。

handleRequest方法的两个参数与我们以前的servlet中service方法一样，request和response对象，我们可以使用这个两个对象完成一次请求的所有工作，比如你可以使用request接受参数，或者使用response重定向等等，注意方法除了返回值以外还有一个返回值ModelAndView。

 1  SpringMVC的控制器Controller，和Struts2中的action一样。
 2  */
 3 public class HelloController implements Controller{
 4     /**
 5      * 处理请求方法。
 6      * request:封装了请求对象；
 7      * response：封装了这个请求的响应对象
 8      * 返回一个ModelAndView对象：
 9      *    Model：模型 ,封装我们的数据
10      *    View：视图，返回的jsp页面
11      *    ModelAndView对象是springmvc控制器中的一个对象，用于封装数据模型和返回页面视图
12      */
13     public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
14         //获取请求参数
15         System.out.println("HelloController....");
16         //调用service进行业务逻辑处理
17         System.out.println("HelloController 已经进行了业务逻辑处理");
18         //返回jsp页面视图
19         ModelAndView mAndView = new ModelAndView();
20         mAndView.setViewName("/01jsp/01_hello.jsp");
21         return mAndView;
22     }
23 
24 }

1)配置

SpringMVC是基于Spring，Spring中的核心就是Ioc容器，而Ioc容器中最重要的成员就是<bean>，SpringMVC中的控制器也是一个一个<bean>。使用name属性：表示这个Controller的访问路径

 1 <!-- springmvc的核心控制器，拦截所有的请求，负责分发到对应的Controller中的方法 -->
 2     <servlet>
 3         <servlet-name>springmvc</servlet-name>
 4         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 5         
 6 <!--         启动springmvc的核心控制器的时候，就初始化加载springmvc的配置文件 -->
 7         <init-param>
 8           <param-name>contextConfigLocation</param-name>
 9           <param-value>classpath:applicationContext-mvc.xml</param-value>
10         </init-param>
11 <!--         DispatcherServlet启动比较耗时，在启动加载文件的时候就进行加载 -->
12         <load-on-startup>1</load-on-startup>
13     </servlet>
14     <servlet-mapping>
15         <servlet-name>springmvc</servlet-name>
16         <!-- / 拦截所有的请求
17         /*拦截所有的请求
18         *.do  *.action 拦截.do   .action结尾的请求
19          -->
20         <url-pattern>/</url-pattern>
21     </servlet-mapping>

1.1.1. 入门小结：

①：创建一个动态工程，配置tomcat和编译路径

②：Spring的环境准备：导入基本的5个jar包和一个applicationContext.xml配置文件

③：Springmvc的环境的准备：

spring-web-4.1.2.RELEASE.jar spring 对web项目的支持。

spring-webmvc-4.1.2.RELEASE.jar SpringMVC核心包。

Web ,webmvc的两个jar包；

applicationContext-mvc.xml的配置文件

Web.xml:配置核心控制器：DispatcherServlet

④：Controller的准备：写一个类，实现Controller接口，覆写方法，返回一个视图jsp页面

同时应把这个Controller配置到applicationContext-mvc.xml，变成一个bean，name就是访问的路径

⑤：准备一个jsp视图

⑥:启动测试

1.1. 静态资源文件访问问题

由于我们配置的拦截器规则是”/”,”/”就代表默认控制器，tomcat本身自带有一个默认控制器，这个控制器用于处理静态资源请求，如果我们配置默认控制器，那么tomcat的默认控制器就不生效，导致静态资源无法访问。

解决办法：springmvc开启静态资源控制器。(适应于HTML页面视图)

<mvc:default-servlet-handler/>(release :释放)

1.1. 控制器三种实现方式

① 实现Controller接口

② 实现HttpRequestHandler接口

③ 普通类(pojo)和注解 @RequestMapping

public class ImplController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println("我implements Controller进来了。。。。。");
        return null;
    }
}

配置：将这个Controller交给spring管理，并使用name属性配置映射关系(就是这个Controller的访问路径)

1 public class HandlerController implements HttpRequestHandler {
2     @Override
3     public void handleRequest(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException {
4         System.out.println("进来了implements HttpRequestHandler。。。。");
5     }
6 }

配置：将这个Controller交给spring管理，并使用name属性配置映射关系(就是这个Controller的访问路径)。

缺点：只能有一个方法，不能实现多个地址的映射

普通类(pojo)和注解

 1 @RequestMapping("/user")
 2 public class UserController {
 3     /**
 4      * 一个Index方法
 5      * @return
 6      */
 7      @RequestMapping("/index")//访问地址：/user/index 
 8      public String index(){
 9          System.out.println("我是一个index。。。。。。。。。。。。");
10          return  "";
11      }
12      /**
13       * 一个list方法
14       * @return
15       */
16      @RequestMapping("/list")//访问地址：/user/list 
17      public void  list(){
18          System.out.println("我是一个list。。。。。。。。。。。。");
19      }
20 
21 }

配置：@RequestMapping配置类上和方法上

（只需要配置让spring管理这个bean即可，无需指定路径，因为方法上面通过@RequestMapping指定）

需要开启SprigMVC注解支持:

<mvc:annotation-driven/>

总结

Springmvc中所有控制器，其实在spring中就是一个一个bean。

spring管理bean的方法分为两种，第一种是xml,，第二种是注解。

Springmvc中控制器建议使用注解方式，是官方推荐的，也外面公司使用方式。

控制器注解实现方式

 1 /**
 2  *        
 3  * Controller的实现：
 4  *   全注解：
 5  *      @Controller的配置：相当于一起的xml中的bean配置
 6  *      @RequestMapping("/department")配置：bean的name的配置
 7  *      
 8  *      注意：需要配置spring注解的扫描路径
 9  *             <!-- 开启Spring的注解的扫描：@Controller @Service @Repository @Component等 -->
10                 <context:component-scan base-package="cn.itsource.springmvc"/>
11  *          开启springmvc注解的扫描:
12  *              <!-- 开启Springmvc的注解驱动：扫描@RequestMapping等注解 -->
13                  <mvc:annotation-driven/>
14  * @author admin
15  *
16  */
17 @Controller//将这个类，交给Spring管理，需要开启注解的扫描路径
18 @RequestMapping("/department")
19 public class DepartmentController {
20     
21     @RequestMapping("/index")
22     public void index(){
23         System.out.println("index...........");
24     }
25     @RequestMapping("/del")
26     public void del(){
27         System.out.println("del.......");
28     }
29 
30 }

 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 http://www.springframework.org/schema/beans/spring-beans.xsd
 8     http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
 9     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
10     <!-- 开启springMVC的默认处理控制器 ：处理静态资源 -->
11     <mvc:default-servlet-handler />
12     <!-- 开启spring对mvc注解支持功能,能识别@RequestMapping等注解 -->
13     <mvc:annotation-driven />
14     <!-- 开启spring对注解配置支持，默认这个配置是存在的，但是为了规范起见，还是写上：@Controller:controller @Service:service @Repository:dao @Component :其他 -->
15     <context:annotation-config />
16     <!-- 组件扫描路径 -->
17     <context:component-scan base-package="cn.itsource.springmvc" />
18 </beans>

控制器常用操作

和struts2一样，控制器除了我们前面重点讲解处理请求并返回视图以外，还需要一些事情，比如接收页面传递参数、绑定数据到页面、返回json数据、文件上传、文件下载等

参数接收

配置请求编码过滤器

参数接收，首先要考虑乱码问题。然而springmvc框架本身没有处理请求编码，但是spring框架为我们提供了一个请求编码过滤器，我们在web.xml配置一个请求编码过滤器。

参数接收

配置请求编码过滤器

 1 <!-- 支持UTF-8编码 -->
 2   <filter>
 3       <filter-name>characterEncoding</filter-name>
 4       <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
 5       <init-param>
 6           <param-name>encoding</param-name>
 7           <param-value>UTF-8</param-value>
 8       </init-param>
 9   </filter>
10   <filter-mapping>
11       <filter-name>characterEncoding</filter-name>
12       <url-pattern>/*</url-pattern>
13   </filter-mapping>

1.1.1. 参数接收方式

① 通过控制器的执行方法参数来接收普通参数

② 通过Domain模型对象来接收

③ 通过传统的HttpServletRequest接收

④ 通过url中的参数接收(restfull风格) @PathVariable("id")转换

1.通过控制器的执行方法参数来接收普通参数

2.通过模型对象来接收(常用)

3.接收url中参数的请求,接收用户请求参数值

4.通过传统的HttpServletRequest接收

1.1. 数据传递

就是Controller往前台(页面)传递数据

① 通过ModelAndView对象传递

② 通过Model对象传递

③ 通过request对象传递

④ 通过返回值传递

①通过ModelAndView对象传递

/**
	 * 通过一个ModelAndView对象来传递参数
	 * @return
	 */
	@RequestMapping("/demo1")
	public ModelAndView demo1() {
		ModelAndView modelAndView = new ModelAndView();
		modelAndView.addObject("msg", "大家好啊");
		modelAndView.setViewName("/03jsp_contrlloerParamsToView/controllerToView.jsp");
		User user=new User("zs", 13, 11L);
		modelAndView.addObject(user);
		return modelAndView;

通过Model对象进行数据传递

 1 /**
 2      * 通过形参中的一个Model对象来传递参数。
 3      * springMvc自动创建模型对象传入到方法中，我们只需要在这个模型上添加数据就以。
 4      * @param model 封装数据的模型对象
 5      * @return 返回值是一个字符串，表示是返回的视图view
 6      */
 7     @RequestMapping("/demo2")
 8     public String demo2(Model model) {
 9         model.addAttribute("msg", "一点都不好");
10         return "/03jsp_contrlloerParamsToView/controllerToView.jsp";
11     }

3.通过request对象进行数据传递

 1 /**
 2      * 使用原始的在request上添加属性
 3      * @param request
 4      * @return 返回值是一个字符串，表示返回的视图view
 5      */
 6     @RequestMapping("/demo3")
 7     public String demo3(HttpServletRequest request) {
 8         request.setAttribute("msg", "我是另一种方式了哦");
 9         return "/03jsp_contrlloerParamsToView/controllerToView.jsp";
10     }

4.通过返回值传递数据

 1 /**
 2      * 返回一个自定义对象：user。
 3      * 返回值就是模型数据。
 4      * springmvc会自动创建一个ModelAndView对象，mav，将uer添加到mav中：mav.addObject("user",user);
 5      * 并且返回视图路径就是访问路径：mav.setViewName("/demo4.jsp");
 6      * @return
 7      */
 8     @RequestMapping("/demo4")
 9     public User demo4() {
10         User user=new User("2",34,34L);
11         return user;
12     }
13 
14 yi

SpringMcv返回JSON

要把Java对象转换为Json，需要框架支持

Jackson：http://jackson.codehaus.org/ springMVC

JSON-lib：http://json-lib.sourceforge.net/ struts2

Gson：http://code.google.com/p/google-gson/

FastJson阿里开源

加入jackson json工具包

 1 出现406状态异常
 2 
 3   加入json jar包 jackson
 4 
 5 处理如果有乱码的问题：springContext-mvc.xml
 6 
 7 <!-- 为了处理返回的JSON数据的编码，设置为UTF-8 --> 
 8 
 9 <bean id="mappingJacksonHttpMessageConverter"  class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"> 
10 
11     <property name="supportedMediaTypes">
12 
13         <list>
14 
15              <value>text/html;charset=UTF-8</value>
16 
17           </list>
18 
19      </property>
20 
21 </bean>
22 
23

对日期格式的特殊处理(后面要用到的知识)

从后台向前台：

默认返回的日期格式为时间戳，而在前台我们希望显示出指定规则的日期字符串。如：

默认：{"name"："小明哥","birthdate"：121223223}

期望: {"name"："小明哥","birthdate"："2025-12-12 14:12:12"}

在日期get属性，字段上，添加一个格式化注解

@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")

从前台向后台：

在后台模型的setter方法上，添加注解

@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")

访问地址：localhost:8080/jsonV587?birthDay=2017-06-13 16:50:53

文件上传/下载

@RequestMapping(value = "/upload", method = RequestMethod.GET)

//映射关系的匹配有很多参数可以选：value:表示请求的路径，可以默认不写

//method:表示这个方法的请求方式：get或者post。当明显指定了访问方式后：就必须对应的方式才能进入。

文件上传

由于springmvc自己没有实现文件上传，它使用是apache.commons.fileupload ，需要导入以下的包

com.springsource.org.apache.commons.fileupload-1.2.0.jar

com.springsource.org.apache.commons.io-1.4.0.jar

 1 **
 2  * 文件的上传:
 3  * springmvc没有自己的上传方法。需要使用Apache.commons.fileupload
 4  * com.springsource.org.apache.commons.fileupload-1.2.0.jar
 5    com.springsource.org.apache.commons.io-1.4.0.jar
 6 */
 7 @Controller
 8 public class UploadController {
 9     /**
10      * 显示指定这个方法是get请求
11      * 前台通过get请求访问这个路径，返回一个jsp文件上传页面
12      * @return
13      */
14     @RequestMapping(value = "/upload", method = RequestMethod.GET)
15     public String uploadFileGet() {
16         System.out.println("get....");
17         return "/WEB-INF/05_upload_jsp/upload.jsp";
18     }
19 
20     /**
21      * 文件上传实现方法：
22      * ①：获取上传文件的原始文件名
23      * ②：随机生产一个UUID作为上传后的文件名，放置文件名重复
24      * ③：获取文件名后缀，结合①②生产保存的文件名
25      * ④：获取需要保存的文件的服务器路径
26      * ⑤：使用file流写文件
27      * ⑥：完成文件保存
28      * @param name  注册名
29      * @param img 上传的文件图片对象
30      * @param request request请求
31      * @return
32      * @throws FileNotFoundException
33      * @throws IOException
34      */
35     @RequestMapping(value = "/upload", method = RequestMethod.POST)
36     public String uploadFilePost(String name,MultipartFile img,HttpServletRequest request) throws FileNotFoundException, IOException {
37         //获取上传文件的原始文件名
38         String oFileName=img.getOriginalFilename();
39         //获取文件名的后缀
40         String fNameSuffix= FilenameUtils.getExtension(oFileName);
41         //生产一个随机的文件名
42         String uuidName = UUID.randomUUID().toString();
43         String fileName=uuidName+"."+fNameSuffix;
44         //获取保存文件的路径
45         String fileDir = request.getServletContext().getRealPath("/uploads");
46         //使用file流写文件
47         File file=new File(fileDir,fileName);
48         if(!file.getParentFile().exists()){
49             file.getParentFile().mkdirs();
50         }
51         IOUtils.copy(img.getInputStream(),new FileOutputStream(file));
52         return "/WEB-INF/05_upload_jsp/upload.jsp";
53     }
54 }

1 <!—文件上传：必须写：enctype="multipart/form-data"—>
2 <form action="/upload" method="post" enctype="multipart/form-data">
3        用户名:<input type="text" name="name"/><br/>
4        头像：<input type="file" name="img"/><br/>
5        <input type="submit" value="提交"/>
6   </form>

1 <!--     配置文件上传解析器：id="multipartResolver",这个id不能乱写 
2           设置一个maxUploadSize属性，就是上传文件的大小
3 -->
4     <bean id="multipartResolver"
5     class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
6         <property name="maxUploadSize">
7             <value>2000000000</value>
8         </property>
9    </bean>

 1 6.4.2.文件下载（还是原生Servlet方式）
 2 /**
 3      * 文件下载：原生的servlet
 4      * ①：设置response的头信息
 5      * ②：获取文件输出流
 6      * ③：获取需要下载的文件输入流
 7      * ④：文件流的拷贝
 8      * @param response
 9      * @param request
10      * @throws IOException
11      */
12     @RequestMapping("/downLoad")
13     public void downLoad(HttpServletResponse response,HttpServletRequest request) throws IOException{
14         //设置响应response的头信息和文件名
15         String filename="mm.jpg";
16         response.setHeader("Content-Disposition", "attachment; filename="+filename+"");
17         //获取文件输出流
18         OutputStream out=response.getOutputStream();
19         
20         //获取下载文件的地址
21         String filePath =request.getServletContext().getRealPath("/upload");
22         String fileAllPath=filePath+"/mm.jpg";
23         //获取文件输入流
24         FileInputStream in=new FileInputStream(fileAllPath);
25         //文件流拷贝
26         IOUtils.copy(in, out);
27     }

执行流程

流程图

控制器=处理器(Handler)

1. 用户向服务器发送请求，请求被SpringMVC前端控制DispatcherServlet捕获；

2. DispatcherServlet通过调用HandlerMapping（处理器映射管理对象）获得该请求对应的Handler对象（包括控制器以及Handler对象对应的拦截器）

HandlerExecutionChain对象（包含：控制器+2个拦截器）；

3. DispatcherServlet 根据获得的Handler，选择一个合适(管理Controller的方式:有xml方式和注解方式)的HandlerAdapter。（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法）

4. 提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：

HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息

数据转换：对请求消息进行数据转换。如String转换成Integer、Double等

数据格式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等

数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中

5.Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；

6.根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet ；

7. ViewResolver 结合Model和View，来渲染视图(Model+View合成)

8. 将渲染结果返回给客户端。

1.1. 简易描述(面试用)

1. 客户端请求提交到DispatcherServlet

2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller。

3. 通过Handler匹配一个合适HandlerAdapter ，通过HandlerAdapter 调用对象Controller方法。

4. Controller调用业务逻辑处理后，返回ModelAndView

5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图。

6. 视图负责将结果显示到客户端。

Converter 变换器;

DataBinder 数据连接器

核心对象

1.1. HandlerMapping 处理器映射管理对象

HanderMapping 处理器映射管理对象:

作用：根据不同的请求选择最合适的处理器(自己编写的控制器)，处理器映射管理对象可以配置多个，谁最先匹配就执行谁。

SpringMVC默认：/org/springframework/web/servlet/DispatcherServlet.properties

Java程序员必会springmvc框架三大组件工作流程与struts2框架区别

SpringMVC围绕着Servlet进行开发Web,代码的实现上同时也依赖Spring开发，不然也不会叫做SpringMVC，本文着重强调的重点在于SpringMVC的工作流程，并不设计具体代码开发，所以并不要求掌握Spring的知识。

SpringMVC的处理流程为,用户访问的地址被DispathcherServlet的url-pattern匹配到后,

DispathcherServlet会在内部从Spring容器中拿到HandlerMapping对象

该对象内部有一个LinkedHashMap,

在Spring容器初始化时,我们在@requestMapping中填写的url路径被存入这个map中作为Key值,一旦用户发送请求DispathcherServlet通过RequestMappingHandlerMapping中获取请求地址然后迭代这个Map寻求匹配的Key值,也就是我们在@requestMapping中写的路径,如果匹配成功就能够获取到我们的controller处理器的全包名和方法名

这时候DispathcherServlet创建一个HandlerAdapter接口下的子类对象执行从map中获取的方法,也就是我们在controller编写的方法

,返回一个ModelAndView对象,DispathcherServlet又从SpringWeb容器中拿到ViewResolver对象,

ViewResolver对象能够将上面方法的返回值ModelAndView中的ViewName解析出,该ViewName就是我们写的/WebINFO/下的JSP页面的这段字符串,ViewResolver通过该地址将整个jsp页面解析成View对象,将对象返回给DispathcherServlet。然后调用processDispatchResult方法对页面进行渲染,也就是将controller处理后的model数据与ViewResolver返回的view对象进行渲染,就是将他们重新组合成了一个处理后的jsp页面对象返回给浏览器。

以上就是DispathcherServlet的工作流程了,可以说整个流程都是在DispathcherServlet的方法内部进行的,SpringMVC框架的三大组件处理器映射器,处理器适配器,和视图解析器都是由DispathcherServlet从Spring的webapp容器中获取的。非常有意思的设计,下面让我们来看看这三大组件都有哪些配置。

这是一个property文件,位于springmvc框架的依赖jar包下。红色框框标识出都是DispathcherServlet中的对象属性。

LocaleResolver 是一个国际化的解析器,它使用i18n国际化的标准能够为不同国家的展示不同语言的页面。ThemeResolver 用于防止注入式攻击。HandlerMapping 配置默认使用的requestMapping映射器。HandlerAdapter 配置默认使用的requestMapping适配器。HandlerExceptionResolver 异常解析器RequestToViewNameTranslator 请求jsp路径时的事务管理器ViewResolver 配置默认使用的r视图解析器。

等等等等,同类型Struts2框架有22种拦截器分别对应不同的功能,因为web层与用户进行直接交互所以功能相比service和dao都要复杂些。我们也可以在xml文件中自定义每个功能所使用的类。

我们可以在xml文件中手动指定想要使用的组件类型,只需要将该类注册到spring容器中即可,不需要配置其他东西。

该标签用于启动mvc的注解驱动,有这个标签相当于我们默认使用注解来表示请求路径，就是@requestMapping注解,默认在上面property文件中是启用的,所以这个标签可以不写。

InternalResourceViewResolver则是个很有用的功能,他能够为我们controller中set的ViewName补充前后缀。见下图

图中代码本是配置jsp页面的路径的,有了上面的配置后我们可以省略所以jsp页面共同的前后缀部分,最后拼接后的路径为/WIN-INF/asas.jsp。

核心对象

1.1. HandlerMapping 处理器映射管理对象

HanderMapping 处理器映射管理对象:

作用：根据不同的请求选择最合适的处理器(自己编写的控制器)，处理器映射管理对象可以配置多个，谁最先匹配就执行谁。

SpringMVC默认：/org/springframework/web/servlet/DispatcherServlet.properties

BeanNameUrlHandlerMapping	处理通过<bean name="/xxx">注册的控制器。控制器需要实现Controller接口。
DefaultAnnotationHandlerMapping	处理通过注解@Controller(类标签) 及@RequestMapping(方法标签) 注册的控制器。该处理器映射管理对象已经在Spring 3.2 版本过时，替换为RequestMappingHandlerMapping。

spring 中提供的内置处理器映射：

简单url处理器映射

org.springframework.web.servlet.handler.SimpleUrlHandlerMapping

（了解即可，现在已经基本不用了）

<value>

/helloworld(url 地址)=helloworldController(bean id)

/helloworld002=helloworldController

</value>

</property>

</bean>

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping 采用注解方式请求处理器映射。

使用<mvc:annotation-driven/>开启新的映射处理器。

HandlerAdapter 处理器适配

作用：支持多种类型的处理器，如何来执行"处理器（控制器）"；如何执行我们的控制器。

Spring默认处理器适配：

org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter 处理实现了HttpRequestHandler接口对应的控制器

org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter 处理实现了Controlle接口对应的控制器。

使用<mvc:annotation-driven/>开启新的处理器适配

org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter 处理通过注解方式的控制器。 3.2中已过时，替换为org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

1.1. ViewResolver 视图解析器 (struts2视图类型类似)

作用：根据不同的视图，响应不同的结果，比如普通的jsp或json.

SpringMVC默认：

InternalResourceViewResolver : 支持默认视图，采用forward,redirect。

视图名规则

不写前缀默认为"转发"

视图名字符串前缀:

forward:/xxx.jsp 采用转发。

redirect:/xxx.jsp 采用重定向。

new ModelAndView("forward:/userList");

new ModelAndView("redirect:/user");

设置视图路径的前后缀，该配置可以让我们写视图路径的时候更简单。

</bean>

路径简写：

注意事项："forward:"与"redirect:"前缀问题

页面不在前缀路径中的情况（或者页面路径不是以.jsp为后缀）

课程总结

重点

Controller的实现方式：全注解

参数的接收：在形参中使用java内置的类型接收(常用)

在形参中使用domain接收(常用)

视图返回：返回一个String的字符串

参数的返回：json的返回