手把手教你手写一个SpringMVC的框架!
你知道的越多，不知道的就越多，业余的像一棵小草！
你来，我们一起精进！你不来，我和你的竞争对手一起精进！
编辑：业余草
blog.csdn.net/m0_37892044
推荐：https://www.xttblog.com/?p=5322
由于最近太忙，很多微信网友给我的私信都没来得及回复，大家见谅！
现在上海疫情严重，需要在金三银四面试的网友，可应该趁这个时间认真刷刷面试题。其中 SpringMVC 应该是非常高频的面试，今天我们一起来手写一个 SpringMVC。
目录大纲
- SpringMVC的使用
- SpringMVC原理图
- 预备知识Servlet
- 实现SpringMVC三部曲
- 加载期
- 初始化
- 运行期
- 手写实现原理图
- 代码实现
- 代码结构
- Controller注解
- RequestMapping 注解
- DispatcherServlet
- ClassUtil 工具类
- 实现效果
SpringMVC的使用
首先来回忆一下，我们使用 SpringMVC 的时候。在 springMVC 项目或者SpringBoot项目中请求如下的 xttblog 这个方法。
http://[ip:端口]/xxxxx/demo/xttblog
我们是如何找到这个控制器类的嗯？当然是通过DomeController 上面的@RequestMapping中的demo。那我们又是如何找到是hutao这个方法的呢？当然也是通过@RequestMapping中的hutao。
@Controller
@RequestMapping("/demo")
public class DomeController {
@RequestMapping("/xttblog")
public String xttblog() {
return "xttblogxttblogxttblogxttblogxttblog";
}
}
我们通过@Controller注解来标识这个类是一个请求接入控制器类，在结合@RequestMapping注解来识别我们调用的是控制器的哪一个方法。在这个主流程中最核心的类是由DispatcherServlet来实现的。本文就开始来用我们的方式来实现DispatcherServlet吧。
SpringMVC原理图
先上一张SpringMVC的原理示意图。
SpringMVC原理图如果我们现在要实现自己的MVC，参考上图，我们需要梳理如下流程。
- 编写DispatcherServlet实现Servlet拦截所有的请求接入；
- DispatcherServlet根据请求地址中的RequestMapping映射参数，找到对象，对象在调用对应的方法；
- DispatcherServlet把控制器类处理结果返回给调用方。
预备知识Servlet
Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。
「Servlet 的生命周期：加载—>初始化—>服务—>销毁。」
加载：在web.xml中配置加载。
「init（）」：在Servlet的生命周期中，仅执行一次init()方法。它是在服务器装入Servlet时执行的，负责初始化Servlet对象。可以配置服务器，以在启动服务器或客户机首次访问Servlet时装入Servlet。无论有多少客户机访问Servlet，都不会重复执行init（）。
「service（）」：它是Servlet的核心，负责响应客户的请求。每当一个客户请求一个HttpServlet对象，该对象的Service()方法就要调用，而且传递给这个方法一个“请求”（ServletRequest）对象和一个“响应”（ServletResponse）对象作为参数。在HttpServlet中已存在Service()方法。默认的服务功能是调用与HTTP请求的方法相应的do功能。
「destroy（）」：仅执行一次，在服务器端停止且卸载Servlet时执行该方法。当Servlet对象退出生命周期时，负责释放占用的资源。一个Servlet在运行service()方法时可能会产生其他的线程，因此需要确认在调用destroy()方法时，这些线程已经终止或完成。
Servlet 加载，并且初始化，只会被执行一次，之后根据请求方式的不同，service决定调用doPost还是doGet。
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
String method = req.getMethod();
if (method.equals(METHOD_GET)) {
long lastModified = getLastModified(req);
if (lastModified == -1) {
// servlet doesn't support if-modified-since, no reason
// to go through further expensive logic
doGet(req, resp);
} else {
long ifModifiedSince;
try {
ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
} catch (IllegalArgumentException iae) {
// Invalid date header - proceed as if none was set
ifModifiedSince = -1;
}
if (ifModifiedSince < (lastModified / 1000 * 1000)) {
// If the servlet mod time is later, call doGet()
// Round down to the nearest second for a proper compare
// A ifModifiedSince of -1 will always be less
maybeSetLastModified(resp, lastModified);
doGet(req, resp);
} else {
resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
}
}
} else if (method.equals(METHOD_HEAD)) {
long lastModified = getLastModified(req);
maybeSetLastModified(resp, lastModified);
doHead(req, resp);
} else if (method.equals(METHOD_POST)) {
doPost(req, resp);
} else if (method.equals(METHOD_PUT)) {
doPut(req, resp);
} else if (method.equals(METHOD_DELETE)) {
doDelete(req, resp);
} else if (method.equals(METHOD_OPTIONS)) {
doOptions(req,resp);
} else if (method.equals(METHOD_TRACE)) {
doTrace(req,resp);
} else {
//
// Note that this means NO servlet supports whatever
// method was requested, anywhere on this server.
//
String errMsg = lStrings.getString("http.method_not_implemented");
Object[] errArgs = new Object[1];
errArgs[0] = method;
errMsg = MessageFormat.format(errMsg, errArgs);
resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
}
}
实现SpringMVC三部曲
按照阶段我们可以把实现分为三部分：加载，初始化，运行。
加载期
web项目在启动的时候，回去读取web.xml，因此要在项目启动的时候去加载我们所编写的DispatcherServlet。
<servlet>
<servlet-name>dispatcherservlet-name>
<servlet-class>com.sunwise.alm.spring.container.DispatcherServletservlet-class>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>dispatcherservlet-name>
<url-pattern>/alm/*url-pattern>
servlet-mapping>
初始化
加载 DispatcherServlet 的时候，重写 servlet 的init()方法，这个方法需要去扫描指定路径下的class文件，找到含有Controller注解的类型，并且创建Controller类，放到SpringMVC容器中，这里我们使用Map来实现容器。
/**
* 存放被@Controller修饰的类所创建的Controller对象
*/
private ConcurrentHashMap springmvcBeans = new ConcurrentHashMap();
将调用的请求地址，和我们要具体调用的方法形成映射关系，即通过调用地址来确定我们要调用的是那一个方法，这里我们也是用Map来实现容器。
/**
* url请求地址,value为对应方法
*/
private ConcurrentHashMap urlBeans = new ConcurrentHashMap();
根据调用的请求地址，找到我们要调用的是我们所创建的哪一个对象，这里我们同样用Map来实现容器
/**
* key为url请求地址,value为对应实例对象
*/
private ConcurrentHashMap urlMethods = new ConcurrentHashMap();
运行期
当别人通过 http 请求的时候，我们的 XML 下配置了拦截的地址，因此会拦截我们所配置的的所有请求，然后根据请求地址，找到我们所要调用的对象，调用的方法。调用完毕后，返回结果给调用方。
/**
* 从请求地址中，找到需要调用的是哪一个对象
*/
Object object = urlBeans.get(controllerUrl);
/**
* 从请求地址中，找到需要调用的是哪一个方法
*/
String methodName = urlMethods.get(controllerUrl);
/**
* 调用这个对象的这个方法
*/
String result = (String) methodInvoke(object, methodName,req,resp);
手写实现原理图
手写实现原理图代码实现
代码结构
代码结构Controller注解
/**
* @Description Controller注解
*/
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface Controller {
}
RequestMapping 注解
/**
* @Description RequestMapping注解
*/
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestMapping {
String value() default "";
}
DispatcherServlet
/**
* @Description DispatcherServlet实现MVC
*/
public class DispatcherServlet extends HttpServlet {
private static Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);
private static final long serialVersionUID = 1L;
/**
* 存放被@Controller修饰的类所创建的Controller对象
*/
private ConcurrentHashMap springmvcBeans = new ConcurrentHashMap();
/**
* key为url请求地址,value为对应方法
*/
private ConcurrentHashMap urlBeans = new ConcurrentHashMap();
/**
* key为url请求地址,value为对应实例对象
*/
private ConcurrentHashMap urlMethods = new ConcurrentHashMap();
/**
* @Description DispatcherServlet加载初始化
*/
public void init() throws ServletException {
// 1.获取当前包下的所有的类
List> classes = ClassUtil.getClasses("com.sunwise.alm.spring");
// 2.将扫包范围所有的类,注入到springmvc容器里面，存放在Map集合中 key为默认类名小写，value 对象
try {
findClassMVCAnnotation(classes);
} catch (Exception e) {
// TODO: handle exception
}
// 3.将url映射和方法进行关联
handlerMapping();
}
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
//http://localhost/polarion/aem/dispatcher/demo/test
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html; charset=utf-8");
PrintWriter writer = resp.getWriter();
String requestURI = req.getRequestURI();
String controllerUrl = "";
if(requestURI!=null) {
controllerUrl = requestURI.replace("/polarion/sunwise/alm", "");
}
if (controllerUrl == null || "".equals(controllerUrl)) {
return;
}
/**
* 从请求地址中，找到需要调用的是哪一个对象
*/
Object object = urlBeans.get(controllerUrl);
if (object == null) {
resp.getWriter().println(" 404 ");
return;
}
/**
* 从请求地址中，找到需要调用的是哪一个方法
*/
String methodName = urlMethods.get(controllerUrl);
if (methodName == null || "".equals(methodName)) {
resp.getWriter().println(" not found method 404");
}
/**
* 调用这个对象的这个方法
*/
String result = (String) methodInvoke(object, methodName,req,resp);
writer.print(result);
writer.close();
}
/**
* @Description DispatcherServlet实现MVC
*/
private Object methodInvoke(Object object, String methodName,HttpServletRequest req, HttpServletResponse resp) {
try {
Class classInfo = object.getClass();
Method[] methods = classInfo.getMethods();
Method method = null;
for(Method me : methods) {
if(me.getName().equals(methodName)) {
method = me;
break;
}
}
Object result = method.invoke(object);
//Object result = method.invoke(object,req, resp);
return result;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* @Description 找到含有Controller修饰的类，并且创建对象放到springmvcBeans容器中
*/
public void findClassMVCAnnotation(List> classes)
throws ClassNotFoundException, InstantiationException, IllegalAccessException {
for (Class classInfo : classes) {
Controller extController = classInfo.getDeclaredAnnotation(Controller.class);
if (extController != null) {
String beanId = ClassUtil.toLowerCaseFirstOne(classInfo.getSimpleName());
Object object = ClassUtil.newInstance(classInfo);
springmvcBeans.put(beanId, object);
}
}
}
/**
* @Description 映射绑定，根据请求地址确定请求调用的对象和方法
*/
public void handlerMapping() {
for (Map.Entry mvcBean : springmvcBeans.entrySet()) {
Object object = mvcBean.getValue();
Class classInfo = object.getClass();
RequestMapping declaredAnnotation = classInfo.getDeclaredAnnotation(RequestMapping.class);
String baseUrl = "";
if (declaredAnnotation != null) {
baseUrl = declaredAnnotation.value();
}
Method[] declaredMethods = classInfo.getDeclaredMethods();
for (Method method : declaredMethods) {
RequestMapping methodExtRequestMapping = method.getDeclaredAnnotation(RequestMapping.class);
if (methodExtRequestMapping != null) {
String methodUrl = baseUrl + methodExtRequestMapping.value();
urlBeans.put(methodUrl, object);
urlMethods.put(methodUrl, method.getName());
}
}
}
}
}
ClassUtil 工具类
public class ClassUtil {
/**
* @Description 根据文件名获取class文件
*/
public static List> getClasses(List list) {
// 第一个class类的集合
List> classes = new ArrayList>();
try {
for(String controllerName : list) {
Class controllerClass = Class.forName(controllerName);
classes.add(controllerClass);
}
} catch (Exception e) {
e.printStackTrace();
}
return classes;
}
/**
* @Description 首字母变小写
*/
public static String toLowerCaseFirstOne(String s) {
if (Character.isLowerCase(s.charAt(0)))
return s;
else
return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
}
/**
* @Description 初始化对象
*/
public static Object newInstance(Class classInfo)
throws ClassNotFoundException, InstantiationException, IllegalAccessException {
return classInfo.newInstance();
}
/**
* @Description 根据包名获取包路径下的class
*/
public static List> getClasses(String packageName) {
// 第一个class类的集合
List> classes = new ArrayList>();
// 是否循环迭代
boolean recursive = true;
// 获取包的名字 并进行替换
String packageDirName = packageName.replace('.', '/');
// 定义一个枚举的集合 并进行循环来处理这个目录下的things
Enumeration dirs;
try {
//String property = System.getProperty("catalina.home");
dirs = DispatcherServlet.class.getClassLoader().getResources(packageDirName);
//dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
// 循环迭代下去
while (dirs.hasMoreElements()) {
URL url = dirs.nextElement();
String protocol = url.getProtocol();
if ("file".equals(protocol)) {
// 获取包的物理路径
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
// 以文件的方式扫描整个包下的文件 并添加到集合中
findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
}else if ("bundleresource".equals(protocol)) {
//针对我的特定项目实现的一种方式，正常的项目采用file协议
Enumeration resources = Thread.currentThread().getContextClassLoader().getResources("");
URL nextElement = resources.nextElement();
String file = nextElement.getFile();
String substring = file.substring(0,file.lastIndexOf(packageName)).replace("file:", "")+packageName+"/bin/"+packageName.replace(".", "/");
// 以文件的方式扫描整个包下的文件 并添加到集合中
findAndAddClassesInPackageByFile(packageName,substring, recursive, classes);
}else if ("jar".equals(protocol)) {
// 如果是jar包文件
// 定义一个JarFile
JarFile jar;
try {
// 获取jar
jar = ((JarURLConnection) url.openConnection()).getJarFile();
// 从此jar包 得到一个枚举类
Enumeration entries = jar.entries();
// 同样的进行循环迭代
while (entries.hasMoreElements()) {
// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
JarEntry entry = entries.nextElement();
String name = entry.getName();
// 如果是以/开头的
if (name.charAt(0) == '/') {
// 获取后面的字符串
name = name.substring(1);
}
// 如果前半部分和定义的包名相同
if (name.startsWith(packageDirName)) {
int idx = name.lastIndexOf('/');
// 如果以"/"结尾 是一个包
if (idx != -1) {
// 获取包名 把"/"替换成"."
packageName = name.substring(0, idx).replace('/', '.');
}
// 如果可以迭代下去 并且是一个包
if ((idx != -1) || recursive) {
// 如果是一个.class文件 而且不是目录
if (name.endsWith(".class") && !entry.isDirectory()) {
// 去掉后面的".class" 获取真正的类名
String className = name.substring(packageName.length() + 1, name.length() - 6);
try {
// 添加到classes
classes.add(Class.forName(packageName + '.' + className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return classes;
}
/**
* 以文件的形式来获取包下的所有Class
*
* @param packageName
* @param packagePath
* @param recursive
* @param classes
*/
public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
List> classes) {
// 获取此包的目录 建立一个File
File dir = new File(packagePath);//file:/D:/workSpace/casco/com.sunwise.alm.spring/
///D:/workSpace/casco/com.sunwise.alm.spring/bin/com/sunwise/alm/spring/springIOC/service/impl
// 如果不存在或者 也不是目录就直接返回
if (!dir.exists() || !dir.isDirectory()) {
return;
}
// 如果存在 就获取包下的所有文件 包括目录
File[] dirfiles = dir.listFiles(new FileFilter() {
// 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
public boolean accept(File file) {
return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
}
});
// 循环所有文件
for (File file : dirfiles) {
// 如果是目录 则继续扫描
if (file.isDirectory()) {
findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
classes);
} else {
// 如果是java类文件 去掉后面的.class 只留下类名
String className = file.getName().substring(0, file.getName().length() - 6);
try {
// 添加到集合中去
classes.add(Class.forName(packageName + '.' + className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
实现效果
手写SpringMVC
评论