Spring MVC 原理＋底层实现
Spring MVC 实现原理
核心组件
- DispatcherServlet：前端控制器，是整个流程控制的核心，控制其他组件的执行，统一调度，降低组件之间的耦合性，相当于总指挥。
- Handler：处理器，完成具体业务逻辑，相当于 Servlet 或 Action。
- HandlerMapping：DispatcherServlet 接收到请求之后，通过 HandlerMapping 将不同的请求分发到不同的 Handler。
- HandlerInterceptor：处理器拦截器，是一个接口，如果我们需要做一些拦截处理，可以来实现这个接口。
- HandlerExecutionChain：处理器执行链，包括两部分内容，Handler 和 HandlerInterceptor（系统会有一个默认的 HandlerInterceptor，如果需要额外拦截处理，可以添加拦截器设置）。
- HandlerAdapter：处理器适配器，Handler 执行业务方法之前，需要进行一系列的操作，包括表单数据的验证、数据类型的转换，将表单数据封装到 JavaBean 等这一系列的操作，都是由 HandlerAdapter 来完成，DispatcherServlet 通过 HandlerAdapter 执行不同的 Handler。
- ModelAndView：装载了模型数据和视图信息，作为 Handler 的处理结果，返回给 DispatcherServlet。
- ViewResolver：视图解析器，DispatcherServlet 通过它将逻辑视图解析成物理视图，最终将渲染结果响应给客户端。
以上就是 Spring MVC 的核心组件，那么这些组件之间是如何进行交互的呢？
Spring MVC 的实现流程
- 客户端请求被 DispatcherServlet（前端控制器）接收。
- 根据 HandlerMapping 映射到 Handler。
- 生成 Handler 和 HandlerInterceptor（如果有则生成）。
- Handler 和 HandlerInterceptor 以 HandlerExecutionChain 的形式一并返回给 DispatcherServlet。
- DispatcherServlet 通过 HandlerAdapter 调用 Handler 的方法做业务逻辑处理。
- 返回一个 ModelAndView 对象给 DispatcherServlet。
- DispatcherServlet 将获取的 ModelAndView 对象传给 ViewResolver 视图解析器，将逻辑视图解析成物理视图 View。
- ViewResolver 返回一个 View 给 DispatcherServlet。
- DispatcherServlet 根据 View 进行视图渲染（将模型数据填充到视图中）。
- DispatcherServlet 将渲染后的视图响应给客户端。
通过以上的分析，大致可以将 Spring MVC 流程理解如下。
首先需要一个前置控制器 DispatcherServlet，作为整个流程的核心，由它去调用其他组件，共同完成业务。主要组件有两个：一是 Controller，调用其业务方法 Method，执行业务逻辑；二是 ViewResolver 视图解析器，将业务方法的返回值解析为物理视图 + 模型数据，返回客户端。
我们自己写框架就按照这个思路来。
初始化工作
根据 Spring IoC 的思路，需要将参与业务的对象全部创建并保存，供流程调用。因此，首先需要创建 Controller 对象，HTTP 请求是通过注解找到对应的 Controller 对象，我们需要将所有的 Controller 与其注解建立关联，很显然，使用 key-value 结构的 Map 集合来保存最合适不过了，这样就模拟了 IoC 容器。
Controller 的 Method 也是通过注解与 HTTP 请求映射的。同样地，我们需要将所有的 Method 与其注解建立关联，HTTP 直接通过注解的值找到对应的 Method，这里也用 Map 集合保存。
实例化视图解析器
初始化工作完成，接下来处理 HTTP 请求，业务流程如下：
- DispatcherServlet 接收请求，通过映射从 IoC 容器中获取对应的 Controller 对象；
- 根据映射获取 Controller 对象对应的 Method；
- 调用 Method，获取返回值；
- 将返回值传给视图解析器，返回物理视图；
- 完成页面跳转。
创建类
思路捋清楚了，接下来开始写代码，我们需要创建以下类。
- MyDispatcherServlet：模拟 DispatcherServlet
- MyController：模拟 Controller 注解
- MyRequestMapping：模拟 RequestMapping 注解
- MyViewResolver：模拟 ViewResolver 视图解析器
创建 MyDispatcherServlet，init 方法完成初始化。
把 Controller 与注解进行关联
将 Controller 与注解进行关联，保存到 iocContainer 中。哪些 Controller 是需要添加到 iocContainer 中的呢？必须同时满足两点：
- springmvc.xml 中配置扫描的类
- 类定义处添加了注解
注意这两点必须同时满足。
代码思路
- 解析 springmvc.xml
- 获取 component-scan 标签配置的包下的所有类
- 判断若这些类添加了 @MyController 注解，则创建实例对象，并且保存到 iocContainer
- @MyRequestMapping 的值为键，Controller 对象为值
把 Controller 中的 Method 与注解进行关联
将 Controller 中的 Method 与注解进行关联，保存到 handlerMapping 中。
代码思路
- 遍历 iocContainer 中的 Controller 实例对象
- 遍历每一个 Controller 对象的 Method
- 判断 Method 是否添加了 @MyRequestMapping 注解，若添加，则进行映射并保存
- 保存到 handlerMapping 中，@MyRequestMapping 的值为键，Method 为值
实例化 ViewResolver
代码思路
- 解析 springmvc.xml
- 根据 bean 标签的 class 属性获取需要实例化的 MyViewResolver
- 使用反射创建实例化对象，同时获取 prefix 和 suffix 属性，以及 setter 方法
- 使用反射调用 setter 方法给属性赋值，完成 MyViewResolver 的实例化
doPost 方法处理 HTTP 请求：
- 解析 HTTP，分别得到 Controller 和 Method 对应的 URL
- 通过 URL 分别在 iocContainer 和 handlerMapping 中获取对应的 Controller 及 Method
- 使用反射调用 Method，执行业务方法，获取结果
- 结果传给 MyViewResolver 进行解析，返回真正的物理视图（JSP 页面）
- 完成 JSP 的页面跳转
代码
（1）创建 MyController 注解，作用目标为类：
package com.southwind.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 自定义 Controller 注解
* @author southwind
*
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyController {
String value() default "";
}
（2）创建 MyRequestMapping 注解，作用目标为类和方法：
package com.southwind.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 自定义 RequestMapping 注解
* @author southwind
*
*/
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRequestMapping {
String value() default "";
}
（3）创建 MyDispatcherServlet，核心控制器，init 完成初始化工作，doPost 处理 HTTP 请求：
package com.southwind.servlet;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.HttpRetryException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import com.southwind.annotation.MyController;
import com.southwind.annotation.MyRequestMapping;
import com.southwind.view.MyViewResolver;
/**
* DispatcherServlet
* @author southwind
*
*/
public class MyDispatcherServlet extends HttpServlet{
//模拟 IoC 容器，保存 Controller 实例对象
private Map iocContainer = new HashMap();
//保存 handler 映射
private Map handlerMapping = new HashMap();
//自定视图解析器
private MyViewResolver myViewResolver;
@Override
public void init(ServletConfig config) throws ServletException {
//扫描 Controller，创建实例对象，并存入 iocContainer
scanController(config);
//初始化 handler 映射
initHandlerMapping();
//加载视图解析器
loadViewResolver(config);
}
/**
* 扫描 Controller
* @param config
*/
public void scanController(ServletConfig config){
SAXReader reader = new SAXReader();
try {
//解析 springmvc.xml
String path = config.getServletContext().getRealPath("")+"\\WEB-INF\\classes\\"+config.getInitParameter("contextConfigLocation");
Document document = reader.read(path);
Element root = document.getRootElement();
Iterator iter = root.elementIterator();
while(iter.hasNext()){
Element ele = (Element) iter.next();
if(ele.getName().equals("component-scan")){
String packageName = ele.attributeValue("base-package");
//获取 base-package 包下的所有类名
List list = getClassNames(packageName);
for(String str:list){
Class clazz = Class.forName(str);
//判断是否有 MyController 注解
if(clazz.isAnnotationPresent(MyController.class)){
//获取 Controller 中 MyRequestMapping 注解的 value
MyRequestMapping annotation = (MyRequestMapping) clazz.getAnnotation(MyRequestMapping.class);
String value = annotation.value().substring(1);
//Controller 实例对象存入 iocContainer
iocContainer.put(value, clazz.newInstance());
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取包下的所有类名
* @param packageName
* @return
*/
public List getClassNames(String packageName){
List classNameList = new ArrayList();
String packagePath = packageName.replace(".", "/");
ClassLoader loader = Thread.currentThread().getContextClassLoader();
URL url = loader.getResource(packagePath);
if(url != null){
File file = new File(url.getPath());
File[] childFiles = file.listFiles();
for(File childFile : childFiles){
String className = packageName+"."+childFile.getName().replace(".class", "");
classNameList.add(className);
}
}
return classNameList;
}
/**
* 初始化 handler 映射
*/
public void initHandlerMapping(){
for(String str:iocContainer.keySet()){
Class clazz = iocContainer.get(str).getClass();
Method[] methods = clazz.getMethods();
for (Method method : methods) {
//判断方式是否添加 MyRequestMapping 注解
if(method.isAnnotationPresent(MyRequestMapping.class)){
//获取 Method 中 MyRequestMapping 注解的 value
MyRequestMapping annotation = method.getAnnotation(MyRequestMapping.class);
String value = annotation.value().substring(1);
//method 存入 methodMapping
handlerMapping.put(value, method);
}
}
}
}
/**
* 加载自定义视图解析器
* @param config
*/
public void loadViewResolver(ServletConfig config){
SAXReader reader = new SAXReader();
try {
//解析 springmvc.xml
String path = config.getServletContext().getRealPath("")+"\\WEB-INF\\classes\\"+config.getInitParameter("contextConfigLocation");
Document document = reader.read(path);
Element root = document.getRootElement();
Iterator iter = root.elementIterator();
while(iter.hasNext()){
Element ele = (Element) iter.next();
if(ele.getName().equals("bean")){
String className = ele.attributeValue("class");
Class clazz = Class.forName(className);
Object obj = clazz.newInstance();
//获取 setter 方法
Method prefixMethod = clazz.getMethod("setPrefix", String.class);
Method suffixMethod = clazz.getMethod("setSuffix", String.class);
Iterator beanIter = ele.elementIterator();
//获取 property 值
Map propertyMap = new HashMap();
while(beanIter.hasNext()){
Element beanEle = (Element) beanIter.next();
String name = beanEle.attributeValue("name");
String value = beanEle.attributeValue("value");
propertyMap.put(name, value);
}
for(String str:propertyMap.keySet()){
//反射机制调用 setter 方法，完成赋值
if(str.equals("prefix")){
prefixMethod.invoke(obj, propertyMap.get(str));
}
if(str.equals("suffix")){
suffixMethod.invoke(obj, propertyMap.get(str));
}
}
myViewResolver = (MyViewResolver) obj;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
this.doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//获取请求
String handlerUri = req.getRequestURI().split("/")[2];
//获取 Controller 实例
Object obj = iocContainer.get(handlerUri);
String methodUri = req.getRequestURI().split("/")[3];
//获取业务方法
Method method = handlerMapping.get(methodUri);
try {
//反射机制调用业务方法
String value = (String) method.invoke(obj);
//视图解析器将逻辑视图转换为物理视图
String result = myViewResolver.jspMapping(value);
//页面跳转
req.getRequestDispatcher(result).forward(req, resp);
} catch (Exception e) {
e.printStackTrace();
}
}
}
（4）创建视图解析器 MyViewResolver：
package com.southwind.view;
/**
* 自定义视图解析器
* @author southwind
*
*/
public class MyViewResolver {
private String prefix;
private String suffix;
public String getPrefix() {
return prefix;
}
public void setPrefix(String prefix) {
this.prefix = prefix;
}
public String getSuffix() {
return suffix;
}
public void setSuffix(String suffix) {
this.suffix = suffix;
}
public String jspMapping(String value){
return this.prefix+value+this.suffix;
}
}
（5）创建 TestController，处理业务请求：
package com.southwind.controller;
import com.southwind.annotation.MyController;
import com.southwind.annotation.MyRequestMapping;
@MyController
@MyRequestMapping(value = "/testController")
public class TestController {
@MyRequestMapping(value = "/test")
public String test(){
System.out.println("执行test相关业务");
return "index";
}
}
（6）测试：
跳转 index.jsp，同时控制台打印业务日志，访问成功。
阅读《springMVC实战手册》作者：宁楠 所得。。想了解这部分内容的朋友，推荐读这本书。