深入理解SpringMVC ---- 手写简化版

最新推荐文章于 2023-05-26 07:45:00 发布
最新推荐文章于 2023-05-26 07:45:00 发布
阅读量165 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37358860/article/details/100156313
版权

目的

为了能够更好的理解SpringMVC,自己动手去实现一个SpringMVC的简化版,能够记忆更加深刻.

整体思路

  1. 配置web.xml文件,配置自己自定义的前端控制器FatDispatcherServlet
  2. 配置自定义配置文件.
  3. 配置Annotation文件,自定义自己注解,这里定义了几个常用的注解,
    @FatController,@FatService,@FatAutowired,@FatRequestMapping,@FatRequestParam
  4. 新建FatDispatcherServlet类,继承HttpServlet,并重写其中的init()方法和doGet()方法.
  5. 在初始化方法中完成配置文件的加载,类的扫描,对象的创建并放到ioc容器中,创建完对象之后进行依赖注入,最后做url路径和对应控制器中的方法映射.
  6. 在doGet()方法中根据url请求路径,做请求分发及参数处理.

具体实现代码

  • 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>FatDispatcherServlet</servlet-name>
    <servlet-class>mvcframework.servlet.FatDispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>application.properties</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>FatDispatcherServlet</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
  
</web-app>
  • 自定义配置文件application.properties (就一行代码,你没看错)
scanPackage=com.fat.demo
  • 自定义注解(五个注解)
package mvcframework.annotation;

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

/**
 * @ClassName FatController
 * @Auther LangGuofeng
 * @Date: 2019/8/28/028 10:43
 * @Description: TODO
 */
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface FatController {
}


package mvcframework.annotation;

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

/**
 * @ClassName FatService
 * @Auther LangGuofeng
 * @Date: 2019/8/28/028 10:46
 * @Description: TODO
 */
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface FatService {
    String value() default "";
}


package mvcframework.annotation;

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

/**
 * @ClassName FatAutowired
 * @Auther LangGuofeng
 * @Date: 2019/8/28/028 11:25
 * @Description: TODO
 */
@Target({ElementType.TYPE,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface FatAutowired {
    String value() default "";
}


package mvcframework.annotation;

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

/**
 * @ClassName FatRequestMapping
 * @Auther LangGuofeng
 * @Date: 2019/8/28/028 12:31
 * @Description: TODO
 */
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface FatRequestMapping {
    String value();
}


package mvcframework.annotation;

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 FatRequestParam {
    String value();
}
  • FatDispatcherServlet(这个类就比较核心了)
package mvcframework.servlet;

import mvcframework.annotation.*;

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.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.net.URL;
import java.util.*;

/**
 * @ClassName FatDispatcherServlet
 * @Auther LangGuofeng
 * @Date: 2019/8/28/028 8:52
 * @Description: TODO
 */
public class FatDispatcherServlet extends HttpServlet {

    //保存application配置文件中的内容
    private Properties contexConfig = new Properties();
    //保存扫描到的类名
    private List<String> classNames = new ArrayList<>();
    //IOC容器
    private Map<String, Object> ioc = new HashMap<>();
    //保存url和Method的对应关系
    private Map<String, Method> handlerMapping = new HashMap<>();


    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //7.调用, 运行阶段
        try {
            doDispatch(req, resp);
        } catch (Exception e) {
            e.printStackTrace();
            resp.getWriter().write("500 Excetion,Detail : " + Arrays.toString(e.getStackTrace()));
        }
    }

    @Override
    public void init(ServletConfig config) throws ServletException {
//      1. 加载配置文件
        doLoadConfig(config.getInitParameter("contextConfigLocation"));
//      2.扫描相关的类
        doScanner(contexConfig.getProperty("scanPackage"));
//      3.初始化扫描到的类,并将它放入IOC容器
        doInstance();
//      4.完成依赖注入
        doAutowired();
//      5.初始化HandlerMapping
        initHandlerMapping();

        System.out.println("Fat Spring framework is init.");
    }

    /**
     * @Author LangGuofeng
     * @Description 请求分发及参数处理
     * @Date  2019/8/30/030 15:22
     * @Param [req, resp]
     * @return void
     **/
    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws IOException, InvocationTargetException, IllegalAccessException {
        //绝对路径
        String url = req.getRequestURI();
        //处理成相对路径
        String contexPath = req.getContextPath();
        url = url.replaceAll(contexPath, "").replaceAll("/+", "/");
        if (!this.handlerMapping.containsKey(url)) {
            resp.getWriter().write("404 Not Found!!!");
            return;
        }

        Method method = this.handlerMapping.get(url);

        //通过反射通过method获取class method.getDeclaringClass()
        String beanName = toLowerFirstCase(method.getDeclaringClass().getSimpleName());

        //从request中获取参数列表
        Map<String, String[]> parameterMap = req.getParameterMap();
        //从method中获取形参列表
        Parameter[] params = method.getParameters();


        Object[] paramValues = new Object[params.length];

        for (int i = 0; i < params.length; i++) {
            Parameter param = params[i];
            Class parameterType = param.getType();
            if (parameterType == HttpServletRequest.class) {
                paramValues[i] = req;
                continue;
            } else if (parameterType == HttpServletResponse.class) {
                paramValues[i] = resp;
                continue;
            } else {
                //获取param上的注解
                Annotation[] annos = param.getAnnotations();

                for (Annotation annotation : annos) {
                    if (annotation instanceof FatRequestParam) {
                        String paramName = ((FatRequestParam) annotation).value();
                        //判断req参数列表中是否包含paramName
                        if (parameterMap.containsKey(paramName.trim())) {
                            String value = Arrays.toString(parameterMap.get(paramName)).replaceAll("\\[|\\]|,", "");
                            System.out.println(value);
                            Object val = convert(parameterType, value);

                            paramValues[i] = val;
                        }
                    }
                }
            }
        }

        method.invoke(ioc.get(beanName), paramValues);
    }

    /**
     * @return java.lang.Object
     * @Author LangGuofeng
     * @Description String 转换成对应类型
     * @Date 2019/8/30/030 10:31
     * @Param [parameterType, value]
     **/
    private Object convert(Class parameterType, String value) {

        Object val = null;


        if (parameterType == Integer.class || parameterType == int.class) {
            val = new Integer(value);
        }

        if (parameterType == String.class) {
            val = value;
        }

        return val;
    }


    /**
     * @return void
     * @Author LangGuofeng
     * @Description 初始化url和method的一对一对应关系
     * @Date 2019/8/28/028 12:01
     * @Param []
     **/
    private void initHandlerMapping() {
        if (ioc.isEmpty()) {
            return;
        }

        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            Class<?> clazz = entry.getValue().getClass();

            if (!clazz.isAnnotationPresent(FatController.class)) {
                continue;
            }

            //保存写在类上面的@FatRequestMapping("/demo")
            String baseUrl = "";
            if (clazz.isAnnotationPresent(FatRequestMapping.class)) {
                FatRequestMapping fatRequestMapping = clazz.getAnnotation(FatRequestMapping.class);
                baseUrl = fatRequestMapping.value();
            }

            //默认获取所有的public方法
            for (Method method : clazz.getMethods()) {

                if (!method.isAnnotationPresent(FatRequestMapping.class)) {
                    continue;
                }

                FatRequestMapping requestMapping = method.getAnnotation(FatRequestMapping.class);
                String url = ("/" + baseUrl + "/" + requestMapping.value()).replaceAll("/+", "/");
                handlerMapping.put(url, method);
                System.out.println("Mapped :" + url + "," + method);
            }
        }
    }

    /**
     * @return void
     * @Author LangGuofeng
     * @Description 依赖注入
     * @Date 2019/8/28/028 11:17
     * @Param []
     **/
    private void doAutowired() {
        if (ioc.isEmpty()) {
            return;
        }

        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            //Declared 所有的, 特定的 字段, 包括private
            Field[] fields = entry.getValue().getClass().getDeclaredFields();
            for (Field field : fields) {
                if (!field.isAnnotationPresent(FatAutowired.class)) {
                    continue;
                }
                FatAutowired autowired = field.getAnnotation(FatAutowired.class);

                //如果用户没有自定义beanName,默认就根据类型注入
                String beanName = autowired.value().trim();
                if ("".equals(beanName)) {
                    //获得接口的类型名,做为key,用来在ioc中取值
                    beanName = field.getType().getName();
                }

                //如果是public以外的修饰符,只要加了@Autowired注解,都要强制赋值
                //反射中叫做暴力赋值
                field.setAccessible(true);

                try {
                    field.set(entry.getValue(), ioc.get(beanName));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * @return void
     * @Author LangGuofeng
     * @Description 初始化为DI做准备
     * @Date 2019/8/28/028 10:24
     * @Param []
     **/
    private void doInstance() {
        if (classNames.isEmpty()) {
            return;
        }

        for (String className : classNames) {
            try {
                Class<?> clazz = Class.forName(className);
                if (clazz.isAnnotationPresent(FatController.class)) {
                    Object instance = clazz.newInstance();
                    String beanName = toLowerFirstCase(clazz.getSimpleName());
                    ioc.put(beanName, instance);
                } else if (clazz.isAnnotationPresent(FatService.class)) {
                    //1.自定义的beanName
                    FatService service = clazz.getAnnotation(FatService.class);
                    String beanName = service.value();
                    //2.默认类名首字母小写
                    if ("".equals(beanName)) {
                        beanName = toLowerFirstCase(clazz.getSimpleName());
                    }

                    Object instance = clazz.newInstance();
                    ioc.put(beanName, instance);

                    //3.根据类型自动赋值
                    for (Class<?> i : clazz.getInterfaces()) {
                        if (ioc.containsKey(i.getName())) {
                            throw new Exception("The " + i.getName() + " is exists!!");
                        }
                        ioc.put(i.getName(), instance);
                    }
                } else {
                    continue;
                }

            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * @return java.lang.String
     * @Author LangGuofeng
     * @Description 首字母大写转小写
     * @Date 2019/8/28/028 10:49
     * @Param [simpleName]
     **/
    private String toLowerFirstCase(String simpleName) {
        char[] chars = simpleName.toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }

    /**
     * @return void
     * @Author LangGuofeng
     * @Description 扫描出相关的类
     * @Date 2019/8/28/028 9:31
     * @Param [scanPackage]
     **/
    private void doScanner(String scanPackage) {
        //scanPackage=com.fat.demo , 存储的是包路径
        //转换为文件路径,实际上就是把 . 替换为 /
        //classpath
        URL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.", "/"));
        File classPath = new File(url.getFile());
        for (File file : classPath.listFiles()) {
            if (file.isDirectory()) {
                doScanner(scanPackage + "." + file.getName());
            } else {
                if (!file.getName().endsWith(".class")) {
                    continue;
                }
                String className = (scanPackage + "." + file.getName().replace(".class", ""));
                classNames.add(className);
            }
        }
    }

    /**
     * @return void
     * @Author LangGuofeng
     * @Description 加载配置文件
     * @Date 2019/8/28/028 9:25
     * @Param [contextConfigLocation]
     **/
    private void doLoadConfig(String contextConfigLocation) {

        //直接从类路径中找到Spring主配置文件所在的路径
        //并且将其读取出来放到properties对象中
        //相当于将配置文件保存到内存中
        InputStream fis = null;
        fis = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);

        try {
            contexConfig.load(fis);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {

            }
        }

    }
}
  • Controller类(简易版,传参的时候一定要使用@FatRequestParam注解)
package com.fat.demo;

import mvcframework.annotation.FatAutowired;
import mvcframework.annotation.FatController;
import mvcframework.annotation.FatRequestMapping;
import mvcframework.annotation.FatRequestParam;

import javax.management.Query;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @ClassName DemoController
 * @Auther LangGuofeng
 * @Date: 2019/8/28/028 12:45
 * @Description: TODO
 */
@FatController()
@FatRequestMapping("demo")
public class DemoController {

    @FatAutowired()
    private IDemoService demoService;

    @FatRequestMapping("query")
    public void query(HttpServletResponse resp, HttpServletRequest req, @FatRequestParam("name")String name) {

        String res = demoService.query(name);

        try {
            resp.getWriter().write(res);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @FatRequestMapping("add")
    public void add(@FatRequestParam("a")int a, @FatRequestParam("b")int b, HttpServletResponse resp){

        int c = a + b;
        String str = a+" + "+b + " = " + c;

        try {
            resp.getWriter().write(str);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}
  • IDemoService
package com.fat.demo;

public interface IDemoService {

    String query(String name);
}
  • DemoServiceImpl
package com.fat.demo;

import mvcframework.annotation.FatService;

/**
 * @ClassName DemoServiceImpl
 * @Auther LangGuofeng
 * @Date: 2019/8/28/028 12:50
 * @Description: TODO
 */
@FatService()
public class DemoServiceImpl implements IDemoService {

    @Override
    public String query(String name) {
        return "The Student name is " + name + ".";
    }

}

注意: 需要注意的一点就是你的FatDispatcherServlet需要继承HttpServlet的话需要引用servlet的api,我这里用的maven构建的项目,如果不是maven构建的自行下个jar包.

  • maven引入servlet-api
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
    </dependency>

总结

每天进步一点点,只要你去做了,就一定会有收获.

TheBiggestMouse
关注
【SpringMVC原理】自己手动开发一个简易版SpringMVC框架
Kaptcha的学习
06-07 277
1 【骨架】项目框架搭建 使用Gradle进行依赖管理 首先在Idea中选择File—>New—>Project，在左侧选择Gradle—>Java，填写一些项目信息，这里名为mini-spring，创建项目完成 之后，在项目上右键New—>Module，在左侧选择Gradle—>Java，ArtifactId填为framework，创建模块完成 重复上面的步骤，创...
spring 原理分析（简化版spring架构）
qq_27081015的博客
05-12 1173
spring 主要分为3个阶段 a:配置阶段 b:初始化阶段 c:运行阶段 配置阶段分为： 配置web.xml ， 编辑配置文件init-pattern，编辑url-pattern ,编辑aop注解接口 初始化阶段分为： 加载init方法加载配置文件（properties or xml） ==》》初始化容器（hashmap）==》》扫描相关的类（配置文件中）==》》通过反射机制将类实例化到容器中 ==》》扫描容器中的实例给没有赋值的自动添加属性（spring中的@Autowired servi
手写spring(简易版)
weixin_33797791的博客
12-17 427
本文版权归 远方的风lyh和博客园共有，欢迎转载，但须保留此段声明，并给出原文链接，谢谢合作，如有错误之处忘不吝批评指正! 理解Spring本质: 　　　　相信之前在使用spring的时候大家都配置web.xml文件、会配置spring，(如下)配置其实就是一个Servlet，DispatcherServlet源码中，它(父类)重写了 HttpServlet接口,所有的请求将交给Di...
自研简易版Spring框架
我不会java的博客
01-28 377
自研简易版Spring框架 自研框架实现SpringIoC、SpringAOP、SpringMVC等功能 项目源码已经上传到GitHub，先点赞在观看养成好习惯 GitHub：https://github.com/Tjoker-cell/simpleframework 必备知识 Spring基础知识 设计模式：单例、工厂、模板方法、代理、责任链等设计模式 注解创建与使用 Java反射机制 JDK动态代理、CGLIB动态代理 lombok插件的使用 项目结构 框架环境搭建 以下环境是我开发自研框架所使用
SpringMVC相比Servlet到底简化了什么
qwe780310的博客
07-24 3084
SpringMVC 1、回顾MVC 1.1 什么是MVC MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。 是将业务逻辑、数据、显示分离的方法来组织代码。 MVC主要作用是降低了视图与业务逻辑间的双向偶合。 MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。 Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不
zyu-springmvc.rar
07-11
首先，让我们深入理解SpringMVC的关键概念： 1. **注解驱动**：在描述中提到，项目使用了自定义的注解来模拟SpringMVC的行为。在SpringMVC中，我们经常使用如@Controller、@RequestMapping、@Autowired等注解来标记...
深入理解SpringMVC工作原理，像大牛一样手写SpringMVC框架
xhbzl的博客
09-06 147
SpringMVC是Spring家族中的元老之一，它是一个基于MVC三层架构模式的Web应用框架，它的出现也一统了JavaWEB应用开发的项目结构，从而避免将所有业务代码都糅合在同一个包下的复杂情况。在该框架中通过把M/Model模型：由等JavaBean构成，主要负责业务逻辑处理。V/View视图：负责向用户进行界面的展示，由等组成。控制器：主要负责接收请求、调用业务服务、根据结果派发页面。SpringMVC贯彻落实了MVC思想，以分层工作的模式，把整个较为复杂的web。
手写springmvc 简易版
10-28
在这个“手写springmvc简易版”项目中，我们有机会深入理解Spring MVC的核心概念和工作原理。下面将详细介绍这个简易版Spring MVC实现中的关键知识点。 1. **DispatcherServlet**：作为Spring MVC的前端控制器，...
手写SpringMVC
03-07
在这个“手写SpringMVC”的项目中，我们将深入理解SpringMVC的工作原理，并尝试使用纯Java代码来实现其核心功能。 1. **URL映射**：在SpringMVC中，请求URL通过DispatcherServlet被拦截，然后根据`@RequestMapping`...
手写简易版SpringMVC，探索SpringMVC原理
06-30
SpringMVC是Spring框架的一个模块，它主要用于构建Web应用程序，实现了模型-视图-控制器（MVC）的设计模式。...通过这个过程，我们可以深入理解SpringMVC的内部机制，为日常开发工作打下坚实的基础。
手写Spring源码（简化版）
最新发布
vincewm的博客
05-26 1768
Spring包下的类、手写@ComponentScan注解、@Component注解、@Autowired注解、@Scope注解、手写BeanDefinition、BeanNameAware、InitializingBean、BeanPostProcessor 、手写AnnotationConfigApplicationContext
spring笔记（精简版）
bintoYu的博客
03-17 454
Spring的核心是控制反转（IoC）和面向切面（AOP） IoC 所谓的IoC：Spring是个大容器，存放着各种各样的bean，以往这些bean是你自己主动去new出来的。有了spring后，所有的bean是通过spring容器来进行生成，因此控制权就由你自己反转到了容器上。 IoC的使用方式： ① 将所有的bean都配置xml中：&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;am
手写一个简易版的Spring框架
endwas
12-26 386
Spring框架很庞大和复杂，为了更好的理解其实现，尝试去模仿其功能手写一个简易版本，暂时只包括简略的几个功能，为了看情况更新。 1. 包含功能 @ComponentScan包体扫描 @Autowire依赖注入 @Scope单例实现 BeanPostProcessor后置处理器 InitializingBean初始化bean接口 BeanNameAware名字资源设置 BeanDefinition定义 SingletonObjects单例池 BeanDefinitionMap池 基于注解配置的Appl.
Spring启动过程(精简版)
luoqy8的博客
12-05 561
项目开放中, spring框架的启动过程是什么样的呢? 以下就简单的概述一下 首先了解一些基本的概念, 1. BeanFactory : spring构建过程中的核心接口, 顶级接口, 主要提供根据beanName获取Bean实例 getBean(String beanName) 方法, 注意: 这个获取Bean实例存在"第一次惩罚"的情况, 即懒加载的问题 2. ApplicationCo
springmvc 最简化配置
07-25 923
一、新建maven webapp项目 http://blog.csdn.net/jxq0816/article/details/76063973 二、pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:sche
Spring Ioc 精简版
Piemon&Anokata的博客
10-25 268
抽象 容器的核心抽象类： BeanFactory：Spring Ioc的核心，即是BeanFactory，它即是我们常说的Spring容器，它负责Bean实例的创建于管理 ApplicationContext：它是BeanFactory子接口，但是添加了更多的企业级功能 功能类： Environment：容器的环境，默认的实现是StandardEnvironment，Environment中...
手写SpringMVC源码（简化版）
凡是过往，皆为序章
09-04 501
目录 SpringMVC流程架构图 项目结构图 项目依赖 具体实现 1. Annotation UVAutowired UVController UVRequestMapping UVResponseBody UVService 2. core MethodHandler 3. servlet 4. Controller User UserSerive 和 User...
Spring MVC 简单介绍
雅客
06-01 806
1.Spring MVC是什么？    springMVC，是spring的一个开源子框架，在spring原有基础上，又提供了web应用的MVC模块，可以简单的把springMVC理解为是spring的一个模块（类似AOP，IOC这样的模块）。2.Spring MVC有什么优点？    简化WEB开发（有Spring的特点，并使用了MVC架构模式的思想，将web层进行职责解耦）。3.Spring ...
面经：Spring
studyForMokey的博客
02-28 423
Spring八股
SpringMVC url-pattern配置详解与实战
本文将深入解析SpringMVC的URL-pattern配置及其原理，并通过示例代码帮助理解。 首先，让我们看下XML配置文件中的关键部分。在`<servlet-mapping>`标签中，`<servlet-name>`元素用于指定Spring MVC的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值