手撕SpringMVC简单版

手撕阿里 Spring 框架:AOP、IOC、注解、事务,带你统统拿下 前言 Spring 框架自 2002 年诞生以来一直备受开发者青睐,它包括 SpringMVC、SpringBoot、Spring Cloud、Spring Cloud Dataflow 等解决方案。有人亲切的称之为:Spring 全家桶。 很多研发人员把 spring 看作心目中最好的 java 项目,没有之一。所以这是重点也是难点,工作中必须会,面试时肯定考。那么,花费 10 分钟,由阿里一线架构师,带你梳理 Spring 框架相关知识。 以下所整理的 Spring 相关面试题(含答案)、Spr 阅读详情

文章目录,里面的类都有详细的注释

 

1、创建过程与文件目录

1.1、创建Maven工程

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2、pom依赖与配置文件

2.1、pom依赖

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zhz</groupId>
    <artifactId>simulation-springmvc</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>simulation-springmvc Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.5</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.1</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>simulation-springmvc</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95

2.2、springmvc配置类

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <!--配置创建容器时要扫描的包-->
    <component-scan base-package="com.zhz.controller,com.zhz.service"></component-scan>
</beans>
  • 1
  • 2
  • 3
  • 4
  • 5

2.3、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>DispatcherServlet</servlet-name>
    <servlet-class>com.zhz.springmvc.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!--Web服务器一旦启动,Servlet就会实例化创建对象,然后初始化(预备创建对象)-->
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

3、实体类(User)

实体类:User.java

package com.zhz.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author :zhz
 * @date :Created in 2021/01/04
 * @version: V1.0
 * @slogan: 天下风云出我辈,一入代码岁月催
 * @description: 实体类
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
   private Integer id;
   private String name;
   private String password;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

4、控制器(UserController)

package com.zhz.controller;

import com.zhz.bean.User;
import com.zhz.service.UserService;
import com.zhz.springmvc.annotation.Autowired;
import com.zhz.springmvc.annotation.Controller;
import com.zhz.springmvc.annotation.RequestMapping;
import com.zhz.springmvc.annotation.ResponseBody;

/**
 * @author :zhz
 * @date :Created in 2021/01/03
 * @version: V1.0
 * @slogan: 天下风云出我辈,一入代码岁月催
 * @description: 控制器
 **/
@Controller
public class UserController {

    @Autowired(value = "userService")
    private UserService userService;

    @RequestMapping("/listUsers")
    public String listUsers(){
        userService.listUsers();
        return "forward:/success.jsp";
    }

    @RequestMapping("/getData")
    @ResponseBody  //返回json格式的数据
    public User getData(){
        //调用服务层
        return userService.getUser();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

5、业务处理类与实现类(UserService,UserServiceImpl)

package com.zhz.service;

import com.zhz.bean.User;

/**
 * @author :zhz
 * @date :Created in 2021/01/03
 * @version: V1.0
 * @slogan: 天下风云出我辈,一入代码岁月催
 * @description:
 **/
public interface UserService {
    void listUsers();

    User getUser();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
package com.zhz.service.impl;

import com.zhz.bean.User;
import com.zhz.service.UserService;
import com.zhz.springmvc.annotation.Service;

/**
 * @author :zhz
 * @date :Created in 2021/01/03
 * @version: V1.0
 * @slogan: 天下风云出我辈,一入代码岁月催
 * @description:
 **/
@Service("userService")
public class UserServiceImpl implements UserService {

    @Override
    public void listUsers() {
        System.out.println("===调用===UserServiceImpl===listUser===");
    }

    @Override
    public User getUser() {
        return new User(1,"zhz","123456");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

6、手撕mvc具体代码

6.1、核心annotation注解

package com.zhz.springmvc.annotation;

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

/**
 * @Retention注解表示Annotation的保留策略 RetentionPolicy.Class:运行时不保留,不可以通过反射读取。
 * RetentionPolicy.RUNTIME:运行是保留,可以通过反射读取。
 * RetentionPolicy.SOURCE:丢弃。
 */
@Target(value = ElementType.FIELD)  //作用在属性上
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Autowired {
    String value();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
package com.zhz.springmvc.annotation;

import java.lang.annotation.*;


@Target(ElementType.TYPE)  //  //作用在类上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Controller {

    String value() default "";
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
package com.zhz.springmvc.annotation;

import java.lang.annotation.*;


@Target(ElementType.METHOD)    //作用在方法上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestMapping {

    String value() default "";
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
package com.zhz.springmvc.annotation;

import java.lang.annotation.*;

/**
 * @BelongsProject: SpringMvc
 */
@Target(ElementType.METHOD)    //作用在方法上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ResponseBody {
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
package com.zhz.springmvc.annotation;

import java.lang.annotation.*;

/**
 * @Description: 自定义注解
 */
@Target(ElementType.TYPE)  //作用在类上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {

    String value();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

6.2、context上下文(SpringMVC容器)

package com.zhz.springmvc.context;

import com.zhz.springmvc.annotation.Autowired;
import com.zhz.springmvc.annotation.Controller;
import com.zhz.springmvc.annotation.Service;
import com.zhz.springmvc.xml.XmlParse;

import java.io.File;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author :zhz
 * @date :Created in 2021/01/03
 * @version: V1.0
 * @slogan: 天下风云出我辈,一入代码岁月催
 * @description: SpringMVC容器
 **/
public class WebApplicationContext {

    //classpath:springmvc.xml
    String contextConfigLocation;

    //定义集合  用于存放 bean 的权限名|包名.类名
    List<String> classNameList = new ArrayList<>();

    //创建Map集合用于扮演IOC容器:  key存放bean的名字   value存放bean实例
    public Map<String, Object> iocMap = new ConcurrentHashMap<>();

    public WebApplicationContext() {
    }

    public WebApplicationContext(String contextConfigLocation) {
        this.contextConfigLocation = contextConfigLocation;
    }

    /**
     * 初始化Spring容器
     */
    public void onRefresh() {
        //1、进行解析spring mvc配置文件操作  ==》 com.zhz.controller,com.zhz.service
        String basePackage = XmlParse.getBasePackage(contextConfigLocation.split(":")[1]);
        //通过","来分割com.zhz.controller,com.zhz.service 获得对应的包名
        String[] packs = basePackage.split(",");
        //2、进行包扫描
        for (String pack : packs) {
            executeScanPackage(pack);
        }
        //3、实例化容器中的bean
        executeInstance();

        //4、进行自动注入操作
        executeAutowired();
    }

    /**
     * 进行包扫描
     *
     * @param pack
     */
    private void executeScanPackage(String pack) {
        //1、把com.zhz.controller====>com/zhz/controller   com.zhz.service====>com/zhz/controller
        URL url = this.getClass().getClassLoader().getResource("/" + pack.replaceAll("\\.", "/"));
        String path = url.getFile();
        //2、/com/zhz/service
        File dir = new File(path);
        for (File file : dir.listFiles()) {
            if (file.isDirectory()) {//说明是com.zhz.service.impl层
                executeScanPackage(pack + "." + file.getName());
            } else {
                //文件目录下文件  获取全路径   UserController.class  ==> com.zhz.controller.UserController
                String className = pack + "." + file.getName().replaceAll(".class", "");
                classNameList.add(className);
            }
        }

    }

    /**
     * 实例化容器
     */
    private void executeInstance() {
        try {
            // com.zhz.controller.UserController      com.zhz.service.impl.UserServiceImpl
            for (String className : classNameList) {
                Class<?> clazz = Class.forName(className);
                if (clazz.isAnnotationPresent(Controller.class)) {
                    //控制层的bean,得到类的简写名称也就是UserController
                    String beanName = clazz.getSimpleName().substring(0, 1).toLowerCase()+clazz.getSimpleName().substring(1);//首位变为小写
                    iocMap.put(beanName, clazz.newInstance());
                } else if (clazz.isAnnotationPresent(Service.class)) {
                    //Service层,主要是为了获得他的value
                    Service service = clazz.getAnnotation(Service.class);
                    String beanName = service.value();
                    iocMap.put(beanName, clazz.newInstance());
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }

    /**
     * 进行自动注入操作
     */
    private void executeAutowired() {
        try {
            //从容器中取出bean,然后判断bean中是否有属性上使用Autowired,如果使用了该注解,就需要进行自动注入操作
            for (Map.Entry<String, Object> entry : iocMap.entrySet()) {
                //取出容器中的bean
                Object bean = entry.getValue();
                //从bean中获取属性
                Field[] fields = bean.getClass().getDeclaredFields();
                for (Field field : fields) {
                    if (field.isAnnotationPresent(Autowired.class)) {
                        //获取注解中的value值,该值是bean的name
                        Autowired autowired = field.getAnnotation(Autowired.class);
                        String beanName = autowired.value();
                        ;
                        //取消检查机制
                        field.setAccessible(true);
                        field.set(bean, iocMap.get(beanName));
                    }
                }
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139

6.3、映射处理(url与ccontroller之间的映射)

package com.zhz.springmvc.handler;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.lang.reflect.Method;

/**
 * @author :zhz
 * @date :Created in 2021/01/04
 * @version: V1.0
 * @slogan: 天下风云出我辈,一入代码岁月催
 * @description:
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class HandlerMapping {

    //请求URL地址
    private String url;
    //控制器
    private Object controller;
    //控制器的方法
    private Method method;
}

6.4、前端处理器

package com.zhz.springmvc.servlet;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.zhz.springmvc.annotation.Controller;
import com.zhz.springmvc.annotation.RequestMapping;
import com.zhz.springmvc.annotation.ResponseBody;
import com.zhz.springmvc.context.WebApplicationContext;
import com.zhz.springmvc.handler.HandlerMapping;

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.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @author :zhz
 * @date :Created in 2021/01/03
 * @version: V1.0
 * @slogan: 天下风云出我辈,一入代码岁月催
 * @description: 前端控制器
 **/
public class DispatcherServlet extends HttpServlet {

    //指定SpringMvc容器
    private WebApplicationContext webApplicationContext;
    //创建集合,用于存放映射关系、映射地址与控制器.方法,用于发送请求直接从该集合中进行匹配
    List<HandlerMapping> handList = new ArrayList<>();

    @Override
    public void init() throws ServletException {
        //1、从web.xml中获得加载初始化参数contextConfigLocation的值classpath:springmvc.xml
        String configLocation = this.getServletConfig().getInitParameter("contextConfigLocation");
        //2、创建SpringMVC容器
        webApplicationContext = new WebApplicationContext(configLocation);

        //3、进行初始化操作
        webApplicationContext.onRefresh();

        //4、初始化请求映射关系   /findUser   ===》控制器.方法
        initHandlerMapping();
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //进行请求分发处理
        doDispatcher(request, response);
    }


    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }

    /**
     * 初始化请求映射关系(获取链接地址0
     */
    private void initHandlerMapping() {
        //遍历map, key存放bean的名字   value存放bean实例
        for (Map.Entry<String, Object> entry : webApplicationContext.iocMap.entrySet()) {
            //获得bean的class类型
            Class<?> clazz = entry.getValue().getClass();
            if (clazz.isAnnotationPresent(Controller.class)) {
                //获取bean中所有的方法,为这些方法建立映射关系
                Method[] methods = clazz.getDeclaredMethods();
                for (Method method : methods) {
                    if (method.isAnnotationPresent(RequestMapping.class)) {
                        RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
                        //获取注解中的值
                        String url = requestMapping.value();
                        //建立映射地址,与控制器 方法
                        HandlerMapping handlerMapping = new HandlerMapping(url, entry.getValue(), method);
                        handList.add(handlerMapping);
                    }
                }
            }
        }
    }

    /**
     * 进行请求分发处理
     *
     * @param request
     * @param response
     */
    private void doDispatcher(HttpServletRequest request, HttpServletResponse response) {
        try {
            //根据用户的请求地址(/listUsers)查找Controller
            HandlerMapping handlerMapping = getHandler(request);

            if (handlerMapping == null) {
                response.getWriter().print("<h1>404 NOT  FOUND!</h1>");
            } else {
                //调用处理方法之前 进行参数的注入

                //调用目标方法---》获得方法的返回值类型
                Object result = handlerMapping.getMethod().invoke(handlerMapping.getController());
                if (result instanceof String){
                    //跳转到JSP中
                    String viewName = (String)result;
                    //forward:/success.jsp重定向
                    if (viewName.contains(":")){
                        String viewType=viewName.split(":")[0];//也就是forward或者redirect
                        String viewPage=viewName.split(":")[1];//跳转的页面
                        if (viewType.equals("forward")){//请求转发
                            request.getRequestDispatcher(viewPage).forward(request,response);
                        }else{//重定向
                            response.sendRedirect(viewPage);
                        }
                    }else{
                        //默认请求转发
                        request.getRequestDispatcher(viewName).forward(request,response);
                    }
                }else{
                    //返回JSON格式数据
                    Method method=handlerMapping.getMethod();
                    if (method.isAnnotationPresent(ResponseBody.class)){
                        //将返回值转换成 json格式数据
                        ObjectMapper objectMapper = new ObjectMapper();
                        String json = objectMapper.writeValueAsString(result);
                        response.setContentType("text/html;charset=utf-8");
                        PrintWriter writer= response.getWriter();
                        writer.print(json);
                        writer.flush();
                        writer.close();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (ServletException e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据用户请求查找对应的Handler======>获取请求对应的handler(也就是从handList中取出)
     *
     * @param request
     * @return
     */
    private HandlerMapping getHandler(HttpServletRequest request) {
        String requestURI = request.getRequestURI();
        for (HandlerMapping handlerMapping : handList) {
            //从容器的Handle取出URL  和  用户的请求地址进行匹配,找到满足条件的Handler(controller)
            if (handlerMapping.getUrl().equals(requestURI)) {
                return handlerMapping;
            }
        }
        return null;
    }

}

6.5、解析XML

package com.zhz.springmvc.xml;

import lombok.val;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.io.InputStream;

/**
 * @author :zhz
 * @date :Created in 2021/01/04
 * @version: V1.0
 * @slogan: 天下风云出我辈,一入代码岁月催
 * @description: 解析spring mvc.xml
 **/
public class XmlParse {

    public static String getBasePackage(String xml){
        try {
            SAXReader saxReader=new SAXReader();
            // 通过reader对象的read方法加载spring mvc.xml文件,获取docuemnt对象。
            InputStream inputStream = XmlParse.class.getClassLoader().getResourceAsStream(xml);
            Document document = saxReader.read(inputStream);
            // 通过document对象获取根节点beans
            Element rootElement = document.getRootElement();
            // 通过element对象的返回给定本地名称和任何名称空间的第一个元素
            Element componentScan = rootElement.element("component-scan");
            //返回componentScan的参数
            Attribute attribute = componentScan.attribute("base-package");
            //返回base-package的值
            String basePackage = attribute.getText();
            return basePackage;
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return "";
    }
}

7、前端页面

7.1、index.jsp

<html>
<body>
<h2>Hello World!</h2>
</body>
</html>

7.2、succes.jsp

<html>
<body>
<h2>Hello World!</h2>
   跳转至success.jsp页面
</body>
</html>
SpringMVC手撕源码重写第一篇看懂SpringMVC的设计 前言 今年今年的金三银四确实受到很大影响,但是说实话,作为Java程序开发工程师,工作3~5年之后一定要开始看源码,只有通过学习它的源码设计,然后接全盘接受他的设计思想,然后作为自己的消化,消化完成之后作为自己的实力,然后通过自己的工作中的那个项目重构或者说是项目开发,能够很好的运用这些思想,能够很提升,很大的提升你的工程化能力。 下面就是说我这一个系列就主要讲解的是我如何通过spring源码。然后来重新写一遍自己实现的这个spring mvc的源码,在一个系列的课程通过学习,通过分享。不仅是帮助了你, 阅读详情

相关推荐

VisionMaster SDK C#二次开发核心技术指南

以下是基于**VisionMaster SDK C#二次开发核心技术指南**,结合实战案例与关键代码解析,帮助开发者快速掌握工业视觉应用集成。

东城十三 3066

requests.exceptions.SSLError: HTTPSConnectionPool(host='xxx'): Max retries exceeded with url

Python_Err:request请求报错日志 Traceback (most recent call last): File "&lt;stdin&gt;", line 1, in &lt;module&gt; File "C:\Python27\lib\site-packages\requests\api.py", line 75, in get return request...

Delphinidae 1万+

基于Matlab-Simulink的大林算法控制系统设计与振铃消除实验

本文详细介绍了基于Matlab-Simulink的大林算法控制系统设计与振铃消除实验。通过分析纯滞后系统的控制难题,探讨大林算法在工业控制中的应用优势,并提供Matlab-Simulink环境搭建、控制器D(z)设计、振铃消除及仿真实验的完整流程。文章还对比了大林算法与PID控制的性能差异,为工程实践提供参考。

dropout6artist的博客 798

网络请求之urllib库

# 另一种方法: # quote( ) 和 unquote( ) from urllib import parse url = 'https://www.baidu.com/s?wd=中国' #quote()将字符串进行编码 str2 = parse.quote(str1) print(str2) # >>&gt...

u014490943的博客 5419

Abel逆变换及其求解方法

Abel逆变换常应用在轴对称的、光学薄的火焰、羽流或等离子体重建。

weixin_49783507的博客 8382

超声信号处理——硬件电路中的混频应用

本文介绍了超声多普勒系统的信号处理原理。系统通过波形振荡器产生高频信号,经换能器转换为超声波发射,接收反射信号后与原始信号混频,利用三角函数的积化和差特性产生包含多普勒频移的低频差频信号和高频和频信号。通过低通滤波器滤除高频成分后,即可获得纯净的多普勒信号。这种处理方法将MHz级高频信号转换为可听低频信号,降低了系统复杂度与成本。数学推导表明,差频信号频率正好

fcxgfdjy的博客 1125

欲先攻其事必先利其器 (第三方资源篇)

一:源代码实例 1:快速搭建项目源代码 地址:https://github.com/wujunyang/MobileProject 2:高仿美团iOS版 地址:https://github.com/lookingstars/meituan 3:模仿网易新闻做的精仿网易新闻 地址:https://github.com/dsxNiubility/SXNews

毛文豪的博客 6971

电动汽车远程监控与诊断软件:BMW ConnectedDrive EV远程监控二次开发_7.数据安全与隐私保护

数据加密是保护数据安全的重要手段之一。在电动汽车远程监控与诊断软件中,加密技术可以确保数据在传输过程中的安全性和完整性。常见的加密技术包括对称加密和非对称加密。

zhubeibei168的博客 886

了解URL编码与解码

了解URL编码与解码   通常如果一样东西需要编码,说明这样东西并不适合传输。原因多种多样,如Size过大,包含隐私数据,对于Url来说,之所以要进行编码,是因为Url中有些字符会引起歧义。 例如Url参数字符串中使用key=value键值对这样的形式来传参,键值对之间以&amp;符号分隔,如/s?q=abc&amp;ie=utf-8。如果你的value字符串中包含了=或者&am...

u012851078的博客 588

流媒体之LL-HLS 低延时HLS协议

LL-HLS协议通过扩展了HLS协议,为实时直播场景提供了更丰富的功能,如延迟控制、播放列表增量更新、阻止播放列表重新加载等。同时客户端可以更灵活地控制播放列表的加载和播放,以适应各种场景和需求。LL-HLS在直播中的延时可以控制在3s内, 但是即使这样, 还是不如RTMP, RTSP等协议的实时性。

技术控的笔记 3368

使用LSTM实现自动调制识别(RML2018.01a)

目录一、LSTM的代码实现1.1 导入包1.2 数据读取及数据集划分1.3 数据预处理1.4 构建LSTM模型 本文基于RML2018.01a大型数据集,给出LSTM的信号识别的实现方式(附代码) RML2018.01a数据集信息如下: 模型 传送门 CNN/ResNet 使用CNN/ResNet实现自动调制识别(RML2018.01a) LSTM 使用LSTM实现自动调制识别(RML2018.01a)) 一、LSTM的代码实现 1.1 导入包 import numpy as np

QAQIknow的博客 6124

常访问的网址网站

bookmark 常用网站 -->  感谢您的注册 - 博客园       http://home.cnblogs.com/blog/ 新的博客地址        http://www.w3school.com.cn/index.html  在w3school,你可以找到你所需要的所有的网站建设教程。        http://tieba.baidu.com/club/10262790

carl2380的专栏 1万+

YOLO11涨点优化:知识蒸馏 | 引入FGD(Focal and Global Distillation)蒸馏,让轻量学生模型汲取大模型全局感知力

文章摘要 目标检测模型YOLO11在轻量化部署中存在"全局盲区"问题,即轻量模型感受野不足导致大尺度场景下性能下降。知识蒸馏技术FGD(Focal and Global Distillation)通过双分支机制有效解决这一问题:Focal Distillation分离前景背景特征,让学生模型聚焦关键区域;Global Distillation传递像素间关系信息,弥补全局感知缺陷。实验表明,FGD可使YOLO11轻量版mAP提升2.5%以上,且不增加推理耗时。本文详细解析了FGD原理,并给出YOLO11上的实

2601_95807009的博客 236

手撕一个简易版springMVC框架

今天我们要介绍的主角就是SpringMVC框架,刚开始玩这个的时候,给我最直接的感觉就是,真好用!

程序员志哥的博客 971

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

SpringMVC原理及手撕源码

目录简介MVC的工作流程手撕源码自定义注解接口方法定义controllerDispacherServlet 简介 使用过spring mvc的小伙伴都知道,mvc在使用的时候,我们只需要在controller上注解上@controller跟@requestMapping(“URL”),当我们访问对应的路径的时候,框架便会帮我们去映射到指定的controller里面的指定方法,那么这一切都是怎么做到的呢?还有我们所传递过去的参数,为什么通过request.getParam就能轻易地 拿到呢?大家都知道mvc的

陆林烽的博客 363

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

学习(顺便手撕)SpringMVC

SpringMVC SpringMVC这么火,要不我们手撕一下吧~ _(¦3」∠)_ 手撕是深层理解框架的必经之路。最近就手撕了一个比较具体而微型的SpringMVC核心功能(只是实现了接受请求时调用的逻辑)。发出来给大家分享分享~ 了解SpringMVC SpringMVC接受用户请求时的调用逻辑顺序如下: 步骤解读: 用户发送请求到前端控制器DispatcherServlet Disp...

龙套的博客 564

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

【手撕Spring源码】深度理解SpringMVC【下】

本文涉及控制器方法执行流程、@ModelAttribute、返回值处理器、MessageConverter、@ResponseBodyAdvice、BeanNameUrlHandlerMapping 与 SimpleControllerHandlerAdapter、RouterFunctionMapping 与 HandlerFunctionAdapter、SimpleUrlHandlerMapping 与 HttpRequestHandlerAdapter、映射器适配器小结、MVC和Tomcat异常处理等

十八岁讨厌编程的博客 1293

SpringMVC | 快速上手SpringMVC

本节讲解了SpringMVC的基本使用

BoBooY的Java学习笔记 3365

手撕spring和springmvc父子容器

一、背景 Spring和SpringMVC是有父子容器关系的,而且正是因为这个才往往会出现包扫描的问题,我们在此来分析和理解Spring和SpringMVC的父子容器关系并且给出Spring和SpringMVC配置文件中包扫描的官方推荐方式。 二、概念理解和知识铺垫 在Spring整体框架的核心概念中,容器是核心思想,就是用来管理Bean的整个生命周期的,而在一个项目中,容器不一定只有一个,Spring中可以包括多个容器,而且容器有上下层关系,目前最常见的一种场景就是在一个项目中引入Spring和Sprin

程序员麦冬的博客(公众号同名) 305

【手撕Spring源码】深度理解SpringMVC【上】

本文涉及DispatcherServlet 、RequestMappingHandlerMapping 、RequestMappingHandlerAdapter、参数解析器、获取参数名、对象绑定与类型转换、@ControllerAdvice 之 @InitBinder、MVC整体理解等内容。

十八岁讨厌编程的博客 1337

SSM之SpringMVC 01 —— SpringMVC原理及概念、Hello SpringMVC 注解版和配置版

系列文章 SSM之SpringMVC 01 — SpringMVC原理及概念、Hello SpringMVC 注解版和配置版 文章目录系列文章1、回顾Servlet2、SpringMVC2.1、什么是SpringMVC2.2 中心控制器2.3、SpringMVC执行原理3、Hello SpringMVC3.1、配置版3.1、注解版小结 1、回顾Servlet 在学习SpringMVC前需要先了解什么是MVC,这部分可以看我另一篇博客 JavaWeb 开发 04 —— JSP(原理、语法、指令、内置对象、

zcy的博客 416

唰唰的手撕一个简单的Spring Mvc 框架

文章目录自定义实现Spring Mvc框架前言具体操作:步骤代码实现环境搭建自定义注解定义service 和 controller代码定义DisPatcherServlet处理器加载配置文件包扫描bean实例化和依赖维护handlerMapper 处理映射器doPost中 处理请求测试代码地址 自定义实现Spring Mvc框架 前言 在使用Spring Mvc时候我们需要配置一个中央处理器DispatcherServlet用于分发请求,根据url查找处理器,然后再根据处理器去处理不同的Url去执行不同的方

. 558

【SpringMVC 笔记】SpringMVC 原理 + 入门项目(xml 配置版 vs 注解版)

SpringMVC1、回顾MVC 源自 狂神说 Java 1、回顾MVC 1.1、什么是MVC MVC是模型(Model)、视图(View)、控制器(Controller)的简写,是一种软件设计规范。 是将业务逻辑、数据、显示分离的方法来组织代码。 MVC主要作用是降低了视图与业务逻辑间的双向偶合。 MVC不是一种设计模式,MVC是一种架构模式。当然不同的MVC存在差异。 Model(模型):数据模型,提供要展示的数据,因此包含数据和行为,可以认为是领域模型或JavaBean组件(包含数据和行为),不过

萌宅鹿的技术小屋 1015

深度分析!深入浅出总结手撕SpringMVC要点,建议收藏

你对SpringMVC了解多少呢?SpringMVC可以说得上是当前最优秀的MVC框架,采用了松散耦合可插拔组件结构,比其他MVC框架更具扩展性和灵活性;为了提高框架的扩展性和灵活性,设计了松耦合可插拔的组件。理解SpringMVC的原理,在面试或工作中都十分的重要。SpringMVC的原理在网络上到处都可以找得到,但是写得都很概括、零散;对应阅读源码经验较少的小伙伴来说,自己去看源码被很多细节所干扰阻碍,不能够很好地抽离出springMVC原理的主线。下面就给大家分享一下LZ整理的有关SpringMVC的

wdj_yyds的博客 356
上一篇: SpringBoot实现身份证实名认证(阿里云实现)
下一篇: 常考集合面试题之Map(四)
爱玛士
博客等级 码龄7年 720粉丝 253原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值