第一篇 - 手写SpringMvc框架

最新推荐文章于 2022-05-29 16:26:41 发布
最新推荐文章于 2022-05-29 16:26:41 发布
阅读量533 收藏 3
点赞数 3
分类专栏： 手写源码 文章标签： 手写 源码 spring springmvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37499059/article/details/100940663
版权

在这里插入图片描述
Github源码下载地址：https://github.com/chenxingxing6/springmvc
CSDN源码下载地址：https://download.csdn.net/download/m0_37499059/11783232

在这里插入图片描述

一、前言

SpringMVC是Spring框架的一个模块,是基于mvc的webframework模块。mvc是一种设计模式，即model-view-controller，mvc在b/s系统下的应用如下图所示。
在这里插入图片描述

SpringMvc原理图：

在这里插入图片描述

二、手写SpringMvc

代码下载Github：https://github.com/chenxingxing6/springmvc

我们所有的注解都自己定义，并对注解进行解析处理。通过写这个SpringMvc框架，我们可以大致掌握SpringMvc的实现思路，用户请求怎么进来的，怎么通过Mapping映射到具体需要执行的方法上，并如何对结果进行处理（Json数据格式，视图）。

需要依赖的包：

 <dependency>
     <groupId>javax.servlet</groupId>
     <artifactId>javax.servlet-api</artifactId>
     <version>3.1.0</version>
     <optional>true</optional>
     <scope>provided</scope>  #应用服务器，比如tomcat都有这个jar包
</dependency>

在这里插入图片描述

GitHub里面对进行了更新，完善了更多的功能，具体看Github.
在这里插入图片描述

2.1项目结构

在这里插入图片描述

2.2登陆测试Demo

访问地址：http://localhost:8080/test/view?path=login

在这里插入图片描述
在这里插入图片描述

@RequestMapping("/login")
    public MyModeAndView login(@RequestParam("name") String name, @RequestParam("pwd") String pwd){
        MyModeAndView modeAndView = new MyModeAndView();
        modeAndView.setViewName("index");
        modeAndView.addObject("name", name);
        return modeAndView;
    }

<html>
<head>
    <title>登陆</title>
</head>
<body>
<div>
    <h1>欢迎登陆</h1>
    <form action="/test/login" method="get">
   <div>
       <label>用户名：</label>
       <input name="name" type="text"/>
   </div>
    <div>
        <label>用户名：</label>
        <input name="pwd" type="password"/>
    </div>
    <div>
        <label></label>
        <input type="submit" value="提交"/>
    </div>
    </form>
</div>
</body>
</html>


<html>
<head>
    <title>Title</title>
</head>
<body>
<div>
    <h1>手写SpringMvc</h1>
    <h3 style="color: blue;">欢迎 ${name} 你使用本系统....</h3>
</div>
</body>
</html>
2.3核心代码
package org.springframework.servlet;

import com.alibaba.fastjson.JSON;
import org.springframework.annotation.*;
import org.springframework.core.*;

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.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;

/**
 * @Author: cxx
 * @Date: 2019/8/27 22:45
 */
public class MyDispatcherServlet extends HttpServlet{
    // 存放配置信息
    Properties props = null;

    // 所有的类名
    private List<String> classNames = null;

    // 实例化对象
    Map<String, Object> ioc = null;

    // Handler
    List<Handler> handlers;

    // 默认适配器
    IHandlerAdapter defaultHandlerAdapter = null;

    public MyDispatcherServlet(){
        props = new Properties();
        classNames = new ArrayList<>();
        ioc = new ConcurrentHashMap<>();
        handlers = new ArrayList<>();
        defaultHandlerAdapter = new DefaultHandlerAdapter();
    }

    // 初始化
    @Override
    public void init(ServletConfig config) throws ServletException {
        System.out.println("------ My mvc is init start...... ------");
        // 1.加载配置文件
        doLoadConfig(config.getInitParameter("contextConfigLocation"));
        System.out.println("------ 1.加载配置文件成功-doLoadConfig() ------");

        // 2.根据配置文件扫描所有相关类
        doScanner(props.getProperty("scanPackage"));
        System.out.println("------ 2.扫描所有相关类-ddoScanner() ------");

        // 3.初始化所有相关类的实例，并将放入IOC容器中
        doInstance();
        System.out.println("------ 3.实例化成功-doInstance() ------");

        // 4.实现DI
        doAutowried();
        System.out.println("------ 4.依赖注入成功-doAutowried() ------");

        // 5.初始化HandlerMapping
        initHandlerMapping();
        System.out.println("------ 5.HandlerMapping初始化成功-initHandlerMapping() ------");

        System.out.println("------ My mvc is init end...... ------");
    }

    public void doLoadConfig(String location){
        String configName = location.split(":")[1];
        InputStream is = this.getClass().getClassLoader().getResourceAsStream(configName);
        try {
            props.load(is);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (is != null){
                try {
                    is.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }

    public void doScanner(String packageName){
        // 进行递归扫描
        URL url = this.getClass().getClassLoader().getResource("/" + packageName.replace(".", "/"));
        File classDir = new File(url.getFile());
        for (File file : classDir.listFiles()) {
            if (file.isDirectory()){
                doScanner(packageName + "." + file.getName());
            }else {
                String className = packageName + "." + file.getName().replace(".class", "");
                classNames.add(className);
            }
        }
    }

    /**
     * IOC容器规则 key-value
     * 1.key默认用类名小写字段，否则优先使用用户自定义名字
     * 2.如果是接口，用接口的类型作为key
     */
    public void doInstance(){
        if (classNames.isEmpty()){
            return;
        }
        // 利用反射，将扫描的className进行初始化
        try {
            for (String className : classNames) {
                Class clazz = Class.forName(className);
                // 进行Bean实例化，初始化IOC
                if (clazz.isAnnotationPresent(Controller.class)){
                    String beanName = lowerFirstCase(clazz.getSimpleName());
                    ioc.put(beanName, clazz.newInstance());
                }else if (clazz.isAnnotationPresent(Service.class)){
                    Service service = (Service) clazz.getAnnotation(Service.class);
                    String beanName = service.value();
                    if ("".equals(beanName.trim())){
                        beanName = lowerFirstCase(clazz.getSimpleName());
                    }
                    Object instance = clazz.newInstance();
                    ioc.put(beanName, instance);

                    // 接口也需要注入,接口类型作为key
                    Class<?>[] interfaces = clazz.getInterfaces();
                    for (Class<?> i : interfaces) {
                        ioc.put(i.getName(), instance);
                    }
                }else {
                    continue;
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void doAutowried(){
        if (ioc.isEmpty()){
            return;
        }
        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            // 获取到所有字段,不管什么类型，都强制注入
            Field[] field = entry.getValue().getClass().getDeclaredFields();
            for (Field f : field) {
                if (f.isAnnotationPresent(Autowired.class)){
                    Autowired autowired = f.getAnnotation(Autowired.class);
                    String beanName = autowired.value().trim();
                    if ("".equals(beanName)){
                        // com.demo.service.ITestService
                        beanName = f.getType().getName();
                    }
                    // 不管愿不愿意，都需要强吻
                    f.setAccessible(true);
                    try {
                        // 例如：TestController -> TestService
                        f.set(entry.getValue(), ioc.get(beanName));
                    }catch (Exception e) {
                        e.printStackTrace();
                        continue;
                    }
                }
            }
        }
    }


    public void initHandlerMapping(){
        if (ioc.isEmpty()){
            return;
        }
        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            Class clazz = entry.getValue().getClass();
            if (!clazz.isAnnotationPresent(Controller.class)){
                continue;
            }
            String baseUrl = "";
            if (clazz.isAnnotationPresent(RequestMapping.class)){
                RequestMapping requestMapping = (RequestMapping)clazz.getAnnotation(RequestMapping.class);
                baseUrl = requestMapping.value();
            }

            Method[] methods = clazz.getMethods();
            for (Method method : methods) {
                if (!method.isAnnotationPresent(RequestMapping.class)){
                    continue;
                }
                RequestMapping requestMapping = (RequestMapping)method.getAnnotation(RequestMapping.class);
                String regex = ("/" + baseUrl + requestMapping.value()).replaceAll("/+", "/");
                Pattern pattern = Pattern.compile(regex);
                handlers.add(new Handler(pattern, entry.getValue(), method));
                System.out.println("------   Mapping: " + regex + ", method:" + method);
            }
        }
    }

    // 6.运行阶段，等待请求
    @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 {
        try {
            doDispatch(req, resp);
            String url = req.getRequestURI();
            String contextpath= req.getContextPath();
            url = url.replace(contextpath, "").replaceAll("/+", "/");
            System.out.println("进行请求....url：" + url);
        }catch (FileNotFoundException e){
            resp.getWriter().write("404 Not Found");
            return;
        }catch (Exception e){
            resp.getWriter().write("500 error \r\n\n" + Arrays.toString(e.getStackTrace()));
            return;
        }
    }

    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception{
        boolean jsonResult = false;
        // 获取适配器
        IHandlerAdapter handlerAdapter = defaultHandlerAdapter;
        Handler handler = handlerAdapter.getHandler(req, handlers);
        if (handler == null){
            throw new FileNotFoundException();
        }
        Object[] paramValues = handlerAdapter.hand(req, resp, handlers);
        Method method = handler.method;
        Object controller = handler.controller;
        String beanName = lowerFirstCase(method.getDeclaringClass().getSimpleName());

        //如果controller或这个方法有UVResponseBody修饰，返回json
        if (controller.getClass().isAnnotationPresent(ResponseBody.class) || method.isAnnotationPresent(ResponseBody.class)){
            jsonResult = true;
        }
        Object object = method.invoke(ioc.get(beanName), paramValues);
        if (jsonResult && object !=null){
            resp.getWriter().write(JSON.toJSONString(object));
        }else {
            // 返回视图
            doResolveView(object, req, resp);
        }
    }

    public void doResolveView(Object object, HttpServletRequest req, HttpServletResponse resp) throws Exception{
        // 视图前缀
        String prefix = props.getProperty("view.prefix");
        // 视图后缀
        String suffix = props.getProperty("view.suffix");

        MyModeAndView modeAndView = null;
        if (object instanceof MyModeAndView){
            modeAndView = (MyModeAndView) object;
        }else {
            modeAndView = new MyModeAndView(object.toString());
        }
        DefaultViewResolver viewResolver = new DefaultViewResolver(prefix, suffix);
        viewResolver.resolve(modeAndView, req, resp);
    }

    /**
     * 首字母小写
     * @param old
     * @return
     */
    private static String lowerFirstCase(String old){
        char [] chars = old.toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }
}

三、总结

服务启动会去读取web.xml配置文件，然后执行MyDispatcherServlet的init()方法，初始化一些配置，IOC，依赖注入，RequestMapping等，然后对发送进来的请求进行解析，通过反射方式调用到具体Controller的某个方法，然后对执行的结果进行处理。

 <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <display-name>DispatcherServlet</display-name>
        <servlet-class>org.springframework.servlet.MyDispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:application.properties</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
添加过滤器对编码进行设置：
<!-- 过滤器 -->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

package org.springframework.web.filter;

import javax.servlet.*;
import java.io.IOException;

/**
 * @Author: cxx
 * @Date: 2019/9/15 23:56
 */
public class CharacterEncodingFilter implements Filter{
    // 编码格式
    private String encoding;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("------ filter init .......");
        encoding = filterConfig.getInitParameter("encoding");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("------ 过滤器处理编码问题......" + encoding);
        servletRequest.setCharacterEncoding(encoding);
        servletResponse.setCharacterEncoding(encoding);
        servletResponse.setContentType("text/html");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {

    }
}
蓝星花
关注
专栏目录
我的架构梦：（八）手写SpringMVC框架
riemann_的博客
06-11 676
手写SpringMVC框架一、SpringMVC的请求处理流程二、Spring MVC 高级技术三、手写 SpringMVC 框架 手写SpringMVC框架之前呢，我觉得有必要先了解SpringMVC的请求处理流程以及高级特性。 一、SpringMVC的请求处理流程 1、请求处理流程 流程说明： 第一步：用户发送请求至前端控制器DispatcherServlet。 第二步：DispatcherServlet收到请求调用HandlerMapping处理器映射器。 第三步：处理器映射器根据请求Url找到具体
springmvc学习笔记加心得
qq_36603180的博客
10-01 210
1、在web.xml中配置核心控制器 <servlet> <servlet-name>dispatcherServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocatio
SpringMVC 注解 和非注解
路虽远行则将至，事虽难做则必成
01-26 147
首先看看非注解的项目结构 [img]http://dl2.iteye.com/upload/attachment/0093/5380/60ef9462-e498-3385-a8ca-4344c3bb073a.jpg[/img] 在web.xml文件 配置springmvc 转发调度servlet 和 Date 类型参数的自动转型 [code="xml"] ...
【SpringMVC（八）】@ResponseBody 使用 及 原理
u010900754的专栏
08-10 2158
@Response注解用于表明控制器返回的是json而非jsp页面。 例子： @RequestMapping("/testBody") @ResponseBody public Object testBody(){ Person person = new Person(); person.setAge(10); person.s...
SpringMVC 自定义json转化格式
chikai1的专栏
03-12 547
这篇文章主要讲下spring如何自定义json转化格式。如输出日期格式为"yyyy-MM-dd HH:mm:ss" 方式一： <mvc:annotation-driven > <mvc:message-converters> <bean class="org.springframework.http.convert...
SpringMVC4.x源码分析（六）：消息转换器自动转换json、xml原理分析
weixin_34220179的博客
06-19 365
2019独角兽企业重金招聘Python工程师标准>>> ...
纯手写SpringMVC框架
weixin_45017862的博客
07-11 674
通过策略接口，Spring 框架是高度可配置的，而且包含多种视图技术，例如 JavaServer Pages（ JSP）技术、Velocity、Tiles、iText 和 POI。Spring MVC 框架并不知道使用的视图，所以不会强迫您只使用 JSP 技术。Spring MVC 分离了 控制器、模型 对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。 Lifecycle fo...
从0开始手写一个 SpringMVC 框架，向高手进阶
m0_68850571的博客
05-29 207
Spring框架对于Java后端程序员来说再熟悉不过了，以前只知道它用的反射实现的，但了解之后才知道有很多巧妙的设计在里面。如果不看Spring的源码，你将会失去一次和大师学习的机会：它的代码规范，设计思想很值得学习。我们程序员大部分人都是野路子，不懂什么叫代码规范。写了一个月的代码，最后还得其他老司机花3天时间重构，相信大部分老司机都很头疼看新手的代码。 废话不多说，我们进入今天的正题，在Web应用程序设计中，MVC模式已经被广泛使用。SpringMVC以DispatcherServlet为核心，负责协
java手写SpringMvc框架
11-02
手写Spring MVC框架的第一步是实现DispatcherServlet，它扮演着请求调度者的角色。我们需要重写doDispatch方法，这里会涉及到请求的拦截、匹配、转发等操作。同时，需要设计一个简单的注解系统，如@Controller、@...
SpringMVC进阶（二）手写MVC框架
舞鹤白沙编码日志
01-07 293
一.手写MVC框架实现功能 （一）SpringMVC请求处理流程回顾 （二）手写MVC框架主要实现功能 二. 准备阶段 （一）自定义注解 package com.lagou.edu.mvcframework.annotations; import java.lang.annotation.*; @Documented @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface
18.手写Spring MVC
编程之心的博客
04-11 211
1.Spring MVC顶层设计 2.Spring MVC执行流程 下面是代码实现 3.GPdispatcherServelet 分发器 Serviet 的生命周期由 init（）到 service（）再到 destory（）组成， destory（）方法我们 不做实现。 package com.gupaoedu.vip.spring.framework.webmvc.servlet; i...
SpringMVC-组件分析之视图解析器（prefix，suffix）
Kevinnsm的博客
11-24 3162
SpringMVC的默认组件都是在DispatcherServlet.properties配置文件中配置的； spring-webmvc->org/springframewrok/web/servlet/DispatcherServlet.properties,该文件中配置了默认的视图解析器 打开org.springframework.web.servlet.view.UrlBasedViewResolver翻看该解析器源码，可以看到该解析器的默认设置 public static final S
Maven搭建SpringMVC+Mybatis项目详解
不忘初心的博客
05-29 753
1.项目目的 a.通过Spring+Mybatis实现通过web访问达成mySql的操作 b.理解Spring+Mybatis的配置 c.理解maven对项目的管理 2.配置文件 a.采用maven约定结构，src/main/java、src/main/resources、src/main/test b.基本springMVC+Mybatis需要用到的jar spri
第八篇 - 手写Redis(Java实现)
蓝星花
12-06 3575
Github源码下载：https://github.com/chenxingxing6/sourcecode/tree/master/code-redis 一、前言 Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、key-value数据库。它通常被称为数据结构服务器，因为值（value）可以是字符串（String），哈希（Hash），列...
第五篇 - 手写Tomcat(基于Netty)&热部署
蓝星花
10-09 1045
Github源码下载地址：https://github.com/chenxingxing6/sourcecode/tree/master/code-netty-tomcat 一、前言
第七篇 - 手写Aop(面向切面编程)
蓝星花
10-21 956
Github源码下载地址：https://github.com/chenxingxing6/sourcecode/tree/master/code-springaop 一、前言 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Sprin...
第三篇 - 手写ORM框架
蓝星花
09-19 812
一、前言 ORM对象关系映射（Object Relational Mapping）,用于实现面向对象编程语言里不通类型系统的数据之间进行转换。简单来说，ORM就是通过使用描述对象和数据库之间映射的元数据，将程序中的对象与关系数据库进行相互映射。 MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设...
第九篇 - 手写心跳检测
蓝星花
12-19 763
Github源码下载：https://github.com/chenxingxing6/sourcecode/tree/master/study-net 一、前言 1.1 什么是心跳检测 在分布式系统中，分布在不同主机上的节点需要检测其他节点的状态，如服务器节点需要检测从节点是否失效。为了检测对方节点的有效性，每隔固定时间就发送一个固定信息给对方，对方回复一个固定信息，如果长时间没有收到对方...
Spring-SpringMVC-MyBatis框架整合实战与开发指南
"本文将介绍如何整合Spring、SpringMVC和MyBatis这三大框架，以及在实际开发中的应用。我们将利用MyEclipse作为开发环境，Tomcat作为应用服务器，Maven进行项目构建管理，以及SVN进行版本控制。此外，还将涉及Spring...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值