为什么要使用SpringMVC？
很多应用程序的问题在于处理业务数据的对象和显示业务数据的视图之间存在紧密耦合，通常，更新业务对象的命令都是从视图本身发起的，使视图对任何业务对象更改都有高度敏感性。而且，当多个视图依赖于同一个业务对象时是没有灵活性的。
SpringMVC是一种基于Java，实现了Web MVC设计模式，请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将Web层进行职责解耦。基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，SpringMVC也是要简化我们日常Web开发。
MVC设计模式
MVC设计模式的任务是将包含业务数据的模块与显示模块的视图解耦。这是怎样发生的？在模型和视图之间引入重定向层可以解决问题。此重定向层是控制器，控制器将接收请求，执行更新模型的操作，然后通知视图关于模型更改的消息。
SpringMVC架构
SpringMVC是Spring的一部分，如图：
SpringMVC的核心架构：
具体流程：
（1）首先浏览器发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；
（2）DispatcherServlet——>HandlerMapping，处理器映射器将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器对象、多个HandlerInterceptor拦截器）对象；
（3）DispatcherServlet——>HandlerAdapter，处理器适配器将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
（4）HandlerAdapter——>调用处理器相应功能处理方法，并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；
（5）ModelAndView对象（Model部分是业务对象返回的模型数据，View部分为逻辑视图名）——> ViewResolver， 视图解析器将把逻辑视图名解析为具体的View；
（6）View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构；
（7）返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。
SpringMVC入门程序
（1）web.xml
<web-app>
<servlet>
<!-- 加载前端控制器 -->
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--
加载配置文件
默认加载规范：
* 文件命名：servlet-name-servlet.xml====springmvc-servlet.xml
* 路径规范：必须在WEB-INF目录下面
修改加载路径：
-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
（2）springmvc.xml
<beans>
<!-- 配置映射处理器：根据bean(自定义Controller)的name属性的url去寻找handler；springmvc默认的映射处理器是
BeanNameUrlHandlerMapping
-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
<!-- 配置处理器适配器来执行Controlelr ,springmvc默认的是
SimpleControllerHandlerAdapter
-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>
<!-- 配置自定义Controller -->
<bean id="myController" name="/hello.do" class="org.controller.MyController"></bean>
<!-- 配置sprigmvc视图解析器：解析逻辑试图；
后台返回逻辑试图：index
视图解析器解析出真正物理视图：前缀+逻辑试图+后缀====/WEB-INF/jsps/index.jsp
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsps/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
（3）自定义处理器
public class MyController implements Controller{
public ModelAndView handleRequest(HttpServletRequest arg0,
HttpServletResponse arg1) throws Exception {
ModelAndView mv = new ModelAndView();
//设置页面回显数据
mv.addObject("hello", "欢迎学习springmvc！");
//返回物理视图
//mv.setViewName("/WEB-INF/jsps/index.jsp");
//返回逻辑视图
mv.setViewName("index");
return mv;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
（4）index页面
<html>
<body>
<h1>${hello}</h1>
</body>
</html>
1
2
3
4
5
（5）测试地址
http://localhost:8080/springmvc/hello.do
1
HandlerMapping
处理器映射器将会把请求映射为 HandlerExecutionChain 对象（包含一个 Handler 处理器对象、多个 HandlerInterceptor 拦截器）对象，通过这种策略模式，很容易添加新的映射策略。
处理器映射器有三种，三种可以共存，相互不影响，分别是BeanNameUrlHandlerMapping、SimpleUrlHandlerMapping和ControllerClassNameHandlerMapping；
BeanNameUrlHandlerMapping
默认映射器，即使不配置，默认就使用这个来映射请求。
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
//映射器把hello.do请求映射到该处理器
<bean id="testController" name="/hello.do" class="org.controller.TestController"></bean>
1
2
3
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>
1
2
3
4
5
6
7
8
9
10
ControllerClassNameHandlerMapping
该处理器映射器可以不用手动配置映射, 通过[类名.do]来访问对应的处理器.
//这个Mapping一配置, 我们就可以使用Controller的 [类名.do]来访问这个Controller.
<bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"></bean>
1
2
HandlerAdapter
处理器适配器有两种，可以共存，分别是SimpleControllerHandlerAdapter和HttpRequestHandlerAdapter。
SimpleControllerHandlerAdapter
SimpleControllerHandlerAdapter是默认的适配器，所有实现了org.springframework.web.servlet.mvc.Controller 接口的处理器都是通过此适配器适配, 执行的。
HttpRequestHandlerAdapter
该适配器将http请求封装成HttpServletResquest 和HttpServletResponse对象. 所有实现了 org.springframework.web.HttpRequestHandler 接口的处理器都是通过此适配器适配, 执行的. 实例如下所示:
（1）配置HttpRequestHandlerAdapter适配器
<!-- 配置HttpRequestHandlerAdapter适配器 -->
<bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"></bean>
1
2
（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);
}
}
1
2
3
4
5
6
7
8
9
10
（3）index页面
<html>
<body>
<h1>${hello}</h1>
</body>
</html>
1
2
3
4
5
Adapter源码分析
模拟场景：前端控制器（DispatcherServlet）接收到Handler对象后，传递给对应的处理器适配器（HandlerAdapter），处理器适配器调用相应的Handler方法。
（1）模拟处理器
//以下是Controller接口和它的是三种实现
public interface Controller {
}
public class SimpleController implements Controller{
public void doSimpleHandler() {
System.out.println("Simple...");
}
}
public class HttpController implements Controller{
public void doHttpHandler() {
System.out.println("Http...");
}
}
public class AnnotationController implements Controller{
public void doAnnotationHandler() {
System.out.println("Annotation..");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
（2）模拟处理器适配器
//以下是HandlerAdapter接口和它的三种实现
public interface HandlerAdapter {
public boolean supports(Object handler);
public void handle(Object handler);
}
public class SimpleHandlerAdapter implements HandlerAdapter{
public boolean supports(Object handler) {
return (handler instanceof SimpleController);
}
public void handle(Object handler) {
((SimpleController)handler).doSimpleHandler();
}
}
public class HttpHandlerAdapter implements HandlerAdapter{
public boolean supports(Object handler) {
return (handler instanceof HttpController);
}
public void handle(Object handler) {
((HttpController)handler).doHttpHandler();
}
}
public class AnnotationHandlerAdapter implements HandlerAdapter{
public boolean supports(Object handler) {
return (handler instanceof AnnotationController);
}
public void handle(Object handler) {
((AnnotationController)handler).doAnnotationHandler();
}
}
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
30
31
32
33
34
35
（3）模拟DispatcherServlet
public class Dispatcher {
public static List<HandlerAdapter> handlerAdapter = new ArrayList<HandlerAdapter>();
public Dispatcher(){
handlerAdapter.add(new SimpleHandlerAdapter());
handlerAdapter.add(new HttpHandlerAdapter());
handlerAdapter.add(new AnnotationHandlerAdapter());
}
//核心功能
public void doDispatch() {
//前端控制器（DispatcherServlet）接收到Handler对象后
//SimpleController handler = new SimpleController();
//HttpController handler = new HttpController();
AnnotationController handler = new AnnotationController();
//传递给对应的处理器适配器（HandlerAdapter）
HandlerAdapter handlerAdapter = getHandlerAdapter(handler);
//处理器适配器调用相应的Handler方法
handlerAdapter.handle(handler);
}
//通过Handler找到对应的处理器适配器（HandlerAdapter）
public HandlerAdapter getHandlerAdapter(Controller handler) {
for(HandlerAdapter adapter : handlerAdapter){
if(adapter.supports(handler)){
return adapter;
}
}
return null;
}
}
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
30
31
32
33
（4）测试
public class Test {
public static void main(String[] args) {
Dispatcher dispather = new Dispatcher();
dispather.doDispatch();
}
}
1
2
3
4
5
6
Handler
这里只介绍上文提到的两种处理器, 除此之外还有很多适用于各种应用场景的处理器, 尤其是Controller接口还有很多实现类, 大家可以自行去了解.
Controller
org.springframework.web.servlet.mvc.Controller, 该处理器对应的适配器是 SimpleControllerHandlerAdapter.
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
该处理器方法用于处理用户提交的请求, 通过调用service层代码, 实现对用户请求的计算响应, 并最终将计算所得数据及要响应的页面封装为一个ModelAndView 对象, 返回给前端控制器(DispatcherServlet).
Controller接口的实现类:
HttpRequestHandler
org.springframework.web.HttpRequestHandler, 该处理器对应的适配器是 HttpRequestHandlerAdapter.
public interface HttpRequestHandler {
void handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws ServletException, IOException;
}
1
2
3
该处理器方法没有返回值, 不能像 ModelAndView 一样, 将数据及目标视图封装为一个对象, 但可以将数据放入Request, Session等域属性中, 并由Request 或 Response完成目标页面的跳转.
ViewResolver
视图解析器负责将处理结果生成View视图. 这里介绍两种常用的视图解析器:
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;
}
}
1
2
3
4
5
6
7
8
9
(2) 视图解析器配置
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
1
2
3
4
当然, 若不指定前缀与后缀, 直接将内部资源路径写到 setViewName()中也可以, 相当于前缀与后缀均为空串.
mv.setViewName("/WEB-INF/jsp/index.jsp");
1
BeanNameViewResolver
InternalResourceViewResolver视图解析器存在一个问题, 就是只可以完成将内部资源封装后的跳转, 无法跳转向外部资源, 如外部网页.
BeanNameViewResolver 视图解析器将资源(内部资源和外部资源)封装为bean实例, 然后在 ModelAndView 中通过设置bean实例的id值来指定资源. 在配置文件中可以同时配置多个资源bean.
(1) 处理器
public class MyController implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
return new ModelAndView("myInternalView");
// return new ModelAndView("baidu");
}
}
1
2
3
4
5
6
7
8
(2) 视图解析器配置
<!--视图解析器-->
<bean class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
<!--内部资源view-->
<bean id="myInternalView" class="org.springframework.web.servlet.view.JstlView">
<property name="url" value="/jsp/show.jsp"/>
</bean>
<!--外部资源view-->
<bean id="baidu" class="org.springframework.web.servlet.view.RedirectView">
<property name="url" value="https://www.baidu.com/"/>
</bean>
1
2
3
4
5
6
7
8
9
10
了解完这两种视图解析器后是不是有种熟悉感, 是的, 就是请求转发和重定向.
中文乱码解决
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>
————————————————
版权声明：本文为CSDN博主「椰子Tyshawn」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/litianxiang_kaola/article/details/79169148