自己动手开发了一个 SpringMVC 框架，用起来太香了 - Go语言中文社区

自己动手开发了一个 SpringMVC 框架，用起来太香了

本文转载自微信公众号「Java极客技术」，作者 鸭血粉丝 。转载本文请联系Java极客技术公众号。

一、介绍

在日常的 web 开发中，熟悉 java 的同学一定知道，Spring MVC 可以说是目前最流行的框架，之所以如此的流行，原因很简单：编程简洁、上手简单!

我记得刚开始入行的时候，最先接触到的是Struts1 + Hibernate + Spring来web系统的整体开发框架，简单的描述一下当时的编程心情：超难用，各种配置项很多，而且不容易快速入手!

之后，新的项目换成了Struts2 + hibernate + spring来作为主体开发框架，Struts2相比Struts1编程要简单很多，而且加强了对拦截器与IoC的支持，而在Struts1中，这些特性是很难做的的!

然而随着Struts2的使用量越来越广，业界爆出关于Struts2的bug和安全漏洞却越来越多!

黑客们可以轻易的利用安全漏洞直接绕开安全防线，获取用的隐私数据，网名因个人信息泄露造成的经济损失高达 915 亿元!

至此很多开发者开始转到SpringMVC框架阵营!

今天我们要介绍的主角就是SpringMVC框架，刚开始玩这个的时候，给我最直接的感觉就是：很容易简单!

直接通过几个注解就可以完成方法的暴露，比起Struts2中繁琐的xml配置，SpringMVC的使用可以说更加友好!

熟悉SpringMVC框架的同学一定清楚下面这张图，

这张图就是 SpringMVC 在处理 http 请求的整个流程中所做的一些事情。

1、用户发送请求至前端控制器DispatcherServlet

2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4、DispatcherServlet通过HandlerAdapter处理器适配器调用处理器

5、执行处理器(Controller，也叫后端控制器)。

6、Controller执行完成返回ModelAndView

7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet

8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器

9、ViewReslover解析后返回具体View

10、DispatcherServlet对View进行渲染视图(即将模型数据填充至视图中)。

11、DispatcherServlet响应用户。

DispatcherServlet 主要承担接收请求、响应结果、转发等作用，剩下的就交给容器来处理!

基于上面的流程，我们可以编写出一款简化版的Spring MVC框架，话不多说，直接撸起来!

二、程序实践

首先上图!

这个就是我们简易版的Spring MVC框架的实现流程图!

1、首先创建一个DispatcherServlet类，在服务启动的时候，读取要扫描的包路径，然后通过反射将类信息存储到ioc容器，同时通过@Autowired注解，实现自动依赖注入，最后读取@RequestMapping注解中的方法，将映射路径与类的关系存储到映射容器中。

2、当用户发起请求的时候，通过请求路径到映射容器中找到对应的执行类，然后调用具体的方法，发起逻辑处理，最后将处理结果返回给前端用户!

以下是具体实践过程!

2.1、创建扫描注解

因为Spring MVC基本全部都是基于注解开发，因此我们事先也需要创建对应的注解，各个含义与Spring MVC一致!

  1. /** 
  2.  * 控制层注解 
  3.  * @Controller  
  4.  */ 
  5. @Target({ElementType.TYPE}) 
  6. @Retention(RetentionPolicy.RUNTIME) 
  7. @Documented 
  8. public @interface Controller { 
  9.  
  10.     String value() default ""; 
  11. } 

请求路径注解

  1. /** 
  2.  * 请求路径注解 
  3.  * @RequestMapping 
  4.  */ 
  5. @Target({ElementType.METHOD,ElementType.TYPE}) 
  6. @Retention(RetentionPolicy.RUNTIME) 
  7. @Documented 
  8. public @interface RequestMapping { 
  9.  
  10.     String value() default ""; 
  11. } 

参数注解

  1. /** 
  2.  * 参数注解 
  3.  * @RequestParam 
  4.  */ 
  5. @Target({ElementType.PARAMETER}) 
  6. @Retention(RetentionPolicy.RUNTIME) 
  7. @Documented 
  8. public @interface RequestParam { 
  9.  
  10.     String value() default ""; 
  11. } 

服务层注解

  1. /** 
  2.  * 服务层注解 
  3.  * @Controller 
  4.  */ 
  5. @Target({ElementType.TYPE}) 
  6. @Retention(RetentionPolicy.RUNTIME) 
  7. @Documented 
  8. public @interface Service { 
  9.  
  10.     String value() default ""; 
  11. } 

自动装载注解

  1. /** 
  2.  * 自动装载注解 
  3.  * @Autowrited 
  4.  */ 
  5. @Target({ElementType.FIELD}) 
  6. @Retention(RetentionPolicy.RUNTIME) 
  7. @Documented 
  8. public @interface Autowired { 
  9.  
  10.     String value() default ""; 
  11. } 

2.2、编写 DispatcherServlet 类

DispatcherServlet是一个Servlet类，主要承担的任务是：接受前端用户的请求，然后进行转发，最后响应结果给前端用户!

详细代码如下：

  1.  * servlet跳转层 
  2.  */ 
  3. @WebServlet(name = "DispatcherServlet",urlPatterns = "/*", loadOnStartup = 1, initParams = {@WebInitParam(name="scanPackage", value="com.example.mvc")}) 
  4. public class DispatcherServlet extends HttpServlet { 
  5.  
  6.     private static final long serialVersionUID = 1L; 
  7.  
  8.     private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class); 
  9.  
  10.     /**请求方法映射容器*/ 
  11.     private static List<RequestHandler> handlerMapping = new ArrayList<>(); 
  12.  
  13.     /** 
  14.      * 服务启动的时候，进行初始化，流程如下： 
  15.      * 1、扫描指定包下所有的类 
  16.      * 2、通过反射将类实例，放入ioc容器 
  17.      * 3、通过Autowired注解，实现自动依赖注入，也就是set类中的属性 
  18.      * 4、通过RequestMapping注解，获取需要映射的所有方法，然后将类信息存放到容器中 
  19.      * @param config 
  20.      * @throws ServletException 
  21.      */ 
  22.     @Override 
  23.     public void init(ServletConfig config) throws ServletException { 
  24.         try { 
  25.             //1、扫描指定包下所有的类 
  26.             String scanPackage = config.getInitParameter("scanPackage"); 
  27.             //1、扫描指定包下所有的类 
  28.             List<String> classNames = doScan(scanPackage); 
  29.             //2、初始化所有类实例，放入ioc容器，也就是map对象中 
  30.             Map<String, Object> iocMap = doInstance(classNames); 
  31.             //3、实现自动依赖注入 
  32.             doAutowired(iocMap); 
  33.             //5、初始化方法mapping 
  34.             initHandleMapping(iocMap); 
  35.         } catch (Exception e) { 
  36.             logger.error("dispatcher-servlet类初始化失败!",e); 
  37.             throw new ServletException(e.getMessage()); 
  38.         } 
  39.     } 
  40.  
  41.  
  42.     /** 
  43.      * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) 
  44.      */ 
  45.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException { 
  46.         doPost(request, response); 
  47.     } 
  48.  
  49.     /** 
  50.      * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) 
  51.      */ 
  52.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException { 
  53.         //跳转 
  54.         doDispatch(request, response); 
  55.     } 
  56.  
  57.     /** 
  58.      * 扫描指定包下的类文件 
  59.      * @param packageName 
  60.      * @return 
  61.      */ 
  62.     private List<String> doScan(String packageName){ 
  63.         if(StringUtils.isBlank(packageName)){ 
  64.             throw new RuntimeException("mvc配置文件中指定扫描包名为空!"); 
  65.         } 
  66.         return PackageHelper.getClassName(packageName); 
  67.     } 
  68.  
  69.     private Map<String, Object> doInstance(List<String> classNames) { 
  70.         Map<String, Object> iocMap = new HashMap<>(); 
  71.         if(!CollectionUtils.isNotEmpty(classNames)){ 
  72.             throw new RuntimeException("获取的类为空!"); 
  73.         } 
  74.         for (String className : classNames) { 
  75.             try { 
  76.                 //通过反射机制构造对象 
  77.                 Class<?> clazz = Class.forName(className); 
  78.                 if(clazz.isAnnotationPresent(Controller.class)){ 
  79.                     //将类名第一个字母小写 
  80.                     String baneName = firstLowerCase(clazz.getSimpleName()); 
  81.                     iocMap.put(baneName, clazz.newInstance()); 
  82.                 }else if(clazz.isAnnotationPresent(Service.class)){ 
  83.                     //服务层注解判断 
  84.                     Service service = clazz.getAnnotation(Service.class); 
  85.                     String beanName = service.value(); 
  86.                     //如果该注解上没有自定义类名，则默认首字母小写 
  87.                     if(StringUtils.isBlank(beanName)){ 
  88.                         beanName = clazz.getName(); 
  89.                     } 
  90.                     Object instance = clazz.newInstance(); 
  91.                     iocMap.put(beanName, instance); 
  92.                     //如果注入的是接口，可以巧妙的用接口的类型作为key 
  93.                     Class<?>[] interfaces = clazz.getInterfaces(); 
  94.                     for (Class<?> clazzInterface : interfaces) { 
  95.                         iocMap.put(clazzInterface.getName(), instance); 
  96.                     } 
  97.                 } 
  98.             } catch (Exception e) { 
  99.                 logger.error("初始化mvc-ioc容器失败!",e); 
  100.                 throw new RuntimeException("初始化mvc-ioc容器失败!"); 
  101.             } 
  102.         } 
  103.         return iocMap; 
  104.     } 
  105.  
  106.     /** 
  107.      * 实现自动依赖注入 
  108.      * @throws Exception 
  109.      */ 
  110.     private void doAutowired(Map<String, Object> iocMap) { 
  111.         if(!MapUtils.isNotEmpty(iocMap)){ 
  112.             throw new RuntimeException("初始化实现自动依赖失败，ioc为空!"); 
  113.         } 
  114.         for(Map.Entry<String, Object> entry : iocMap.entrySet()){ 
  115.             //获取对象下所有的属性 
  116.             Field[] fields = entry.getValue().getClass().getDeclaredFields(); 
  117.             for (Field field : fields) { 
  118.                 //判断字段上有没有@Autowried注解，有的话才注入 
  119.                 if(field.isAnnotationPresent(Autowired.class)){ 
  120.                     try { 
  121.                         Autowired autowired = field.getAnnotation(Autowired.class); 
  122.                         //获取注解上有没有自定义值 
  123.                         String beanName = autowired.value().trim(); 
  124.                         if(StringUtils.isBlank(beanName)){ 
  125.                             beanName = field.getType().getName(); 
  126.                         } 
  127.                         //如果想要访问到私有的属性，我们要强制授权 
  128.                         field.setAccessible(true); 
  129.                         field.set(entry.getValue(), iocMap.get(beanName)); 
  130.                     } catch (Exception e) { 
  131.                         logger.error("初始化实现自动依赖注入失败!",e); 
  132.                         throw new RuntimeException("初始化实现自动依赖注入失败"); 
  133.                     } 
  134.                 } 
  135.             } 
  136.         } 
  137.     } 
  138.  
  139.     /** 
  140.      * 初始化方法mapping 
  141.      */ 
  142.     private void initHandleMapping(Map<String, Object> iocMap){ 
  143.         if(!MapUtils.isNotEmpty(iocMap)){ 
  144.             throw new RuntimeException("初始化实现自动依赖失败，ioc为空"); 
  145.         } 
  146.         for(Map.Entry<String, Object> entry:iocMap.entrySet()){ 
  147.             Class<?> clazz = entry.getValue().getClass(); 
  148.             //判断是否是controller层 
  149.             if(!clazz.isAnnotationPresent(Controller.class)){ 
  150.                 continue; 
  151.             } 
  152.             String baseUrl = null; 
  153.             //判断类有没有requestMapping注解 
  154.             if(clazz.isAnnotationPresent(RequestMapping.class)){ 
  155.                 RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class); 
  156.                 baseUrl= requestMapping.value(); 
  157.             } 
  158.             Method[] methods = clazz.getMethods(); 
  159.             for (Method method : methods) { 
  160.                 //判断方法上有没有requestMapping 
  161.                 if(!method.isAnnotationPresent(RequestMapping.class)){ 
  162.                     continue; 
  163.                 } 
  164.                 RequestMapping requestMethodMapping = method.getAnnotation(RequestMapping.class); 
  165.                 //"/+",表示将多个"/"转换成"/" 
  166.                 String regex = (baseUrl + requestMethodMapping.value()).replaceAll("/+", "/"); 
  167.                 Pattern pattern = Pattern.compile(regex); 
  168.                 handlerMapping.add(new RequestHandler(pattern, entry.getValue(), method)); 
  169.             } 
  170.         } 
  171.     } 
  172.  
  173.     /** 
  174.      * servlet请求跳转 
  175.      * @param request 
  176.      * @param response 
  177.      * @throws IOException 
  178.      */ 
  179.     private void doDispatch(HttpServletRequest request, HttpServletResponse response) throws IOException { 
  180.         try { 
  181.             request.setCharacterEncoding("UTF-8"); 
  182.             response.setHeader("Cache-Control", "no-cache"); 
  183.             response.setHeader("Pragma", "no-cache"); 
  184.             response.setDateHeader("Expires", -1); 
  185.             response.setContentType("text/html"); 
  186.             response.setHeader("content-type", "text/html;charset=UTF-8"); 
  187.             response.setCharacterEncoding("UTF-8"); 
  188.             RequestHandler handle = getHandleMapping(request); 
  189.             if(Objects.isNull(handle)){ 
  190.                 //异常请求地址 
  191.                 logger.warn("异常请求地址!地址:" + request.getRequestURI()); 
  192.                 response.getWriter().append("error request url"); 
  193.                 return; 
  194.             } 
  195.             //获取参数列表 
  196.             Object[] paramValues = RequestParamHelper.buildRequestParam(handle, request, response); 
  197.             Object result = handle.getMethod().invoke(handle.getController(), paramValues); 
  198.             if(result != null){ 
  199.                 PrintWriter out = response.getWriter(); 
  200.                 out.println(result); 
  201.                 out.flush(); 
  202.                 out.close(); 
  203.             } 
  204.         } catch (Exception e) { 
  205.             logger.error("接口请求失败!",e); 
  206.             PrintWriter out = response.getWriter(); 
  207.             out.println("请求异常,请稍后再试"); 
  208.             out.flush(); 
  209.             out.close(); 
  210.         } 
  211.     } 
  212.  
  213.     /** 
  214.      * 将类名第一个字母小写 
  215.      * @param clazzName 
  216.      * @return 
  217.      */ 
  218.     private String firstLowerCase(String clazzName){ 
  219.         char[] chars = clazzName.toCharArray(); 
  220.         chars[0] += 32; 
  221.         return String.valueOf(chars); 
  222.     } 
  223.  
  224.  
  225.     /** 
  226.      * 获取用户请求方法名 
  227.      * 与handlerMapping中的路径名进行匹配 
  228.      * @param request 
  229.      * @return 
  230.      */ 
  231.     private RequestHandler getHandleMapping(HttpServletRequest request){ 
  232.         if(CollectionUtils.isNotEmpty(handlerMapping)){ 
  233.             //获取用户请求路径 
  234.             String url = request.getRequestURI(); 
  235.             String contextPath = request.getContextPath(); 
  236.             String serviceUrl = url.replace(contextPath, "").replaceAll("/+", "/"); 
  237.             for (RequestHandler handle : handlerMapping) { 
  238.                 //正则匹配请求方法名 
  239.                 Matcher matcher = handle.getPattern().matcher(serviceUrl); 
  240.                 if(matcher.matches()){ 
  241.                     return handle; 
  242.                 } 
  243.             } 
  244.         } 
  245.         return null; 
  246.     } 
  247. } 

这里要重点介绍一下初始化阶段所做的操作!

DispatcherServlet在服务启动阶段，会调用init方法进行服务初始化，此阶段所做的事情主要有以下内容：

1、扫描指定包下所有的类信息，返回的结果主要是包名 + 类名

2、通过反射机制，将类进行实例化，将类实例化对象存储到ioc容器中，其中key是类名(小些驼峰)，value是类对象

3、通过Autowired注解找到类对象中的属性，通过小驼峰从ioc容器中寻找对应的属性值，然后进行set操作

4、通过Controller和RequestMapping注解寻找需要暴露的方法，并获取对应的映射路径，最后将映射路径

5、最后，当前端用户发起一个请求时，DispatcherServlet获取到请求路径之后，通过与RequestMapping中的路径进行匹配，找到对应的controller类中的方法，然后通过invoke完成方法调用，将调用结果返回给前端!

2.3、编写 controller 类

当DispatcherServlet编写完成之后，紧接着我们需要编写对应的controller控制类来接受前端用户请求，下面我们以用户登录为例，程序示例如下：

编写一个LoginController控制类，接受前端用户调用

  1. @Controller 
  2. @RequestMapping("/user") 
  3. public class LoginController { 
  4.  
  5.     @Autowired 
  6.     private UserService userService; 
  7.  
  8.     /** 
  9.      * 用户登录 
  10.      * @param request 
  11.      * @param response 
  12.      * @param userName 
  13.      * @param userPwd 
  14.      * @return 
  15.      */ 
  16.     @RequestMapping("/login") 
  17.     public String login(HttpServletRequest request, HttpServletResponse response, 
  18.                         @RequestParam("userName") String userName, 
  19.                         @RequestParam("userPwd") String userPwd){ 
  20.         boolean result = userService.login(userName, userPwd); 
  21.         if(result){ 
  22.             return "登录成功！"; 
  23.         } else { 
  24.             return "登录失败！"; 
  25.         } 
  26.     } 
  27. } 

编写一个UserService服务类，用于判断账户、密码是否正确

  1. public interface UserService { 
  2.  
  3.     /** 
  4.      * 登录 
  5.      * @param userName 
  6.      * @param userPwd 
  7.      * @return 
  8.      */ 
  9.     boolean login(String userName, String userPwd); 
  10. } 
  1. @Service 
  2. public class UserServiceImpl implements UserService { 
  3.  
  4.     @Override 
  5.     public boolean login(String userName, String userPwd) { 
  6.         if("zhangsan".equals(userName) && "123456".equals(userPwd)){ 
  7.             return true; 
  8.         } else { 
  9.             return false; 
  10.         } 
  11.     } 
  12. } 

最后，将项目打包成war，通过tomcat启动服务!

在浏览器中访问http://localhost:8080/user/login?userName=hello&userPwd=123，结果显示如下：

当我们将userName和userPwd换成正确的数据，访问地址如下：http://localhost:8080/user/login?userName=zhangsan&userPwd=123456

可以很清晰的看到，服务调用正常!

三、总结

本文主要以Spring MVC框架为背景，手写了一个简易版的Spring MVC框架，虽然功能简陋了一点，但是基本无张俱全，里面讲解了ioc和自动依赖注入的实现过程，还有前端发起一个路径请求，是如何映射到对应的controller类中的方法上!

当然实际的Spring MVC框架的跳转流程比这个复杂很多很多，里面包括各种拦截器、权限安全管理等等，在后面的文章，小编也会陆续进行详细介绍!

鉴于笔者才疏学浅，如果有理解不对的地方，欢迎网友批评支持!

下面是手写的简易版Spring MVC框架源码地址，感兴趣的朋友，在后台回复：springmvc，即可获取!

四、参考

1、博客园 - 手动模拟实现 Spring-MVC

版权声明：本文来源51CTO，感谢博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。
原文链接：http://developer.51cto.com/art/202104/659661.htm
站方申明：本站部分内容来自社区用户分享，若涉及侵权，请联系站方删除。

你可能感兴趣的文章

精选的优质文章

0 条评论

请先 登录 后评论

官方社群

GO教程

推荐文章

猜你喜欢

随便看看

来源51CTO

如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！