SpringMVC小结

「爱情、让人受尽委屈。」 2022-03-20 03:39 140阅读 0赞

**目录**

1、历史背景

1.1、servlet

1.2、Struts2

1.3、Spring MVC

1.4、Servlet和SpringMvc区别

1.5、SpringMvc和Mybatis区别

2、结构图解

2.1、mvc思想进阶图

2.2、spring Mvc结构流程

3、内容概括

3.1、对象讲解

3.2、功能讲解

3.2.0、请求转发与重定向

3.2.0.1、返回 ModelAndView

3.2.0.2、返回 String

3.2.0.3、返回 void

3.2.0.4、请求转发和重定向总结

3.2.1、包装类型pojo参数绑定

3.3、 Springmvc校验

3.4、 数据回显

3.5 、异常处理

3.6 、上传图片

3.7 、RESTful支持

3.8、 拦截器

3.9、中文乱码

3.10、类型转化器

4、注解开发

5、案例图解

6、问题解决

6.1、静态资源的访问

--------------------

## 1、历史背景 ##

**目前很多公司的架构，从Struts2迁移到了SpringMVC。你有想过为什么不使用Servlet+JSP来构建Java web项目，而是采用SpringMVC呢？**

既然这样，我们从源头说起。Struts2的源头其实也是Servlet。Servlet的作用是接收浏览器传给服务端的请求（request），并将服务端处理完的响应（response）返回给用户的浏览器，**浏览器和服务端之间通过http协议进行沟通，其过程是浏览器根据用户的选择将相关信息按http协议报文的规范组装请求的http报文，报文通过网络传输到指定的服务器，服务器通过特定的web容器接收这个报文信息，例如：tomcat，jetty，jboss这样的web容器，web容器会将http报文解析出来，如果是用户请求，最终解析出来的报文信息会用一个request对象存储起来，服务端使用这个request做完相应的处理后，服务端程序将结果信息封装到response对象里，然后将response对象交给web容器，web容器则把这个response对象转变为http协议的报文，并将报文回传给浏览器**，浏览器最后解析这个响应报文，将最终结果展示给用户。

Web容器创造了servlet接口，servlet接口就是开发人员自己实现业务逻辑的地方，程序员开发servlet就好比做填空题，而填空题的语境或者说上下文提示就是由request和response对象，但是javaEE规范里的servlet接口很简单，就三个方法init，service和destory，但是这个接口太笼统，所以规范里还提供了一个HttpServlet类，这个类根据http请求类型提供了doGet，doPost等方法，servlet接口最大的特点就是根据http协议的特点进行定义，因此做servlet开发时候如果使用者对http协议特点不是特别熟悉，都会碰到或多或少令人迷惑的问题，特别是碰到一些复杂特殊的请求时候：例如文件上传，返回特殊的文件格式到浏览器，这时候使用servlet开发就不是很方便了，servlet开发还有个问题可能大家常常被忽视，就是请求的数据的类型转化，http协议传输都是文本形式，到了web容器解析后也是文本类型，如果碰到货币，数字，日期这样的类型需要我们根据实际情况进行转化，如果页面传送的信息非常多，我们就不得不做大量类型转化，这种工作没有什么技术含量，是个体力活而且很容易导致程序错误。同时java的企业开发都是围绕javabean进行，类型转化好的数据还要封装到对应的javabean里，这种转来转去的事情对于项目开发绝对不是什么好事情，所以古老的struts1为这种问题找到了一种解决方案，就是定义了一个DTO对象（数据传输对象），专门负责做这样的事情，不过到了struts2，整个替代servlet的action本身就是一个javabean。

Java的企业开发一个技术特点就是使用javabean进行的，struts2的特点之一就是它替代servlet的操作类就是一个典型的javabean，首先struts2框架将页面传输的数据进行类型转化和封装后将请求信息封装到了这个javabean的属性里，这样我们开发web程序时候就省去了烦心的类型转化和封装的问题，前面我讲到传统的servlet是根据http协议进行定义的，它会按你请求方式（post还是get方式）来处理用户的请求，但是对于一名程序开发人员而言，一个请求，具体到一个url，其实对于服务端而言就是服务端对外提供的一个功能，或者说是服务端对外的一个动作，如果我们使用servlet开发程序我们就得把http的动作转化为具体的业务动作，这就让程序开发变得繁琐，增强了开发的难度，所以struts2替代servlet的javabean就屏蔽了servlet里http的请求方式和具体业务动作转化的问题，javabean里的每一个方法都可以和每一个url请求一一对应，这必然减轻了开发的难度问题。

Servlet另一个作用就是构造response对象，让页面获得正确的响应，其实现代的浏览器是一个多媒体工具，文字，图片，视屏等等东西都可以在浏览器里显示，资源的不同就会导致http响应报文的差别，如果我们使用servlet开发就要根据资源的不同在java程序里用硬编码的形式处理，这样的程序很难复用，而且如果程序员对某种资源的处理理解不到位，就会导致问题的出现，struts2通过配置文件的形式将这样的逻辑从java程序里剥离出来，使用配置的方式进行统一管理，这个做法和spring的AOP方式类似，这样就让结果处理方式更加统一，更加利于管理，同时也提升了程序的健壮性以及降低了开发的难度。

Servlet在MVC开发模式里就是其中C层即控制层，控制层就像俄罗斯的双头鹰（一个头向东看一个头向西看）一样，一个头向M层模型层看，一个头向V层视图层看，模型层也是用java编写的，控制层也属于服务端语言开发，所以M层和C层的沟通没有天然的障碍，但是和V层视图层就不一样了，这是一个跨语言的沟通，对于浏览器，它只懂得html，javascript和css，浏览器是理解不了java这种语言的东西，但是要让服务端的东西能被浏览器理解接受，我们就必须得把服务端的响应信息放到页面里，因此就需要一个技术把java的信息转化到html页面里，这就是javaEE规范里提供了jsp技术，jsp其实是一种服务端技术而非客户端技术，不过它看起来似乎更像html技术，最早的jsp开发里都是直接将java代码写到页面里，这种坏处谁都知道，之后javaEE规范提供了自定义标签技术，使用一种类似html标签的方式来解析java代码，struts2框架提供了一整套完整的自定义标签技术，这似乎听起来不算啥，但是它的作用非凡，因为自定义标签之所以叫自定义就是每个人都可以自己来定义，如果没有一个规范必然产生混乱，而且一套完善的自定义标签是个系统工程，一套完整的自定义标签相当于我们在自己定义一套新的开发语言，做程序的人听到这个一定就会明白开发一套完整的自定义标签的工作量和开发难度都是难以想象的，而且自定义标签都是和控制层紧密相连，其难度又会增加一个维度，所以struts2提供的自定义标签对于业务开发带来的将是质的飞越。

Servlet里还有两个重要的技术：监听器和过滤器，对于监听器在web开发里使用的场景比较少，都是一些十分特别的情况才会使用，大部分web开发里可以忽略它的使用，我们用的最多的监听器可能就是对ServletContext创建和销毁的监听器，ServletContext是整个web应用的全局对象，它和Web应用的生命周期绑定在一起，因此使用这个监听器对Web应用的全局信息进行初始化和销毁操作，例如spring容器的初始化操作。比较有意思的是过滤器，在struts2里有个拦截器，它们的作用相同都是用来拦截请求的，因为拦截器是struts2的特有功能，在struts2里使用拦截器自然比使用过滤器更顺手，其实拦截器所用的技术比过滤器更加先进，因为拦截器使用了反射技术，因此拦截器拦截的面更大，控制请求的能力更强，它能完成的任务也会更加的丰富多彩。

在我第一次接触struts2时候，有人告诉我struts设计的一个目的就是想屏蔽在控制层里操作request和response对象，因为这两个http协议的儿子会造成web开发里思路的混乱，但是我在实际开发里却经常不自觉的使用这两个对象。而且本人做前端开发非常喜欢使用ajax，使用ajax技术时候我就很讨厌struts2的自定义标签，我更加喜欢在页面里用javascript技术处理各种信息，最终struts2在我眼里就是一个servlet的变体，因此曾经有段时间我常常在想是不是可以抛弃struts2，直接用servlet，因为struts2里用到了太多反射机制，特别是使用注解做配置（注解是用反射实现的），在java里反射的执行效率是非常低的，直接使用servlet一定能提升web应用的执行效率。其实这个倒很难做到，因为当时我没法在servlet里灵活的运用spring技术。

原文：[https://blog.csdn.net/lee\_sire/article/details/53333023][https_blog.csdn.net_lee_sire_article_details_53333023](只是摘抄了一部分，原文强烈推荐)

> 上面内容也讲到了servlet----->Struts----->SpringMVC，但是侧重点和我想要的不太一样，下面重新围绕这三个技术来讲一下spring mvc的背景，以及Struts2和spring mvc比较

### 1.1、servlet ###

1、servlet执行流程

1. 请求发送到8080端口，被connector监听到，创建request和response对象用来请求交换数据，并创建新的线程处理这个请求

2. Connector将该请求交给它所在的service的engine处理，并等待回应

3. Engine根据请求的URL，匹配相应的虚拟主机

4. 匹配成功后，将请求交给此虚拟主机来处理

5. 虚拟主机获得/test/index.jsp，匹配他所拥有的的context

6. Path为test的context获得index.jsp，在里面找到\*.JSP的jspservlet

7. 调用jspservlet的doget,dopost方法

8. 执行完成后将response返回给engine

9. Engine将response返回给connector，再返回给客户端浏览器

### 1.2、Struts2 ###

2.Struts2工作流程  
a) 客户端发出一个请求到servlet容器

b) 请求经过一些列过滤被filterdispatcher调用，filterdispatch通过actionMapper去找相对应的action。

c) Actionmapper找到对应的action返回给filterdispatch，dispatch把处理权交给actionproxy

d) Actionproxy通过配置文件找到对应的action类

e) Actionproxy创建一个actionIinvocation的实例处理业务逻辑

f) 一旦action处理完毕，actioninvocation负责根据stuts.xml的配置找到对应的返回结果。返回结果通常是jsp页面。

### 1.3、Spring MVC ###

1. 发起请求到前端控制器

2. 前端控制器查找handlerMapping查找handler

3. 控制器调用适配器执行handler

4. Handler处理完成之后会返回modelandview

5. 前端控制器解析modelandview，将其结析为真正的视图返回view，填充到request作用域中

6. 前端控制器向用户响应结果

### 1.4、Servlet和SpringMvc区别 ###

Servlet：性能最好，处理Http请求的标准。

SpringMVC：开发效率高（好多共性的东西都封装好了，是对Servlet的封装，核心的DispatcherServlet最终继承自HttpServlet），复杂类型的转换强与servlet，多种资源的处理强于servlet。

这两者的关系，就如同MyBatis和JDBC，一个性能好，一个开发效率高，是对另一个的封装。

### 1.5、SpringMvc和Mybatis区别 ###

*          1.springmvc入口是一个servlet前端控制器(DispatcherServlet),struts2入口是一filter过滤器(StrutsPrepareAndExecuteFilter).
 *          2.struts2通过在action类中定义成员变量接收参数,(属性驱动和模型驱动),它只能使用多例模式管理action.
 *   springmvc通过在coontroller方法中定义形参接收参数,springmvc可以使用单例模式管理controller.      
 *          3.springmvc是基于方法开发的,注解开发中使用requestMapping将url和方法进行 映射,如果根据url找到controller类的方法生成一个handler处理器对象(只包括一个method).
 *  struts2是基于类开发的,每个请求过来创建一个action实例,实例对象中有若干个方法.
 *  开发中建议使用springmvc,springmvc方法更类似service业务方法.
 *          4.struts2采用值栈存储请求和相应的数据,通过OGNL存取数据,springmvc通过参数绑定期将request请求内容解析,并给方法形参赋值.
 *          5.struts2和springmvc的速度是相当的,由于struts2的漏洞较多,跟多企业使用springmvc

**运行性能上**：

JSP+Servlet>Struts1>spring mvc>struts2+freemarker>>struts2,ognl值栈。

**开发效率上，基本正好相反，值得强调的是，spring mvc开发效率和struts2不相上下。**

struts2的性能低的原因是因为OGNL值栈造成的。所以，如果你的系统并发量高，可以使用freemarker进行显示，而不是采用OGNL和值栈。这样，在性能上会有相当大的提高。

## 2、结构图解 ##

### 2.1、mvc思想进阶图 ###

![XApjGKM.png][]

![iEQSPKx.png][]

### 2.2、spring Mvc结构流程 ###

![932062-20160909153624488-530274633.png][]

【流程图说明】

1.用户发送请求至前端控制器DispatcherServlet（中央控制器）。

2.前端控制器DispatcherServlet收到请求后调用处理器映射器HandlerMapping。

3.处理器映射器HandlerMapping根据请求的Url找到具体的处理器，生成**处理器对象Handler**及**处理器拦HandlerIntercepter**（如果有则生成）一并返回给前端控制器DispatcherServlet。

4.前端控制器DispatcherServlet通过处理器适配器HandlerAdapter调用处理器Controller。

5.执行处理器（Controller，也叫后端控制器）

6.处理器Controller执行完后返回ModelAnView。

7.处理器映射器HandlerAdapter将处理器Controller执行返回的结果ModelAndView返回给前端控制器DispatcherServlet。

8.前端控制器DispatcherServlet将ModelAnView传给视图解析器ViewResolver。

9.视图解析器ViewResolver解析后返回具体的视图View。

10.前端控制器DispatcherServlet对视图View进行渲染视图（即：将模型数据填充至视图中）

11.前端控制器DispatcherServlet响应用户。

> 下边两个组件通常情况下需要开发：在下面会逐个讲解。。
> 
> Handler：处理器，即后端控制器用controller表示。
> 
> View：视图，即展示给用户的界面，视图中通常需要标签语言展示模型数据。

## 3、内容概括 ##

### 3.1、对象讲解 ###

**3.1.1.DisPatcherServlet：前端控制器（不需要程序员开发）**

用户请求到达前端控制器，它相当于MVC模式中的C（Controller），DispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet的存在降低了组件之间的耦合性。

作用：作为接受请求，相应结果，相当于转发器，中央处理器，减少其他组件之间的耦合度。

* 中央处理器的映射路径<url-pattern/>常使用后辍匹配方式，建议写为\*.do。
 * 如果写为“/”则会将请求当做一个controller请求，中央处理器就会去处理器映射器查找对应的处理器。当然是找不到，所有的jsp报404.
 * 如果写为“/\*”中央处理器也会当成一个controller请求，静态资源也会找不到。。。

**3.1.2.HandlerMapping：处理器映射器（不需要程序员开发）**

处理器映射器将会把请求映射为 HandlerExecutionChain 对象（包含一个 Handler 处理器对象、多个 HandlerInterceptor 拦截器）对象，通过这种策略模式，很容易添加新的映射策略。HandlerMapping负责根据用户请求找到Handler（即：处理器），SpringMVC提供了不同的映射器实现实现不同的映射方式，例如：配置文件方式、实现接口方式、注解方式等。

处理器映射器有三种，三种可以共存，相互不影响，分别是BeanNameUrlHandlerMapping、SimpleUrlHandlerMapping和ControllerClassNameHandlerMapping；

a）BeanNameUrlHandlerMapping

默认映射器，即使不配置，默认就使用这个来映射请求。

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
 //映射器把hello.do请求映射到该处理器
 <bean id="testController" name="/hello.do" class="org.controller.TestController"></bean>

**缺点：**

1：处理器 Bean 的 id 为一个 url 请求路径，而不是 Bean 的名称，有些不伦不类

2：处理器 Bean的定义与请求 url绑定在了一起。若出现多个 url请求同一个处理器的情况，

就需要在 Spring 容器中配置多个该处理器类的<bean/>。这将导致容器会创建多个该处理器类实例。

b）SimpleUrlHandlerMapping

该处理器映射器可以配置多个映射对应一个处理器.

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
     <property name="mappings">
         <props>
             <prop key="/ss.do">testController</prop>
             <prop key="/abc.do">testController</prop>
         </props>
     </property>
 </bean>
 
 //上面的这个映射配置表示多个*.do文件可以访问同一个Controller。    
 <bean id="testController" name="/hello.do" class="org.controller.TestController"></bean>
 
 
 <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
 	
 	
 	
 	<property name="urlMap">
 		<map>
 			<entry key="/hello.do" value="myController"/>		
 		</map>
 	</property> 
 </bean>
 
 
 
 <bean id="myController" class="controller.MyController"/>

c）ControllerClassNameHandlerMapping

该处理器映射器可以不用手动配置映射, 根据类名（UserController）类名.do来访问,类名首字母小写.这种方式一般不采用,因为一旦控制器名称更改的话,访问路径也得跟着更改,变动性较大.

//这个Mapping一配置, 我们就可以使用Controller的 [类名.do]来访问这个Controller.
 <bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"></bean>

注意：如果在映射配置文件中配置了多个映射处理器，请求的时候具体走哪一个是有顺序的，可以通过一个参数进行设置。

> <bean name="/home.action" class="cn.itcast.springmvc.HomeController">
> 
>  
>  <property name="order" value="0"/>
> 
> </bean>

**3.1.3.HandlerAdapter：处理器适配器**

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

作用：按照特定的规则（HandlerAdapter要求的规则）去执行Handler

处理器适配器有两种，可以共存，分别是SimpleControllerHandlerAdapter和HttpRequestHandlerAdapter。

a）SimpleControllerHandlerAdapter  
SimpleControllerHandlerAdapter是默认的适配器，所有实现了org.springframework.web.servlet.mvc.Controller 接口的处理器都是通过此适配器适配, 执行的。其本质是执行Controller中的handleRequest方法。

（1）配置HttpRequestHandlerAdapter适配器

<bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"></bean>

（2）编写处理器

public class HttpController implements HttpRequestHandler{
    
        public void handleRequest(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            //给Request设置值，在页面进行回显
            request.setAttribute("hello", "这是HttpRequestHandler！");
            //跳转页面
            request.getRequestDispatcher("/WEB-INF/jsps/index.jsp").forward(request, response);
        }
    }

b）HttpRequestHandlerAdapter  
该适配器将http请求封装成HttpServletResquest 和HttpServletResponse对象. 所有实现了 org.springframework.web.HttpRequestHandler 接口的处理器都是通过此适配器适配, 执行的. 底层是调用HttpRequestHandler.handlerRequest(request,response);:

**3.1.4.HandLer：处理器（需要程序员开发）**

Handler是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下，Handler对具体的用户请求进行处理。

由于Handler设计到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

> 注意：编写Handler时按照HandlerAdpter的要求去做，这样才可以去正确执行Handler。

这里只介绍上文提到的两种处理器, 除此之外还有很多适用于各种应用场景的处理器, 尤其是Controller接口还有很多实现类, 大家可以自行去了解.

**           **a）Controller

org.springframework.web.servlet.mvc.Controller, 该处理器对应的适配器是 SimpleControllerHandlerAdapter.  
  
该处理器方法用于处理用户提交的请求, 通过调用service层代码, 实现对用户请求的计算响应, 并最终将计算所得数据及要响应的页面封装为一个ModelAndView 对象, 返回给前端控制器(DispatcherServlet).

public interface Controller {
    
    	/**
    	 * Process the request and return a ModelAndView object which the DispatcherServlet
    	 * will render. A {@code null} return value is not an error: it indicates that
    	 * this object completed request processing itself and that there is therefore no
    	 * ModelAndView to render.
    	 * @param request current HTTP request
    	 * @param response current HTTP response
    	 * @return a ModelAndView to render, or {@code null} if handled directly
    	 * @throws Exception in case of errors
    	 */
    	ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
    
    }

Controller接口的实现类:

![IcG30SM.png][]

b）HttpRequestHandler

org.springframework.web.HttpRequestHandler, 该处理器对应的适配器是 HttpRequestHandlerAdapter.

public interface HttpRequestHandler {
        void handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws ServletException, IOException;
    }

该处理器方法没有返回值, 不能像 ModelAndView 一样, 将数据及目标视图封装为一个对象, 但可以将数据放入Request, Session等域属性中, 并由Request 或 Response完成目标页面的跳转.

**3.1.5.ViewResolver：视图解析器（不需要程序员开发）**

ViewResolver负责将处理结果生成View视图，ViewResolver首先根据逻辑视图名解析成物理视图名，即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面的展示给用户。SpringMVC框架提供了很多View视图类型，包括：JSTLView、freemarkerView、pdfView等等.

视图解析器负责将处理结果生成View视图. 这里介绍两种常用的视图解析器:

a）InternalResourceViewResolver（只能访问内部资源）

该视图解析器用于完成对当前Web应用内部资源的封装和跳转. 而对于内部资源的查找规则是, 将ModelAndView中指定的视图名称与视图解析器配置的前缀与后缀想结合, 拼接成一个Web应用内部资源路径. 内部资源路径 = 前缀 + 视图名称 + 后缀.

InternalResourceViewResolver解析器会把处理器方法返回的模型属性都存放到对应的request中, 然后将请求转发到目标URL.

(1) 处理器

public class MyController implements Controller {
        @Override
        public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
            ModelAndView mv = new ModelAndView();
            mv.addObject("hello", "hello world!");
            mv.setViewName("index");
            return mv;
        }
    }

(2) 视图解析器配置

当然, 若不指定前缀与后缀, 直接将内部资源路径写到 setViewName()中也可以, 相当于前缀与后缀均为空串.

mv.setViewName("/WEB-INF/jsp/index.jsp");

b）BeanNameViewResolver（外部资源的访问,根据）

InternalResourceViewResolver视图解析器存在一个问题, 就是只可以完成将内部资源封装后的跳转, 无法跳转向外部资源, 如外部网页.BeanNameViewResolver 视图解析器将资源(内部资源和外部资源)封装为bean实例, 然后在 ModelAndView 中通过设置bean实例的id值来指定资源. 在配置文件中可以同时配置多个资源bean.

第一种：匹配bean类

1. 在SpringMVC配置文件中添加BeanNameViewResolver

> <bean class="org.springframework.web.servlet.view.BeanNameViewResolver"> 
> <property name="order" value="10" /> 
> </bean> 
> 
>  
> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
> <property name="prefix" value="/WEB-INF/"></property> 
> <property name="suffix" value=".jsp"></property> 
> </bean>

2. 创建一个HelloView类，实现View接口

> import java.util.Date; 
> import java.util.Map; 
> 
> import javax.servlet.http.HttpServletRequest; 
> import javax.servlet.http.HttpServletResponse; 
> 
> import org.springframework.stereotype.Component; 
> import org.springframework.web.servlet.View; 
> 
> @Component 
> public class HelloView implements View{ 
> 
> public String getContentType() { 
> // TODO Auto-generated method stub 
> return "text/html"; 
> } 
> 
> public void render(Map<String, ?> model, HttpServletRequest request, 
> HttpServletResponse response) throws Exception { 
> // TODO Auto-generated method stub 
> response.getWriter().print("Welcome to View:"+new Date()); 
> } 
> 
> }

3. 创建控制器

>     import org.springframework.stereotype.Controller;  
>     import org.springframework.web.bind.annotation.RequestMapping;  
>       
>     @RequestMapping(value="/springmvc")  
>     @Controller  
>     public class MyView {  
>         @RequestMapping(value="/testMyView")  
>         public String testView(){  
>             System.out.println("testView");  
>             return "helloView";
>         }  
>     }

这里return的是视图名的第一个字母小写，springmvc会根据这个helloView名，去getBean,得到这个视图对象

第二种：匹配ID名

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 1][]

**3.1.6.View视图 （需要程序员开发 jsp）**

ModelAndView其本质是一个hashmap，

View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf）

一般情况下需要通过页面标签或者页面模板技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

### 3.2、功能讲解 ###

### 3.2.0、请求转发与重定向 ###

当处理器对请求处理完毕后，向其它资源进行跳转时，有两种跳转方式：请求转发与重  
定向。而根据所要跳转的资源类型，又可分为两类：跳转到页面与跳转到其它处理器。  
注意，对于请求转发的页面，可以是 WEB-INF中页面；而重定向的页面，是不能为 WEB-INF  
中页的。因为重定向相当于用户再次发出一次请求，而用户是不能直接访问 WEB-INF 中资  
源的  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 2][]

### **3.2.0.1、返回 ModelAndView** ###

**1）返回 ModelAndView 时的请求转发**

默认情况下， 当处理器方法返回 ModelAndView 时，跳转到指定的 View，使用的是请求转发。但也可显式的进行指出。 此时，需在 setViewName()指定的视图前添加 forward:，且此时的视图不会再与视图解析器中的前辍与后辍进行拼接。即必须写出相对于项目根的路径。故此时的视图解析器不再需要前辍与后辍。  
![20190211103939330.png][]

**请求转发到其它 Controller：**  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 3][]

**2）返回 ModelAndView 时的重定向**  
返回 ModelAndView 时的重定向，需在 setViewName()指定的视图前添加 redirect:，且此时的视图不会再与视图解析器中的前辍与后辍进行拼接。即必须写出相对于项目根的路径。故此时的视图解析器不再需要前辍与后辍。**重定向的目标资源中，将无法访问用户提交请求 request 中的数据。因为服务器再次发出请求。。**  
重定向到页面：  
![20190211104541157.png][]

> 在重定向时，请求参数是无法通过 request 的属性向下一级资源中传递的。但可以通过  
> 以下方式将请求参数向下传递。

**1、通过 ModelAndView 的 Model 携带参数**  
当 ModelAndView 中的 ***Model 存入数据后，视图解析器 InternalResourceViewResolver 会将 map 中的 key 与 value，以请求参数的形式放到请求的 URL 后。记住所有存放入Model中的数据都是放到URL后的。。***  
不过需要注意以下几点：

*   由于视图解析器会将 Map 的 value 放入到 URL 后作为请求参数传递出去，所以无论什么类型的 value，均会变为 String。故此， 放入到 Model 中的 value，只能是基本数据类型与 String，不能是自定义类型的对象数据。
 *   重定向的面页中是无法从 request 中读取数据的。但由于 map 中的 key 与 value，以请
 *  求参数的形式放到了请求的 URL 后，所以，页面可以通过 EL 表达式中的请求参数 param
 *  读取。
 *   重定向的页面不能是/WEB-INF 中的页面。

由于 Model 中的数据是放在 URL 后的参数，所以页面需要使用 param 来接收。  
![20190211104711135.png][]

**4）使用 HttpSession 携带参数**  
（2） 重定向到 Controller  
重定向到其它 Controller 时，若要携带参数， 完全可以采用前面的方式。而对于目标Controller 接收这些参数，则各不相同  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 4][]

参数名相同即可。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 5][]

### 3.2.0.2、返回 String ###

**1）返回 String 时的请求转发**  
当处理器方法返回 String 时，该 String 即为要跳转的视图。在其前面加上前辍 forward:，则可显式的指定跳转方式为请求转发。 同样，视图解析器不会对其进行前辍与后辍的拼接。请求转发的目标资源无论是一个页面，还是一个 Controller，用法相同。  
注意，此时不能再使用 ModelAndView 传递数据了。因为在处理器方法中定义的ModelAndView 对象就是个局部变量，方法运行结束，变量销毁。而当前的处理器方法返回的为 String，而非 ModelAndView，所以这个创建的 ModelAndView 就不起作用了。不过， 需要注意的是， 对于处理器方法返回字符串的情况， 当处理器接收到请求中的参数后，发现用于接收这些参数的处理方法形参为包装类对象，则除了会将参数封装为对象传递给形参外，还会存放到 request 域属性中。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 6][]

**2）返回 String 时的重定向**  
在处理器方法返回的视图字符串的前面添加前辍 redirect:，则可实现重定向跳转。当重定向到目标资源时，若需要向下传递参数值，除了可以直接通过请求 URL 携带参数，通过 HttpSession 携带参数外，还可使用其它方式  
**3）通过 Model 形参携带参数**  
可以在 Controller 形参中添加 Model 参数，将要传递的数据放入 Model 中进行参数传递。该方式同样也是将参数拼接到了重定向请求的 URL 后，所以放入其中的数据只能是基本类型数据，不能是自定义类型  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 7][]

**4）通过形参 RedirectAttributes 的 addAttribute()携带参数**  
RedirectAttributes 是 Spring3.1 版本后新增的功能，专门是用于携带重定向参数的。它是一个继承自 Model 的接口，其底层仍然使用 ModelMap 实现。通过 addAttribute()方法会将参数名及参数值放入该 Map 中，然后视图解析器会将其拼接到请求的 URL 中。 所以，这种携带参数的方式，不能携带自定义对象。和model一样  
**5）重定向到 Controller**  
重定向到 Controller 时，携带参数的方式，除了可以使用请求 URL 后携带方式，HttpSession携带方式， Model 形参携带方式，及 RedirectAttributes 形参的 addAttibute()携带方式外，还可以使用 RedirectAttributes 形参的 addFlushAttibute()携带方式。

###    3.2.0.3、返回 void  ###

**1）返回 void 时的请求转发**  
当处理器方法返回 void 时，若要实现请求转发，则需要使用 HttpServletRequest 的请求转发方法。 无论下一级资源是页面，还是 Controller，用法相同。不过，需要注意的是，若有数据需要向下一级资源传递，则需要将数据放入到 request或 session 中。 不能将数据放到 Model、 RedirectAttributes 中。 因为它们中的数据都是通过拼接到处理器方法的返回值中，作为请求的一部分出现向下传递的。这里没有返回值，所以它们中的数据便无法向下传递了

**2）返回 void 时的重定向**

当处理器方法返回 void 时，若要实现重定向，则需要使用 HttpServletResponse 的重定向方法 sendRedirect()。不过，需要注意的是，若有数据需要向下一级资源传递，则需要将数据放入到 session中

### 3.2.0.4、请求转发和重定向总结 ###

1）返回类型为ModelAndView：

携带参数的方式有ModelAndView，model（URL 后的参数，所以页面需要使用 param 来接收。），HttpSession

2）返回类型为String：

携带参数的方式有HttpSession（则除了会将参数封装为对象传递给形参外，还会存放到 request 域属性中。）、RedirectAttributes 的addAttribute()（map的URL）、RedirectAttributes 形参的 addFlushAttibute()

3）返回类型为Void：

HttpServletRequest ，session

###    3.2.1、包装类型pojo参数绑定 ###

方法一：在形参中 添加HttpServletRequest request参数，通过request接收查询条件参数。  
方法二：在形参中让包装类型的pojo接收查询条件参数。

举例方法二

商品名称：<input name="itemsCustom.name" /> 
注意：itemsCustom和包装pojo中的属性一致即可。

Controller代码，这时itemsQueryVo中的itemsCustom中的name属性就有值了。

@Controller
 @RequestMapping("/items")
 
 public class ItemsController {
 @RequestMapping("/queryItems")
 public ModelAndView queryItems(HttpServletRequest request,
 ItemsQueryVo itemsQueryVo) throws Exception {
 // 测试forward后request是否可以共享
 
 System.out.println(request.getParameter("id"));
 
 // 调用service查找 数据库，查询商品列表
 List<ItemsCustom> itemsList = itemsService.findItemsList(itemsQueryVo);
 
 // 返回ModelAndView
 ModelAndView modelAndView = new ModelAndView();
 // 相当 于request的setAttribut，在jsp页面中通过itemsList取数据
 modelAndView.addObject("itemsList", itemsList);
 
 // 指定视图
 // 下边的路径，如果在视图解析器中配置jsp路径的前缀和jsp路径的后缀，修改为
 // modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");
 // 上边的路径配置可以不在程序中指定jsp路径的前缀和jsp路径的后缀
 modelAndView.setViewName("items/itemsList");
 
 return modelAndView;
 }
 }

此外，集合类型绑定也是相同的，name属性要与后台pojo中的属性对应，即可完成传值。

###    3.3、 Springmvc校验 ###

SpringMVC 支持 JSR（Java Specification Requests， Java 规范提案）303 - Bean Validation  
数据验证规范。而该规范的实现者很多，其中较常用的是 Hibernate Validator。需要注意的是，  
Hibernate Validator 是与 Hibernate ORM 并列的 Hibernate 的产品之一。这一点从 Hibernate 官  
网上所提供的资源形式可以看出它们之间的关系。

**3.30.jar包准备**

![20190211120803551.png][]

**3.3.1.比较**

@Valid是使用hibernate validation的时候使用  
@Validated 是只用spring  Validator 校验机制使用\\  
**3.3.2.实现**  
其中，@valid，java的jsr303声明了这类接口，hibernate-validator对其进行了实现  
**3.3.3.依赖**  
在使用maven框架整合时，需要引入的依赖部分如下：

<dependency>  
             <groupId>javax.validation</groupId>  
             <artifactId>validation-api</artifactId>  
             <version>1.1.0.Final</version>  
         </dependency>  
   
         <dependency>  
             <groupId>org.hibernate</groupId>  
             <artifactId>hibernate-validator</artifactId>  
             <version>5.2.1.Final</version>  
         </dependency>

**3.3.4.JSR303定义的校验类型**

> <table> 
> <tbody> 
> <tr> 
> <td>序号</td> 
> <td>验证注解</td> 
> <td>说明</td> 
> </tr> 
> <tr> 
> <td>1</td> 
> <td>@AssertFalse</td> 
> <td>验证注解的元素值是 false</td> 
> </tr> 
> <tr> 
> <td>2</td> 
> <td>@AssertTrue</td> 
> <td>验证注解的元素值是 true</td> 
> </tr> 
> <tr> 
> <td>3</td> 
> <td>@DecimalMax（value=x）</td> 
> <td>验证注解的元素值小于等于指定的十进制 value 值</td> 
> </tr> 
> <tr> 
> <td>4</td> 
> <td>@DecimalMin（value=x）</td> 
> <td>验证注解的元素值大于等于指定的十进制 value 值</td> 
> </tr> 
> <tr> 
> <td>5</td> 
> <td>@Digits(integer=整数位数, fraction=小数位数)</td> 
> <td>验证注解的元素值的整数位数和小数位数 上限</td> 
> </tr> 
> <tr> 
> <td>6</td> 
> <td>@Future</td> 
> <td>验证注解的元素值（日期类型）比当前时 间晚</td> 
> </tr> 
> <tr> 
> <td>7</td> 
> <td>@Max（value=x）</td> 
> <td>验证注解的元素值小于等于指定的 value 值</td> 
> </tr> 
> <tr> 
> <td>8</td> 
> <td>@Min（value=x）</td> 
> <td>验证注解的元素值大于等于指定的 value 值</td> 
> </tr> 
> <tr> 
> <td>9</td> 
> <td>@NotNull</td> 
> <td>验证注解的元素值丌是 null</td> 
> </tr> 
> </tbody> 
> </table>
> 
> <table> 
> <tbody> 
> <tr> 
> <td>10</td> 
> <td>@Null</td> 
> <td>验证注解的元素值是 null</td> 
> </tr> 
> <tr> 
> <td>11</td> 
> <td>@Past</td> 
> <td>验证注解的元素值（日期类型）比当前时 间早</td> 
> </tr> 
> <tr> 
> <td>12</td> 
> <td>@Pattern(regex=正则表达式)</td> 
> <td>验证注解的元素值不指定的正则表达式匹 配</td> 
> </tr> 
> <tr> 
> <td>13</td> 
> <td>@Size(min=最小值, max=最大值)</td> 
> <td>验证注解的元素值的在 min 和 max（包含） 指定区间之内，如字符长度、集合大小</td> 
> </tr> 
> <tr> 
> <td>14</td> 
> <td>@Valid</td> 
> <td>验证关联的对象，如账户对象里有一个订 单对象，指定验证订单对象</td> 
> </tr> 
> <tr> 
> <td>15</td> 
> <td>@NotEmpty</td> 
> <td>验证注解的元素值丌为 null 且丌为空（字 符串长度丌为 0、集合大小丌为 0）</td> 
> </tr> 
> <tr> 
> <td>16</td> 
> <td>@Range(min=最小值, max=最大 值)</td> 
> <td>验证注解的元素值在最小值和最大值之间</td> 
> </tr> 
> <tr> 
> <td>17</td> 
> <td>@NotBlank</td> 
> <td>验证注解的元素值丌为空（丌为 null、去 除首位空格后长度为 0），丌同于 @NotEmpty，@NotBlank 只应用于字符 串且在比较时会去除字符串的空格</td> 
> </tr> 
> </tbody> 
> </table>
> 
> <table> 
> <tbody> 
> <tr> 
> <td>18</td> 
> <td>@Length(min=下限, max=上限)</td> 
> <td>验证注解的元素值长度在 min 和 max 区间 内</td> 
> </tr> 
> <tr> 
> <td>19</td> 
> <td>@Email</td> 
> <td>验证注解的元素值是 Email，也可以通过正 则表达式和 flag 指定自定义的 email 格式</td> 
> </tr> 
> </tbody> 
> </table>

**3.3.5.使用**

（1） 修改 springmvc 配置文件  
验证器由 SpringMVC 框架的 LocalValidtorFactoryBean 类生成，而真正验证器的提供者则是 HibernateValidator。在 SpringMVC 配置文件中将验证器注册后， 需要将其注入给注解驱动。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 8][]

（2） 在实体属性上添加验证注解  
使用的验证器注解均为 javax.validation.constraints 包中的类。在注解的 message 属性中，可以使用\{属性名\}的方式来引用指定的注解的属性值。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 9][]

（3） 修改 Controller  
![20190211122733996.png][]

由于这里使用的验证器为 Bean 对象验证器，所以对于要验证的参数数据，需要打包后由处理器方法以 Bean 形参类型的方式接收，并使用@Validated 注解标注。注意， 不能将@Validated 注解在 String 类型与基本类型的形参前。紧跟着@Validated 所注解的形参的后面，是一个 BindingResult 类型的形参。通过该形参可获取到所有验证异常信息。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 10][]

只要发生数据验证失败，则需要将页面重新跳转到 index.jsp 表单页面，让用户重填。BindingResult 接口中常用的方法有：  
 getAllErrors()：获取到所有的异常信息。其返回值为 List，但若没有发生异常，则该 List为也被创建，只不过其 size()为 0，而非 List 为 Null。  
 getFieldError()：获取指定属性的异常信息  
 getErrorCount()：获取所有异常的数量  
 getRawFieldValue()：获取到用户输入的引发验证异常的原始值  
![20190211122823874.png][]

### 3.4、 数据回显 ###

提交后，如果出现错误，将刚才提交的数据回显到刚才的提交页面。

**3.4.1 springmvc默认对pojo数据进行回显**

pojo数据传入controller方法后，springmvc自动将pojo数据放到request域，key等于pojo类型（首字母小写）  
使用@ModelAttribute指定pojo回显到页面在request中的key。

**3.4.2 @ModelAttribute还可以将方法的返回值传到页面**

在商品查询列表页面，通过商品类型查询商品信息。  
在controller中定义商品类型查询方法，最终将商品类型传到页面。

@RequestMapping("/editItemsSubmit")
 public String editItemsSubmit(Model model,
 HttpServletRequest request,
 Integer id,
 @Validated(value = { ValidGroup1.class }) ItemsCustom itemsCustom,
 MultipartFile items_pic,//接收商品图片
 BindingResult bindingResult) throws Exception{
 
 // 获取校验错误信息
 if (bindingResult.hasErrors()) {
 // 输出错误信息
 List<ObjectError> allErrors = bindingResult.getAllErrors();
 
 for (ObjectError objectError : allErrors) {
 // 输出错误信息
 System.out.println(objectError.getDefaultMessage());
 
 }
 // 将错误信息传到页面
 model.addAttribute("allErrors", allErrors);
 
 
 //可以直接使用model将提交pojo回显到页面
 model.addAttribute("items", itemsCustom);
 
 // 出错重新到商品修改页面
 return "items/editItems";
 }
 }

回显页面

<form id="itemForm" action="${pageContext.request.contextPath }/items/editItemsSubmit.action" method="post" enctype="multipart/form-data">
 <input type="hidden" name="id" value="${items.id }"/>
 修改商品信息：
 <table width="100%" border=1>
 <tr>
 <td>商品名称</td>
 <td><input type="text" name="name" value="${items.name}"/></td>
 </tr>
 <tr>
 <td>商品价格</td>
 <td><input type="text" name="price" value="${items.price}"/></td>
 </tr>
 <tr>
 <td>商品生产日期</td>
 <td><input type="text" name="createtime" value="<fmt:formatDate value="${items.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/>"/></td>
 </tr>
 </table>
 </form>

### 3.5 、异常处理 ###

**3.5.1 异常处理思路**

系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。

系统的dao、service、controller出现都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理，如下图：

![Image 1][]

image.png

springmvc提供全局异常处理器（一个系统只有一个异常处理器）进行统一异常处理。

第一种：使用spring mvc提供的异常处理器

**SimpleMappingExceptionResolver 异常处理器** 
该方式只需要在 SpringMVC 配置文件中注册该异常处理器 Bean 即可。该 Bean 比较特 
殊，没有 id 属性，无需显式调用或被注入给其它<bean/>，当异常发生时会自动执行该类。 
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 11][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 12][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 13][]

（3）注册异常处理器

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 14][]

第二种：自定义异常处理器

使用 SpringMVC 定义好的 SimpleMappingExceptionResolver 异常处理器，可以实现发生  
指定异常后的跳转。但若要实现在捕获到指定异常时，执行一些操作的目的，它是完成不了  
的。此时，就需要自定义异常处理器。  
自定义异常处理器，需要实现 HandlerExceptionResolver接口，并且该类需要在 SpringMVC  
配置文件中进行注册。  
（1） 定义异常处理器  
当一个类实现了 HandlerExceptionResolver 接口后，只要有异常发生，无论什么异常，  
都会自动执行接口方法 resolveException()。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 15][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 16][]

### 3.6 、上传图片 ###

**3.6.1 在springmvc.xml中配置multipart类型解析器**

<bean id="multipartResolver"
 class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
 
 <property name="maxUploadSize">
 <value>5242880</value>
 </property>
 </bean>

**3.6.2 创建图片虚拟目录存储图片**

[https://blog.csdn.net/cheney550995353/article/details/70185282][https_blog.csdn.net_cheney550995353_article_details_70185282]

**3.6.3 代码上传图片**

@RequestMapping("/editItemsSubmit")
        public String editItemsSubmit(Model model,
                                      HttpServletRequest request,
                                      Integer id,
                                      @Validated(value = { ValidGroup1.class }) ItemsCustom itemsCustom,
                                      MultipartFile items_pic,//接收商品图片
                                      BindingResult bindingResult) throws Exception{
    
            //原始名称
            String originalFilename = items_pic.getOriginalFilename();
    
            //上传图片
            if(items_pic!=null && originalFilename!=null && originalFilename.length()>0){
    
                //存储图片的物理路径
                String pic_path = "G:\\mine\\pic\\";
    
                //新的图片名称
                String newFileName = UUID.randomUUID() + originalFilename.substring(originalFilename.lastIndexOf("."));
                //新图片
                File newFile = new File(pic_path+newFileName);
                //将内存中的数据写入磁盘
                items_pic.transferTo(newFile);
                //将新图片名称写到itemsCustom中
                itemsCustom.setPic(newFileName);
            }
            itemsService.updateItems(id,itemsCustom);
    
            return "forward:queryItems.action";
    }

### 3.7 、RESTful支持 ###

**3.7.1 controller书写方式**

@RequestMapping(value="/ itemsView/\{id\}")：\{×××\}占位符，请求的URL可以是“/viewItems/1”或“/viewItems/2”，通过在方法中使用@PathVariable获取\{×××\}中的×××变量。  
@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上。  
如果RequestMapping中表示为"/ itemsView /\{id\}"，id和形参名称一致，@PathVariable不用指定名称。

//查询商品信息，输出json
        ///itemsView/{id}里边的{id}表示占位符，通过@PathVariable获取占位符中的参数，
        //如果占位符中的名称和形参名一致，在@PathVariable可以不指定名称
        @RequestMapping("/itemsView/{id}")
        public @ResponseBody
        ItemsCustom itemsView(@PathVariable("id") Integer id)throws Exception{
    
            //调用service查询商品信息
            ItemsCustom itemsCustom = itemsService.findItemsById(id);
            return itemsCustom;
        }

**3.7.2 REST方法的前端控制器配置**

<servlet>
 <servlet-name>springmvc_rest</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 
 <init-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>classpath:spring/springmvc.xml</param-value>
 </init-param>
 </servlet>
 
 <servlet-mapping>
 <servlet-name>springmvc_rest</servlet-name>
 <url-pattern>/</url-pattern>
 </servlet-mapping>

配置前端控制器的url-parttern中指定/，对静态资源的解析出现问题：  
在springmvc.xml中添加静态资源解析方法。

<mvc:resources location="/js/" mapping="/js/**"/>

### 3.8、 拦截器 ###

[https://www.cnblogs.com/black-spike/p/7813238.html][https_www.cnblogs.com_black-spike_p_7813238.html]

### 3.9、中文乱码 ###

Get请求乱码

Tomcat8已经解决了Get请求乱码, 如果是Tomcat8以下的版本, 可以使用以下两种方法:

更改Tomcat的配置文件server.xml

对参数进行重新编码

> String userName =new  
> String(request.getParamter(“userName”).getBytes(“ISO-8859-1”),“UTF-8”); //ISO-8859-1是Tomcat8以下版本的默认编码

Post请求乱码  
在web.xml中加入：

<filter>
     <filter-name>characterEncoding</filter-name>
     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
     <init-param>
         <param-name>encoding</param-name>
         <param-value>UTF-8</param-value>
     </init-param>
 </filter>
 <filter-mapping>
     <filter-name>characterEncoding</filter-name>
     <url-pattern>/*</url-pattern>
 </filter-mapping>

**也可以观看[https://blog.csdn.net/qq\_39313596/article/details/80549483][https_blog.csdn.net_qq_39313596_article_details_80549483]**

### **3.10、类型转化器** ###

在前面的程序中，表单提交的无论是 int 还是 double 类型的请求参数，用于处理该请求的处理器方法的形参，均可直接接收到相应类型的相应数据，而非接收到 String 再手工转换。那是因为在 SpringMVC 框架中， 有默认的类型转换器。这些默认的类型转换器，可以将 String类型的数据，自动转换为相应类型的数据。  
但默认类型转换器并不是可以将用户提交的 String，转换为所有用户需要的类型。此时，就需要自定义类型转换器了。  
例如，在 SpringMVC 的默认类型转换器中，没有日期类型的转换器，因为日期的格式太多。若要使表单中提交的日期字符串，被处理器方法形参直接接收为 java.util.Date，则需要自定义类型转换器了  
（1）自定义类型转换器  
若要定义类型转换器，则需要实现 Converter 接口。 该 Converter 接口有两个泛型：第一个为待转换的类型，第二个为目标类型。而该接口的方法 convert()，用于完成类型转换。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 17][]

**对类型转换器的配置**  
类型转换器定义完毕后，需要在 SpringMVC 的配置文件中对类型转换进行配置。 首先要注册类型转换器，然后再注册一个转换服务 Bean。将类型转换器注入给该转换服务 Bean。最后由处理器适配器来使用该转换服务 Bean。  
（1） 注册类型转换器  
![20190211115953381.png][]

（2） 创建转换服务 Bean  
对于类型转换器，并不是直接使用，而是通过转换服务 Bean 来调用类型转换器。而转换服务 Bean 的创建，是由转换服务工厂 Bean -- ConversionServiceFactoryBean 完成。该工厂 Bean 有一个 Set 集合属性 converters，用于指定该转换服务可以完成的转换，即可以使用的转换器。从 Set 集合可知，各转换器间无先后顺序。  
![20190211120025359.png][]

由于 SpringMVC 对于类型转换的完成，不是直接使用类型转换器，而是通过创建出具有多种转换功能的转换服务 Bean 来完成的。所以， SpringMVC 同时支持多种类型转换器。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 18][]

（3） SpringMVC 配置文件总的配置  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 19][]

（4）注册多种日期转换器

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 20][]

## 4、注解开发 ##

**第一步：为 HelloController 添加注解**

package controller;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.servlet.ModelAndView;
    
    @Controller
     @RequestMapping("/demo")
    public class HelloController{
    
        @RequestMapping("/hello")
        public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
            ModelAndView mav = new ModelAndView("index.jsp");
            mav.addObject("message", "Hello Spring MVC");
            return mav;
        }
    }

把实现的接口也给去掉。

*  **简单解释一下：**
 *  `@Controller` 注解：  
    很明显，这个注解是用来声明控制器的，但实际上这个注解对 Spring MVC 本身的影响并不大。（Spring 实战说它仅仅是辅助实现组件扫描，可以用 `@Component` 注解代替，但我自己尝试了一下并不行，因为上述例子没有配置 JSP 视图解析器我还自己配了一个仍没有成功...）
 *  `@RequestMapping` 注解：  
    很显然，这就表示路径 `/hello` 会映射到该方法上

**第二步：配置文件修改**

1）处理器映射器RequestMappingHandlerMapping

2）处理器适配器 RequestMappingHandlerAdapter

这两个要搭配使用，或者使用<mvc:annotation-driven />也可以。Spring 3.0.x中使用了mvc:annotation-driven后，默认会帮我们注册默认处理请求，参数和返回值的类，其中最主要的两个类：DefaultAnnotationHandlerMapping 和AnnotationMethodHandlerAdapter ，分别为HandlerMapping的实现类和HandlerAdapter的实现类，

在 dispatcher-servlet.xml 文件中，注释掉之前的配置，然后增加一句组件扫描：

<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 
 
 
 
 
 
 
 
 
 
 
 
 
 <context:component-scan base-package="controller"/>
 </beans>

**第三步：重启服务器**

当配置完成，重新启动服务器，输入 `localhost/hello` 地址仍然能看到效果：

## 5、案例图解 ##

下面两种方案都可以参考，或者直接观看原文

**1、创建 web 工程，并导入相应的 jar 包。或者pom导入亦可，同样的也可以使用maven直接创建spring mvc工程**

![1120165-20170817211939162-1253836348.png][]

这里我们加入了 Spring 3.2 的所有 jar 包，正好也佐证了上面所说的 SpringMVC 是 Spring 架构的一部分，注意：一定要包括红色椭圆圈起来的 spring-webmvc-3.2.0.RELEASE.jar

**3、新建 SpringMVC 全局配置文件**

在 src 目录下新建 springmvc.xml 文件，并添加如下代码：

![1120165-20170817212821318-1142951347.png][]

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
 http://www.springframework.org/schema/context 
 http://www.springframework.org/schema/context/spring-context-3.1.xsd 
 http://www.springframework.org/schema/mvc 
 http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd"&gt;</code></pre> &nbsp; &nbsp; &lt;/beans&gt; </td> 
 </tr> 
 </tbody> 
</table>

** 4、在 web.xml 文件中配置前端过滤器　**

**5、编写处理器 Handler**

**6、在 springmvc.xml 文件中配置 Handler,处理器映射器，处理器适配器，以及试图解析器　　**

在 springmvc.xml 文件中添加如下代码：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 </td> 
 <td> <code>&lt;!-- 配置Handler --&gt;&nbsp;&nbsp;&nbsp;</code> <code>&lt;bean name=</code><code>"/hello.do"</code>&nbsp;<code>class</code><code>=</code><code>"com.ys.controller.HelloController"</code>&nbsp;<code>/&gt;</code> <code>&nbsp;&nbsp;&nbsp;</code><code>&lt;!-- 配置处理器映射器</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>将bean的name作为url进行查找，需要在配置Handler时指定bean name（就是url）--&gt;</code> <code>&lt;bean&nbsp;</code><code>class</code><code>=</code><code>"org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"</code>&nbsp;<code>/&gt;</code> <code>&nbsp;&nbsp;&nbsp;</code><code>&lt;!-- 配置处理器适配器，所有适配器都得实现 HandlerAdapter接口 --&gt;</code> <code>&nbsp;&nbsp;&nbsp;</code><code>&lt;bean&nbsp;</code><code>class</code><code>=</code><code>"org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"</code>&nbsp;<code>/&gt;</code> &nbsp; <code>&lt;!-- 配置视图解析器</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>进行jsp解析，默认使用jstl标签，classpath下得有jstl的包--&gt;</code> <code>&lt;bean&nbsp;</code><code>class</code><code>=</code><code>"org.springframework.web.servlet.view.InternalResourceViewResolver"</code>&nbsp;<code>/&gt;</code> </td> 
 </tr> 
 </tbody> 
</table>

**7、在  /WEB-INF/view 目录下创建 index.jsp 文件**

![1120165-20170817221528943-1751142410.png][]

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 </td> 
 <td> <code>&lt;%@ page language=</code><code>"java"</code>&nbsp;<code>contentType=</code><code>"text/html; charset=UTF-8"</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pageEncoding=</code><code>"UTF-8"</code><code>%&gt;</code> <code>&lt;!DOCTYPE html PUBLIC&nbsp;</code><code>"-//W3C//DTD HTML 4.01 Transitional//EN"</code>&nbsp;<code>"http://www.w3.org/TR/html4/loose.dtd"</code><code>&gt;</code> <code>&lt;html&gt;</code> <code>&lt;head&gt;</code> <code>&lt;meta http-equiv=</code><code>"Content-Type"</code>&nbsp;<code>content=</code><code>"text/html; charset=UTF-8"</code><code>&gt;</code> <code>&lt;title&gt;Insert title here&lt;/title&gt;</code> <code>&lt;/head&gt;</code> <code>&lt;body&gt;</code> <code>hello:${name}</code> <code>&lt;/body&gt;</code> <code>&lt;/html&gt;</code> </td> 
 </tr> 
 </tbody> 
</table>

**8、在浏览器输入 http://localhost:8080/SpringMVC\_01/hello.do**

![1120165-20170817221649443-1009033504.png][]

原文：[https://www.cnblogs.com/ysocean/p/7376596.html][https_www.cnblogs.com_ysocean_p_7376596.html]！

**第二种：**

**配置前端控制器**

在 web.xml 文件中进行如下配置：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 </td> 
 <td> <code>&lt;?</code><code>xml</code>&nbsp;<code>version="1.0" encoding="UTF-8"?&gt;</code> <code>&lt;</code><code>web-app</code>&nbsp;<code>xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>xmlns="http://java.sun.com/xml/ns/javaee"</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>xsi:schemaLocation="http://java.sun.com/xml/ns/javaee</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0"&gt;</code> <code>&nbsp;&nbsp;</code><code>&lt;</code><code>display-name</code><code>&gt;SpringMVC_01&lt;/</code><code>display-name</code><code>&gt;</code> <code>&nbsp;&nbsp;</code><code>&lt;!-- 配置前端控制器DispatcherServlet --&gt;</code> <code>&nbsp;&nbsp;</code><code>&lt;</code><code>servlet</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>servlet-name</code><code>&gt;springmvc&lt;/</code><code>servlet-name</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>servlet-class</code><code>&gt;org.springframework.web.servlet.DispatcherServlet&lt;/</code><code>servlet-class</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;!--springmvc.xml 是自己创建的SpringMVC全局配置文件，用contextConfigLocation作为参数名来加载</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>如果不配置 contextConfigLocation，那么默认加载的是/WEB-INF/servlet名称-servlet.xml，在这里也就是 springmvc-servlet.xml</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>--&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>init-param</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>param-name</code><code>&gt;contextConfigLocation&lt;/</code><code>param-name</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>param-value</code><code>&gt;classpath:springmvc.xml&lt;/</code><code>param-value</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;/</code><code>init-param</code><code>&gt;</code> <code>&nbsp;&nbsp;</code><code>&lt;/</code><code>servlet</code><code>&gt;</code> &nbsp; <code>&nbsp;&nbsp;</code><code>&lt;</code><code>servlet-mapping</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>servlet-name</code><code>&gt;springmvc&lt;/</code><code>servlet-name</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;!--第一种配置：*.do,还可以写*.action等等，表示以.do结尾的或者以.action结尾的URL都由前端控制器DispatcherServlet来解析</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>第二种配置：/,所有访问的 URL 都由DispatcherServlet来解析，但是这里最好配置静态文件不由DispatcherServlet来解析</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>错误配置：/*,注意这里是不能这样配置的，应为如果这样写，最后转发到 jsp 页面的时候，仍然会由DispatcherServlet进行解析，而这时候会找不到对应的Handler，从而报错！！！</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>--&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>url-pattern</code><code>&gt;*.do&lt;/</code><code>url-pattern</code><code>&gt;</code> <code>&nbsp;&nbsp;</code><code>&lt;/</code><code>servlet-mapping</code><code>&gt;</code> <code>&lt;/</code><code>web-app</code><code>&gt;</code> </td> 
 </tr> 
 </tbody> 
</table>

、**配置处理器适配器**

在 springmvc.xml 文件中配置。用来约束我们所需要编码的 Handler类。

**第一种配置：编写 Handler 时必须要实现 Controller**

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 </td> 
 <td> <code>&lt;!-- 配置处理器适配器，所有适配器都得实现 HandlerAdapter接口 --&gt;</code> <code>&lt;</code><code>bean</code>&nbsp;<code>class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" /&gt;</code> </td> 
 </tr> 
 </tbody> 
</table>

我们可以查看源码：　![1120165-20170820153439396-594465168.png][]

**第二种配置：编写 Handler 时必须要实现 HttpRequestHandler**

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 </td> 
 <td> <code>&lt;!-- 配置处理器适配器第二种方法，所有适配器都得实现 HandlerAdapter接口 ，这样配置所有Handler都得实现 HttpRequestHandler接口--&gt;</code> <code>&lt;</code><code>bean</code>&nbsp;<code>class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter" /&gt;</code> </td> 
 </tr> 
 </tbody> 
</table>

![1120165-20170820154638537-1136538291.png][]

**编写 Handler**

在 springmvc.xml 文件中配置。通俗来讲，就是请求的 URL 到我们这里所编写的 Handler 类的某个方法进行一些业务逻辑处理。

我们在上面讲解了两个处理器适配器来约束 Handler，那么我们就通过上面两种配置分别编写两个 Handler

**第一种：实现Controller 接口**

**第二种：实现 HttpRequestHandler 接口**

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 </td> 
 <td> <code>package com.ys.controller;</code> &nbsp; <code>import java.io.IOException;</code> &nbsp; <code>import javax.servlet.ServletException;</code> <code>import javax.servlet.http.HttpServletRequest;</code> <code>import javax.servlet.http.HttpServletResponse;</code> &nbsp; <code>import org.springframework.web.HttpRequestHandler;</code> &nbsp; <code>public class HelloController2 implements HttpRequestHandler{ </code> &nbsp; <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>@Override</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>public void handleRequest(HttpServletRequest request, HttpServletResponse response)</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>throws ServletException, IOException { </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>request.setAttribute("name", "张三");</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>request.getRequestDispatcher("/WEB-INF/view/index.jsp").forward(request, response);</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>}</code> &nbsp; <code>}</code> </td> 
 </tr> 
 </tbody> 
</table>

总结：通常我们使用第一种方式来编写 Handler ，但是第二种没有返回值，我们可以通过 response 修改相应内容，比如返回 json 数据。

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 </td> 
 <td> <code>response.setCharacterEncoding("utf-8");</code> <code>response.setContentType("application/json;charset=utf-8");</code> <code>response.getWriter().write("json字符串");</code> </td> 
 </tr> 
 </tbody> 
</table>

所以具体使用哪一种根据实际情况来判断。

**配置处理器映射器**

在 springmvc.xml 文件中配置。通俗来讲就是请求的 URL 怎么能被 SpringMVC 识别，从而去执行我们上一步所编写好的 Handler

**第一种方法：**

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 </td> 
 <td> <code>&lt;!-- 配置Handler --&gt;</code>&nbsp;&nbsp;&nbsp; <code>&lt;</code><code>bean</code>&nbsp;<code>name="/hello.do" class="com.ys.controller.HelloController2" /&gt;</code> &nbsp; <code>&lt;!-- 配置处理器映射器</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>将bean的name作为url进行查找，需要在配置Handler时指定bean name（就是url）--&gt;</code> <code>&lt;</code><code>bean</code>&nbsp;<code>class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" /&gt;</code> </td> 
 </tr> 
 </tbody> 
</table>

这样配置的话，那么请求的 URL，必须为 http://localhost:8080/项目名/hello.do

**第二种方法：**

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 </td> 
 <td> <code>&lt;!-- 配置Handler --&gt;</code>&nbsp;&nbsp;&nbsp; <code>&lt;</code><code>bean</code>&nbsp;<code>id="hello1" class="com.ys.controller.HelloController" /&gt;</code> <code>&lt;</code><code>bean</code>&nbsp;<code>id="hello2" class="com.ys.controller.HelloController" /&gt;</code> <code>&lt;!-- 第二种方法：简单URL配置处理器映射器 --&gt;</code> <code>&lt;</code><code>bean</code>&nbsp;<code>class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>property</code>&nbsp;<code>name="mappings"&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>props</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>prop</code>&nbsp;<code>key="/hello1.do"&gt;hello1&lt;/</code><code>prop</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>prop</code>&nbsp;<code>key="/hello2.do"&gt;hello2&lt;/</code><code>prop</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;/</code><code>props</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;/</code><code>property</code><code>&gt;</code> <code>&lt;/</code><code>bean</code><code>&gt;</code> </td> 
 </tr> 
 </tbody> 
</table>

这种配置请求的 URL可以为 http://localhost:8080/项目名/hello1.do，或者http://localhost:8080/项目名/hello2.do

总结：上面两种处理器映射器配置可以并存，前端控制器会正确的去判断 url 用哪个 Handler 去处理。

**配置视图解析器**

**第一种配置:**

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 </td> 
 <td> <code>&lt;!-- 配置视图解析器</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>进行jsp解析，默认使用jstl标签，classpath下得有jstl的包--&gt;</code> <code>&lt;</code><code>bean</code>&nbsp;<code>class="org.springframework.web.servlet.view.InternalResourceViewResolver" /&gt;</code> </td> 
 </tr> 
 </tbody> 
</table>

如果这样配，那么在 Handler 中返回的必须是路径+jsp页面名称+".jsp"

**第二种配置：**

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 </td> 
 <td> <code>&lt;!--配置视图解析器&nbsp; --&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>bean</code>&nbsp;<code>class="org.springframework.web.servlet.view.InternalResourceViewResolver"&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;!-- 返回视图页面的前缀 --&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>property</code>&nbsp;<code>name="prefix" value="/WEB-INF/view"&gt;&lt;/</code><code>property</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;!-- 返回页面的后缀 --&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;</code><code>property</code>&nbsp;<code>name="suffix" value=".jsp"&gt;&lt;/</code><code>property</code><code>&gt;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>&lt;/</code><code>bean</code><code>&gt;</code> </td> 
 </tr> 
 </tbody> 
</table>

如果这样配，那么在 Handler 中只需要返回在 view 文件夹下的jsp 页面名就可以了。

**DispatcherServlet.properties**

上面我们讲解了各种配置，可能有人会问这么多配置，万一少配置了一样，那不就不能运行了，那我们能不能不配置呢？答案是肯定的，SpringMVC 给我们提供了一个 DispatcherServlet.properties 文件。系统会首先加载这里面的配置，如果我们没有配置，那么就默认使用这个文件的配置；如果我们配置了，那么就优先使用我们手动配置的。

![1120165-20170820162418006-1365651786.png][]

在 SpringMVC 运行之前，会首先加载 DispatcherServlet.properties 文件里面的内容，那么我们来看看这里面都是什么。

我们可以从上面得出，如果我们不手动进行各种配置，那么也有会默认的

①、处理器适配器默认：org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter

②、处理器映射器默认：org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping

③、视图解析器默认：org.springframework.web.servlet.view.InternalResourceViewResolver

[https://www.cnblogs.com/ysocean/p/7375405.html][https_www.cnblogs.com_ysocean_p_7375405.html]

## 6、问题解决 ##

### 6.1、静态资源的访问 ###

> 静态资源的访问是针对于中央处理器（前端处理器）的映射路径“/”，关于映射路径有三个，推荐“\*.do”,"/\*"是jsp都不能访问的或，强烈不推荐。。
> 
> 而“/”能访问jsp但是不能访问静态资源，这里呢讲一下“/”映射路径访问静态资源。

**（1） 使用 Tomcat 中名为 default 的 Servlet** 
在 Tomcat 中，有一个专门用于处理静态资源访问的 Servlet – DefaultServlet。 其<servlet-name/>为 default。可以处理各种静态资源访问请求。 该 Servlet 注册在 Tomcat 服务器的 web.xml 中。在 Tomcat 安装目录/conf/web.xml。 
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 21][]

我们需要做的就是直接使用它即可，即直接在 web.xml 中注册<servlet-mapping/>即可 
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 22][]

**（2） 使用<mvc:default-servlet-handler/>** 
只需要在 springmvc.xml 中添加<mvc:default-servlet-handler/>标签即可。

![20190211095218137.png][]

<mvc:default-servlet-handler/> 会 将 对 静 态 资 源 的 访 问 请 求 添 加 到SimpleUrlHandlerMapping 的 urlMap 中， key 就是请求的 URI， 而 value 则为默认 Servlet 请求处理器 DefaultServletHttpRequestHandler 对象。而该处理器调用了 Tomcat 的 DefaultServlet来处理静态资源的访问请求。当然了，要想使用<mvc: …/>标签，需要引入 mvc 约束。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 23][] 
该约束可从 Spring 帮助文档中搜索关键字 spring-mvc.xsd 即可获取：docs/spring-framework-reference/htmlsingle/index.html 
**（3） 使用<mvc:resources/>** 
在 Spring3.0.4 版本后， Spring 中定义了专门用于处理静态资源访问请求的处理器ResourceHttpRequestHandler。并且添加了<mvc:resources/>标签，专门用于解决静态资源无法访问问题。 需要在 springmvc.xml 中添加如下形式的配置：

![20190211095340196.png][]  
location 表示静态资源所在目录。 当然，这里的目录包含/WEB-INF/目录及其子目录。mapping 表示对该资源的请求。 注意，后面是两个星号\*\*。该配置会把对该静态资源的访问请求添加到 SimpleUrlHandlerMapping 的 urlMap 中，key就 是 真 正 mapping 的 URI 匹 配 的 URI ， 而 value 则 为 静 态 资 源 处 理 器 对 象ResourceHttpReq

[https_blog.csdn.net_lee_sire_article_details_53333023]: https://blog.csdn.net/lee_sire/article/details/53333023
[XApjGKM.png]: https://i.imgur.com/XApjGKM.png
[iEQSPKx.png]: https://i.imgur.com/iEQSPKx.png
[932062-20160909153624488-530274633.png]: /images/20220320/8dbd7167d0dc40168a53f3c855ecdfee.png
[IcG30SM.png]: https://i.imgur.com/IcG30SM.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70]: /images/20220320/7f2b5e18f0094311827b945a47820b91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 1]: /images/20220320/9633472f1ea94f689a9f1d4cfb2ec4cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 2]: /images/20220320/a17cbd3fea064b81852d3264fcb4cd67.png
[20190211103939330.png]: /images/20220320/d1d5c96600c141f48e0e7b800fc5dff0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 3]: /images/20220320/0629806a3fe0475e9125c70be1d56ae6.png
[20190211104541157.png]: /images/20220320/c585a7631d014af3a927203007ed41db.png
[20190211104711135.png]: /images/20220320/f6562eb16bc7461bb05fa7a0d900026a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 4]: /images/20220320/486e51830d5746c7841240f689c9b6db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 5]: /images/20220320/c20fe80685ad498bb0942ee2d8093ace.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 6]: /images/20220320/aad5653ab1fb47a39b807de4dd432490.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 7]: /images/20220320/a3d7d0ebb46e4a22b39441c45c21a605.png
[20190211120803551.png]: /images/20220320/d7d02cdbf2004d7982fae8576a516fa6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 8]: /images/20220320/3528b2c70e7f49edb7efdfaa6acf0b87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 9]: /images/20220320/c0d2af30c1244906a944d547409f0b70.png
[20190211122733996.png]: /images/20220320/e4305601bbe04eeb802111f0b4e3110f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 10]: /images/20220320/00003a46e6074c73bc21377c6fb574b5.png
[20190211122823874.png]: /images/20220320/ac00f8e6f6ea492f854ff09ca1fecff8.png
[Image 1]: 
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 11]: /images/20220320/db1423b5c0944883a5735b10da6b94f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 12]: /images/20220320/28bdda0382e44c7b8b551b8db1e6444f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 13]: /images/20220320/61aa0024fa874f289575ba189c52b877.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 14]: /images/20220320/941b87fd8fd245dcaf4a273ac3baa1f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 15]: /images/20220320/85f9270a1433439d8549c70ebaae7df5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 16]: /images/20220320/ca18e558953146f78809c6bf4a9ae157.png
[https_blog.csdn.net_cheney550995353_article_details_70185282]: https://blog.csdn.net/cheney550995353/article/details/70185282
[https_www.cnblogs.com_black-spike_p_7813238.html]: https://www.cnblogs.com/black-spike/p/7813238.html
[https_blog.csdn.net_qq_39313596_article_details_80549483]: https://blog.csdn.net/qq_39313596/article/details/80549483
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 17]: /images/20220320/07399520c09d4a6ab6815740cb1dbdd1.png
[20190211115953381.png]: /images/20220320/f320c187e1ff4634a4c9982d1b4c673e.png
[20190211120025359.png]: /images/20220320/151374591ef7478f938c6df0ae996c79.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 18]: /images/20220320/432a34f3ac2448ddbeb081270baf8dc2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 19]: /images/20220320/4ae69c18a7474caab4cba2cb16a68251.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 20]: /images/20220320/600fa833a6c94990962b7f818051eacf.png
[1120165-20170817211939162-1253836348.png]: /images/20220320/31c6ea22573443b9895b88afb834c24b.png
[1120165-20170817212821318-1142951347.png]: /images/20220320/449201516ae449a98c478753ae799884.png
[1120165-20170817221528943-1751142410.png]: /images/20220320/8fa59e33afdc48789900861c8bbbbf78.png
[1120165-20170817221649443-1009033504.png]: /images/20220320/6f21930fb49146a184aa1e308683f6b9.png
[https_www.cnblogs.com_ysocean_p_7376596.html]: https://www.cnblogs.com/ysocean/p/7376596.html
[1120165-20170820153439396-594465168.png]: /images/20220320/c5b669efa690412185cda6c34dd4af6f.png
[1120165-20170820154638537-1136538291.png]: /images/20220320/74604269cb40453c8e88df68f18ffac6.png
[1120165-20170820162418006-1365651786.png]: /images/20220320/7473068f293b4a22afb944430ab0660e.png
[https_www.cnblogs.com_ysocean_p_7375405.html]: https://www.cnblogs.com/ysocean/p/7375405.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 21]: /images/20220320/c211aa6c8b8e42b794e4a836fc864aa1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 22]: /images/20220320/b98a9574cb5840b18ac741c89c26f0ed.png
[20190211095218137.png]: /images/20220320/b3b036e55b0d445cb1a0209bebdee08a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3MDY0Mjg2_size_16_color_FFFFFF_t_70 23]: /images/20220320/f822c9d5fe144c01b176f2d5e4dfb6e8.png
[20190211095340196.png]: /images/20220320/a7b10a467834470996c2affcba0f4f6a.png