手写SpringMVC 框架

手写springmvc框架

 

细嗅蔷薇 心有猛虎

背景：spring 想必大家都听说过，可能现在更多流行的是spring boot 和spring cloud 框架；但是springmvc 作为一款实现了mvc 设计模式的web (表现层) 层框架，其高开发效率和高性能也是现在很多公司仍在采用的框架；除此之外，spring 源码大师级的代码规范和设计思想都十分值得学习；退一步说，spring boot 框架底层也有很多spring 的东西，而且面试的时候还会经常被问到springmvc 原理，一般人可能也就是只能把springmvc 的运行原理背出来罢了，至于问到有没有了解其底层实现(代码层面)，那很可能就歇菜了，但您要是可以手写springmvc 框架就肯定可以令面试官刮目相看，所以手写springmvc 值得一试。

在设计自己的springmvc 框架之前，需要了解下其运行流程。

一、springmvc 运行流程

图1. springmvc 运行流程

1、用户向服务器发送请求，请求被spring 前端控制器dispatcherservlet 捕获;

2、dispatcherservlet 收到请求后调用handlermapping 处理器映射器；

3、处理器映射器对请求url 进行解析，得到请求资源标识符(uri)；然后根据该uri，调用handlermapping 获得该handler 配置的所有相关的对象(包括handler 对象以及handler 对象对应的拦截器)，再以handlerexecutionchain 对象的形式返回给dispatcherservlet；

4、dispatcherservlet 根据获得的handler，通过handleradapter 处理器适配器选择一个合适的handleradapter；(附注:如果成功获得handleradapter 后，此时将开始执行拦截器的prehandler(...)方法)；

5、提取request 中的模型数据，填充handler 入参，开始执行handler(即controller)；【在填充handler的入参过程中，根据你的配置，spring 将帮你做一些额外的工作如：httpmessageconveter：将请求消息(如json、xml等数据)转换成一个对象，将对象转换为指定的响应信息；数据转换：对请求消息进行数据转换，如string转换成integer、double等；数据格式化：对请求消息进行数据格式化，如将字符串转换成格式化数字或格式化日期等；数据验证：验证数据的有效性(长度、格式等)，验证结果存储到bindingresult或error中 】

6、controller 执行完成返回modelandview 对象；

7、handleradapter 将controller 执行结果modelandview 对象返回给dispatcherservlet；

8、dispatcherservlet 将modelandview 对象传给viewreslover 视图解析器；

9、viewreslover 根据返回的modelandview，选择一个适合的viewresolver (必须是已经注册到spring容器中的viewresolver)返回给dispatcherservlet；

10、dispatcherservlet 对view 进行渲染视图（即将模型数据填充至视图中)；

11、dispatcherservlet 将渲染结果响应用户(客户端)。

二、springmvc 框架设计思路

1、读取配置阶段

图2. springmvc 继承关系

      第一步就是配置web.xml，加载自定义的dispatcherservlet。而从图中可以看出，springmvc 本质上是一个servlet，这个servlet 继承自httpservlet，此外，frameworkservlet 负责初始springmvc的容器，并将spring 容器设置为父容器；为了读取web.xml 中的配置，需要用到servletconfig 这个类，它代表当前servlet 在web.xml 中的配置信息，然后通过web.xml 中加载我们自己写的mydispatcherservlet 和读取配置文件。

2、初始化阶段

初始化阶段会在dispatcherservlet 类中，按顺序实现下面几个步骤：

1、加载配置文件；

2、扫描当前项目下的所有文件；

3、拿到扫描到的类，通过反射机制将其实例化，并且放到ioc 容器中(map的键值对  beanname-bean) beanname默认是首字母小写；

4、初始化path 与方法的映射；

5、获取请求传入的参数并处理参数通过初始化好的handlermapping 中拿出url 对应的方法名，反射调用。

3、运行阶段

      运行阶段，每一次请求将会调用doget 或dopost 方法，它会根据url 请求去handlermapping 中匹配到对应的method，然后利用反射机制调用controller 中的url 对应的方法，并得到结果返回。

三、实现springmvc 框架

      首先，小老弟springmvc 框架只实现自己的@controller 和@requestmapping 注解，其它注解功能实现方式类似，实现注解较少所以项目比较简单，可以看到如下工程文件及目录截图。

图3. 工程文件及目录

 1、创建java web 工程

创建java web 工程，勾选javaee 下方的web application 选项，next。

图4. 创建java web 工程

 2、在工程web-inf 下的web.xml 中加入下方配置

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
 3          xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
 4          xsi:schemalocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
 5          version="4.0">
 6 
 7     <servlet>
 8         <servlet-name>dispatcherservlet</servlet-name>
 9         <servlet-class>com.tjt.springmvc.dispatcherservlet</servlet-class>
10     </servlet>
11     <servlet-mapping>
12         <servlet-name>dispatcherservlet</servlet-name>
13         <url-pattern>/</url-pattern>
14     </servlet-mapping>
15 
16 </web-app>

3、创建自定义controller 注解

 1 package com.tjt.springmvc;
 2 
 3 
 4 import java.lang.annotation.*;
 5 
 6 
 7 /**
 8  * @mycontroller 自定义注解类
 9  *
10  * @@target(elementtype.type)
11  * 表示该注解可以作用在类上;
12  *
13  * @retention(retentionpolicy.runtime)
14  * 表示该注解会在class 字节码文件中存在，在运行时可以通过反射获取到
15  *
16  * @documented
17  * 标记注解，表示可以生成文档
18  */
19 @target(elementtype.type)
20 @retention(retentionpolicy.runtime)
21 @documented
22 public @interface mycontroller {
23 
24     /**
25      * public class mycontroller
26      * 把 class 替换成 @interface 该类即成为注解类
27      */
28 
29     /**
30      * 为controller 注册别名
31      * @return
32      */
33     string value() default "";
34     
35 }

4、创建自定义requestmapping 注解

 1 package com.tjt.springmvc;
 2 
 3 
 4 import java.lang.annotation.*;
 5 
 6 
 7 /**
 8  * @myrequestmapping 自定义注解类
 9  *
10  * @target({elementtype.method,elementtype.type})
11  * 表示该注解可以作用在方法、类上;
12  *
13  * @retention(retentionpolicy.runtime)
14  * 表示该注解会在class 字节码文件中存在，在运行时可以通过反射获取到
15  *
16  * @documented
17  * 标记注解，表示可以生成文档
18  */
19 @target({elementtype.method, elementtype.type})
20 @retention(retentionpolicy.runtime)
21 @documented
22 public @interface myrequestmapping {
23 
24     /**
25      * public @interface myrequestmapping
26      * 把 class 替换成 @interface 该类即成为注解类
27      */
28 
29     /**
30      * 表示访问该方法的url
31      * @return
32      */
33     string value() default "";
34 
35 }

5、设计用于获取项目工程下所有的class 文件的封装工具类

  1 package com.tjt.springmvc;
  2 
  3 
  4 import java.io.file;
  5 import java.io.filefilter;
  6 import java.net.jarurlconnection;
  7 import java.net.url;
  8 import java.net.urldecoder;
  9 import java.util.arraylist;
 10 import java.util.enumeration;
 11 import java.util.list;
 12 import java.util.jar.jarentry;
 13 import java.util.jar.jarfile;
 14 
 15 /**
 16  * 从项目工程包package 中获取所有的class 工具类
 17  */
 18 public class classutils {
 19 
 20     /**
 21      * 静态常量
 22      */
 23     private static string file_constant = "file";
 24     private static string utf8_constant = "utf-8";
 25     private static string jar_constant = "jar";
 26     private static string point_class_constant = ".class";
 27     private static char point_constant = '.';
 28     private static char left_line_constant = '/';
 29 
 30 
 31     /**
 32      * 定义私有构造函数来屏蔽隐式公有构造函数
 33      */
 34     private classutils() {
 35     }
 36 
 37 
 38     /**
 39      * 从项目工程包package 中获取所有的class
 40      * getclasses
 41      *
 42      * @param packagename
 43      * @return
 44      */
 45     public static list<class<?>> getclasses(string packagename) throws exception {
 46 
 47 
 48         list<class<?>> classes = new arraylist<class<?>>();  // 定义一个class 类的泛型集合
 49         boolean recursive = true;  // recursive 是否循环迭代
 50         string packagedirname = packagename.replace(point_constant, left_line_constant);  // 获取包的名字 并进行替换
 51         enumeration<url> dirs;  // 定义一个枚举的集合 分别保存该目录下的所有java 类文件及jar 包等内容
 52         dirs = thread.currentthread().getcontextclassloader().getresources(packagedirname);
 53         /**
 54          * 循环迭代 处理这个目录下的things
 55          */
 56         while (dirs.hasmoreelements()) {
 57             url url = dirs.nextelement();  // 获取下一个元素
 58             string protocol = url.getprotocol();  // 得到协议的名称 protocol
 59             // 如果是
 60             /**
 61              * 若protocol 是文件形式
 62              */
 63             if (file_constant.equals(protocol)) {
 64                 string filepath = urldecoder.decode(url.getfile(), utf8_constant); // 获取包的物理路径
 65                 findandaddclassesinpackagebyfile(packagename, filepath, recursive, classes); // 以文件的方式扫描整个包下的文件 并添加到集合中
 66                 /**
 67                  * 若protocol 是jar 包文件
 68                  */
 69             } else if (jar_constant.equals(protocol)) {
 70                 jarfile jar;  // 定义一个jarfile
 71                 jar = ((jarurlconnection) url.openconnection()).getjarfile();  // 获取jar
 72                 enumeration<jarentry> entries = jar.entries();  // 从jar 包中获取枚举类
 73                 /**
 74                  * 循环迭代从jar 包中获得的枚举类
 75                  */
 76                 while (entries.hasmoreelements()) {
 77                     jarentry entry = entries.nextelement();  // 获取jar里的一个实体，如目录、meta-inf等文件
 78                     string name = entry.getname();
 79                     /**
 80                      * 若实体名是以 / 开头
 81                      */
 82                     if (name.charat(0) == left_line_constant) {
 83                         name = name.substring(1);  // 获取后面的字符串
 84                     }
 85                     // 如果
 86                     /**
 87                      * 若实体名前半部分和定义的包名相同
 88                      */
 89                     if (name.startswith(packagedirname)) {
 90                         int idx = name.lastindexof(left_line_constant);
 91                         /**
 92                          * 并且实体名以为'/' 结尾
 93                          * 若其以'/' 结尾则是一个包
 94                          */
 95                         if (idx != -1) {
 96                             packagename = name.substring(0, idx).replace(left_line_constant, point_constant);  // 获取包名 并把'/' 替换成'.'
 97                         }
 98                         /**
 99                          * 若实体是一个包 且可以继续迭代
100                          */
101                         if ((idx != -1) || recursive) {
102                             if (name.endswith(point_class_constant) && !entry.isdirectory()) {  // 若为.class 文件 且不是目录
103                                 string classname = name.substring(packagename.length() + 1, name.length() - 6);  // 则去掉.class 后缀并获取真正的类名
104                                 classes.add(class.forname(packagename + '.' + classname)); // 把获得到的类名添加到classes
105                             }
106                         }
107                     }
108                 }
109             }
110         }
111 
112         return classes;
113     }
114 
115 
116     /**
117      * 以文件的形式来获取包下的所有class
118      * findandaddclassesinpackagebyfile
119      *
120      * @param packagename
121      * @param packagepath
122      * @param recursive
123      * @param classes
124      */
125     public static void findandaddclassesinpackagebyfile(
126             string packagename, string packagepath,
127             final boolean recursive,
128             list<class<?>> classes) throws exception {
129 
130 
131         file dir = new file(packagepath);  // 获取此包的目录并建立一个file
132 
133         if (!dir.exists() || !dir.isdirectory()) {  // 若dir 不存在或者 也不是目录就直接返回
134             return;
135         }
136 
137         file[] dirfiles = dir.listfiles(new filefilter() {  // 若dir 存在 则获取包下的所有文件、目录
138 
139             /**
140              * 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class 结尾的文件(编译好的java 字节码文件)
141              * @param file
142              * @return
143              */
144             @override
145             public boolean accept(file file) {
146                 return (recursive && file.isdirectory()) || (file.getname().endswith(point_class_constant));
147             }
148         });
149 
150         /**
151          * 循环所有文件获取java 类文件并添加到集合中
152          */
153         for (file file : dirfiles) {
154             if (file.isdirectory()) {  // 若file 为目录 则继续扫描
155                 findandaddclassesinpackagebyfile(packagename + "." + file.getname(), file.getabsolutepath(), recursive,
156                         classes);
157             } else {  // 若file 为java 类文件 则去掉后面的.class 只留下类名
158                 string classname = file.getname().substring(0, file.getname().length() - 6);
159                 classes.add(class.forname(packagename + '.' + classname));  // 把classname 添加到集合中去
160 
161             }
162         }
163     }
164 }

6、访问跳转页面index.jsp

 1 <%--
 2   created by intellij idea.
 3   user: apple
 4   date: 2019-11-07
 5   time: 13:28
 6   to change this template use file | settings | file templates.
 7 --%>
 8 <%--
 9 <%@ page contenttype="text/html;charset=utf-8" language="java" %>
10 --%>
11 <html>
12   <head>
13     <title>my fucking springmvc</title>
14   </head>
15   <body>
16   <h2>the lie we live!</h2>
17   <h2>my fucking springmvc</h2>
18   </body>
19 </html>

7、自定义dispatcherservlet 设计，继承httpservlet，重写init 方法、doget、dopost 等方法，以及自定义注解要实现的功能。

  1 package com.tjt.springmvc;
  2 
  3 
  4 import javax.servlet.servletconfig;
  5 import javax.servlet.servletexception;
  6 import javax.servlet.http.httpservlet;
  7 import javax.servlet.http.httpservletrequest;
  8 import javax.servlet.http.httpservletresponse;
  9 import java.io.ioexception;
 10 import java.lang.reflect.invocationtargetexception;
 11 import java.lang.reflect.method;
 12 import java.util.list;
 13 import java.util.map;
 14 import java.util.objects;
 15 import java.util.concurrent.concurrenthashmap;
 16 
 17 
 18 
 19 /**
 20  * dispatcherservlet 处理springmvc 框架流程
 21  * 主要流程：
 22  * 1、包扫描获取包下面所有的类
 23  * 2、初始化包下面所有的类
 24  * 3、初始化handlermapping 方法,将url 和方法对应上
 25  * 4、实现httpservlet 重写dopost 方法
 26  *
 27  */
 28 public class dispatcherservlet extends httpservlet {
 29 
 30     /**
 31      * 部分静态常量
 32      */
 33     private static string package_class_null_ex = "包扫描后的classes为null";
 34     private static string http_not_exist = "sorry http is not exit 404";
 35     private static string method_not_exist = "sorry method is not exit 404";
 36     private static string point_jsp = ".jsp";
 37     private static string left_line = "/";
 38 
 39     /**
 40      * 用于存放springmvc bean 的容器
 41      */
 42     private concurrenthashmap<string, object> mvcbeans = new concurrenthashmap<>();
 43     private concurrenthashmap<string, object> mvcbeanurl = new concurrenthashmap<>();
 44     private concurrenthashmap<string, string> mvcmethodurl = new concurrenthashmap<>();
 45     private static string project_package_path = "com.tjt.springmvc";
 46 
 47 
 48     /**
 49      * 按顺序初始化组件
 50      * @param config
 51      */
 52     @override
 53     public void init(servletconfig config) {
 54         string packagepath = project_package_path;
 55         try {
 56             //1.进行报扫描获取当前包下面所有的类
 57             list<class<?>> classes = comscanpackage(packagepath);
 58             //2.初始化springmvcbean
 59             initspringmvcbean(classes);
 60         } catch (exception e) {
 61             e.printstacktrace();
 62         }
 63         //3.将请求地址和方法进行映射
 64         inithandmapping(mvcbeans);
 65     }
 66 
 67 
 68     /**
 69      * 调用classutils 工具类获取工程中所有的class
 70      * @param packagepath
 71      * @return
 72      * @throws exception
 73      */
 74     public list<class<?>> comscanpackage(string packagepath) throws exception {
 75         list<class<?>> classes = classutils.getclasses(packagepath);
 76         return classes;
 77     }
 78 
 79     /**
 80      * 初始化springmvc bean
 81      *
 82      * @param classes
 83      * @throws exception
 84      */
 85     public void initspringmvcbean(list<class<?>> classes) throws exception {
 86         /**
 87          * 若包扫描出的classes 为空则直接抛异常
 88          */
 89         if (classes.isempty()) {
 90             throw new exception(package_class_null_ex);
 91         }
 92 
 93         /**
 94          * 遍历所有classes 获取@mycontroller 注解
 95          */
 96         for (class<?> aclass : classes) {
 97             //获取被自定义注解的controller 将其初始化到自定义springmvc 容器中
 98             mycontroller declaredannotation = aclass.getdeclaredannotation(mycontroller.class);
 99             if (declaredannotation != null) {
100                 //获取类的名字
101                 string beanid = lowerfirstcapse(aclass.getsimplename());
102                 //获取对象
103                 object beanobj = aclass.newinstance();
104                 //放入spring 容器
105                 mvcbeans.put(beanid, beanobj);
106             }
107         }
108 
109     }
110 
111     /**
112      * 初始化handlermapping 方法
113      *
114      * @param mvcbeans
115      */
116     public void inithandmapping(concurrenthashmap<string, object> mvcbeans) {
117         /**
118          * 遍历springmvc 获取注入的对象值
119          */
120         for (map.entry<string, object> entry : mvcbeans.entryset()) {
121             object objvalue = entry.getvalue();
122             class<?> aclass = objvalue.getclass();
123             //获取当前类 判断其是否有自定义的requestmapping 注解
124             string mappingurl = null;
125             myrequestmapping anrequestmapping = aclass.getdeclaredannotation(myrequestmapping.class);
126             if (anrequestmapping != null) {
127                 mappingurl = anrequestmapping.value();
128             }
129             //获取当前类所有方法,判断方法上是否有注解
130             method[] declaredmethods = aclass.getdeclaredmethods();
131             /**
132              * 遍历注解
133              */
134             for (method method : declaredmethods) {
135                 myrequestmapping methoddeclaredannotation = method.getdeclaredannotation(myrequestmapping.class);
136                 if (methoddeclaredannotation != null) {
137                     string methodurl = methoddeclaredannotation.value();
138                     mvcbeanurl.put(mappingurl + methodurl, objvalue);
139                     mvcmethodurl.put(mappingurl + methodurl, method.getname());
140                 }
141             }
142 
143         }
144 
145     }
146 
147     /**
148      * @param str
149      * @return 类名首字母小写
150      */
151     public static string lowerfirstcapse(string str) {
152         char[] chars = str.tochararray();
153         chars[0] += 32;
154         return string.valueof(chars);
155 
156     }
157 
158     /**
159      * dopost 请求
160      * @param req
161      * @param resp
162      * @throws servletexception
163      * @throws ioexception
164      */
165     @override
166     protected void dopost(httpservletrequest req, httpservletresponse resp) throws servletexception, ioexception {
167         try {
168             /**
169              * 处理请求
170              */
171             doservelt(req, resp);
172         } catch (nosuchmethodexception e) {
173             e.printstacktrace();
174         } catch (invocationtargetexception e) {
175             e.printstacktrace();
176         } catch (illegalaccessexception e) {
177             e.printstacktrace();
178         }
179     }
180 
181     /**
182      * doservelt 处理请求
183      * @param req
184      * @param resp
185      * @throws ioexception
186      * @throws nosuchmethodexception
187      * @throws invocationtargetexception
188      * @throws illegalaccessexception
189      * @throws servletexception
190      */
191     private void doservelt(httpservletrequest req, httpservletresponse resp) throws ioexception, nosuchmethodexception, invocationtargetexception, illegalaccessexception, servletexception {
192         //获取请求地址
193         string requesturl = req.getrequesturi();
194         //查找地址所对应bean
195         object object = mvcbeanurl.get(requesturl);
196         if (objects.isnull(object)) {
197             resp.getwriter().println(http_not_exist);
198             return;
199         }
200         //获取请求的方法
201         string methodname = mvcmethodurl.get(requesturl);
202         if (methodname == null) {
203             resp.getwriter().println(method_not_exist);
204             return;
205         }
206 
207 
208         //通过构反射执行方法
209         class<?> aclass = object.getclass();
210         method method = aclass.getmethod(methodname);
211 
212         string invoke = (string) method.invoke(object);
213         // 获取后缀信息
214         string suffix = point_jsp;
215         // 页面目录地址
216         string prefix = left_line;
217         req.getrequestdispatcher(prefix + invoke + suffix).forward(req, resp);
218 
219 
220 
221 
222     }
223 
224     /**
225      * doget 请求
226      * @param req
227      * @param resp
228      * @throws servletexception
229      * @throws ioexception
230      */
231     @override
232     protected void doget(httpservletrequest req, httpservletresponse resp) throws servletexception, ioexception {
233         this.dopost(req, resp);
234     }
235 
236 
237 }

8、测试手写springmvc 框架效果类testmyspringmvc 。

 1 package com.tjt.springmvc;
 2 
 3 
 4 /**
 5  * 手写springmvc 测试类
 6  * testmyspringmvc
 7  */
 8 @mycontroller
 9 @myrequestmapping(value = "/tjt")
10 public class testmyspringmvc {
11 
12 
13     /**
14      * 测试手写springmvc 框架效果 testmymvc1
15      * @return
16      */
17     @myrequestmapping("/mvc")
18     public string testmymvc1() {
19         system.out.println("he lie we live!");
20         return "index";
21     }
22 
23 
24 }

9、配置tomcat 用于运行web 项目。

图5. 配置tomcat

10、运行项目，访问测试。

1、输入正常路径 http://localhost:8080/tjt/mvc 访问测试效果如下：

图6. 正常路径测试效果

2、输入非法(不存在)路径 http://localhost:8080/tjt/mvc8 访问测试效果如下：

图7. 非法路径测试效果

3、控制台打印“the lie we live”如下：

图8. 控制台打印

测试效果如上则证明成功手写springmvc 框架，恭喜。

 

 

细嗅蔷薇 心有猛虎