手写 Spring - 详细思路与实践

系统管理员 2021-11-05 09:04 196阅读 0赞

### 手写 Spring - 详细思路与实践 ###

之前的一篇 [手写 Spring][Spring]，这样的文章很多，到处都是，要说真的能简单手写出 Spring MVC 其实不多，因为要理解，记忆，实践才能掌握，这不是一篇博客就能实现的，可能需要两篇。。再说面试的时候，要不要说呢，自己还没底。。自定义命名部分为加 X- 前缀，请自行理解

#### 一、必背思路框架 ####

1、创建项目，准备 Jar 包  
2、properties 和 web.xml  
3、自定义注解（XController，XRequestMapping，XService，XAutowired）  
4、XDispatchServlet（重点）  
（1）继承 HttpServlet，重写 doGet，doPost 方法  
（2）在 doPost 中先用注释，写出思路，7 步  
（3）逐个填写方法

#### 二、思路对应的详细步骤 ####

这里代码有的为图片，建议手敲，需要的话可查看：[手写 Spring][Spring]

##### 1、创建项目，准备 Jar 包 #####

（1）创建项目，个人建议结构：  
![20190808222924595.png][]

（2）需要一个 Jar 包

<dependency>
    	<groupId>javax.servlet</groupId>
    	<artifactId>javax.servlet-api</artifactId>
    	<version>3.1.0</version>
    </dependency>

##### 2、properties 和 web.xml #####

（1）web.xml 配置

> <servlet> 和 一配一对  
> <init-param> 初始化的时候加载 properties 文件  
> <servlet-mapping> 中用 /\*

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9pY29kZS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]  
（2）application.properties 配置要扫描的包名

scan-package=com.xiaopengwei

##### 3、自定义注解 #####

先只定义 4 个注解（XController，XRequestMapping，XService，XAutowired），定义的时候想想使用的地方，用于区别注解的 Target。

> @Target 说明该 Annotation 可以修饰的对象范围  
> @Retention 描述注解的生命周期  
> @Documented 用于描述其它类型的 annotation 被作为被标注的程序成员的公共 API，因此可以被例如 javadoc 此类的工具文档化。Documented 是一个标记注解，没有成员。

@Target({ ElementType.FIELD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface XAutowired { 
        String value() default "";
    }

@Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface XController { 
        String value() default "";
    }

@Target({ ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface XRequestMapping { 
        String value() default "";
    }

@Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface XService { 
        String value() default "";
    }

##### 4、XDispatchServlet #####

**整理思路：**

初始化，启动阶段

> 1、加载配置文件  
> 2、扫描相关的类  
> 3、初始化 IOC 容器  
> 4、依赖注入  
> 5、初始化 HandlerMapping  
> 6、运行时进行匹配

运行，匹配阶段

> 1、处理请求，进行匹配

**（1）继承 HttpServlet，重写 doGet，doPost，init 方法**

提示：IDEA 快捷键，Alt + Insert 和 Ctrl + O 都可以重写方法

> 重写方法，将 deGet 也走 doPost

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9pY29kZS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1]

**（2）在 init 方法中先用注释，写出思路，搭建骨架**

> 1、加载配置文件  
> 2、扫描相关的类  
> 3、初始化 IOC 容器  
> 4、依赖注入  
> 5、初始化 HandlerMapping  
> 6、运行时进行匹配

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9pY29kZS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 2]

**（3）加载配置文件 doLoadConfig()**

在调用时添加参数，注意名称和 web.xml 中的参数名称一致  
![在这里插入图片描述][20190808235132207.png]

/** * 属性配置文件 */
        private Properties contextConfig = new Properties();
    
        /** * servletConfig 参数是 web.xml 中配置的字符串为 application.properties * @param servletConfig servletConfig */
        private void doLoadConfig(String servletConfig) { 
    
            InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(servletConfig);
    
            try { 
                contextConfig.load(resourceAsStream);
            } catch (IOException e) { 
                e.printStackTrace();
            } finally { 
                // InputStream 不会自动关闭
                if (resourceAsStream != null) { 
                    try { 
                        resourceAsStream.close();
                    } catch (IOException e) { 
                        e.printStackTrace();
                    }
                }
            }
    
        }

**（4） 扫描相关的类 doScanner()**

在调用时添加参数，注意名称和 web.xml 中的参数名称一致  
![在这里插入图片描述][20190813223454360.png]

private List<String> classNameList = new ArrayList<>();
    
        /** * 扫描相关的类 * @param scanPackage properties --> scan-package */
        private void doScanner(String scanPackage) { 
    
            // . 转化为 /
            URL resourcePath = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.", "/"));
    
            // 递归结束条件
            if (resourcePath == null) {  return; }
    
            // 或 filePath 对应的 File 对象
            File classPath = new File(resourcePath.getFile());
    
            for (File file : classPath.listFiles()) { 
    
                if (file.isDirectory()) { 
                    // 子目录递归
                    doScanner(scanPackage + "." + file.getName());
                } else { 
                    if (!file.getName().endsWith(".class")) {  continue; }
    
                    // 转换成 com.xiaopengwei.TestController 的形式
                    String className = (scanPackage + "." + file.getName()).replace(".class", "");
                    // 保存在内容
                    classNameList.add(className);
                }
            }
        }

**（5）初始化 IOC 容器 doInstance()**

/** * IOC 容器 */
        Map<String, Object> iocMap = new HashMap<String, Object>();
    
        /** * 初始化 IOC 容器，将所有相关的类实例保存到 IOC 容器中 */
        private void doInstance() { 
            if (classNameList.isEmpty()) {  return; }
    
            try { 
                for (String className : classNameList) { 
    
                    Class<?> clazz = Class.forName(className);
    
                    if (clazz.isAnnotationPresent(XController.class)) { 
                        String beanName = toLowerFirstCase(clazz.getSimpleName());
                        Object instance = clazz.newInstance();
    
                        // 保存在 ioc 容器
                        iocMap.put(beanName, instance);
    
                    } else if (clazz.isAnnotationPresent(XService.class)) { 
    
                        String beanName = toLowerFirstCase(clazz.getSimpleName());
    
                        // 如果注解包含自定义名称, 例如 @Service("testService")
                        XService xService = clazz.getAnnotation(XService.class);
                        if (!"".equals(xService.value())) { 
                            beanName = xService.value();
                        }
    
                        Object instance = clazz.newInstance();
                        iocMap.put(beanName, instance);
    
                        // getInterfaces 此方法返回这个类中实现接口的数组
                        for (Class<?> i : clazz.getInterfaces()) { 
                            if (iocMap.containsKey(i.getName())) { 
                                throw new Exception("The Bean Name Is Exist.");
                            }
                            // 接口不能实例化，接口存实现类的实例
                            iocMap.put(i.getName(), instance);
                        }
                    }
    
                }
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
        /** * 获取类的首字母小写的名称 * * @param className ClassName * @return java.lang.String */
        private String toLowerFirstCase(String className) { 
            char[] charArray = className.toCharArray();
            charArray[0] += 32;
            return String.valueOf(charArray);
        }

**（6）依赖注入 doAutowired()**

/** * 依赖注入 */
        private void doAutowired() { 
            if (iocMap.isEmpty()) {  return; }
    
            for (Map.Entry<String, Object> entry : iocMap.entrySet()) { 
    
                // 获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的生命字段
                Field[] fields = entry.getValue().getClass().getDeclaredFields();
    
                for (Field field : fields) { 
                    if (!field.isAnnotationPresent(XAutowired.class)) { 
                        continue;
                    }
    
                    // 获取注解对应的类
                    XAutowired xAutowired = field.getAnnotation(XAutowired.class);
                    String beanName = xAutowired.value().trim();
    
                    // 获取 XAutowired 注解的值
                    if ("".equals(beanName)) { 
                        beanName = field.getType().getName();
                    }
    
                    // 只要加了注解，都要加载，不管是 private 还是 protect
                    field.setAccessible(true);
    
                    try { 
                        field.set(entry.getValue(), iocMap.get(beanName));
                    } catch (IllegalAccessException e) { 
                        e.printStackTrace();
                    }
                }
            }
        }

**（7）初始化 HandleMapping**

Map<String, Method> handlerMapping = new HashMap<String, Method>();
        
    	/** * 5、初始化 HandlerMapping */
        private void initHandlerMapping() { 
    
            if (iocMap.isEmpty()) {  return; }
    
            for (Map.Entry<String, Object> entry : iocMap.entrySet()) { 
                Class<?> clazz = entry.getValue().getClass();
    
                if (!clazz.isAnnotationPresent(XController.class)) {  continue; }
    
                String baseUrl = "";
    
                if (clazz.isAnnotationPresent(XRequestMapping.class)) { 
                    XRequestMapping xRequestMapping = clazz.getAnnotation(XRequestMapping.class);
                    baseUrl = xRequestMapping.value();
                }
    
                for (Method method : clazz.getMethods()) { 
                    if (!method.isAnnotationPresent(XRequestMapping.class)) {  continue; }
    
                    XRequestMapping xRequestMapping = method.getAnnotation(XRequestMapping.class);
    
                    String url = ("/" + baseUrl + "/" + xRequestMapping.value()).replaceAll("/+", "/");
    
                    handlerMapping.put(url, method);
                }
            }
    
        }

**（8）进行匹配 doDispatch()**

Map<String, Method> handlerMapping = new HashMap<String, Method>();
    
        /** * 5、初始化 HandlerMapping */
        private void initHandlerMapping() { 
    
            if (iocMap.isEmpty()) {  return; }
    
            for (Map.Entry<String, Object> entry : iocMap.entrySet()) { 
                Class<?> clazz = entry.getValue().getClass();
    
                if (!clazz.isAnnotationPresent(XController.class)) {  continue; }
    
                String baseUrl = "";
    
                if (clazz.isAnnotationPresent(XRequestMapping.class)) { 
                    XRequestMapping xRequestMapping = clazz.getAnnotation(XRequestMapping.class);
                    baseUrl = xRequestMapping.value();
                }
    
                for (Method method : clazz.getMethods()) { 
                    if (!method.isAnnotationPresent(XRequestMapping.class)) {  continue; }
    
                    XRequestMapping xRequestMapping = method.getAnnotation(XRequestMapping.class);
    
                    String url = ("/" + baseUrl + "/" + xRequestMapping.value()).replaceAll("/+", "/");
    
                    handlerMapping.put(url, method);
                }
            }
    
        }

提示：[手写 Spring][Spring] 中代码更全

##### 5. 使用与测试 #####

TestController

import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.util.List;
    
    /** * <p> * 前置控制器 * * @author XiaoPengwei * @since 2019-07-19 */
    @XController
    @XRequestMapping("/test")
    public class TestController { 
    
        @XAutowired
        ITestXService testXService;
    
        /** * 测试方法 /test/query * * @param req 请求体 * @param resp 响应体 */
        @XRequestMapping("/query")
        public void query(HttpServletRequest req, HttpServletResponse resp) { 
    
            if (req.getParameter("username") == null) { 
    
                try { 
                    resp.getWriter().write("param username is null");
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            } else { 
    
                String paramName = req.getParameter("username");
    
                try { 
                    resp.getWriter().write("param username is " + paramName);
                } catch (IOException e) { 
                    e.printStackTrace();
                }
    
                System.out.println("[INFO-req] New request param username-->" + paramName);
            }
        }
    
        /** * 测试方法 /test/listClassName * * @param req 请求体 * @param resp 响应体 */
        @XRequestMapping("/listClassName")
        public void listClassName(HttpServletRequest req, HttpServletResponse resp) { 
    
            String str = testXService.listClassName();
    
            System.out.println("testXService----------=-=-=>" + str);
            try { 
                resp.getWriter().write(str);
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    
    
    }

ITestService

public interface ITestXService { 
    
        String listClassName();
    }

TestServiceImpl

@XService
    public class TestXServiceImpl implements ITestXService { 
    
        @Override
        public String listClassName() { 
    
            // 假装来自数据库
    
            return "123456TestXServiceImpl";
        }
    
    }

[Spring]: https://icode.blog.csdn.net/article/details/96505433
[20190808222924595.png]: /images/20211104/575917fd416c4d58894230686df5dbb2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9pY29kZS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]: /images/20211104/2f79474fe3c74fa1be7ec04d01fdd2b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9pY29kZS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1]: /images/20211104/94342bf30b8a41b0a621b1841a8f3662.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9pY29kZS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 2]: /images/20211104/54bd33075ac74a489659dafb7045ac0a.png
[20190808235132207.png]: /images/20211104/47d73baed6164a279b5e064005543a88.png
[20190813223454360.png]: /images/20211104/93d67675cf1f4dcbac5f57b409aabc09.png