SpringMVC 底层机制的简易实现

Posted 2023-02-02 Al_tair

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringMVC 底层机制的简易实现相关的知识，希望对你有一定的参考价值。

SpringMVC 底层机制的简易实现

项目基础

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>

    <!--原生 Servlet-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <!--作用范围-->
        <!--provided：表示该项目在打包放在生产环境的时候不用带上 servlet-api.jar 包-->
        <!--目的: 防止和 tomcat 中该jar冲突-->
        <scope>provided</scope>
    </dependency>

    <!--引入 xml 解析工具-->
    <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>
</dependencies>

配置 xml 文件

mySpringMVC.xml 文件：用来指定扫描包路径

<?xml version="1.0" encoding="utf-8" ?>
<beans>
    <component-scan base-package="com.al_tair"></component-scan>
</beans>

web.xml 文件

指定要操作的 spring 容器配置文件名
配置自动加载
路径全部访问中央控制器

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>MyDispatcherServlet</servlet-name>
    <servlet-class>com.al_tair.servlet.MyDispatcherServlet</servlet-class>
    <!--指定要操作的 spring 容器配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:mySpringMVC.xml</param-value>
    </init-param>
    <!--自动加载-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>MyDispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

开发指南

开发步骤

MyDispatcherServlet 本质就是一个 Servlet ，那么我们就知道他的基本特性，刚启动服务的时候，我们会进行初始化，然后每进行 http 请求，就会访问 Service 方法（这里交给 Servet 的父类来实现，我们只需要实现 doPost 和 doGet 的方法）

1.初始化数据

@Override
public void init(ServletConfig config) throws ServletException 
    // 需要将 config 传给父类，才可以获取工程路径
    super.init(config);
    // 上述 web.xml 文件中指定了该参数为 Spring 容器的文件名 mySpringMVC.xml
    String contextConfigLocation = config.getInitParameter("contextConfigLocation");
    // 分成两步骤进行理解
    // 1.通过 xml 解析获取到该 mySpringMVC.xml 的包路径
    // 2.将该路径进行扫描，生成 ioc 容器
    ioc = new SpringIocApplicationContext(XmlParser.getBasePackage(contextConfigLocation.split(":")[1]));
    // 初始化映射器
    initHandlerMapper();

XmlParser 解析器

public class XmlParser 
    public static String getBasePackage(String fileName)
        // 解析器
        SAXReader saxReader = new SAXReader();
        // 获取到资源路径
        InputStream in = XmlParser.class.getClassLoader().getResourceAsStream(fileName);

        String basePackage = null;
        try 
            Document read = saxReader.read(in);
            // 获取到 component-scan 元素
            Element element = read.getRootElement().element("component-scan");
            // 扫描包路径
            basePackage = element.attribute("base-package").getText();
         catch (Exception e) 
            e.printStackTrace();
        
        return basePackage;

初始化 ioc 容器（我主要介绍实现过程）
1. 获取扫描包的全路径
2. 通过类加载器获取到对应包的资源路径
3. 扫描资源路径，将 java 文件生成的 .class 文件路径保存到 List 集合中
4. 遍历每个 java 文件路径，并进行类加载，通过判断是否有注解（MyController 、MyService、MyMapper、MyComponent）
5. 然后通过注解上的值来获取对应 id（默认方法名首字母小写），并划分单例还是多例（用于判断是否当下就创建对象并放入 ioc 容器中）
6. ioc 容器用于存储 id <=> BeanDefinition对象（属性有 scope、Class对象）
7. singletonObject 单例池用于存储 id <=> 单例对象

初始化映射器

private void initHandlerMapper() 
    // 默认所有映射都是非懒加载的单例池中
    ConcurrentHashMap<String, Object> singletonObject = ioc.getSingletonObject();
    if (singletonObject.isEmpty()) 
        return;
     else 
        for (Map.Entry<String, Object> entry : singletonObject.entrySet()) 
            // 拿到加载的类对应的 Class 类
            Class<?> aClass = entry.getValue().getClass();
            // 判断是否是控制类
            if (aClass.isAnnotationPresent(MyController.class)) 
                // 1.获取类注解值
                String classValue = "";
                // 2.获取类上路径地址
                if (aClass.isAnnotationPresent(MyRequestMapping.class)) 
                    MyRequestMapping annotation = aClass.getAnnotation(MyRequestMapping.class);
                    classValue = annotation.value();
                

                // 3.获取到控制类中的所有方法
                Method[] declaredMethods = aClass.getDeclaredMethods();
                for (Method declaredMethod : declaredMethods) 
                    if (declaredMethod.isAnnotationPresent(MyRequestMapping.class)) 
                        MyRequestMapping MyRequestMappingAnnotation =
                            declaredMethod.getAnnotation(MyRequestMapping.class);
                        // getServletContext().getContextPath()  获取工程路径
                        String url = getServletContext().getContextPath() + classValue
                            + MyRequestMappingAnnotation.value();
                        // 创建 HandlerMapper 对象(用于存储 访问的 url、controller 对象、对应的方法)
                        HandlerMapper handlerMapper =
                            new HandlerMapper(url, entry.getValue(), declaredMethod);
                        // HandlerList 集合用来保存每个能够访问到的对应类的对应方法信息
                        HandlerList.add(handlerMapper);

2.中央控制器 - 分发请求

刚开始讲到了中央控制器本质就是 Servlet，每次请求都会访问 Service，然后分发到对应的请求类型比如 get、post等等

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException 
    // 防止乱码
    req.setCharacterEncoding("utf-8");
    resp.setCharacterEncoding("utf-8");
    // 分发请求
    executeDispatch(req, resp);


@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException 
    this.doGet(req, resp);

分发请求（同时也会接收返回的结果，这个后续讲解）

<!-- 用于获取请求参数名（默认为 args0、args1等）-->
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>3.7.0</version>
  <configuration>
    <source>1.8</source>
    <target>1.8</target>
    <compilerArgs>
      <arg>-parameters</arg>
    </compilerArgs>
    <encoding>utf-8</encoding>
  </configuration>
</plugin>

private void executeDispatch(HttpServletRequest req, HttpServletResponse resp) 
    HandlerMapper handler = getHandler(req);
    // 判断路径是否匹配成功
    if (handler == null) 
        try 
            resp.getWriter().print("<h1>404 not found</h1>");
         catch (IOException e) 
            log.print(e.getMessage());
        
     else 
        // 1.获取请求的方法
        Method method = handler.getMethod();
        // 2.获取请求方法的参数类型列表
        Class<?>[] parameterTypes = method.getParameterTypes();
        // 用于匹配对应方法的参数，可以自动化装配
        Object[] params = new Object[parameterTypes.length];
        // 3.遍历每个参数，并填充数据
        for (int i = 0; i < parameterTypes.length; i++) 
            Class<?> parameterType = parameterTypes[i];
            // 4.获取类型的简单名称，就是类名（原来名称全包名）
            String simpleName = parameterType.getSimpleName();
            if ("HttpServletRequest".equals(simpleName)) 
                params[i] = req;
             else if ("HttpServletResponse".equals(simpleName)) 
                params[i] = resp;
            
        
        // 5.传入的参数的 key - value
        Map<String, String[]> parameterMap = req.getParameterMap();
        // 6.对应方法参数上的信息
        Parameter[] parameters = method.getParameters();
        // 7.遍历方法的每个参数并根据参数名或者注解值来填入数据
        for (int i = 0; i < params.length; i++) 
            if(params[i] == null)
                boolean isMyRequestParam = parameters[i].isAnnotationPresent(MyRequestParam.class);
                // 参数名
                String paramName = "";
                if(isMyRequestParam)
                    paramName = parameters[i].getDeclaredAnnotation(MyRequestParam.class).value();
                else
                    // 注意获取参数名必须添加脚本文件在 pom.xml 中
                    paramName = parameters[i].getName();
                
                for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) 
                    if(paramName.equals(entry.getKey()))
                        // 根据类型来判断是否是数组或者集合等等
                        if("List".equals(parameterTypes[i].getSimpleName()))
                            params[i] = Arrays.asList(entry.getValue());
                        else if(parameterTypes[i].getSimpleName().contains("[]"))
                            params[i] = entry.getValue();
                        else
                            params[i] = entry.getValue()[0];
                        
                        break;
                    
                
            
        
        try 
            // 匹配成功，通过反射来调用对应的类(返回结果暂时就是默认 String 类型)
            Object result = method.invoke(handler.getController(), params);
            // 重定向或者请求转发（视图解析操作）
            viewParser(req,resp,method,result);

         catch (Exception e) 
            log.print(e.getMessage());

3.开发者角度

开发控制层、服务层、Dao层，用于接口的开发等等…

4.视图解析器

主要用于方法调用完之后接下来的操作（重定向、请求转发、或者返回 json 格式数据等等操作）

    <!--引入jackson 使用他的工具类可以进行json操作 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.12.4</version>
    </dependency>

public void viewParser(HttpServletRequest request,HttpServletResponse response,Method method,Object result)
    if(result instanceof String)
        // 返回结果: forward:/200_ok.jsp(例子)
        String res = (String)result;
        if(res.contains(":"))
            String[] split = res.split(":");
            if("forward".equals(split[0]))
                try 
                    request.getRequestDispatcher(split[1]).forward(request,response);
                 catch (Exception e) 
                    System.out.println("请求转发异常" + e.getMessage());
                
            else if("redirect".equals(split[0]))
                try 
                    // 重定向需要获取工程路径
                    response.sendRedirect(getServletContext().getContextPath() + split[1]);
                 catch (IOException e) 
                    System.out.println("重定向异常" + e.getMessage());
                
            
            // 默认请求转发
        else
            try 
                request.getRequestDispatcher(res).forward(request,response);
             catch (Exception e) 简易实现Spring Framework底层机制
 简易实现Spring Framework底层机制
 手写Spring MVC框架 实现简易版mvc框架
 深入底层，仿SpringMVC自己写框架
 java spring的底层机制和原理是啥？
 手动实现一个简易版SpringMvc