Java面试总结（2021优化版）已发布在个人微信公众号【技术人成长之路】，优化版首先修正了读者反馈的部分答案存在的错误，同时根据最新面试总结，删除了低频问题，添加了一些常见面试题，对文章进行了精简优化，欢迎大家关注！😊😊
 
 
【技术人成长之路】，助力技术人成长！更多精彩文章第一时间在公众号发布哦！
 
 
 


 
文章目录
 
概述
什么是Spring MVC？简单介绍下你对Spring MVC的理解？
Spring MVC的优点
   
核心组件
Spring MVC的主要组件？
什么是DispatcherServlet
什么是Spring MVC框架的控制器？
Spring MVC的控制器是不是单例模式,如果是,有什么问题,怎么解决？
   
工作原理
请描述Spring MVC的工作流程？描述一下 DispatcherServlet 的工作流程？
   
MVC框架
MVC是什么？MVC设计模式的好处有哪些
   
常用注解
注解原理是什么
Spring MVC常用的注解有哪些？
SpingMvc中的控制器的注解一般用哪个,有没有别的注解可以替代？
@Controller注解的作用
@RequestMapping注解的作用
@ResponseBody注解的作用
@PathVariable和@RequestParam的区别
   
其他
Spring MVC与Struts2区别
Spring MVC怎么样设定重定向和转发的？
Spring MVC怎么和AJAX相互调用的？
如何解决POST请求中文乱码问题，GET的又如何处理呢？
Spring MVC的异常处理？
如果在拦截请求中，我想拦截get方式提交的方法,怎么配置
怎样在方法里面得到Request,或者Session？
如果想在拦截的方法里面得到从前台传入的参数,怎么得到？
如果前台有很多个参数传入,并且这些参数都是一个对象的,那么怎么样快速得到这个对象？
Spring MVC中函数的返回值是什么？
Spring MVC用什么对象从后台向前台传递数据的？
怎么样把ModelMap里面的数据放入Session里面？
Spring MVC里面拦截器是怎么写的
介绍一下 WebApplicationContext
  
 

 
Java面试总结汇总，整理了包括Java基础知识，集合容器，并发编程，JVM，常用开源框架Spring，MyBatis，数据库，中间件等，包含了作为一个Java工程师在面试中需要用到或者可能用到的绝大部分知识。欢迎大家阅读，本人见识有限，写的博客难免有错误或者疏忽的地方，还望各位大佬指点，在此表示感激不尽。文章持续更新中…
 
序号
内容
链接地址
1
Java基础知识面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104390612
2
Java集合容器面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104588551
3
Java异常面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104390689
4
并发编程面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104863992
5
JVM面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104390752
6
Spring面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104397516
7
Spring MVC面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104397427
8
Spring Boot面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104397299
9
Spring Cloud面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104397367
10
MyBatis面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/101292950
11
Redis面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/103522351
12
MySQL数据库面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104778621
13
消息中间件MQ与RabbitMQ面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104588612
14
Dubbo面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104390006
15
Linux面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104588679
16
Tomcat面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104397665
17
ZooKeeper面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104397719
18
Netty面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/104391081
19
架构设计&分布式&数据结构与算法面试题（2020最新版）
https://thinkwon.blog.csdn.net/article/details/105870730
概述
 
什么是Spring MVC？简单介绍下你对Spring MVC的理解？
 
Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把模型-视图-控制器分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。
 
Spring MVC的优点
 
（1）可以支持各种视图技术,而不仅仅局限于JSP；
 
（2）与Spring框架集成（如IoC容器、AOP等）；
 
（3）清晰的角色分配：前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping), 处理器适配器（HandlerAdapter), 视图解析器（ViewResolver）。
 
（4） 支持各种请求资源的映射策略。
 
核心组件
 
Spring MVC的主要组件？
 
（1）前端控制器 DispatcherServlet（不需要程序员开发）
 
作用：接收请求、响应结果，相当于转发器，有了DispatcherServlet 就减少了其它组件之间的耦合度。
 
（2）处理器映射器HandlerMapping（不需要程序员开发）
 
作用：根据请求的URL来查找Handler
 
（3）处理器适配器HandlerAdapter
 
注意：在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器HandlerAdapter才可以正确的去执行Handler。
 
（4）处理器Handler（需要程序员开发）
 
（5）视图解析器 ViewResolver（不需要程序员开发）
 
作用：进行视图的解析，根据视图逻辑名解析成真正的视图（view）
 
（6）视图View（需要程序员开发jsp）
 
View是一个接口， 它的实现类支持不同的视图类型（jsp，freemarker，pdf等等）
 
什么是DispatcherServlet
 
Spring的MVC框架是围绕DispatcherServlet来设计的，它用来处理所有的HTTP请求和响应。
 
什么是Spring MVC框架的控制器？
 
控制器提供一个访问应用程序的行为，此行为通常通过服务接口实现。控制器解析用户输入并将其转换为一个由视图呈现给用户的模型。Spring用一个非常抽象的方式实现了一个控制层，允许用户创建多种用途的控制器。
 
Spring MVC的控制器是不是单例模式,如果是,有什么问题,怎么解决？
 
答：是单例模式,所以在多线程访问的时候有线程安全问题,不要用同步,会影响性能的,解决方案是在控制器里面不能写字段。
 
工作原理
 
请描述Spring MVC的工作流程？描述一下 DispatcherServlet 的工作流程？
 
（1）用户发送请求至前端控制器DispatcherServlet；
 （2） DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle；
 （3）处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet；
 （4）DispatcherServlet 调用 HandlerAdapter处理器适配器；
 （5）HandlerAdapter 经过适配调用 具体处理器(Handler，也叫后端控制器)；
 （6）Handler执行完成返回ModelAndView；
 （7）HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet；
 （8）DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析；
 （9）ViewResolver解析后返回具体View；
 （10）DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）
 （11）DispatcherServlet响应用户。
 
 
MVC框架
 
MVC是什么？MVC设计模式的好处有哪些
 
mvc是一种设计模式（设计模式就是日常开发中编写代码的一种好的方法和经验的总结）。模型（model）-视图（view）-控制器（controller），三层架构的设计模式。用于实现前端页面的展现与后端业务数据处理的分离。
 
mvc设计模式的好处
 
1.分层设计，实现了业务系统各个组件之间的解耦，有利于业务系统的可扩展性，可维护性。
 
2.有利于系统的并行开发，提升开发效率。
 
常用注解
 
注解原理是什么
 
注解本质是一个继承了Annotation的特殊接口，其具体实现类是Java运行时生成的动态代理类。我们通过反射获取注解时，返回的是Java运行时生成的动态代理对象。通过代理对象调用自定义注解的方法，会最终调用AnnotationInvocationHandler的invoke方法。该方法会从memberValues这个Map中索引出对应的值。而memberValues的来源是Java常量池。
 
Spring MVC常用的注解有哪些？
 
@RequestMapping：用于处理请求 url 映射的注解，可用于类或方法上。用于类上，则表示类中的所有响应请求的方法都是以该地址作为父路径。
 
@RequestBody：注解实现接收http请求的json数据，将json转换为java对象。
 
@ResponseBody：注解实现将conreoller方法返回对象转化为json对象响应给客户。
 
SpingMvc中的控制器的注解一般用哪个,有没有别的注解可以替代？
 
答：一般用@Controller注解,也可以使用@RestController,@RestController注解相当于@ResponseBody ＋ @Controller,表示是表现层,除此之外，一般不用别的注解代替。
 
@Controller注解的作用
 
在Spring MVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。在Spring MVC 中提供了一个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controller 标记一个类是Controller ，然后使用@RequestMapping 和@RequestParam 等一些注解用以定义URL 请求和Controller 方法之间的映射，这样的Controller 就能被外界访问到。此外Controller 不会直接依赖于HttpServletRequest 和HttpServletResponse 等HttpServlet 对象，它们可以通过Controller 的方法参数灵活的获取到。
 
@Controller 用于标记在一个类上，使用它标记的类就是一个Spring MVC Controller 对象。分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping 注解。@Controller 只是定义了一个控制器类，而使用@RequestMapping 注解的方法才是真正处理请求的处理器。单单使用@Controller 标记在一个类上还不能真正意义上的说它就是Spring MVC 的一个控制器类，因为这个时候Spring 还不认识它。那么要如何做Spring 才能认识它呢？这个时候就需要我们把这个控制器类交给Spring 来管理。有两种方式：
 
在Spring MVC 的配置文件中定义MyController 的bean 对象。
在Spring MVC 的配置文件中告诉Spring 该到哪里去找标记为@Controller 的Controller 控制器。
 
@RequestMapping注解的作用
 
RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
 
RequestMapping注解有六个属性，下面我们把她分成三类进行说明（下面有相应示例）。
 
value， method
 
value： 指定请求的实际地址，指定的地址可以是URI Template 模式（后面将会说明）；
 
method： 指定请求的method类型， GET、POST、PUT、DELETE等；
 
consumes，produces
 
consumes： 指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;
 
produces: 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；
 
params，headers
 
params： 指定request中必须包含某些参数值是，才让该方法处理。
 
headers： 指定request中必须包含某些指定的header值，才能让该方法处理请求。
 
@ResponseBody注解的作用
 
作用： 该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。
 
使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；
 
@PathVariable和@RequestParam的区别
 
请求路径上有个id的变量值，可以通过@PathVariable来获取 @RequestMapping(value = “/page/{id}”, method = RequestMethod.GET)
 
@RequestParam用来获得静态的URL请求入参 spring注解时action里用到。
 
其他
 
Spring MVC与Struts2区别
 
相同点
 
都是基于mvc的表现层框架，都用于web项目的开发。
 
不同点
 
1.前端控制器不一样。Spring MVC的前端控制器是servlet：DispatcherServlet。struts2的前端控制器是filter：StrutsPreparedAndExcutorFilter。
 
2.请求参数的接收方式不一样。Spring MVC是使用方法的形参接收请求的参数，基于方法的开发，线程安全，可以设计为单例或者多例的开发，推荐使用单例模式的开发（执行效率更高），默认就是单例开发模式。struts2是通过类的成员变量接收请求的参数，是基于类的开发，线程不安全，只能设计为多例的开发。
 
3.Struts采用值栈存储请求和响应的数据，通过OGNL存取数据，Spring MVC通过参数解析器是将request请求内容解析，并给方法形参赋值，将数据和视图封装成ModelAndView对象，最后又将ModelAndView中的模型数据通过reques域传输到页面。Jsp视图解析器默认使用jstl。
 
4.与spring整合不一样。Spring MVC是spring框架的一部分，不需要整合。在企业项目中，Spring MVC使用更多一些。
 
Spring MVC怎么样设定重定向和转发的？
 
（1）转发：在返回值前面加"forward:"，譬如"forward:user.do?name=method4"
 
（2）重定向：在返回值前面加"redirect:"，譬如"redirect:http://www.baidu.com"
 
Spring MVC怎么和AJAX相互调用的？
 
通过Jackson框架就可以把Java里面的对象直接转化成Js可以识别的Json对象。具体步骤如下 ：
 
（1）加入Jackson.jar
 
（2）在配置文件中配置json的映射
 
（3）在接受Ajax方法里面可以直接返回Object,List等,但方法前面要加上@ResponseBody注解。
 
如何解决POST请求中文乱码问题，GET的又如何处理呢？
 
（1）解决post请求乱码问题：
 
在web.xml中配置一个CharacterEncodingFilter过滤器，设置成utf-8；
 
<filter>
    <filter-name>CharacterEncodingFilter</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>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
 
（2）get请求中文参数出现乱码解决方法有两个：
 
①修改tomcat配置文件添加编码与工程编码一致，如下：
 
<ConnectorURIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>
 
②另外一种方法对参数进行重新编码：
 
String userName = new String(request.getParamter(“userName”).getBytes(“ISO8859-1”),“utf-8”)
 
ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码。
 
Spring MVC的异常处理？
 
答：可以将异常抛给Spring框架，由Spring框架来处理；我们只需要配置简单的异常处理器，在异常处理器中添视图页面即可。
 
如果在拦截请求中，我想拦截get方式提交的方法,怎么配置
 
答：可以在@RequestMapping注解里面加上method=RequestMethod.GET。
 
怎样在方法里面得到Request,或者Session？
 
答：直接在方法的形参中声明request,Spring MVC就自动把request对象传入。
 
如果想在拦截的方法里面得到从前台传入的参数,怎么得到？
 
答：直接在形参里面声明这个参数就可以,但必须名字和传过来的参数一样。
 
如果前台有很多个参数传入,并且这些参数都是一个对象的,那么怎么样快速得到这个对象？
 
答：直接在方法中声明这个对象,Spring MVC就自动会把属性赋值到这个对象里面。
 
Spring MVC中函数的返回值是什么？
 
答：返回值可以有很多类型,有String, ModelAndView。ModelAndView类把视图和数据都合并的一起的，但一般用String比较好。
 
Spring MVC用什么对象从后台向前台传递数据的？
 
答：通过ModelMap对象,可以在这个对象里面调用put方法,把对象加到里面,前台就可以通过el表达式拿到。
 
怎么样把ModelMap里面的数据放入Session里面？
 
答：可以在类上面加上@SessionAttributes注解,里面包含的字符串就是要放入session里面的key。
 
Spring MVC里面拦截器是怎么写的
 
有两种写法,一种是实现HandlerInterceptor接口，另外一种是继承适配器类，接着在接口方法当中，实现处理逻辑；然后在Spring MVC的配置文件中配置拦截器即可：
 
<!-- 配置Spring MVC的拦截器 -->
<mvc:interceptors>
    <!-- 配置一个拦截器的Bean就可以了 默认是对所有请求都拦截 -->
    <bean id="myInterceptor" class="com.zwp.action.MyHandlerInterceptor"></bean>
    <!-- 只针对部分请求拦截 -->
    <mvc:interceptor>
       <mvc:mapping path="/modelMap.do" />
       <bean class="com.zwp.action.MyHandlerInterceptorAdapter" />
    </mvc:interceptor>
</mvc:interceptors>
 
介绍一下 WebApplicationContext
 
WebApplicationContext 继承了ApplicationContext 并增加了一些WEB应用必备的特有功能，它不同于一般的ApplicationContext ，因为它能处理主题，并找到被关联的servlet。

 
 
本文致力于由浅入深的去介绍，使用Spring MVC；细节比较多，希望能对正在观看的你有所帮助！
 博主水平有限，难免存在缺陷和错误，欢迎大佬的指出与补充，谢谢！
 
 
0x01.认识Spring MVC
 
1.Spring MVC概述
 
Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。
使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的Spring MVC框架或集成其他MVC开发框架，如Struts1(现在一般不用)，Struts 2(一般老项目使用)等。
Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把模型-视图-控制器分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。
Spring MVC属于表现层的框架。
 
2.MVC的理解
 
MVC全名是Model View Controller模型视图控制器，每个部分各司其职。
Model：数据模型，JavaBean的类，用来进行数据封装。
View：指JSP、HTML用来展示数据给用户。
Controller：用来接收用户的请求，整个流程的控制器。用来进行数据校验等。
 
 
3.Spring MVC在Spring中的地位
 
 
0x02.简单使用Spring MVC
 
1.写一个jsp页面
 
写一个测试使用的index.jsp页面，仅包含一个超链接标签。
 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Spring MVC来啦~</title>
</head>
<body>
    <h1>测试</h1>
    <a href="atfwus">开始</a>
</body>
</html>
 
2.写一个控制器
 
加上Spring MVC的注解。
返回字符串success。
 
@Controller
public class ATFWUS {
    @RequestMapping(path = "/atfwus")
    public String sayHello(){
        System.out.println("ATFWUS!!!");
        return "success";
    }
}
 
3.编写Spring MVC的配置文件
 
配置视图解析器，并告知Spring需要扫描的包。
 
<?xml version="1.0" encoding="UTF-8"?>
<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.xsd  http://www.springframework.org/schema/mvc
 http://www.springframework.org/schema/mvc/spring-mvc.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置spring创建容器时要扫描的包 -->
    <context:component-scan base-package="com.atfwus"></context:component-scan>
    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    <mvc:annotation-driven/>
</beans>
 
4.编写成功的跳转页面
 
-在WEB-INF/pages里面写 success.jsp页面。
 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Success</title>
</head>
<body>
    <h3>Success！！！</h3>
</body>
</html>
 
5.配置web.xml文件
 
配置Spring MVC的核心控制器。
 
<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

 
6.启动服务器，测试
 

 
 
0x03.Spring MVC工作流程剖析
 
1.例子中的流程分析
 
麻雀虽小，五脏俱全，在上述的小case中，已经包含Spring MVC的主要部分。我们看一下上述case的执行流程吧：
 
因为在web.xml中配置了load-on-startup，所以，服务器一启动，就创建了DispatcherServlet对象。
在DispatcherServlet标签的内部，配置了springmvc.xml的位置，所以服务器开始加载这个配置文件。
用户点击index.jsp的超链接标签，向服务器发送了请求。
请求到达DispatcherServlet核心控制器。
控制器根据配置@RequestMapping注解找到执行的具体方法。
方法执行完毕，返回字符串success。
根据配置的视图解析器，前往指定的目录中查找指定名称且后缀为jsp的文件。
查找文件成功，服务器开始渲染页面，做出响应。
跳转到success页面。
 
2.Spring MVC的请求响应流程
 
（1） 用户通过浏览器发送请求至服务器，然后直接进入前端控制器DispatcherServlet；
 （2）DispatcherServlet收到请求后，开始调用HandlerMapping处理器映射器，请求获取Handle；
 （3）处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServ3let；
 （4）DispatcherServlet 调用 HandlerAdapter处理器适配器，请求执行Handler；
 （5） HandlerAdapter 经过适配调用 具体处理器(Handler，也叫后端控制器)；
 （6）Handler执行完成返回ModelAndView；
 （7）HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet；
 （8）DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析；
 （9）ViewResolver解析后视图后返回具体View对象；
 （10）DispatcherServlet将模型数据填充至视图中（对View进行渲染视图）；
 （11）DispatcherServlet通过服务器返回响应的结果给用户。
 
 
3.Spring MVC核心组件
 
（1）前端控制器 DispatcherServlet
 
接收请求、转发请求，响应结果，相当于是一个中转站，是整个流程中的核心部分。
统一调度，降低组件之间的耦合性，提高每个组件的扩展性。
此组件框架提供。
 
（2）处理器映射器HandlerMapping
 
根据请求的URL来查找Handler。
此组件框架提供。
 
（3）处理器适配器HandlerAdapter
 
按照特定规则去执行Handler。
需要对适配器进行拓展。
 
（4）处理器Handler
 
Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
此组件需要根据需求编写。
 
（5）视图解析器View resolver
 
进行视图的解析，根据视图逻辑名解析成真正的视图。
此组件框架提供。
 
（6）视图View
 
View是一个接口， 它的实现类支持不同的视图类型，如（html，jsp，pdf）。
此组件需要根据具体需求编写。
 
0x04.Spring MVC参数绑定机制
 
1.绑定说明
 
 
SpringMVC的参数绑定过程是把表单提交的请求参数，作为控制器中方法的参数进行绑定的。
 
 
表单提交的数据都是k=v格式。
 
 
支持绑定的数据类型：
 
  
基本数据类型和字符串类型。
实体类型（JavaBean）。
集合数据类型（List、map集合等）。
 
 
2.基本数据类型和String类型
 
必须保证提交表单的name和参数的名称是相同的。
 
控制类：
 
@Controller
@RequestMapping("/param")
public class ParamController {
 
    @RequestMapping("/saveAccount")
    public String saveAccount(String username,String password){
        System.out.println(username+password);
        return "success";
    }

}
 
jsp页面：
 
<a href="param/testParam?username=atfwus&password=atfwus">请求参数绑定</a>
 
3.JavaBean
 
提交表单的name和JavaBean中的属性名称需要一致。
如果一个JavaBean类中包含其他的引用类型，那么表单的name属性需要编写成：对象.属性。（如data.msg）
 
bean：
 
public class Data implements Serializable {
    private Integer status;
    private String msg;

    //getters and setters

    @Override
    //Override toString methond
}
 
public class Account implements Serializable {
    private String username;
    private String password;
    private double money;
    private Data data;

    //getters and setters

    @Override
    //Override toString methond
}
 
控制器：
 
@Controller
@RequestMapping("/param")
public class ParamController {

    @RequestMapping("/saveAccount")
    public String saveAccount(Account acount){
        System.out.println(acount);
        return "success";
    }
    
}
 
jsp页面：
 
<form action="param/saveAccount" method="post">
    名称:<input type="text" name="username"/><br/>
    密码:<input type="text" name="password"/><br/>
    余额:<input type="text" name="money"/><br/>
    状态:<input type="text" name="data.status"/><br/>
    信息：<input type="text" name="data.msg"/><br/>
    <input type="submit" value="提交" />
</form>
 
4.集合类型封装
 
在jsp页面中的表单name里面写list[index].属性（index为集合下标）。
其它部分与JavaBean基本一致。
 
5.Spring MVC解决请求参数乱码
 
SpringMVC内置了解决请求参数乱码的过滤器，只需在web.xml中配置即可。
 
<!--  配置解决中文乱码的控制器-->
<filter>
  <filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
 
6.自定义类型转换器
 
表单提交的任何数据类型全部都是字符串类型。
Spring框架内部会默认进行数据类型转换。
如果想自定义数据类型转换，可以实现Converter的接口
 
自定义一个类型转换的工具类并实现Converter接口：
 
public class StringToDate implements Converter<String,Date> {
    @Override
    public Date convert(String source) {
        if(source==null){
            throw new RuntimeException("数据为空！");
        }
        DateFormat df=new SimpleDateFormat("yyyy年-MM月-dd号");
        try {
            return df.parse(source);
        } catch (ParseException e) {
            throw new RuntimeException("转换异常！");
        }
    }
}
 
配置文件中注册自定义类型转换器：
 
<!--    配置自定义类型转换器-->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
     <property name="converters">
        <set>
            <bean id="StringToDate" class="com.atfwus.utils.StringToDate"></bean>
        </set>
    </property>
</bean>
<mvc:annotation-driven conversion-service="conversionService"/>
 
7.获取servlet原生API
 
 
SpringMVC支持使用原始 ServletAPI对象作为控制器方法的参数。
 
 
具体API如下：
 
  
HttpServletRequest ，HttpServletResponse ，HttpSession ，java.security.Principal ，Locale ，InputStream ，OutputStream ，Reader， Writer。
 
 
只需要在控制器的方法参数定义这些这些API的对象即可。
 
 
0x05.Spring MVC常用注解
 
1.@RequestMapping：
 
 
用于处理请求 url 映射的注解，可用于类或方法上。用于类上，则表示类中的所有响应请求的方法都是以该地址作为父路径。
 
 
作用在类上是 第一级的访问目录，作用在方法上是 第二级的访问目录。
 
 
路径可以不写 / 表示应用的根目录开始。
 
 
在请求的页面中，路径可以省略${ pageContext.request.contextPath }，但是不能写/。
 
 
属性：
 
  
path：指定请求路径的url。
value：和path属性是一样的。
mthod：指定该方法的请求方式。
params：指定限制请求参数的条件。
headers：发送的请求中必须包含的请求头。
consumes：指定处理请求的提交内容类型，如application/json, text/html。
produces： 指定返回的内容类型，仅当request请求头中的类型中包含该指定类型才返回。
 
 
2.@RequestParam：
 
 
作用：把请求中的指定名称的参数传递给控制器中的形参赋值。
 
 
属性：
 
  
value：请求参数中的名称。
required：请求参数中是否必须提供此参数，默认值是true，必须提供。
 
 
例如：
 
public String atfwus(@RequestParam(value="username",required=false)String name) 
 
3.@RequestBody:
 
 
作用：用于获取请求体的内容（get方式没有请求体）。
 
 
属性：
 
  
required：是否必须有请求体，默认值是true。
 
 
例如：
 
public String atfwus(@RequestBody String body) 
 
4.@PathVariable：
 
 
作用：用于绑定url中的占位符。例如：url中有/delete/{id}，{id}就是占位符。
 
 
url支持占位符是 springmvc支持 rest风格 URL的一个重要标志。
 
 
属性：
 
  
value：指定url中的占位符名称。
 
 
例如：
 
@RequestMapping(path="/hello/{id}")
public String atfwus(@PathVariable(value="id") String id) {
 
5.@RequestHeader:
 
 
作用：获取指定请求头的值.
 
 
属性：
 
  
value：请求头的名称。
 
 
例如：
 
public String atfwus(@RequestHeader(value="Accept") String header) 
 
6.@CookieValue：
 
 
作用：用于获取指定cookie的名称的值。
 
 
属性：
 
  
value：cookie的名称。
 
 
例如：
 
public String atfwus(@CookieValue(value="JSESSIONID") String cookieValue)
 
7.@ModelAttribute：
 
出现在方法上：表示当前方法会在控制器方法执行前先执行。
出现在参数上：获取指定的数据给参数赋值。
用途：当提交表单数据不是完整的实体数据时，保证没有提交的字段使用数据库原来的数据。
如果所在方法有返回值，那么直接返回，如果没有，需要提供一个map集合，先将数据存入map集合。
 
8.@SessionAttributes：
 
 
作用：用于多次执行控制器方法间的参数共享。
 
 
属性：
 
  
value：指定存入属性的名称。
 
 
例如：
 
@Controller
@RequestMapping("/anno")
@SessionAttributes(value={"msg"})   
public class AnnoController {
    @RequestMapping(value="/testSessionAttributes")
    public String testSessionAttributes(Model model){
        model.addAttribute("msg","atfwus");
        return "success";
    }
    @RequestMapping(value="/getSessionAttributes")
    public String getSessionAttributes(ModelMap modelMap){
        String msg = (String) modelMap.get("msg");
        System.out.println(msg);
        return "success";
    }
    @RequestMapping(value="/delSessionAttributes")
    public String delSessionAttributes(SessionStatus status){
        status.setComplete();
        return "success";
    }
}
 
0x06.Spring MVC响应数据
 
1.String类型返回值
 
Controller方法返回字符串可以指定逻辑视图的名称，根据视图解析器为物理视图的地址。
如上述例子中，返回success，然后试图解析器解析后，跳转到success.jsp页面。
实际用途：调用此方法的同时，将数据存入到model中，然后框架将数据存入request中，将数据转发到新的页面。
 
2.void类型返回值
 
果控制器的方法返回值编写是void，默认会跳转到@RequestMapping(value="/initUpdate") initUpdate的页面。
可以使用请求转发或者重定向跳转到指定的页面。还可以直接响应。
 
@RequestMapping("/testVoid")
public void testVoid(HttpServletRequest request, HttpServletResponse response) throws Exception {
    // 请求转发
    request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);

    // 重定向
    response.sendRedirect(request.getContextPath()+"/index.jsp");

    // 解决中文乱码
    response.setCharacterEncoding("UTF-8");
    response.setContentType("text/html;charset=UTF-8");

    // 直接进行响应
    response.getWriter().print("响应");
}
 
3.ModelAndView对象类型返回值
 
ModelAndView对象是Spring提供的一个对象，可以用来调整具体的JSP视图。
 
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
    // 创建ModelAndView对象
    ModelAndView mv = new ModelAndView();
    String name="ATFWUS";
    // 把name存储到mv对象中，也会把name存入到request对象
    mv.addObject("user",name);
    // 跳转页面
    mv.setViewName("success")
    return mv;
}
 
4.Spring MVC提供的转发和重定向
 
forward请求转发：
 
 return "forward:/WEB-INF/pages/success.jsp";
 
redirect重定向：
 
 return "redirect:/add.jsp";
 
5.响应json数据（ResponseBody）
 
配置静态资源不进行拦截：
 
DispatcherServlet会拦截到所有的资源，导致静态资源（img、css、js）也会被拦截到，如果需要设置不拦截，需要在springmvc.xml中进行配置。
mvc:resources：标签配置不过滤。
location元素表示webapp目录下的包下的所有文件
mapping元素表示以/static开头的所有请求路径。
 
<!-- 设置静态资源不过滤 -->
<mvc:resources location="/css/" mapping="/css/**"/> 
<mvc:resources location="/images/" mapping="/images/**"/> 
<mvc:resources location="/js/" mapping="/js/**"/>  
 
使用@RequestBody注解把json的字符串转换成JavaBean的对象：
 
发送ajax请求：
 
<script>
    $(function(){
        $("#btn").click(function(){
            $.ajax({
                // 编写json格式，设置属性和值
                url:"user/testAjax",
                contentType:"application/json;charset=UTF-8",
                data:'{"username":"atfwus","password":"atfwus","age":19}',
                dataType:"json",
                type:"post",
                success:function(data){
                 // 服务器端响应的json的数据，进行解析
                 alert(data);
                }
            });
        });
    });
</script>
 
控制器代码：
 
在导入相关的jar包的前提下，Spring MVC可以直接把相关的json数据转换成JavaBean。
jar包：jackson-annotations，jackson-datablind，jackson-core。
 
@RequestMapping("/testJson")
public void testJson(@RequestBody User user) {
	 System.out.println(user);
}
 
使用@ResponseBody注解把JavaBean对象转换成json字符串：
 
@ResponseBody作用： 该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。
 
@RequestMapping("/testAjax")
public @ResponseBody User testAjax(@RequestBody User user){
    // 后端把json字符串封装到user对象中
    System.out.println(user);
    // 响应
    user.setUsername("ATFWUS");
    return user;
}
 
0x07.Spring MVC文件上传
 
文件上传时form表单的 enctype取值必须是：multipart/form-data。
文件上传时method属性取值必须是 Post。
文件上传需要提供一个文件选择域<input type=”file” />。
下列代码需要的jar包：commons-fileupload，commons-io，jersey-client，jersey-core。
 
1.jsp页面
 
<form action="/user/fileupload1" method="post" enctype="multipart/form-data">
        选择文件：<input type="file" name="upload" /><br/>
        <input type="submit" value="上传" />
</form>
 
2.传统文件上传
 
// 使用fileupload组件完成文件上传
@RequestMapping("/fileupload1")
public String fileuoload1(HttpServletRequest request) throws Exception {
    // 上传的位置
    String path = request.getSession().getServletContext().getRealPath("/uploads/");
    // 判断，该路径是否存在
    File file = new File(path);
    if(!file.exists()){
        // 创建该文件夹
        file.mkdirs();
    }
    // 解析request对象，获取上传文件项
    DiskFileItemFactory factory = new DiskFileItemFactory();
    ServletFileUpload upload = new ServletFileUpload(factory);
    // 解析request
    List<FileItem> items = upload.parseRequest(request);
    // 遍历
    for(FileItem item:items){
        // 进行判断，当前item对象是否是上传文件项
        if(item.isFormField()){
            // 说明普通表单向
        }else{
            // 说明上传文件项
            // 获取上传文件的名称
            String filename = item.getName();
            // 把文件的名称设置唯一值，uuid
            String uuid = UUID.randomUUID().toString().replace("-", "");
            filename = uuid+"_"+filename;
            // 完成文件上传
            item.write(new File(path,filename));
            // 删除临时文件
            item.delete();
        }
    }
    return "success";
}
 
3.Spring MVC上传文件
 
SpringMVC框架提供了MultipartFile对象，该对象表示上传的文件，要求变量名称必须和表单file标签的name属性名称相同。
配置文件解析器：
 
<!--配置文件解析器对象-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="1000000" />
</bean>
 
控制器代码：
 
// 使用fileupload组件完成文件上传
@RequestMapping("/fileupload2")
public String fileuoload2(HttpServletRequest request, MultipartFile upload) throws Exception {
    // 上传的位置
    String path = request.getSession().getServletContext().getRealPath("/uploads/");
    // 判断，该路径是否存在
    File file = new File(path);
    if(!file.exists()){
        // 创建该文件夹
        file.mkdirs();
    }
    // 说明上传文件项
    // 获取上传文件的名称
    String filename = upload.getOriginalFilename();
    // 把文件的名称设置唯一值，uuid
    String uuid = UUID.randomUUID().toString().replace("-", "");
    filename = uuid+"_"+filename;
    // 完成文件上传
    upload.transferTo(new File(path,filename));
    return "success";
}
 
4.跨服务器文件上传：
 
将文件跨服务器进行上传。
 
@RequestMapping("/fileupload3")
public String fileuoload3(MultipartFile upload) throws Exception {
    // 定义上传文件服务器路径
    String path = "http://localhost:8090/uploads/";
    // 说明上传文件项
    // 获取上传文件的名称
    String filename = upload.getOriginalFilename();
    // 把文件的名称设置唯一值，uuid
    String uuid = UUID.randomUUID().toString().replace("-", "");
    filename = uuid+"_"+filename;
    // 创建客户端的对象
    Client client = Client.create();
    // 和图片服务器进行连接
    WebResource webResource = client.resource(path + filename);
    // 上传文件
    webResource.put(upload.getBytes());
    return "success";
}
 
0x08.Spring MVC异常处理
 
系统的 dao、service、controller出现异常都会通过 throws Exception向上抛出，最后由 Spring MVC前端控制器交由异常处理器进行异常处理。
 
1.自定义异常类
 
public class SysException extends Exception{

    // 存储提示信息的
    private String message;
    
    //get and set
    
    public SysException(String message) {
        this.message = message;
    }
}
 
2.自定义异常处理器
 
public class SysExceptionResolver implements HandlerExceptionResolver{

    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        // 获取到异常对象
        SysException e = null;
        if(ex instanceof SysException){
            e = (SysException)ex;
        }else{
            e = new SysException("出异常了");
        }
        // 创建ModelAndView对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("errorMsg",e.getMessage());
        mv.setViewName("error");
        return mv;
    }
}
 
3.配置异常处理器
 
 <!-- 配置异常处理器 -->
<bean id="sysExceptionResolver" class="cn.atfwus.exception.SysExceptionResolver"/>
 
4.测试异常处理
 
@RequestMapping("/testException")
public String testException() throws SysException {
    try {
        // 模拟异常
        int a = 0/0;
    } catch (Exception e) {
        // 打印异常信息
        e.printStackTrace();
        // 抛出自定义异常
        throw new SysException("出异常了");
    }
    return "success";
}
 
0x09.Spring MVC拦截器
 
 
Spring MVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。
 
 
拦截器和过滤器的区别：
 
  
过滤器是Servlet规范的一部分，任何框架都可以使用过滤器技术。拦截器是SpringMVC框架独有的。
过滤器配置了/*，可以拦截任何资源。拦截器只会对控制器中的方法进行拦截。
 
 
拦截器是AOP思想的一种实现方式。
 
 
可以定义拦截器链，连接器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链中的拦截器会按着定义的顺序执行。
 
 
如果需要自定义拦截器，需要实现HandlerInterceptor接口。
 
 
1.自定义拦截器类
 
需要实现HandlerInterceptor接口。
 
public class MyInterceptor1 implements HandlerInterceptor{


     // 预处理，controller方法执行前
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor前");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }


     // 后处理方法，controller方法执行后，success.jsp执行之前
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor执行");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }

    
     //success.jsp页面执行后，该方法会执行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor最后");
    }

}
 
2.配置拦截器
 
<!--配置拦截器-->
<mvc:interceptors>
    <!--配置拦截器-->
    <mvc:interceptor>
        <!--要拦截的具体的方法-->
        <mvc:mapping path="/user/*"/>
        <!--不要拦截的方法
        <mvc:exclude-mapping path=""/>
            -->
        <!--配置拦截器对象-->
        <bean class="cn.atfwus.controller.cn.itcast.interceptor.MyInterceptor1" />
    </mvc:interceptor>

    <!--配置第二个拦截器-->
    <mvc:interceptor>
        <!--要拦截的具体的方法-->
        <mvc:mapping path="/**"/>
        <!--不要拦截的方法
        <mvc:exclude-mapping path=""/>
        -->
        <!--配置拦截器对象-->
        <bean class="cn.itcast.controller.cn.atfwus.interceptor.MyInterceptor2" />
    </mvc:interceptor>
</mvc:interceptors>
 
3.接口中的方法
 
 
preHandle方法：是controller方法执行前拦截的方法。可以使用request或者response跳转到指定的页面。return true放行，执行下一个拦截器，如果没有拦截器，执行controller中的方法。3return false不放行，不会执行controller中的方法。
 
 
postHandle方法：是controller方法执行后执行的方法，在JSP视图执行前。可以使用request或者response跳转到指定的页面。如果指定了跳转的页面，那么controller方法跳转的页面将不会显示。
 
 
postHandle方法：是在JSP执行后执行。request或者response不能再跳转页面了。
 
 
0x0A.再回首，Spring MVC优势分析
 
（01）方便与Spring框架集成（如IoC容器、AOP等）；
 （02）能够使我们进行更简洁的Web层的开发；
 （03）清晰的角色划分，前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping), 处理器适配器（HandlerAdapter), 视图解析器（ViewResolver）。
 （04）可以支持各种视图技术,而不仅仅局限于JSP；
 （05）支持各种请求资源的映射策略。
 （06）可适配、非侵入：可以根据不同的应用场景，选择合适的控制器子类 （simple型、command型、form型、wizard型、multi-action型或者自定义），而不是从单一控制器 （比如Action/ActionForm）继承。
 （07）简单而强大的JSP标签库（SpringTag Library）：支持包括诸如数据绑定和主题之类的许多功能。
 （08）非常灵活的数据验证、格式化和数据绑定机制。
 （09）支持Restful风格。
 （10）灵活的model转换：在Springweb框架中，使用基于Map的 键/值对来达到轻易地与各种视图技术的集成。
 
SpringMVC 和 Struts2 对比：
 
相同点：
 
它们都是表现层框架，都是基于 MVC模型编写的。
它们的底层都离不开原始 ServletAPI。
它们处理请求的机制都是一个核心控制器。
 
不同点：
 
Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter。
Spring MVC 是基于方法设计的，而 Struts2是基于类，Struts2每次执行都会创建一个动作类。所以 Spring MVC 会稍微比 Struts2 快些。
Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便。
Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些，但执行效率并没有比 JSTL 提升，尤其是 struts2的表单标签，远没有 html执行效率高。
与spring整合不一样。Spring MVC是spring框架的一部分，不需要整合。
 
 
 
再次感谢耐心的你看到了这，谢谢！
 
 
 
 
参考书籍与文献：
 
 
《SSM实战》
《Spring实战》第4版
《轻量级J2EE企业应用实战》
百度百科（图1和图2）
Spring MVC源代码
 
 
 
 
ATFWUS --Writing By 2020–04-24
 

推荐：博主历时三年倾注大量心血创作的《大数据平台架构与原型实现：数据中台建设实战》一书已由知名IT图书品牌电子工业出版社博文视点出版发行，真诚推荐给每一位读者！点击《重磅推荐：建大数据平台太难了！给我发个工程原型吧！》了解图书详情，扫码进入京东手机购书页面！
 
 
 
 
从MVC框架看MVC架构的设计
 
尽管MVC早已不是什么新鲜话题了，但是从近些年一些优秀MVC框架的设计上，我们还是会发现MVC在架构设计上的一些新亮点。本文将对传统MVC架构中的一些弊病进行解读，了解一些优秀MVC框架是如何化解这些问题的，揭示其中所折射出的设计思想与设计理念。
 
MVC回顾
 
作为一种经典到不能再经典的架构模式，MVC的成功有其必然的道理，这个道理不同的人会有不同的解读，笔者最认同的一种观点是：通过把职责、性质相近的成分归结在一起，不相近的进行隔离，MVC将系统分解为模型、视图、控制器三部分，每一部分都相对独立，职责单一，在实现过程中可以专注于自身的核心逻辑。MVC是对系统复杂性的一种合理的梳理与切分，它的思想实质就是“关注点分离”。至于MVC三元素的职责划分与相互关系，这里不再赘述，下图给出了非常细致的说明。
 
 
 
 
图1：MVC组件的功能和关系[i]
 
View与Controller的解耦：mediator+二次事件委派
 
笔者早年开发基于swing的GUI应用时,在架构MVC的实践过程中深刻体会到了view与controller之间的紧密耦合问题。在很多事件驱动的GUI框架里，如swing，用户对view的任何操作都会触发一个事件，然后在listener的响应方法里进行处理。如果让view自己注册成为事件的listener,则必须要在view中加入对controller的引用，这不是MVC希望看到的，因为这样view和controller就形成了紧密的耦合关系。若将controller注册为listener，则事件响应将由controller承担，这又会导致controller处理其不该涉及的展现逻辑,造成view和controller难以解耦的原因在于：多数的用户请求都包含一定成分的展现逻辑和一定成分的业务逻辑，两种逻辑揉合在一个请求里，在处理的时候，view与controller很难合理地分工。解决这一问题的关键是要在view与controller之间建立一种可以将展现逻辑与业务逻辑进行有效分割的机制，在这方面，PureMVC[ii]的设计非常值得参考，它通过引入mediator+二次事件委派机制很好的解决了view与controller之间的紧耦合问题。
 
Mediator是一种设计模式，这种模式在组件化的图形界面框架中似乎有着普遍的应用场景，即使是在四人帮的《设计模式》一书中，也使用了一个图形界面程序的示例来讲解mediator。mediator的设计用意在于通过一个媒介对象，完成一组对象的交互，避免对象间相互引用，产生复杂的依赖关系。mediator应用于图形界面程序时，往往作为一组关系紧密的图形组件的交互媒介，完成组件间的协调工作(比如点选某一按钮，其他组件将不可用)。在PureMVC中，mediator被广泛应用，其定位也发生了微妙的变化，它不再只是图形组件间的媒介，同时也成为了图形组件与command之间的媒介，这使得它不再是可选的，而是成为了架构中的必需设施。对应到传统MVC架构中，mediator就是view与controller之间的媒介（当然，也依然是view之间的媒介），所有从view发出的用户请求都经过了mediator再传递给controller，它的出现在一定程度上缓解了view与controller的紧密耦合问题。
 
当view、mediator和controller三者被定义出来，并进行了清晰的职责划分后，剩下的问题就是如何将它们串联起来，以完成一个用户请求了，在这方面，事件机制起到了至关重要的作用。事件机制可以让当前对象专注于处理其职责范围内的事务，而不必关心超出部分由谁来处理以及怎样处理，当前对象只需要广播一个事件，就会有对此事件感兴趣的其他对象出来接手下一步的工作，当前对象与接手对象之间不存在直接依赖，甚至感知不到彼此的存在，这是事件机制被普遍认为是一种松耦合机制的重要原因。讲到这里插一句题外话，在领域驱动设计（Domain-Driven Design）里，著名的Domain Event模式也是有赖于事件机制的这一特性被创造出来的，其用意正是为了保证领域模型的纯净，避免领域模型对repository和service的直接依赖。回到PureMVC, 我们来看在处理用户请求的过程中，事件机制是如何串联view、mediator和controller的。在PureMVC里，当一个用户请求下达时，图形组件先在自身的事件响应方法中实现与自身相关的展现逻辑，然后收集数据，将数据置入一个新的event中，将其广播出去，这是第一次事件委派。这个event会被一个mediator监听到，如果处理该请求需要其他图形组件的协助，mediator会协调它们处理应由它们承担的展现逻辑，然后mediator再次发送一个event(这次的event在PureMVC里称之为notification)，这个event会促使某个command执行，完成业务逻辑的计算，这是第二次事件委派。在两次事件委派中，第一次事件委派让当事图形组件完成“处理其职责范围内的展现逻辑”后，得以轻松“脱身”，免于被“协调其他图件处理剩余展现逻辑”和“选择并委派业务对象处理业务逻辑”所拖累。而“协调其他图形组件处理剩余展现逻辑”显然是mediator的职责，于是第一次广播的事件被委派给了mediator. mediator在完成图形组件的协调工作后，并不会插手“选择并委派业务对象处理业务逻辑”的工作，这不是它的职责，因此，第二次事件委派发生了，一个新的event由mediator广播出去，后被某个command响应到，由command完成了最后的工作——“选择并委派业务对象处理业务逻辑”。
 
 
图2：mediator+二次事件委派机制
 
总结起来，PureMVC是通过在view与controller之间引入mediator，让view与controller变成间接依赖，用户请求从view到mediator，再从mediator到controller均以事件方式委派，mediator+二次事件委派的组合可以说是一种“强力”的解耦机制，它实现了view与controller之间的完全解耦。
 
从Controller到Command，自然粒度的回归
 
目前，很多平台的主流MVC框架在设计上都引入了command模式，command模式的引入改变了传统ＭＶＣ框架的结构，受冲击最大的就是controller。在过去传统的MVC架构里，一个controller可能有多个方法，每个方法往往对应一个user action,因此，一个 controller往往对应多个user action，而在基于command的MVC架构里，一个command往往只对应一个user action。传统MVC架构里将一个user action委派到某个controller的某个方法的过程，在基于command的MVC架构里变成了将useraction与command一一绑定的过程。如果说传统controller的管理方式是在user action与model之间建立“集中式”的映射，那么基于command的管理方式就是在user action与model之间建立“点对点式”的直连映射。
 
 
图3：从基于Controller到基于Command的架构演进
 
主流MVC框架向command转型是有原因的，除了command自身的优势之外，一个非常重要的原因就是：由于缺少合理的组织依据，controller的粒度很难拿捏。controller不同于view与model，view与model都有各自天然的粒度组织依据，view的组织粒度直接承袭用户界面设计，model的组织粒度则是依据某种分析设计思想（如OOA/D）进行领域建模的结果，controller需要同时协调view与model，但是view与model的组织结构和粒度都是不对等的，这就使得controller面临一个“在多大视图范围内沟通与协调多少领域对象”的问题，由于找不出合理的组织依据，设计者在设计controller时往往感到无所适从。相比之下，command则完全没有controller的困惑，因为command有一个天然的组织依据，这就是user action。针对一个user action设计一个command，然后将两者映射在一起，是一件非常自然而简单的事情。不过，需要说明的是这并不意味着所有command的粒度是一样的，因为不同的user action所代表的业务量是不同的，因此也决定了command是有“大”有“小”的。遵循良好的设计原则，对某些较“大”的command进行分解，从中抽离出一些可复用的部分封装成一些较“小”的command是值得推荐的。很多MVC框架就定义了一些相关的接口和抽象类用于支持基于组合模式的命令拼装。
 
不管是基于controller还是基于command，MVC架构中界定的“协调view与model交互”的控制器职责是不会变的，都需要相应的组件和机制去承载与实现。在基于command的架构里，command承担了过去controller的部分职责，从某种意义上说 command是一种细粒度的controller，但是command的特性是偏“被动”的。一方面，它对于view和model的控制力比controller弱化了很多， 比如，一般情况下command是不会直接操纵view的。另一方面，它不知道自己与什么样的user action映射在了一起，也不知道自己会在何种情况下被触发执行。支撑command的运行需要额外的注册、绑定和触发机制，是这些机制加上command一起实现了controller的职责。由于现在多数基于command的MVC框架都实现并封装了这些重要的机制，所以从某种意义上说，是这些框架自身扮演了controller角色。
 
小结
 
本文主要分析了过去传统MVC架构中存在的两大弊病：view与controller的紧密耦合以及controller粒度难以把控的问题，介绍了一些MVC框架是如何应对这些问题的，这些设计方案所体现出的优秀设计思想是非常值得学习的。
 

   
 

 
 
  
[i] 图片来源：http://java.sun.com/blueprints/patterns/MVC-detailed.html
 
 
 
 
 
  
[ii] PureMVC是一种MVC框架，最初使用ActionScript 3实现，现在在多种语言平台上有实现版本。官方站点：http://puremvc.org/
 
  
 
 
  
更多精彩博文：
 
  
 
 
  
领域驱动设计(Domain Driven Design)参考架构详解
   
  
关于垂直切分Vertical Sharding的粒度
   
  
企业应用集成与开源ESB产品ServiceMix和Mule介绍
   
  
论基于数据访问的集合类（Data Access Based Collection）和领域事件(Domain Event)模式
   
  
关于系统异常设计的再思考
   
 
 

本文主要介绍 MVC 模式的相关知识。
 
1 What
 
MVC（Model–View–Controller）模式是软件工程中的一种软件架构模式，它把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。
 
MVC 模式的目的是实现一种动态的程序设计，简化后续对程序的修改和扩展，并且使程序某一部分的重复利用成为可能。除此之外，MVC 模式通过对复杂度的简化，使程序的结构更加直观。软件系统在分离了自身的基本部分的同时，也赋予了各个基本部分应有的功能。专业人员可以通过自身的专长进行相关的分组：
 
模型（Model）：程序员编写程序应有的功能（实现算法等）、数据库专家进行数据管理和数据库设计（可以实现具体的功能）；
控制器（Controller）：负责转发请求，对请求进行处理；
视图（View）：界面设计人员进行图形界面设计。
MVC 模式的描述如下图所示：
 
 
MVC 模式中三个组件的详细介绍如下：
 
模型（Model）：用于封装与应用程序业务逻辑相关的数据以及对数据的处理方法。Model 有对数据直接访问的权力，例如对数据库的访问。Model 不依赖 View 和 Controller，也就是说， Model 不关心它会被如何显示或是如何被操作。但是 Model 中数据的变化一般会通过一种刷新机制被公布。为了实现这种机制，那些用于监视此 Model 的 View 必须事先在此 Model 上注册，由此，View 可以了解在数据 Model 上发生的改变。（如，软件设计模式中的“观察者模式”）；
视图（View）：能够实现数据有目的的显示（理论上，这不是必需的）。在 View 中一般没有程序上的逻辑。为了实现 View 上的刷新功能，View 需要访问它监视的数据模型（即 Model），因此应该事先在被它监视的数据那里注册；
控制器（Controller）：起到不同层面间的组织作用，用于控制应用程序的流程。它处理事件并作出响应。“事件”包括用户的行为和数据 Model 上的改变。
从 MVC 模式的一般理解来看，视图层与模型层是存在直接联系的，并且模型层的变化会通过视图层反映出来，这确实是 MVC 模式的标准理解，不过在我目前接触到的实际应用中，更多的情况是，视图层与模型层是通过控制层联系起来的，两者之间并无直接的联系，三者之间的关系更类似下图所示：
 
 
结合 MVC 模式的标准解释来看，上述模式可能是 MVC 模式的一种变型使用，这只是个人的武断猜测，并无实据，待以后对设计模式有深入了解后，可能就会有准确答案了(^-^)。
 
2 优点与缺点
 
2.1 MVC模式的优点
 
2.1.1 低耦合
 
通过将视图层和业务层分离，允许更改视图层代码而不必重新编译模型和控制器代码，同样，一个应用的业务流程或者业务规则的改变，只需要改动 MVC 的模型层（及控制器）即可。因为模型与控制器和视图相分离，所以很容易改变应用程序的数据层和业务规则。
 
模型层是自包含的，并且与控制器和视图层相分离，所以很容易改变应用程序的数据层和业务规则。如果想把数据库从 MySQL 移植到 Oracle，或者改变基于 RDBMS 的数据源到 LDAP，只需改变模型层即可。一旦正确的实现了模型层，不管数据来自数据库或是 LDAP 服务器，视图层都将会正确的显示它们。由于运用 MVC 的应用程序的三个部件是相互独立，改变其中一个部件并不会影响其它两个，所以依据这种设计思想能构造出良好的松耦合的构件。
 
2.1.2 重用性高
 
随着技术的不断进步，当前需要使用越来越多的方式来访问应用程序了。MVC 模式允许使用各种不同样式的视图来访问同一个服务端的代码，这得益于多个视图（如 WEB（HTTP）浏览器或者无线浏览器（WAP））能共享一个模型。
 
比如，用户可以通过电脑或通过手机来订购某样产品，虽然订购的方式不一样，但处理订购产品的方式（流程）是一样的。由于模型返回的数据没有进行格式化，所以同样的构件能被不同的界面（视图）使用。例如，很多数据可能用 HTML 来表示，但是也有可能用 WAP 来表示，而这些表示的变化所需要的是仅仅是改变视图层的实现方式，而控制层和模型层无需做任何改变。
 
由于已经将数据和业务规则从表示层分开，所以可以最大化的进行代码重用了。另外，模型层也有状态管理和数据持久性处理的功能，所以，基于会话的购物车和电子商务过程，也能被 Flash 网站或者无线联网的应用程序所重用。
 
2.1.3 生命周期成本低
 
MVC 模式使开发和维护用户接口的技术含量降低。
 
2.1.4 部署快
 
使用 MVC 模式进行软件开发，使得软件开发时间得到相当大的缩减，它使后台程序员集中精力于业务逻辑，界面（前端）程序员集中精力于表现形式上。
 
2.1.5 可维护性高
 
分离视图层和业务逻辑层使得 WEB 应用更易于维护和修改。
 
2.1.6 有利软件工程化管理
 
由于不同的组件（层）各司其职，每一层不同的应用会具有某些相同的特征，这样就有利于通过工程化、工具化的方式管理程序代码。控制器同时还提供了一个好处，就是可以使用控制器来联接不同的模型和视图，来实现用户的需求，这样控制器可以为构造应用程序提供强有力的手段。给定一些可重用的模型和视图，控制器可以根据用户的需求选择模型进行处理，然后选择视图将处理结果显示给用户。
 
2.2 MVC模式的缺点
 
2.2.1 没有明确的定义
 
完全理解 MVC 模式并不是很容易的。使用 MVC 模式需要精心的计划，由于它的内部原理比较复杂，所以需要花费一些时间去思考软件的架构。同时由于模型和视图要严格的分离，这样也给调试应用程序带来了一定的困难。每个构件在使用之前都需要经过彻底的测试。
 
2.2.2 不适合小、中型应用程序
 
花费大量时间将 MVC 模式应用到规模并不是很大的应用程序通常会得不偿失。
 
2.2.3 增加系统结构和实现的复杂性
 
对于简单的界面来说，非要严格遵循 MVC 模式，使模型、视图与控制器分离的话，会增加结构的复杂性，并可能产生过多的更新操作，降低运行效率。
 
2.2.4 视图对模型数据的低效率访问
 
依据模型操作接口的不同，视图可能需要多次调用才能获得足够的显示数据。对未变化数据的不必要的频繁访问，也将损害操作性能。
 
说明：如果通过控制器访问模型层（而非视图层直接访问），或许可避免对未变化数据的不必要的频繁访问，从而解决此问题。