自己动手实现一个简单的 SpringMVC

超、凢脫俗 2022-05-28 12:56 264阅读 0赞

# 自己动手实现一个SpringMvc #

springmvc 作为javaweb 主流框架,相比大家都用过,也已经都很熟悉了.但是对springmvc如何实现有了解多少呢?

本文将带你了解并亲手实现一个springmvc框架,带你一探究竟.

在Spring MVC中，将一个普通的java类标注上Controller注解之后，再将类中的方法使用RequestMapping注解标注，那么这个普通的java类就够处理Web请求，示例代码如下：

/** 2 * 使用Controller注解标注LoginUI类 3 */
    /** * 使用Controller注解标注LoginUI类 */
    @Controller
    public class LoginUI { 
    
        //使用RequestMapping注解指明forward1方法的访问路径 
        @RequestMapping("LoginUI/Login2")
        public View forward1(){
            //执行完forward1方法之后返回的视图
            return new View("/login2.jsp");  
        }
    
        //使用RequestMapping注解指明forward2方法的访问路径 
        @RequestMapping("LoginUI/Login3")
        public View forward2(){
            //执行完forward2方法之后返回的视图
            return new View("/login3.jsp");  
        } 
    }

然后我们只需要在web.xml文件中配置一个 Dispatcher Servlet (SpringMvc控制器) 就可以了.

![6941baebtw1epg9al8bv6j20f90aqjrx.jpg][]

> 图片来源: [http://www.importnew.com/15141.html][http_www.importnew.com_15141.html]

spring通过java annotation就可以注释一个类为action ，在方法上添加上一个java annotation 就可以配置请求的路径了，  
那么这种机制是如何实现的呢，今天我们使用”自定义注解+Servlet”来简单模拟一下Spring MVC中的这种注解配置方式。

\*\*首先来讲一下大体思路: 类似SpringMvc,我们也有一个叫做Dispatcher Servlet的东西,用来拦截所有请求,拿到客户端请求路径,  
利用java反射技术,实例化所有带有Controller注解的类,去执行请求路径对应的Controller的方法.\*\*

现在我们就开始动手实践吧.

## 一:编写注解 ##

### Controller注解 ###

开发Controller注解，这个注解只有一个value属性，默认值为空字符串，代码如下:

package annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /** * 自定义Controller注解 */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface Controller { 
    
        public String value() default "";
    }

### RequestMapping注解 ###

开发RequestMapping注解，用于定义请求路径，这个注解只有一个value属性，默认值为空字符串，代码如下：

package annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /** * 自动以RequestMapping注解 */
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface RequestMapping { 
    
        public String value()default "";
    
    }

\*\*以上就是我们自定义的两个注解，注解的开发工作就算是完成了，有了注解之后，那么就必须针对注解来编写处理器，  
否则我们开发的注解配置到类或者方法上面是不起作用的，这里我们使用Servlet来作为注解的处理器。\*\*

## 二、编写核心的注解处理器 ##

### 开发AnnotationHandleServlet ###

这里使用一个Servlet来作为注解处理器，编写一个AnnotationHandleServlet，代码如下：

package handler;
    
    import annotation.Controller;
    import annotation.RequestMapping;
    import utils.BeanUtils;
    import utils.DispatchActionConstant;
    import utils.RequestMapingMap;
    import utils.ScanClassUtil;
    import utils.View;
    import utils.WebContext;
    
    import javax.servlet.ServletConfig;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.Set;
    
    /** * 自定义注解的核心处理器,负责调用目标业务方法处理用户请求,类似于SpringMvc的DespatcherServlet * * @author itguang * @create 2018-04-05 21:54 **/
    public class AnnotationHandleServlet extends HttpServlet { 
    
    
        /** * 从HttpRequest中解析出 请求路径,即 RequestMapping() 的value值. * * @param request * @return */
        private String pareRequestURI(HttpServletRequest request) {
    
            String path = request.getContextPath() + "/";
            String requestUri = request.getRequestURI();
            String midUrl = requestUri.replace(path, "");
            String lastUrl = midUrl.substring(0, midUrl.lastIndexOf("."));
    
    
            return lastUrl;
        }
    
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException
    
        {
            System.out.println("AnnotationHandlerServlet-->doGet....");
            this.excute(request, response);
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            System.out.println("AnnotationHandlerServlet-->doPost....");
            this.excute(request, response);
        }
    
        private void excute(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
            //1.将当前 HttpRequest 放到ThreadLocal中,方便在Controller中使用
            WebContext.requestHodler.set(request);
            //将 HttpReponse 放到ThreadLocal中,方便在Controller中使用
            WebContext.responseHodler.set(response);
    
            //2.解析请求的url
            String requestUrl = pareRequestURI(request);
    
            //3.根据 请求的url获取要使用的类
            Class<?> clazz = RequestMapingMap.getClassName(requestUrl);
            //4.创建类的实例
            Object classInstance = BeanUtils.instanceClass(clazz);
    
            //5.获取类中定义的方法
            Method[] methods = BeanUtils.findDeclaredMethods(clazz);
    
            //遍历所有方法,找出url与RequestMapping注解的value值相匹配的方法
            Method method = null;
            for (Method m : methods) {
    
                if (m.isAnnotationPresent(RequestMapping.class)) {
                    String value = m.getAnnotation(RequestMapping.class).value();
                    if (value != null && !"".equals(value.trim()) && requestUrl.equals(value.trim())) {
                        //找到要执行的目标方法
                        method = m;
                        break;
                    }
    
                }
    
            }
    
            //6.执行url对应的方法,处理用户请求
    
            if (method != null) {
                Object retObject = null;
                try {
                    //利用反射执行这个方法
                    retObject = method.invoke(classInstance);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
    
                //如果有返回值,就代表用户需要返回视图
                if (retObject != null) {
                    View view = (View) retObject;
                    //判断要使用的跳转方式
                    if (view.getDispathAction().equals(DispatchActionConstant.FORWARD)) {
                        //使用服务器端跳转方式
                        request.getRequestDispatcher(view.getUrl()).forward(request, response);
                    } else if (view.getDispathAction().equals(DispatchActionConstant.REDIRECT)) {
                        //使用客户端跳转方式
                        response.sendRedirect(request.getContextPath() + view.getUrl());
                    } else {
                        request.getRequestDispatcher(view.getUrl()).forward(request, response);
                    }
                }
    
    
            }
    
    
        }
    
        @Override
        public void init(ServletConfig config) throws ServletException {
            /** * 重写了Servlet的init方法后一定要记得调用父类的init方法， * 否则在service/doGet/doPost方法中使用getServletContext()方法获取ServletContext对象时 * 就会出现java.lang.NullPointerException异常 */
            super.init(config);
            System.out.println("---初始化开始---");
            //获取web.xml中配置的要扫描的包
            String basePackage = config.getInitParameter("basePackage");
            //如果配置了多个包，例如：<param-value>me.gacl.web.controller,me.gacl.web.UI</param-value>
            if (basePackage.indexOf(",")>0) {
                //按逗号进行分隔
                String[] packageNameArr = basePackage.split(",");
                for (String packageName : packageNameArr) {
                    initRequestMapingMap(packageName);
                }
            }else {
                initRequestMapingMap(basePackage);
            }
            System.out.println("----初始化结束---");
        }
    
        /** * @Method: initRequestMapingMap * @Description:添加使用了Controller注解的Class到RequestMapingMap中 */
        private void initRequestMapingMap(String packageName){
            //得到扫描包下的class
            Set<Class<?>> setClasses =  ScanClassUtil.getClasses(packageName);
            for (Class<?> clazz :setClasses) {
    
                if (clazz.isAnnotationPresent(Controller.class)) {
                    Method [] methods = BeanUtils.findDeclaredMethods(clazz);
                    for(Method m:methods){
       //循环方法，找匹配的方法进行执行
                        if(m.isAnnotationPresent(RequestMapping.class)){
                            String anoPath = m.getAnnotation(RequestMapping.class).value();
                            if(anoPath!=null && !"".equals(anoPath.trim())){
                                if (RequestMapingMap.getRequesetMap().containsKey(anoPath)) {
                                    throw new RuntimeException("RequestMapping映射的地址不允许重复！");
                                }
                                //把所有的映射地址存储起来 映射路径--类
                                RequestMapingMap.put(anoPath, clazz);
                            }
                        }
                    }
                }
            }
        }
    
    
    }

这里说一下AnnotationHandleServlet的实现思路:

*  1.  AnnotationHandleServlet初始化(init)时扫描指定的包下面使用了Controller注解的类，如下图所示：

![这里写图片描述][70]

*  1.  遍历类中的方法，找到类中使用了RequestMapping注解标注的那些方法，  
        获取RequestMapping注解的value属性值，value属性值指明了该方法的访问路径，以RequestMapping注解的value属性值作为key，  
        Class类作为value将存储到一个静态Map集合中。如下图所示：

![这里写图片描述][70 1]

*  1.  当用户请求时(无论是get还是post请求)，会调用封装好的execute方法 ，  
        execute会先获取请求的url，然后解析该URL，根据解析好的URL从Map集合中取出要调用的目标类 ，  
        再遍历目标类中定义的所有方法，找到类中使用了RequestMapping注解的那些方法，  
        判断方法上面的RequestMapping注解的value属性值是否和解析出来的URL路径一致,如果一致，说明了这个就是要调用的目标方法，  
        此时就可以利用java反射机制先实例化目标类对象，然后再通过实例化对象调用要执行的方法处理用户请求。服务器将以下图的方式与客户端进行交互

![这里写图片描述][70 2]

另外，方法处理完成之后需要给客户端发送响应信息，比如告诉客户端要跳转到哪一个页面，采用的是服务器端跳转还是客户端方式跳转，或者发送一些数据到客户端显示，那么该如何发送响应信息给客户端呢，在此，我们可以设计一个View(视图)类，对这些操作属性进行封装，其中包括跳转的路径 、展现到页面的数据、跳转方式。  
这就是AnnotationHandleServlet的实现思路。

### 在Web.xml文件中注册AnnotationHandleServlet ###

就像使用SpringMvc一样我们也需要在web.xml中进行配置:

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0">
        <servlet>
            <servlet-name>AnnotationHandleServlet</servlet-name>
            <servlet-class>handler.AnnotationHandleServlet</servlet-class>
            <init-param>
                <description>配置要扫描包及其子包, 如果有多个包,以逗号分隔</description>
                <param-name>basePackage</param-name>
                <param-value>controller</param-value>
    
            </init-param>
            <load-on-startup>1</load-on-startup>
        </servlet>
    
        <servlet-mapping>
            <servlet-name>AnnotationHandleServlet</servlet-name>
            
            <url-pattern>*.do</url-pattern>
        </servlet-mapping>
    </web-app>

**相关代码与工具类请参考文末给出的github地址.**

*  BeanUtils.java: BeanUtils工具类主要是用来处理一些反射的操作
 *  RequestMapingMap.java: 该类是用于存储方法的访问路径，AnnotationHandleServlet初始化时会将类(使用Controller注解标注的那些类)中使用了RequestMapping注解标注的那些方法的访问路径存储到RequestMapingMap中。
 *  ScanClassUtil.java: 扫描某个包下面的类的工具类
 *  WebContext:

WebContext主要是用来存储当前线程中的HttpServletRequest和HttpServletResponse，  
当别的地方需要使用HttpServletRequest和HttpServletResponse，就可以通过requestHodler和responseHodler获取，  
通过WebContext.java这个类 ，我们可以在作为Controller的普通java类中获取当前请求的request、response或者session相关请求类的实例变量，  
并且线程间互不干扰的，因为用到了ThreadLocal这个类。

*  View.java: 一个视图类，对一些客户端响应操作进行封装，其中包括跳转的路径 、展现到页面的数据、跳转方式.
 *  ViewData.java: request范围的数据存储类，当需要发送数据到客户端显示时，就可以将要显示的数据存储到ViewData类中。使用ViewData.put(String name,Object value)方法往request对象中存数据。
 *  DispatchActionConstant.java: 一个跳转方式的常量类

## 三, Controller注解和RequestMapping注解测试 ##

新建一个controller包,在该包下面新建 LoginController.java,如:

package controller;
    
    import annotation.Controller;
    import annotation.RequestMapping;
    import utils.View;
    import utils.ViewData;
    import utils.WebContext;
    
    import javax.servlet.http.HttpServletRequest;
    
    /** * @author itguang * @create 2018-04-06 09:26 **/
    @Controller
    public class LoginController { 
    
    
        //使用RequestMapping注解指明forward1方法的访问路径
        @RequestMapping("login2")
        public View forward1() {
    
    
            System.out.println("login2...");
    
            HttpServletRequest request = WebContext.requestHodler.get();
    
            String username = request.getParameter("username");
            String password = request.getParameter("password");
    
    
            //执行完forward1方法之后返回的视图
            return new View("/Login2.jsp");
        }
    
        /** * 处理登录请求,接受参数 * @return */
        @RequestMapping("login")
        public View login(){
    
            System.out.println("login...");
    
            //首先获取当前线程的request对象
            HttpServletRequest request = WebContext.requestHodler.get();
    
            String username = request.getParameter("username");
            String password = request.getParameter("password");
    
            //将数据存储到ViewData中
            ViewData viewData = new ViewData();
            viewData.put("msg","欢迎你"+username);
            // 相当于
            // request.setAttribute("msg","欢迎你"+username);
    
    
            return new View("/index.jsp");
        }
    
    
    
    
    
    
    }

index.jsp:

<%-- Created by IntelliJ IDEA. User: itguang Date: 2018/4/5 Time: 15:24 To change this template use File | Settings | File Templates. --%>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
      <head>
        <title>$Title$</title>
      </head>
      <body>
      <label style="color: red;">${msg}</label>
      </body>
    </html>

Login2.jsp

<%@ page language="java" pageEncoding="UTF-8"%>
    <!DOCTYPE HTML>
    <html>
    <head>
        <title>login2.jsp登录页面</title>
    </head>
    
    <body>
    <fieldset>
        <legend>用户登录</legend>
        <form action="${pageContext.request.contextPath}/login.do" method="post">
            用户名：<input type="text" value="${param.usename}" name="username">
            <br/>
            密码：<input type="text" value="${param.pwd}" name="password">
            <br/>
            <input type="submit" value="登录"/>
        </form>
    </fieldset>
    <hr/>
    <label style="color: red;">${msg}</label>
    </body>
    </html>

然后我们访问: [http://localhost:8080/login2.do][http_localhost_8080_login2.do],注意需要以 .do 结尾,我们就会来到登录页面,  
随便输入用户名密码,就会提交表单到 [http://localhost:8080/login.do?username=][http_localhost_8080_login.do_username]小光光&password=123445 这个地址.

最后会转到 index.jsp页面.显示欢迎信息.

以上就是对springmvc的简单模拟.

大家可以参考下面的 gthub源码地址,或者自己导入到ide中进行断点调试,进一步理解.

--------------------

> 本文源码地址: [https://github.com/itguang/springmvc][https_github.com_itguang_springmvc]

[6941baebtw1epg9al8bv6j20f90aqjrx.jpg]: /images/20220528/3db6502d2c5f49958bac970a98bb0cc1.png
[http_www.importnew.com_15141.html]: http://www.importnew.com/15141.html
[70]: /images/20220528/a889a6aefac340b3a56a2b50738aa5f5.png
[70 1]: /images/20220528/3fbb8172f5554f06b6a01a179d37a191.png
[70 2]: /images/20220528/8e94567f5125410d800eacaa1aa800ec.png
[http_localhost_8080_login2.do]: http://localhost:8080/login2.do
[http_localhost_8080_login.do_username]: http://localhost:8080/login.do?username=
[https_github.com_itguang_springmvc]: https://github.com/itguang/springmvc