手写简易版SpringMVC框架

秒速五厘米 2022-03-20 15:48 392阅读 0赞

1.反射工具类

  1. package com.weichai.util;
  3. import java.io.File;
  4. import java.io.FileFilter;
  5. import java.io.IOException;
  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;
  15. /**
  16.  * 反射工具类
  17.  * @author linhaiy
  18.  * @date 2019.01.26
  19.  */
  20. public class ClassUtil {
  22.     /**
  23.         * 取得某个接口下所有实现这个接口的类
  24.      * @param c
  25.      * @return
  26.      */
  27.     public static List<Class> getAllClassByInterface(Class c) {
  28.         List<Class> returnClassList = null;
  30.         if (c.isInterface()) {
  31.             // 获取当前的包名
  32.             String packageName = c.getPackage().getName();
  33.             // 获取当前包下以及子包下所以的类
  34.             List<Class<?>> allClass = getClasses(packageName);
  35.             if (allClass != null) {
  36.                 returnClassList = new ArrayList<Class>();
  37.                 for (Class classes : allClass) {
  38.                     // 判断是否是同一个接口
  39.                     if (c.isAssignableFrom(classes)) {
  40.                         // 本身不加入进去
  41.                         if (!c.equals(classes)) {
  42.                             returnClassList.add(classes);
  43.                         }
  44.                     }
  45.                 }
  46.             }
  47.         }
  49.         return returnClassList;
  50.     }
  52.     /**
  53.         * 取得某一类所在包的所有类名 不含迭代
  54.      * @param classLocation
  55.      * @param packageName
  56.      * @return
  57.      */
  58.     public static String[] getPackageAllClassName(String classLocation, String packageName) {
  59.         // 将packageName分解
  60.         String[] packagePathSplit = packageName.split("[.]");
  61.         String realClassLocation = classLocation;
  62.         int packageLength = packagePathSplit.length;
  63.         for (int i = 0; i < packageLength; i++) {
  64.             realClassLocation = realClassLocation + File.separator + packagePathSplit[i];
  65.         }
  66.         File packeageDir = new File(realClassLocation);
  67.         if (packeageDir.isDirectory()) {
  68.             String[] allClassName = packeageDir.list();
  69.             return allClassName;
  70.         }
  71.         return null;
  72.     }
  74.     /**
  75.            *  从包package中获取所有的Class
  76.      * @param packageName
  77.      * @return
  78.      */
  79.     public static List<Class<?>> getClasses(String packageName) {
  81.         // 第一个class类的集合
  82.         List<Class<?>> classes = new ArrayList<Class<?>>();
  83.         // 是否循环迭代
  84.         boolean recursive = true;
  85.         // 获取包的名字 并进行替换
  86.         String packageDirName = packageName.replace('.', '/');
  87.         // 定义一个枚举的集合 并进行循环来处理这个目录下的things
  88.         Enumeration<URL> dirs;
  89.         try {
  90.             dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
  91.             // 循环迭代下去
  92.             while (dirs.hasMoreElements()) {
  93.                 // 获取下一个元素
  94.                 URL url = dirs.nextElement();
  95.                 // 得到协议的名称
  96.                 String protocol = url.getProtocol();
  97.                 // 如果是以文件的形式保存在服务器上
  98.                 if ("file".equals(protocol)) {
  99.                     // 获取包的物理路径
  100.                     String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
  101.                     // 以文件的方式扫描整个包下的文件 并添加到集合中
  102.                     findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
  103.                 } else if ("jar".equals(protocol)) {
  104.                     // 如果是jar包文件
  105.                     // 定义一个JarFile
  106.                     JarFile jar;
  107.                     try {
  108.                         // 获取jar
  109.                         jar = ((JarURLConnection) url.openConnection()).getJarFile();
  110.                         // 从此jar包 得到一个枚举类
  111.                         Enumeration<JarEntry> entries = jar.entries();
  112.                         // 同样的进行循环迭代
  113.                         while (entries.hasMoreElements()) {
  114.                             // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
  115.                             JarEntry entry = entries.nextElement();
  116.                             String name = entry.getName();
  117.                             // 如果是以/开头的
  118.                             if (name.charAt(0) == '/') {
  119.                                 // 获取后面的字符串
  120.                                 name = name.substring(1);
  121.                             }
  122.                             // 如果前半部分和定义的包名相同
  123.                             if (name.startsWith(packageDirName)) {
  124.                                 int idx = name.lastIndexOf('/');
  125.                                 // 如果以"/"结尾 是一个包
  126.                                 if (idx != -1) {
  127.                                     // 获取包名 把"/"替换成"."
  128.                                     packageName = name.substring(0, idx).replace('/', '.');
  129.                                 }
  130.                                 // 如果可以迭代下去 并且是一个包
  131.                                 if ((idx != -1) || recursive) {
  132.                                     // 如果是一个.class文件 而且不是目录
  133.                                     if (name.endsWith(".class") && !entry.isDirectory()) {
  134.                                         // 去掉后面的".class" 获取真正的类名
  135.                                         String className = name.substring(packageName.length() + 1, name.length() - 6);
  136.                                         try {
  137.                                             // 添加到classes
  138.                                             classes.add(Class.forName(packageName + '.' + className));
  139.                                         } catch (ClassNotFoundException e) {
  140.                                             e.printStackTrace();
  141.                                         }
  142.                                     }
  143.                                 }
  144.                             }
  145.                         }
  146.                     } catch (IOException e) {
  147.                         e.printStackTrace();
  148.                     }
  149.                 }
  150.             }
  151.         } catch (IOException e) {
  152.             e.printStackTrace();
  153.         }
  155.         return classes;
  156.     }
  158.     /**
  159.      * 以文件的形式来获取包下的所有Class
  160.      * @param packageName
  161.      * @param packagePath
  162.      * @param recursive
  163.      * @param classes
  164.      */
  165.     public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
  166.             List<Class<?>> classes) {
  167.         // 获取此包的目录 建立一个File
  168.         File dir = new File(packagePath);
  169.         // 如果不存在或者 也不是目录就直接返回
  170.         if (!dir.exists() || !dir.isDirectory()) {
  171.             return;
  172.         }
  173.         // 如果存在 就获取包下的所有文件 包括目录
  174.         File[] dirfiles = dir.listFiles(new FileFilter() {
  175.             // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
  176.             public boolean accept(File file) {
  177.                 return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
  178.             }
  179.         });
  180.         // 循环所有文件
  181.         for (File file : dirfiles) {
  182.             // 如果是目录 则继续扫描
  183.             if (file.isDirectory()) {
  184.                 findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
  185.                         classes);
  186.             } else {
  187.                 // 如果是java类文件 去掉后面的.class 只留下类名
  188.                 String className = file.getName().substring(0, file.getName().length() - 6);
  189.                 try {
  190.                     // 添加到集合中去
  191.                     classes.add(Class.forName(packageName + '.' + className));
  192.                 } catch (ClassNotFoundException e) {
  193.                     e.printStackTrace();
  194.                 }
  195.             }
  196.         }
  197.     }
  199.     /**
  200.         * 首字母转小写
  201.      * @param s
  202.      * @return
  203.      */
  204.     public static String toLowerCaseFirstOne(String s) {
  205.         if (Character.isLowerCase(s.charAt(0)))
  206.             return s;
  207.         else
  208.             return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
  209.     }
  211.     /**
  212.        * 初始化对象
  213.      * @param classInfo
  214.      * @return
  215.      * @throws ClassNotFoundException
  216.      * @throws InstantiationException
  217.      * @throws IllegalAccessException
  218.      */
  219.     public static Object newInstance(Class<?> classInfo)
  220.             throws ClassNotFoundException, InstantiationException, IllegalAccessException {
  221.         return classInfo.newInstance();
  222.     }
  223. }

2.框架需要的注解类

  1. package com.weichai.annotation;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. /**
  9.     * 自定义控制器注解 
  10.  * @author linhaiy
  11.  * @date 2019.01.26
  12.  */
  13. @Target({ ElementType.TYPE })
  14. @Retention(RetentionPolicy.RUNTIME)
  15. public @interface ExtController {
  17. }
  19. package com.weichai.annotation;
  21. import java.lang.annotation.ElementType;
  22. import java.lang.annotation.Retention;
  23. import java.lang.annotation.RetentionPolicy;
  24. import java.lang.annotation.Target;
  26. /**
  27.     * 自定义RequestMapping
  28.  * @author linhaiy
  29.  * @date 2019.01.26
  30.  */
  31. @Target({ ElementType.METHOD, ElementType.TYPE })
  32. @Retention(RetentionPolicy.RUNTIME)
  33. public @interface ExtRequestMapping {
  34.     String value() default "";
  35. }

3. 自定义前端控制器（SpringMVC框架核心处理）

  1. package com.weichai.servlet;
  3. import java.io.IOException;
  4. import java.lang.reflect.Method;
  5. import java.util.List;
  6. import java.util.Map;
  7. import java.util.concurrent.ConcurrentHashMap;
  9. import javax.servlet.ServletException;
  10. import javax.servlet.http.HttpServlet;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  14. import org.apache.commons.lang.StringUtils;
  16. import com.weichai.annotation.ExtController;
  17. import com.weichai.annotation.ExtRequestMapping;
  18. import com.weichai.util.ClassUtil;
  20. /**
  21.     *   自定义前端控制器
  22.     *    手写springmvc 原理分析<br>
  23.  * 1.创建一个前端控制器（）ExtDispatcherServlet 拦截所有请求(springmvc 基于servlet实现)<br>
  24.  * ####2.初始化操作 重写servlet init 方法<br>
  25.  * #######2.1 将扫包范围所有的类,注入到springmvc容器里面，存放在Map集合中 key为默认类名小写，value 对象<br>
  26.  * #######2.2 将url映射和方法进行关联 <br>
  27.  * ##########2.2.1 判断类上是否有注解,使用java反射机制循环遍历方法 ,判断方法上是否存在注解，进行封装url和方法对应存入集合中<br>
  28.  * ####3.处理请求 重写Get或者是Post方法 <br>
  29.  * ##########3.1
  30.     *    获取请求url,从urlBeans集合获取实例对象,获取成功实例对象后,调用urlMethods集合获取方法名称,使用反射机制执行 2. 
  31.  * @author linhaiy
  32.  * @date 2019.01.26
  33.  */
  34. public class ExtDispatcherServlet extends HttpServlet {
  36.     // SpringMVC容器对象 key:类名id ,value 对象
  37.     private ConcurrentHashMap<String, Object> springmvcBeans = new ConcurrentHashMap<String, Object>();
  38.     // SpringMvc 容器对象 keya:请求地址 ,vlue类
  39.     private ConcurrentHashMap<String, Object> urlBeans = new ConcurrentHashMap<String, Object>();
  40.     // SpringMvc 容器对象 key:请求地址 ,value 方法名称
  41.     private ConcurrentHashMap<String, String> urlMethods = new ConcurrentHashMap<String, String>();
  43.     public void init() throws ServletException {
  44.         // 1.获取当前包下的所有的类
  45.         List<Class<?>> classes = ClassUtil.getClasses("com.weichai.controller");
  46.         try {
  47.             // 2.将扫包范围所有的类,注入到SpringMvc容器里面，存放在Map集合中 key为默认类名小写，value 对象
  48.             findClassMVCAnnotation(classes);
  49.         } catch (Exception e) {
  50.             // TODO Auto-generated catch block
  51.             e.printStackTrace();
  52.         }
  53.         //3.将url映射和方法进行关联
  54.         handlerMapping();
  55.     }
  57.     /**
  58.      * get请求方法
  59.      */
  60.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
  61.         doPost(request,response);
  62.     }
  64.     /**
  65.      * post请求方法
  66.      */
  67.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  68.         // #################处理请求####################
  69.         // 1.获取请求url地址
  70.         String requestURL = request.getRequestURI();                        //此处获取的是带工程名的路径
  71.         String URL = requestURL.substring(requestURL.indexOf("/", 2) + 1);  //去除工程名
  72.         if(StringUtils.isEmpty(requestURL)) {
  73.             return;
  74.         }
  75.         URL = "/"+URL;
  76.         // 2.从Map集合中获取控制对象
  77.         Object object = urlBeans.get(URL);  //  /Main/test
  78.         if(object == null) {
  79.             response.getWriter().println(" not found 404  url");
  80.             return;
  81.         }
  82.         // 3.使用url地址获取方法
  83.         String methodName = urlMethods.get(URL);
  84.         if(StringUtils.isEmpty(methodName)) {
  85.             response.getWriter().println(" not found method");
  86.         }
  87.         // 4.使用java的反射机制调用方法
  88.         String resultPage = (String) methodInvoke(object, methodName);
  89.         // 5.调用视图转换器渲染给页面展示
  90.         extResourceViewResolver(resultPage, request, response);
  91.     }
  93.     /**
  94.         *    调用视图转换器渲染给页面展示
  95.      * @param resultPage
  96.      * @param request
  97.      * @param response
  98.      * @throws IOException 
  99.      * @throws ServletException 
  100.      */
  101.     private void extResourceViewResolver(String resultPage, HttpServletRequest request, HttpServletResponse response)
  102.             throws ServletException, IOException {
  103.         // TODO Auto-generated method stub
  104.         String prefix = "/"; // 根路径
  105.         String suffix = ".jsp";
  106.         request.getRequestDispatcher(prefix + resultPage + suffix).forward(request, response);
  107.     }
  109.     /**
  110.         * 使用java的反射机制调用方法
  111.      * @param object
  112.      * @param methodName
  113.      * @return
  114.      */
  115.     private Object methodInvoke(Object object, String methodName) {
  116.         // TODO Auto-generated method stub
  117.         try {
  118.             Class<? extends Object> classInfo = object.getClass();
  119.             Method method = classInfo.getMethod(methodName);
  120.             Object result = method.invoke(object);
  121.             return result;
  122.         } catch (Exception e) {
  123.             // TODO Auto-generated catch block
  124.             e.printStackTrace();
  125.         } 
  126.         return null;
  127.     }
  129.     /**
  130.         * 将url映射和方法进行关联
  131.      */
  132.     private void handlerMapping() {
  133.         // TODO Auto-generated method stub
  134.         // 1.遍历springmvc bean容器 判断类上属否有url映射注解
  135.         for(Map.Entry<String, Object> mvcBean : springmvcBeans.entrySet()) {
  136.             // 2.遍历所有的方法上是否有url映射注解
  137.             Object object = mvcBean.getValue();    // 获取bean的对象
  138.             // 3.判断类上是否有加url映射注解
  139.             Class<? extends Object> classInfo = object.getClass();
  140.             ExtRequestMapping declaredAnnotation = classInfo.getDeclaredAnnotation(ExtRequestMapping.class);
  141.             String baseUrl = "";
  142.             if(declaredAnnotation !=null) {
  143.                 baseUrl = declaredAnnotation.value();     //获取类上的url映射地址
  144.             }
  145.             //4.判断方法上是否有加url映射地址
  146.             Method[] declaredMethods = classInfo.getDeclaredMethods();
  147.             for(Method method : declaredMethods) {
  148.                 // 判断方法上是否有加url映射注解
  149.                 ExtRequestMapping methodExtRequestMapping = method.getDeclaredAnnotation(ExtRequestMapping.class);
  150.                 if(methodExtRequestMapping !=null) {
  151.                     String methodUrl = baseUrl + methodExtRequestMapping.value();
  152.                     // springmvc 容器对象 keya:请求地址 ,vlue类
  153.                     urlBeans.put(methodUrl, object);
  154.                     // springmvc 容器对象 key:请求地址 ,value 方法名称
  155.                     urlMethods.put(methodUrl, method.getName());
  156.                 }
  157.             }
  158.         }
  159.     }
  161.     /**
  162.         *    将扫包范围所有的类,注入到SpringMvc容器里面，存放在Map集合中 key为默认类名小写，value 对象
  163.      * @param classes
  164.      */
  165.     private void findClassMVCAnnotation(List<Class<?>> classes)
  166.             throws ClassNotFoundException, InstantiationException, IllegalAccessException {
  167.         // TODO Auto-generated method stub
  168.         for (Class<?> classInfo : classes) {
  169.             ExtController extController = classInfo.getDeclaredAnnotation(ExtController.class); // 判断类上是否有加上注解
  170.             if (extController != null) {
  171.                 String beanId = ClassUtil.toLowerCaseFirstOne(classInfo.getSimpleName()); // 默认类名是小写
  172.                 Object object = ClassUtil.newInstance(classInfo); // 实例化对象
  173.                 springmvcBeans.put(beanId, object);
  174.             }
  175.         }
  176.     }
  177. }

4.前端控制器web.xm配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://java.sun.com/xml/ns/j2ee"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
  5.     version="2.4">
  7.     <!-- Spring MVC 核心控制器 DispatcherServlet 配置 -->
  8.     <servlet>
  9.         <servlet-name>dispatcher</servlet-name>
  10.         <servlet-class>com.weichai.servlet.ExtDispatcherServlet
  11.         </servlet-class>
  12.         <load-on-startup>1</load-on-startup>
  13.     </servlet>
  14.     <servlet-mapping>
  15.         <servlet-name>dispatcher</servlet-name>
  16.         <!-- 拦截所有/* 的请求,交给DispatcherServlet处理,性能最好 -->
  17.         <url-pattern>/</url-pattern>
  18.     </servlet-mapping>
  19. </web-app>

5.控制层测试类

  1. package com.weichai.controller;
  3. import com.weichai.annotation.ExtController;
  4. import com.weichai.annotation.ExtRequestMapping;
  6. @ExtController
  7. @ExtRequestMapping("/Main")
  8. public class ExtIndexController {
  10.     @ExtRequestMapping("/test")
  11.     public String test() {
  12.         System.out.println("手写springmvc框架...");
  13.         return "index";
  14.     }
  15. }

发表评论

表情：
评论列表 （有 0 条评论，392人围观）

还没有评论，来说两句吧...

相关阅读

    相关 手写迷你SpringMVC框架

    前言 本文总结自慕课网同名课程。 学习如何使用Spring，SpringMVC是很快的，但是在往后使用的过程中难免会想探究一下框架背后的原理是什么，本文将通过讲解如何手

    秒速五厘米秒速五厘米/ 0 赞/ 186 阅读

    相关 手写SpringMVC框架

    引言 在分析springMVC框架之前，我们根据我们对整个框架的流程分析，先来手写一个简易版的springMVC框架， 这样我们在看源码的时候会更清晰，毕竟框架源码还是非

    女爷i女爷i/ 0 赞/ 213 阅读