手撸springmvc

最新推荐文章于 2024-05-30 11:21:03 发布
最新推荐文章于 2024-05-30 11:21:03 发布
阅读量145 收藏
点赞数
分类专栏： web 文章标签： spring java springmvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq275467589/article/details/116770655
版权

目录

springmvc的执行流程

环境准备

web.xml配置

控制层controller包

自定义RequestMapping注解 ano包

RequestMapping注解代码

RequestMappingInfo实体类（存放注解映射对应的一些信息）

RequestParam注解代码 

spring核心配置文件spring-servlet.xml配置详情

控制器handler包（核心）

HandlerMapping处理器映射接口

BeanIdHandlerMapping（映射类的方式，id作为路径）

AnoHandlerMapping（映射方法的方式，注解value值作为路径）

HandlerAdapter处理器适配器接口

BeanIdHandlerAdapter（id映射方式的适配器）

AnnoHandlerAdapter（注解映射方法方式的适配器）

DispatcherServlet类

测试

id映射到servlet类测试

注解映射到方法测试

 

 

springmvc的执行流程

  • 1、用户请求发送到DispatcherServlet
  • 2、DispatcherServlet根据请求去调用处理器映射器
  • 3、处理器映射器根据请求url找到具体的处理器，生成处理器执行链HandlerExecutionChain(包括处理器对象和处理器拦截器，我们这里就不考虑拦截器了，有兴趣的可以自行扩展
  • 4、将处理器执行链一并返回给DispatcherServlet
  • 5、根据处理器Handler获取处理器适配器HandlerAdapter执行HandlerAdapter处理一系列的操作，如：参数封装，数据格式转换，数据验证等操作
  • 6、执行处理器handler，即执行我们写的controller的方法
  • 7，8、HandlerAdapter将Handler执行结果ModelAndView返回到DispatcherServlet
  • 9、DispatcherServlet将ModelAndView传给视图解析器(ViewResolver)
  • 10、ViewReslover解析后返回具体View
  • 11、DispatcherServlet对View进行渲染视图
  • 12、响应用户
  • 注：8-12的解析器我们也没有考虑，我们只是实现一个简易版springmvc，实现核心的请求-调用这个过程，有兴趣可以自行扩展。

环境准备

  • 使用maven构建项目 依赖包如下
    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.74</version>
        </dependency>
    </dependencies>
  • 项目结构如下

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>DispatcherServlet</servlet-name>
        <servlet-class>com.vuhen.springmvc.DispatcherServlet</servlet-class>
        <!--    spring的核心配置类路径，用于初始化创建spring容器用的    -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-servlet.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

控制层controller包

  • 定义一个测试类1的test方法，用自定义的注解声明路径是/test 这个将作为以注解映射路径的方法方式访问
package com.vuhen.springmvc.controller;

import com.vuhen.springmvc.ano.RequestMapping;
import com.vuhen.springmvc.ano.RequestParam;
import org.springframework.stereotype.Controller;

@Controller
public class TestController {
    @RequestMapping("/test")
    public String test(){
        System.out.println("--RequestMapping");
        return "myspringmvc";
    }
    @RequestMapping("/test2")
    public String test2(@RequestParam("name") String name,@RequestParam("age") Integer age){
        System.out.println("姓名："+name+",年龄："+age);
        return "哈哈";
    }
}
  • 定义一个测试类2的service方法，该类为servlet，在spring中定义为id="/helloServlet" 这个将作为以id映射路径的类方式访问
package com.vuhen.springmvc.controller;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("helloServlet");
    }
}

 

自定义RequestMapping注解 ano包

RequestMapping注解代码

package com.vuhen.springmvc.ano;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)//这边我们不考虑注解可以用到类上，只考虑用到方法上
@Retention(RetentionPolicy.RUNTIME)//设置运行时产生
public @interface RequestMapping {
    String value() default "";
}

RequestMappingInfo实体类（存放注解映射对应的一些信息）

package com.vuhen.springmvc.ano;

import java.lang.reflect.Method;

//实体类 存储用注解映射的方法、类、url具体信息
public class RequestMappingInfo {
    private Method method;//注解value值所对应的方法
    private Object object;//注解所对应的类
    private String url;//注解所对应的url

    public Method getMethod() {
        return method;
    }

    public void setMethod(Method method) {
        this.method = method;
    }

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }
}

RequestParam注解代码 

package com.vuhen.springmvc.ano;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.PARAMETER)//作用域只在参数上
@Retention(RetentionPolicy.RUNTIME)//运行时产生
public @interface RequestParam {
    String value() default "";
}

spring核心配置文件spring-servlet.xml配置详情

  • 下面servlet类注入到spring容器直接配置id为要访问的路径，后续控制器代码会介绍
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!--     扫描所有包下的类，将需要注入到spring容器的类全部注入到spring容器-->
   <context:component-scan base-package="com.vuhen"/>

<!--    servler作为控制器-->
    <bean id="/helloServlet" class="com.vuhen.springmvc.controller.HelloServlet"/>
</beans>

控制器handler包（核心）

HandlerMapping处理器映射接口

  • 之所以要抽象出来，是因为我们有两种方式作为映射，一种是方法的方式，即我们定义的RequestMapping注解的value值；一种是类的方式，即HelloServlet用id作为映射的url方式
package com.vuhen.springmvc.handler;

import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;

public interface HandlerMapping extends InstantiationAwareBeanPostProcessor {//继承的是spring初始化的一个核心类
    public Object getHandler(String url);
}

BeanIdHandlerMapping（映射类的方式，id作为路径）

package com.vuhen.springmvc.handler;

import org.springframework.beans.BeansException;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

@Component
public class BeanIdHandlerMapping implements HandlerMapping {
    static Map<String,Object> map = new HashMap<>();//存储每个url路径对应的bean对象
    @Override
    public Object getHandler(String url) {
        return map.get(url);
    }

    //spring每实例化一个对象到容器后都会执行一次这个方法
    @Override
    /**
     * @bean:实例化到容器的对象
     * @beanName:实例化到容器的对象的id
     */
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        //如果bean对象id是以/开头就说明是要映射地址 存到我们的map中
        if (beanName.startsWith("/")) map.put(beanName,bean);
        return true;//这个如果是false，那在这之后的类即使实现这个接口也不会再调用到这个方法了，类似于放行否
    }
}

AnoHandlerMapping（映射方法的方式，注解value值作为路径）

package com.vuhen.springmvc.handler;

import com.vuhen.springmvc.ano.RequestMapping;
import com.vuhen.springmvc.ano.RequestMappingInfo;
import org.springframework.beans.BeansException;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

@Component
//处理RequestMapping注解的方法url映射
public class AnoHandlerMapping implements HandlerMapping{
    static Map<String,Object> map = new HashMap<>();
    @Override
    public Object getHandler(String url) {
        return map.get(url);
    }

    //spring每实例化一个对象到容器后都会执行一次这个方法
    @Override
    /**
     * @bean:实例化到容器的对象
     * @beanName:实例化到容器的对象的id
     */
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        Method[] methods = bean.getClass().getDeclaredMethods();//获取该bean所有方法
        //遍历该bean所有方法，将所有信息提取出来到RequestMappingInfo实体中，再存储该实体到map中
        for (Method method : methods) {
            RequestMappingInfo requestMappingInfo = createRequestMappingInfo(method, bean);
            map.put(requestMappingInfo.getUrl(),requestMappingInfo);
        }
        return true;
    }
    

    /**
     * 获取map要存储的具体对象
     * @param method bean对象的方法
     * @param bean bean对象
     * @return 存储method，bean，url信息的实体类
     */
    private RequestMappingInfo createRequestMappingInfo(Method method,Object bean){
        RequestMappingInfo requestMappingInfo = new RequestMappingInfo();//实体类
        //判断该方法是否有RequstMapping注解
        if (method.isAnnotationPresent(RequestMapping.class)){
            requestMappingInfo.setMethod(method);//存储有RequestMapping注解的Method
            requestMappingInfo.setObject(bean);//存储有RequestMapping注解的bean
            //存储url 就是RequestMapping注解的value值
            requestMappingInfo.setUrl(method.getDeclaredAnnotation(RequestMapping.class).value());
        }
        return requestMappingInfo;//返回存储method，bean，url信息的实体类
    }
}

HandlerAdapter处理器适配器接口

  • 适配器之所以要抽象出来，跟映射器基本同理，因为我们有多个方式来处理
  • 只有简单的两个方法，support用于判断我们是否有能够处理这种handler的适配器；handle就是具体执行控制层方法的一个调用，带有返回值
package com.vuhen.springmvc.handler;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public interface HandlerAdapter {

    //判断是否是我们可使用的处理器
    public boolean support(Object handler);

    //处理器执行
    public Object handle(HttpServletRequest request, HttpServletResponse response,Object handler) throws Exception;
}

BeanIdHandlerAdapter（id映射方式的适配器）

package com.vuhen.springmvc.handler;

import org.springframework.stereotype.Component;

import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
//beanId映射类的处理器适配器
public class BeanIdHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean support(Object handler) {
        return handler instanceof Servlet;
    }

    @Override
    //servlet类里面只是简单的写了个service方法而已，直接调用就可以了
    public Object handle(HttpServletRequest request, HttpServletResponse response,Object handler) throws ServletException, IOException {
        Servlet servlet = (Servlet) handler;
        servlet.service(request,response);
        return null;
    }
}

AnnoHandlerAdapter（注解映射方法方式的适配器）

  • 这个可以说是整个springmvc请求-调用的核心
package com.vuhen.springmvc.handler;

import com.vuhen.springmvc.ano.RequestMappingInfo;
import com.vuhen.springmvc.ano.RequestParam;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.lang.reflect.Type;
import java.util.Map;

@Component
//注解映射方法方式的处理器适配器
public class AnnoHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean support(Object handler) {
        return handler instanceof RequestMappingInfo;
    }

    @Override
    public Object handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        RequestMappingInfo requestMappingInfo = (RequestMappingInfo) handler;//在该类已经确定是注解处理器了
        Map<String, String[]> map = request.getParameterMap();//获取请求携带的所有参数
        Method method = requestMappingInfo.getMethod();//获取要执行的方法
        Parameter[] parameters = method.getParameters();//获取要执行的方法的所有参数
        Object[] paramValues = new Object[parameters.length];//传入方法的参数
        //遍历方法的所有参数上面的RequestParam注解的value值 目的是为了将请求的参数值存储到paramValues
        for (int i = 0; i < parameters.length; i++) {
            //请求携带的参数含有RequestParamvalue值 存储到paramValues中
            if (map.containsKey(parameters[i].getDeclaredAnnotation(RequestParam.class).value())){
                Type type = parameters[i].getParameterizedType();
                //这里简单的判断一下要绑定的类型，暂时只写了两种类型
                if (type.getTypeName().equals("java.lang.Integer")){
                    paramValues[i] =
                            Integer.parseInt(map.get(parameters[i].getDeclaredAnnotation(RequestParam.class).value())[0]);
                }else if (type.getTypeName().equals("java.lang.String")){
                    paramValues[i] = map.get(parameters[i].getDeclaredAnnotation(RequestParam.class).value())[0];
                }
            }

        }
        //getObject就是该方法对应的类，之前在RequstInfo实体类中已经封装好了
        return method.invoke(requestMappingInfo.getObject(),paramValues);//调用方法并返回方法返回值
    }
}

DispatcherServlet类

package com.vuhen.springmvc;

import com.vuhen.springmvc.handler.HandlerAdapter;
import com.vuhen.springmvc.handler.HandlerMapping;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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.util.ArrayList;
import java.util.List;
import java.util.Map;

public class DispatcherServlet extends HttpServlet {
    private List<HandlerMapping> handlerMappings;//存放spring中所有的HandlerMapping类
    private List<HandlerAdapter> handlerAdapters;//存放spring中所有的HandlerAdapter类
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object handler = getHandler(req);
        try {
            //获取适配器
            HandlerAdapter handlerAdapter = getHandlerAdapter(handler);
            //调用适配器并拿到返回值 如果是注解上的方法有返回值，这步就会获取到返回值
            Object result = handlerAdapter.handle(req, resp, handler);
            System.out.println(result);//打印
        } catch (Exception e) {
            //异常信息，控制台打印提示
            System.out.println("No mapping "+req.getRequestURI());
        }
    }

    @Override
    //tomcat第一次启动访问时初始化方法
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        //初始化spring容器
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext(config.getInitParameter("contextConfigLocation"));
        //将spring容器中所有HandlerMapping类都取出来
        Map<String, HandlerMapping> beansOfType = app.getBeansOfType(HandlerMapping.class);
        handlerMappings = new ArrayList<>(beansOfType.values());
        //将spring容器中所有HandlerAdapter类都取出来
        Map<String, HandlerAdapter> beansOfType1 = app.getBeansOfType(HandlerAdapter.class);
        handlerAdapters = new ArrayList<>(beansOfType1.values());
    }

    //根据request的url获取对应的处理器 此方法已经获取到控制器，但是还没有做适配，并不知道是id映射还是注解映射
    private Object getHandler(HttpServletRequest request){
        if (handlerMappings != null){
            for (HandlerMapping handlerMapping : handlerMappings) {
                Object handler = handlerMapping.getHandler(request.getRequestURI());
                if (handler != null) return handler;
            }
        }
        return null;
    }
    //获取处理器对应的适配器
    private HandlerAdapter getHandlerAdapter(Object handler) throws Exception {
        if (handlerAdapters != null){
            for (HandlerAdapter handlerAdapter : handlerAdapters) {
                //判断该处理器是我们可使用的处理器再返回该适配器
                if(handlerAdapter.support(handler)) return handlerAdapter;
            }
        }
        return null;
    }
}

测试

id映射到servlet类测试

  • 访问我们bean中配的id路径

  • 控制台信息，可以看到确实没问题，我们打印了helloServlet，没有返回值

注解映射到方法测试

  • 访问无参数的方法

  • 控制台信息，打印--RequestMapping，返回值 myspringmvc

​​​​​​​

  • 访问有参数的方法

​​​​​​​

  • 控制台信息，打印信息正确，返回值正确

以上就是springmvc框架的请求-调用的一个简单实现了！springmvc请求-调用的核心基本就是这样了，读者可以根据上面这些去自行实现一个拦截器、解析器等功能出来！

紧张的无痕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
看完这篇文章，你也能手写MVC
博客
06-06 153
我们执行程序从这个类开始，类加载的时候，先执行静态块（扫描所有的文件，把类文件的实例和类文件的方法 用HashMap存起来） main方法中的exec是模拟调用接口，第一个参数是类的@RequestMapping的value值，第二个参数是方法的@ReqeustMapping的value值...
手写 springmvc
01-16
java spring springmvc 手写 博客位置： http://knight-black-bob.iteye.com/blog/2407872
手撸springMvc源码【一】
12-21
文章目录1. springMvc基本概念2. springMvc 核心流程3. 涉及的核心类4. 涉及的核心注解5. 要完成的条件及目标6. 大致流程 1. springMvc基本概念 MVC作为WEB项目开发的核心环节，正如三个单词的分解那样，C（控制器）将V（视图、用户客户端）与M（javaBean:封装数据）分开构成了MVC。 2. springMvc 核心流程 反射，类加载，注解 3. 涉及的核心类 DispatcherServlet （前置控制器） HandlerAdapter（处理适配器） HandlerMapping （处理请求的映射） HandlerExecutio
SpringMvc拦截器和手写模拟SpringMvc工作流程源码详解
qq_43649937的博客
06-18 4193
Spring SpringMvc java
手撕SpringMVC简单版
zhouhengzhe的博客
01-05 1925
文章目录,里面的类都有详细的注释1、创建过程与文件目录1.1、创建Maven工程2、pom依赖与配置文件2.1、pom依赖2.2、springmvc配置类2.3、web.xml3、实体类（User）4、控制器（UserController）5、业务处理类与实现类（UserService，UserServiceImpl）6、手撕mvc具体代码6.1、核心annotation注解6.2、context上下文（SpringMVC容器）6.3、映射处理（url与ccontroller之间的映射）6.4、前端处理器6
自己手撸一个 Spring MVC
公众号：Java后端
05-12 784
点击上方Java后端，选择设为星标优质文章，及时送达Spring MVC的工作流程在 SpringBoot 之前，几乎所有的 Web 应用都是已 web.xml 为入口的，Sprin...
controller调用另一个controller_自己手撸一个SpringMVC，是什么体验
weixin_40007189的博客
11-20 515
传智汇传智播客旗下IT互联网精英社区Spring框架对于Java后端程序员来说再熟悉不过了，以前只知道它用的反射实现的，但了解之后才知道有很多巧妙的设计在里面。如果不看Spring的源码，你将会失去一次和大师学习的机会：它的代码规范，设计思想很值得学习。我们程序员大部分人都是野路子，不懂什么叫代码规范。写了一个月的代码，最后还得其他老司机花3天时间重构，相信大部分老司机都很头疼看新手的代...
手撸springmvc乞丐版
danchuo3575的博客
08-11 199
思路（JDK11）： 1：引入tomcat jar包 2：定义各种注解 3：配置web.xml 定义MyDisptatch消息分发 4：引入配置，需要从哪个包下进行扫描 5：加载扫描类 6：初始化ioc容器 7：依赖注入 8：映射用户的URL和对应的处理类 首先引入jar包 定义注解 配置web.xml application.propertes scan-package = com.spring 加载application.propertes 根据配置加载class类 初始化IOC
手撸了一个 Spring MVC 框架
公众号：Java后端
09-21 217
想要了解Spring MVC框架的原理，探究框架是如何设计的，不错的学习方式是阅读源码，然后自己手写一个框架。本文带领大家简化的手写一个Spring MVC框架。Spring框架对于Jav...
手撸Spring系列6：Spring MVC（源码篇）
云丶言的博客
09-17 795
说在前头： 笔者本人为大三在读学生，书写文章的目的是为了对自己掌握的知识和技术进行一定的记录，同时乐于与大家一起分享，因本人资历尚浅，发布的文章难免存在一些错漏之处，还请阅读此文章的大牛们见谅与斧正。若在阅读时有任何的问题，也可通过评论提出，本人将根据自身能力对问题进行一定的解答。 手撸Spring系列是笔者本人首次尝试的、较为规范的系列博客，将会围绕Spring框架分为 IOC/DI 思想、 Spring MVC、 AOP 思想、 Spring JDBC 四个模块，并且每个模块都会分为 理论篇、 源码篇.
手撸Spring系列7：Spring MVC（实战篇）
云丶言的博客
09-18 1268
说在前头： 笔者本人为大三在读学生，书写文章的目的是为了对自己掌握的知识和技术进行一定的记录，同时乐于与大家一起分享，因本人资历尚浅，发布的文章难免存在一些错漏之处，还请阅读此文章的大牛们见谅与斧正。若在阅读时有任何的问题，也可通过评论提出，本人将根据自身能力对问题进行一定的解答。 手撸Spring系列是笔者本人首次尝试的、较为规范的系列博客，将会围绕Spring框架分为 IOC/DI 思想、 Spring MVC、 AOP 思想、 Spring JDBC 四个模块，并且每个模块都会分为 理论篇、 源码篇.
手写SpringMVC
02-14
根据SpringMVC底层实现原理，手写SpringMVC框架，并进行简单的Controler层测试
手动模拟springMVC
11-04
手动的模拟springMVC，让你对springMVC理解的更加深刻。具体的实现逻辑可以参考本人的博客。
Idea创建spring+springMVC+mybatis+jsp项目
小石潭记丶
05-15 2409
1.创建maven项目。 选择本地安装的maven和对应的setting.xml。 如果没有配置archetypeCatalog这个参数，在maven生成骨架的时候将会非常慢，有时候直接卡住。archetypeCatalog表示插件使用的archetype元数据，不加这个参数时默认为remote，local，即中央仓库archetype元数据，由于中央仓库的archetype太多了所以导致很慢，指定internal来表示仅使用内部元数据。 2.pom.xml添加依赖 <d
从MVC原理开始手敲一个MVC框架，带你体会当大神的乐趣
公众号-老炮说Java
03-08 272
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达关注公众号后台回复pay或mall获取实战项目资料+视频作者：weixin_39751679blog.csdn.net/weixi...
携程Java架构师手把手教你手写SpringMVC，剑指优秀开源框架灵魂
jjc4261的博客
04-06 134
每一次请求将会调用doGet或doPost方法，所以统一运行阶段都放在doDispatch方法里处理，它会根据url请求去HandlerMapping中匹配到对应的Method，然后利用反射机制调用Controller中的url对应的方法，并得到结果返回。由于文章的篇幅原因，在这就不写手写SpringMVC的的代码展示了，当然为了方便大家学习，在这里还是免费分享一下这位大咖的手写SpringMVC视频给大家，提供大家学习观看，有需要的朋友希望能得到你们的转发关注支持一下！
手写简易版SpringMVC（避免死记硬背八股文）
hongs468的博客
09-13 507
1.在把一个``JavaWeb``程序打成``war``包丢入``Tomcat``后，当启动``Tomcat``时，它就会先去加载``web.xml``文件 2.而加载``web.xml``文件时，会碰到``DispacherServlet``需要被加载，所以又会去加载它，当加载``DispacherServlet``时，其实本质上会把``SpringMVC``的组件初始化（执行``init``方法），然后将所有``Controller``的URL资源都映射到一个容器中存储。
手撸Spring系列5：Spring MVC（理论篇）
云丶言的博客
09-15 836
说在前头： 笔者本人为大三在读学生，书写文章的目的是为了对自己掌握的知识和技术进行一定的记录，同时乐于与大家一起分享，因本人资历尚浅，发布的文章难免存在一些错漏之处，还请阅读此文章的大牛们见谅与斧正。若在阅读时有任何的问题，也可通过评论提出，本人将根据自身能力对问题进行一定的解答。 手撸Spring系列是笔者本人首次尝试的、较为规范的系列博客，将会围绕Spring框架分为 IOC/DI 思想、 Spring MVC、 AOP 思想、 Spring JDBC 四个模块，并且每个模块都会分为 理论篇、 源码篇.
【redis】Spring之RedisTemplate配置与使用
最新发布
05-30 331
转载：Spring之RedisTemplate配置与使用用过redis，但直接使用Jedis进行相应的交互操作，现在正好来看一下RedisTemplate是怎么实现的，以及使用起来是否更加便利。
手写springmvc
09-06
- *1* [手写 springmvc](https://download.csdn.net/download/knight_black_bob/10207699)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值