AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

自己手写一个SpringMVC框架

2024-06-20 35
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 自己手写一个SpringMVC框架

手写 Spring MVC

不多说，简历装 X 必备。不过练好还是需要求一定的思维能力。

一、整体思路

思路要熟练背下来

1）配置阶段

  • 配置 web.xml：
  • <sevlet>
  • XDispatchServlet
  • 设定 init-param： contextConfigLocation = applicationContext.properties
  • <servlet-mapping>
  • 设定 url-pattern： /*
  • 配置 Annotation： @XController @XService @XAutowired @XRequestMapping

2）初始化阶段

  • IOC：
  • 调用 init() 方法： 加载配置文件
  • IOC 容器初始化： Map<String, Object>
  • 扫描相关的类： scan-package=“com.xiaopengwei”
  • 创建实例化并保存到容器： 同过反射机制将类实例化放入 IOC 容器中
  • DI：
  • 进行 DI 操作： 扫描 IOC 容器中的实例，给没有赋值的属性自动赋值
  • MVC：
  • 初始化 HandlerMapping： 将一个 URL 和一个 Method 进行一对一的关联映射 Map<String, Method>

3）运行阶段

  • 调用 doGet() / doPost() 方法： Web 容器调用 doGet() / doPost() 方法，获得 request/response 对象
  • 匹配 HandleMapping： 从 request 对象中获得用户输入的 url，找到其对应的 Method
  • 反射调用 method.invoker()： 利用反射调用方法并返回结果
  • response.getWrite().write()： 将返回结果输出到浏览器,手写 Spring MVC
二、源代码

项目结构：

源代码：

（1）在 pom.xml 引入一个 jar 包

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
</dependency>

（2）web.xml 文件：

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >
 
<web-app>
    <display-name>Archetype Created Web Application</display-name>
    <servlet>
        <servlet-name>xmvc</servlet-name>
        <servlet-class>com.xiaopengwei.xspring.servlet.XDispatchServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--you can't use classpath*: -->
            <param-value>application.properties</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>xmvc</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

（3）application.properties 文件：

scan-package=com.xiaopengwei

（4）自定义注解 XAutowired：

package com.xiaopengwei.xspring.annotation;
import java.lang.annotation.*;
/**
 * <p>
 *
 * @author  http://www.wityx.com
 * 
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface XAutowired {
    String value() default "";
}

（5）自定义注解 XController：

package com.xiaopengwei.xspring.annotation;
import java.lang.annotation.*;
/**
 * <p>
 *
 * @author  http://www.wityx.com
 * 
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface XController {
    String value() default "";
}

（6）自定义注解 XRequestMapping：

package com.xiaopengwei.xspring.annotation;
import java.lang.annotation.*;
/**
 * <p>
 *
 * @author  http://www.wityx.com
 * 
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface XRequestMapping {
    String value() default "";
}

（7）自定义注解 XService：

package com.xiaopengwei.xspring.annotation;
import java.lang.annotation.*;
/**
 * <p>
 *
 * @author  http://www.wityx.com
 * 
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface XService {
    String value() default "";
}

（8）核心 XDispatchServlet：

package com.xiaopengwei.xspring.servlet;
import com.xiaopengwei.xspring.annotation.XAutowired;
import com.xiaopengwei.xspring.annotation.XController;
import com.xiaopengwei.xspring.annotation.XRequestMapping;
import com.xiaopengwei.xspring.annotation.XService;
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.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.*;
 
/**
 * <p>
 * XSpring
 *
 * @author  http://www.wityx.com
 * 
 */
public class XDispatchServlet extends HttpServlet {
 
    /**
     * 属性配置文件
     */
    private Properties contextConfig = new Properties();
 
    private List<String> classNameList = new ArrayList<>();
 
    /**
     * IOC 容器
     */
    Map<String, Object> iocMap = new HashMap<String, Object>();
 
    Map<String, Method> handlerMapping = new HashMap<String, Method>();
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req, resp);
    }
 
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        //7、运行阶段
        try {
            doDispatch(req, resp);
        } catch (Exception e) {
            e.printStackTrace();
            resp.getWriter().write("500 Exception Detail:\n" + Arrays.toString(e.getStackTrace()));
        }
 
    }
 
    /**
     * 7、运行阶段，进行拦截，匹配
     *
     * @param req  请求
     * @param resp 响应
     */
    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws InvocationTargetException, IllegalAccessException {
 
        String url = req.getRequestURI();
 
        String contextPath = req.getContextPath();
 
        url = url.replaceAll(contextPath, "").replaceAll("/+", "/");
 
        System.out.println("[INFO-7] request url-->" + url);
 
        if (!this.handlerMapping.containsKey(url)) {
            try {
                resp.getWriter().write("404 NOT FOUND!!");
                return;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
 
        Method method = this.handlerMapping.get(url);
 
        System.out.println("[INFO-7] method-->" + method);
 
 
        String beanName = toLowerFirstCase(method.getDeclaringClass().getSimpleName());
 
        System.out.println("[INFO-7] iocMap.get(beanName)->" + iocMap.get(beanName));
 
        // 第一个参数是获取方法，后面是参数，多个参数直接加，按顺序对应
        method.invoke(iocMap.get(beanName), req, resp);
 
        System.out.println("[INFO-7] method.invoke put {" + iocMap.get(beanName) + "}.");
    }
 
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
 
        //1、加载配置文件
        doLoadConfig(servletConfig.getInitParameter("contextConfigLocation"));
 
        //2、扫描相关的类
        doScanner(contextConfig.getProperty("scan-package"));
 
        //3、初始化 IOC 容器，将所有相关的类实例保存到 IOC 容器中
        doInstance();
 
        //4、依赖注入
        doAutowired();
 
        //5、初始化 HandlerMapping
        initHandlerMapping();
 
        System.out.println("XSpring FrameWork is init.");
 
        //6、打印数据
        doTestPrintData();
    }
 
    /**
     * 6、打印数据
     */
    private void doTestPrintData() {
 
        System.out.println("[INFO-6]----data------------------------");
 
        System.out.println("contextConfig.propertyNames()-->" + contextConfig.propertyNames());
 
        System.out.println("[classNameList]-->");
        for (String str : classNameList) {
            System.out.println(str);
        }
 
        System.out.println("[iocMap]-->");
        for (Map.Entry<String, Object> entry : iocMap.entrySet()) {
            System.out.println(entry);
        }
 
        System.out.println("[handlerMapping]-->");
        for (Map.Entry<String, Method> entry : handlerMapping.entrySet()) {
            System.out.println(entry);
        }
 
        System.out.println("[INFO-6]----done-----------------------");
 
        System.out.println("====启动成功====");
        System.out.println("测试地址：http://localhost:8080/test/query?username=xiaopengwei");
        System.out.println("测试地址：http://localhost:8080/test/listClassName");
    }
 
    /**
     * 5、初始化 HandlerMapping
     */
    private void initHandlerMapping() {
 
        if (iocMap.isEmpty()) {
            return;
        }
 
        for (Map.Entry<String, Object> entry : iocMap.entrySet()) {
            Class<?> clazz = entry.getValue().getClass();
 
            if (!clazz.isAnnotationPresent(XController.class)) {
                continue;
            }
 
            String baseUrl = "";
 
            if (clazz.isAnnotationPresent(XRequestMapping.class)) {
                XRequestMapping xRequestMapping = clazz.getAnnotation(XRequestMapping.class);
                baseUrl = xRequestMapping.value();
            }
 
            for (Method method : clazz.getMethods()) {
                if (!method.isAnnotationPresent(XRequestMapping.class)) {
                    continue;
                }
 
                XRequestMapping xRequestMapping = method.getAnnotation(XRequestMapping.class);
 
                String url = ("/" + baseUrl + "/" + xRequestMapping.value()).replaceAll("/+", "/");
 
                handlerMapping.put(url, method);
 
                System.out.println("[INFO-5] handlerMapping put {" + url + "} - {" + method + "}.");
 
            }
        }
 
    }
 
    /**
     * 4、依赖注入
     */
    private void doAutowired() {
        if (iocMap.isEmpty()) {
            return;
        }
 
        for (Map.Entry<String, Object> entry : iocMap.entrySet()) {
 
            Field[] fields = entry.getValue().getClass().getDeclaredFields();
 
            for (Field field : fields) {
                if (!field.isAnnotationPresent(XAutowired.class)) {
                    continue;
                }
 
                System.out.println("[INFO-4] Existence XAutowired.");
 
                // 获取注解对应的类
                XAutowired xAutowired = field.getAnnotation(XAutowired.class);
                String beanName = xAutowired.value().trim();
 
                // 获取 XAutowired 注解的值
                if ("".equals(beanName)) {
                    System.out.println("[INFO] xAutowired.value() is null");
                    beanName = field.getType().getName();
                }
 
                // 只要加了注解，都要加载，不管是 private 还是 protect
                field.setAccessible(true);
 
                try {
                    field.set(entry.getValue(), iocMap.get(beanName));
 
                    System.out.println("[INFO-4] field set {" + entry.getValue() + "} - {" + iocMap.get(beanName) + "}.");
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
    /**
     * 3、初始化 IOC 容器，将所有相关的类实例保存到 IOC 容器中
     */
    private void doInstance() {
        if (classNameList.isEmpty()) {
            return;
        }
 
        try {
            for (String className : classNameList) {
 
                Class<?> clazz = Class.forName(className);
 
                if (clazz.isAnnotationPresent(XController.class)) {
                    String beanName = toLowerFirstCase(clazz.getSimpleName());
                    Object instance = clazz.newInstance();
 
                    // 保存在 ioc 容器
                    iocMap.put(beanName, instance);
                    System.out.println("[INFO-3] {" + beanName + "} has been saved in iocMap.");
 
                } else if (clazz.isAnnotationPresent(XService.class)) {
 
                    String beanName = toLowerFirstCase(clazz.getSimpleName());
 
                    // 如果注解包含自定义名称
                    XService xService = clazz.getAnnotation(XService.class);
                    if (!"".equals(xService.value())) {
                        beanName = xService.value();
                    }
 
                    Object instance = clazz.newInstance();
                    iocMap.put(beanName, instance);
                    System.out.println("[INFO-3] {" + beanName + "} has been saved in iocMap.");
 
                    // 找类的接口
                    for (Class<?> i : clazz.getInterfaces()) {
                        if (iocMap.containsKey(i.getName())) {
                            throw new Exception("The Bean Name Is Exist.");
                        }
 
                        iocMap.put(i.getName(), instance);
                        System.out.println("[INFO-3] {" + i.getName() + "} has been saved in iocMap.");
                    }
                }
 
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 获取类的首字母小写的名称
     *
     * @param className ClassName
     * @return java.lang.String
     */
    private String toLowerFirstCase(String className) {
        char[] charArray = className.toCharArray();
        charArray[0] += 32;
        return String.valueOf(charArray);
    }
 
    /**
     * 2、扫描相关的类
     *
     * @param scanPackage properties --> scan-package
     */
    private void doScanner(String scanPackage) {
 
        // package's . ==> /
        URL resourcePath = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.", "/"));
 
        if (resourcePath == null) {
            return;
        }
 
        File classPath = new File(resourcePath.getFile());
 
        for (File file : classPath.listFiles()) {
 
            if (file.isDirectory()) {
 
                System.out.println("[INFO-2] {" + file.getName() + "} is a directory.");
 
                // 子目录递归
                doScanner(scanPackage + "." + file.getName());
 
            } else {
 
                if (!file.getName().endsWith(".class")) {
                    System.out.println("[INFO-2] {" + file.getName() + "} is not a class file.");
                    continue;
                }
 
                String className = (scanPackage + "." + file.getName()).replace(".class", "");
 
                // 保存在内容
                classNameList.add(className);
 
                System.out.println("[INFO-2] {" + className + "} has been saved in classNameList.");
            }
        }
    }
 
    /**
     * 1、加载配置文件
     *
     * @param contextConfigLocation web.xml --> servlet/init-param
     */
    private void doLoadConfig(String contextConfigLocation) {
 
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
 
        try {
            // 保存在内存
            contextConfig.load(inputStream);
 
            System.out.println("[INFO-1] property file has been saved in contextConfig.");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != inputStream) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

（9）示例：TestController：

package com.xiaopengwei.demo.xcontroller;
import com.xiaopengwei.demo.xservice.ITestXService;
import com.xiaopengwei.xspring.annotation.XAutowired;
import com.xiaopengwei.xspring.annotation.XController;
import com.xiaopengwei.xspring.annotation.XRequestMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
 
/**
 * <p>
 * 前置控制器
 *
 * @author  http://www.wityx.com
 * 
 */
@XController
@XRequestMapping("/test")
public class TestController {
 
    @XAutowired
    ITestXService testXService;
 
    /**
     * 测试方法 /test/query
     *
     * @param req  请求体
     * @param resp 响应体
     */
    @XRequestMapping("/query")
    public void query(HttpServletRequest req, HttpServletResponse resp) {
 
        if (req.getParameter("username") == null) {
           try {
                resp.getWriter().write("param username is null");
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
 
            String paramName = req.getParameter("username");
            try {
                resp.getWriter().write("param username is " + paramName);
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("[INFO-req] New request param username-->" + paramName);
        }
    }
 
    /**
     * 测试方法 /test/listClassName
     *
     * @param req  请求体
     * @param resp 响应体
     */
    @XRequestMapping("/listClassName")
    public void listClassName(HttpServletRequest req, HttpServletResponse resp) {
        String str = testXService.listClassName();
        System.out.println("testXService----------=-=-=>" + str);
        try {
            resp.getWriter().write(str);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

（10）示例接口：ITestXService：

package com.xiaopengwei.demo.xservice;
/**
 * <p>
 * 接口
 *
 * @author  http://www.wityx.com
 * 
 */
public interface ITestXService {
    String listClassName();
}

（11）示例实现类 TestXServiceImpl：

package com.xiaopengwei.demo.xservice.impl;
import com.xiaopengwei.demo.xservice.ITestXService;
import com.xiaopengwei.xspring.annotation.XService;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.List;
 
/**
 * <p>
 * 业务实现类
 *
 * @author  http://www.wityx.com
 * 
 */
@XService
public class TestXServiceImpl implements ITestXService {
 
    @Override
    public String listClassName() {
 
        // 假装来自数据库
        return "123456TestXServiceImpl";
    }
}

（12）测试：

配置 Tomcat 后，访问：

http://localhost:8080/test/query?username=xiaopengwei

和

http://localhost:8080/test/listClassName

文章标签：
容器
Java
前端开发
Spring
应用服务中间件
weixin_836869520
目录
相关文章
诸葛子房
|
7月前
|
XML Java 数据格式
手写spring框架——第一篇
手写spring框架——第一篇
诸葛子房
49 0
java知路
|
前端开发 Java 应用服务中间件
手写简单版SpringMVC
手写简单版SpringMVC
java知路
54 0
weixin_836869520
|
6月前
|
XML Java 数据格式
手写一个简易的IOC
手写一个简易的IOC
weixin_836869520
37 0
竹子爱熊猫
|
5月前
|
XML 前端开发 Java
深入理解SpringMVC工作原理，像大牛一样手写SpringMVC框架
对于SpringMVC相信诸位并不陌生，这是Java开发过程中使用最频繁的框架，在你的项目中可能不一定用MyBatis，但绝对会使用SpringMVC，因为操作数据库还有Hibernate、JPA等其他ORM框架选择，但SpringMVC这个框架在其领域中，可谓是独领风骚
竹子爱熊猫
55 2
蓝易云
|
4月前
|
Java 开发者 容器
Java反射机制--手写springioc
这是一个非常基础的Spring IoC容器的实现方法。当然，真正的Spring IoC容器功能远不止这些，它还支持依赖注入、生命周期管理、配置方法等更高级和复杂的功能。但是通过这个简单的例子，你可以理解IoC容器的基本原理以及反射在其中的作用。在实际应用中，你通常会使用Spring框架提供的IoC容器，这样可以更加专注业务逻辑的实现，而不需要自己维护这样一个容器。
蓝易云
53 0
薛伟同学
|
7月前
|
XML Java 数据库连接
探秘MyBatis：手写Mapper代理的源码解析与实现
探秘MyBatis：手写Mapper代理的源码解析与实现
薛伟同学
97 1
凯小默
|
7月前
|
索引
09 # 手写 some 方法
09 # 手写 some 方法
凯小默
56 0
凯小默
|
7月前
|
索引
10 # 手写 every 方法
10 # 手写 every 方法
凯小默
58 0
Tom弹架构
|
设计模式 Java Spring
用300行代码手写1个Spring框架，麻雀虽小五脏俱全
为了解析方便，我们用application.properties来代替application.xml文件，具体配置内容如下：
Tom弹架构
47 0
山河亦问安
|
缓存 网络协议 应用服务中间件
手写Tomcat源码简易篇
手写Tomcat源码简易篇
山河亦问安
82 0

热门文章

最新文章

  • 1
    跟阿里云技术专家阙寒一起深度了解视频直播CDN技术
  • 2
    流批一体的近实时数仓的思考与设计
  • 3
    丰富、连接、待集成—MaxCompute 生态再出发
  • 4
    securecrt克隆会话与sshd 的 MaxSessions
  • 5
    McAfee揭秘网络最危险搜索关键词
  • 6
    微软再爆IE 0day漏洞 绿盟科技提供预警及防护手段
  • 7
    uboot命令分析+实现【转】
  • 8
    读书笔记--101个shell脚本 之#11--炫
  • 9
    SQL Server 深入解析索引存储(堆)
  • 10
    OAF_EO系列3 - Initialize详解和实现（案例）
  • 1
    【claude官网中文版】国内如何使用claude?记住这十大技巧！
    100
  • 2
    调用云端Qwen系列大模型（TURBO、PLUS、MAX和MAX_LATEST）在国际商业咨询智能体场景的实践探索
    53
  • 3
    已解决：国内如何使用Claude 3.5 Sonnet \ claude官网中文入口
    42
  • 4
    HarmonyOS 5.0 Next实战应用开发—‘我的家乡’【HarmonyOS Next华为公司完全自研的操作系统】
    64
  • 5
    自学记录鸿蒙API 13：实现多目标识别Object Detection
    158
  • 6
    《探索人工智能产业的可持续发展模式与策略》
    18
  • 7
    《人工智能助力社会学研究：数据挖掘与分析方法的深度探索》
    20
  • 8
    《软体机器人与仿生机器人的人工智能控制技术：挑战与突破》
    18
  • 9
    《探索机器人自主导航与路径规划技术的热点》
    20
  • 10
    《集成学习：堆叠泛化与提升法在人工智能中的应用热点》
    16

    • 相关课程

    更多
  • SpringMVC框架入门

    • 相关电子书

    更多
  • Spring框架入门
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)