前言

上节课我们学习了 Spring MVC 框架的使用，为了更好地理解这个框架，本节课我们来仿写一个 Spring MVC 框架，用到的技术比较简单，只需要 XML 解析+反射就可以完成，不需要 JDK 动态代理。

自己手写框架的前提使必须理解框架的底层原理和运行机制，所以我们还是先来回顾一下 Spring MVC 的实现原理。

Spring MVC 实现原理

核心组件

1. DispatcherServlet：前端控制器，负责调度其他组件的执行，可降低不同组件之间的耦合性，是整个 Spring MVC 的核心模块。
2. Handler：处理器，完成具体业务逻辑，相当于 Servlet 或 Action。
3. HandlerMapping：DispatcherServlet 是通过 HandlerMapping 将请求映射到不同的 Handler。
4. HandlerInterceptor：处理器拦截器，是一个接口，如果我们需要做一些拦截处理，可以来实现这个接口。
5. HandlerExecutionChain：处理器执行链，包括两部分内容：Handler 和 HandlerInterceptor（系统会有一个默认的 HandlerInterceptor，如果需要额外拦截处理，可以添加拦截器设置）。
6. HandlerAdapter：处理器适配器，Handler 执行业务方法之前，需要进行一系列的操作包括表单数据的验证，数据类型的转换，将表单数据封装到 POJO 等等，这一系列的操作，都是由 HandlerAdapter 来完成，DispatcherServlet 通过 HandlerAdapter 执行不同的 Handler。
7. ModelAndView：装载了模型数据和视图信息，作为 Handler 的处理结果，返回给 DispatcherServlet。
8. ViewResolver：视图解析器，DispatcherServlet 通过它将逻辑视图解析成物理视图，最终将渲染结果响应给客户端。

以上就是 Spring MVC 的核心组件。那么这些组件之间是如何进行交互的呢？

工作流程

1. 客户端请求被 DispatcherServlet（前端控制器）接收。
2. 根据 Handler Mapping映射到 Handler。
3. 生成 Handler 和 HandlerInterceptor（如果有则生成）。
4. Handler 和 HandlerInterceptor 以 HandlerExecutionChain 的形式一并返回给 DispatcherServlet。
5. DispatcherServlet 通过 HandlerAdapter 调用 Handler 的方法做业务逻辑处理。
6. 返回一个 ModelAndView 对象给 DispatcherServlet。
7. DispatcherServlet 将获取的 ModelAndView 对象传给 ViewResolver 视图解析器，将逻辑视图解析成物理视图 View。
8. ViewResolver 返回一个 View 给 DispatcherServlet。
9. DispatcherServlet 根据 View 进行视图渲染（将模型数据填充到视图中）。
10. 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 请求，业务流程如下：

1. DispatcherServlet 接收请求，通过映射从 IoC 容器中获取对应的 Controller 对象。
2. 根据映射获取 Controller 对象对应的 Method。
3. 调用 Method，获取返回值。
4. 将返回值传给视图解析器，返回物理视图。
5. 完成页面跳转。

思路捋清楚了，接下来开始写代码，我们需要创建下面这四个类：

1. MyDispatcherServlet：模拟 DispatcherServlet。
2. MyController：模拟 Controller 注解。
3. MyRequestMapping：模拟 RequestMapping 注解。
4. MyViewResolver：模拟 ViewResolver 视图解析器。

首先创建 MyDispatcherServlet，init 方法完成初始化：

1、将 Controller 与注解进行关联，保存到 iocContainer 中，那些 Controller 是需要添加到 iocContainer 中的？

必须同时满足两点：

• springmvc.xml 中配置扫描的类。
• 类定义处添加了注解。

注意这两点必须同时满足。

代码思路：

• 解析 springmvc.xml。
• 获取 component-scan 标签配置的包下的所有类。
• 判断若这些类添加了 @MyController 注解，则创建实例对象，并且保存到 iocContainer。
• @MyRequestMapping 的值为键，Controller 对象为值。

2、将 Controller 中的 Method 与注解进行关联，保存到 handlerMapping 中。

代码思路：

• 遍历 iocContainer 中的 Controller 实例对象。
• 遍历每一个 Controlle r对象的 Method。
• 判断 Method 是否添加了 @MyRequestMapping 注解，若添加，则进行映射并保存。
• 保存到 handlerMapping 中，@MyRequestMapping 的值为键，Method 为值。

3、实例化 ViewResolver。

代码思路：

• 解析 springmvc.xml。
• 根据 bean 标签的 class 属性获取需要实例化的 MyViewResolver。
• 通过反射创建实例化对象，同时获取 prefix 和 suffix 属性，以及 setter 方法。
• 通过反射调用 setter 方法给属性赋值，完成 MyViewResolver 的实例化。

doPost 方法处理 HTTP 请求的流程：

1、解析 HTTP，分别得到 Controller 和 Method 对应的 uri。

2、通过 uri 分别在 iocContainer 和 handlerMapping 中获取对应的 Controller 以及 Method。

3、通过反射调用 Method，执行业务方法，获取结果。

4、将结果传给 MyViewResolver 进行解析，返回真正的物理视图（JSP 页面）。

5、完成 JSP 页面跳转。

代码实现：

1、创建 MyController 注解，作用目标为类。

/**
 * 自定义Controller注解
 * @author southwind
 *
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyController {
    String value() default "";
}

2、创建 MyRequestMapping 注解，作用目标为类和方法。

/**
 * 自定义RequestMapping注解
 * @author southwind
 *
 */
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRequestMapping {
    String value() default "";
}

3、创建 MyDispatcherServlet，核心控制器，init 完成初始化工作，doPost 处理 HTTP 请求。

/**
 * DispatcherServlet
 * @author southwind
 *
 */
public class MyDispatcherServlet extends HttpServlet{

    //模拟IOC容器，保存Controller实例对象
    private Map<String,Object> iocContainer = new HashMap<String,Object>();
    //保存handler映射
    private Map<String,Method> handlerMapping = new HashMap<String,Method>();
    //自定视图解析器
    private MyViewResolver myViewResolver;

    @Override
    public void init(ServletConfig config) throws ServletException {
        // TODO Auto-generated method stub
        //扫描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<String> 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) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 获取包下的所有类名
     * @param packageName
     * @return
     */
    public List<String> getClassNames(String packageName){
        List<String> classNameList = new ArrayList<String>();
        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<String,String> propertyMap = new HashMap<String,String>();
                    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) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        // TODO Auto-generated method stub
        this.doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        // TODO Auto-generated method stub
        //获取请求
        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) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }
}

4、创建视图解析器 MyViewResolver。

/**
 * 自定义视图解析器
 * @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，处理业务请求。

@MyController
@MyRequestMapping(value = "/testController")
public class TestController {
    @MyRequestMapping(value = "/test")
    public String test(){
        System.out.println("执行test相关业务");
        return "index";
    }
}

6、测试。

跳转 index.jsp，同时控制台打印业务日志，访问成功。

总结

本节课我们讲解了 Spring MVC 的底层原理，同时仿照 Spring MVC 手写了一个简单的框架，目的不是让大家自己去写框架，在实际开发中我们也不需要自己写框架，直接使用成熟的第三方框架即可。

手写框架的目的在于让大家更透彻地理解 Spring MVC 的底层流程，学习优秀框架的编程思想，理解了原理，才能更熟练地应用。