用 300 行代码手写提炼 Spring 核心原理 [2]
![用 300 行代码手写提炼 Spring 核心原理 [2]](https://img2024.cnblogs.com/blog/2850366/202409/2850366-20240911162531449-791163230.png)
手写一个 mini 版本的 Spring 框架是一个很好的实践项目，可以让你对框架的核心概念和实现有更深刻的理解。接下来我们从 0-1 逐层深入，一步一步揭开 Spring 的神秘面纱。
系列文章
- 用 300 行代码手写提炼 Spring 核心原理 [1]
- 用 300 行代码手写提炼 Spring 核心原理 [2]
- 用 300 行代码手写提炼 Spring 核心原理 [3]
上文 中我们实现了 mini-spring 的 1.0 版本，接下来我们在此基础上进行优化，将 init() 方法中的代码进行封装。按照之前的思路，先搭建基础框架，再 “填肉注血”。
初始化阶段
init
将 init() 方法中冗长的代码进行模块化拆分：
@Override
public void init(ServletConfig config) throws ServletException {
// 1. 加载配置文件
doLoadConfig(config.getInitParameter("contextConfigLocation"));
// 2. 扫描相关类
doScanner(contextConfig.getProperty("scanPackage"));
// 3. 初始化扫描到的类，并将它们放到IoC容器中
doInstance();
// 4. 依赖注入
doAutowired();
// 5. 初始化handlerMapping
initHandlerMapping();
}
声明全局成员变量，其中 IoC 容器就是注册时单例的具体实例：
// 保存application.properties配置文件中的内容
private Properties contextConfig = new Properties();
// 保存扫描到所有的类名
private List<String> classNames = new ArrayList<>();
// 传说中的IoC容器，我们来揭开它的神秘面纱
// 为了简化程序，暂时不考虑ConcurrentHashMap，主要关注原理和设计思想
private Map<String, Object> IoC = new HashMap<>();
// 保存url -> method的映射关系
private Map<String, Method> handlerMapping = new HashMap<>();
加载配置文件
实现 doLoadConfig() 方法：
/**
* 加载配置文件，本例中配置文件configFileName为application.properties
*/
private void doLoadConfig(String configFileName) {
// 找到Spring主配置文件所在路径
// 读取出来保存到Properties文件中
// 本例中配置文件中的内容只有一行: scanPackage=org.example.minispring
InputStream is = this.getClass().getClassLoader().getResourceAsStream(configFileName);
try {
contextConfig.load(is);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
扫描相关的类
实现 doScanner() 方法：
/**
* 扫描相关的类，本例中scanPackage=org.example.minispring
*/
private void doScanner(String scanPackage) {
// 转换为文件路径，手机上就是把"."替换为"/"
URL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.", "/"));
File classDir = new File(url.getFile());
for (File file : classDir.listFiles()) {
if (file.isDirectory()) {
// 递归扫描子文件夹
doScanner(scanPackage + "." + file.getName());
} else {
// 只需要扫描.class文件
if (!file.getName().endsWith(".class"))
continue;
String clazzName = scanPackage + "." + file.getName().replace(".class", "");
classNames.add(clazzName);
}
}
}
类实例化
实现 doInstance() 方法，原理是通过反射机制将类实例化，保存至 IoC 容器中：
/**
* 初始化扫描到的类，并将它们放到IoC容器中
*
* 本例中IoC容器中的内容如下：
* org.example.minispring.service.IDemoService = org.example.minispring.service.impl.DemoService@c97ae21
* org.example.minispring.service.impl.DemoService = org.example.minispring.service.impl.DemoService@c97ae21
* org.example.minispring.action.DemoAction = org.example.minispring.action.DemoAction@25051c3
*/
private void doInstance() {
if (classNames.isEmpty())
return;
try {
for (String className : classNames) {
Class<?> clazz = Class.forName(className);
// 什么类需要实例化呢?
// 加了注解的类需要实例化, 本例中需要实例化@MyController, @MyService注解的类
if (clazz.isAnnotationPresent(MyController.class)) {
Object instance = clazz.newInstance();
String beanName = clazz.getName();
IoC.put(beanName, instance);
} else if (clazz.isAnnotationPresent(MyService.class)) {
// 自定义的beanName
MyService service = clazz.getAnnotation(MyService.class);
String beanName = service.value();
if ("".equals(beanName.trim())) {
beanName = clazz.getName();
}
Object instance = clazz.newInstance();
IoC.put(beanName, instance);
// 根据接口类型自动赋值
for (Class<?> i : clazz.getInterfaces()) {
if (IoC.containsKey(i.getName())) {
throw new Exception("The '" + i.getName() + "' already exists!");
}
// 把接口的类型直接当做key
IoC.put(i.getName(), instance);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
依赖注入
进行依赖注入，实现 doAutowired() 方法：
/**
* 完成依赖注入
*/
private void doAutowired() {
if (IoC.isEmpty())
return;
for (Entry<String, Object> entry : IoC.entrySet()) {
// 获取所有的字段，包括public, private, protected, default类型的
Field[] fields = entry.getValue().getClass().getDeclaredFields();
for (Field field : fields) {
if (!field.isAnnotationPresent(MyAutowired.class))
continue;
MyAutowired autoWired = field.getAnnotation(MyAutowired.class);
// 如果用户没有定义beanName，默认就根据类型注入
String beanName = autoWired.value().trim();
if ("".equals(beanName)) {
beanName = field.getType().getName();
}
// 如果是public之外的类型，只要加了@MyAutowired注解都要强制赋值
// 反射中叫做暴力访问
field.setAccessible(true);
try {
// 用反射机制动态给字段赋值
// 赋值后DemoAction.demoService = org.example.minispring.service.impl.DemoService@c97ae21
// 也即DemoService实例被注入到了DemoAction对象中，此谓之依赖注入
field.set(entry.getValue(), IoC.get(beanName));
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
初始化 handlerMapping
实现 initHandlerMapping() 方法，这里应用到了策略模式：
/**
* 初始化HandlerMapping
*
* 本例中handlerMapping中的内容是：
* /demo/query = org.example.minispring.action.DemoAction.query(HttpServletRequest, HttpServletResponse, String)
*/
private void initHandlerMapping() {
if (IoC.isEmpty())
return;
for (Entry<String, Object> entry : IoC.entrySet()) {
Class<?> clazz = entry.getValue().getClass();
if (!clazz.isAnnotationPresent(MyController.class))
continue;
String baseUrl = "";
if (clazz.isAnnotationPresent(MyRequestMapping.class)) {
MyRequestMapping requestMapping = clazz.getAnnotation(MyRequestMapping.class);
baseUrl = requestMapping.value();
}
// 解析@MyController中方法上的@MyRequestMapping注解
Method[] methods = clazz.getMethods();
for (Method method : methods) {
if (!method.isAnnotationPresent(MyRequestMapping.class)) {
continue;
}
MyRequestMapping requestMapping = method.getAnnotation(MyRequestMapping.class);
// 组合方法签名上的完整url，正则替换是为防止路径中出现多个连续多个"/"的不规范写法
String url = (baseUrl + "/" + requestMapping.value()).replaceAll("/+", "/");
// 保存url -> method的对应关系
handlerMapping.put(url, method);
System.out.println("Mapped " + url + " -> " + method);
}
}
}
到这里初始化工作完成，接下来实现运行的逻辑。
运行阶段
首先看 doPost() 和 doGet() 方法的代码：
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doPost(req, resp);
}
@Override
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
try {
doDispatch(req, resp);
} catch (Exception e) {
e.printStackTrace();
resp.getWriter().write("500 Exception " + Arrays.toString(e.getStackTrace()));
}
}
核心逻辑在 doDispatch() 方法中实现，其中用到了委派模式的思想：
private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
String url = req.getRequestURI();
String contextPath = req.getContextPath();
url = url.replace(contextPath, "").replaceAll("/+", "/");
if (!this.handlerMapping.containsKey(url)) {
resp.getWriter().write("404 Not Found");
return;
}
// 根据url找到对应的方法
// 例如url(/demo/query)对应的method为
// org.example.minispring.action.DemoAction.query(HttpServletRequest, HttpServletResponse, String)
Method method = (Method) this.handlerMapping.get(url);
// 获取请求参数, 此处为: name = [watermark]
Map<String, String[]> parameterMap = req.getParameterMap();
// 1. method.getDeclaringClass().getName(): beanName, 此处为org.example.minispring.action.DemoAction
// 2. IoC.get(beanName): 根据beanName获取到对应的bean实例:org.example.minispring.action.DemoAction@51e3ce14
// 3. method.invoke调用的就是org.example.minispring.action.DemoAction@51e3ce14.query(req, resp, name)
String beanName = method.getDeclaringClass().getName();
method.invoke(IoC.get(beanName), new Object[] { req, resp, parameterMap.get("name")[0] });
}
在以上代码中，doDispatch() 虽然完成了动态委派并进行了反射调用，但是对 url 参数的处理还是静态的，即只能对 "name" 参数做解析。要实现 url 参数的动态获取，还有些工作要做，我们继续优化 doDispatch() 方法的实现：
private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
String url = req.getRequestURI();
String contextPath = req.getContextPath();
url = url.replace(contextPath, "").replaceAll("/+", "/");
if (!this.handlerMapping.containsKey(url)) {
resp.getWriter().write("404 Not Found");
return;
}
// 根据url找到对应的方法
// 例如url(/demo/query)对应的method为
// org.example.minispring.action.DemoAction.query(HttpServletRequest, HttpServletResponse, String)
Method method = (Method) this.handlerMapping.get(url);
// 获取请求参数, 此处为: name = [watermark]
Map<String, String[]> parameterMap = req.getParameterMap();
// 1. method.getDeclaringClass().getName(): beanName, 此处为org.example.minispring.action.DemoAction
// 2. IoC.get(beanName): 根据beanName获取到对应的bean实例:org.example.minispring.action.DemoAction@51e3ce14
// 3. method.invoke调用的就是org.example.minispring.action.DemoAction@51e3ce14.query(req, resp, name)
// String beanName = method.getDeclaringClass().getName();
// method.invoke(IoC.get(beanName), new Object[] { req, resp, parameterMap.get("name")[0] });
// url参数的动态处理
// 获取method的形参列表
Class<?>[] parameterTypes = method.getParameterTypes();
// 保存赋值参数的位置
Object[] paramValues = new Object[parameterTypes.length];
// 根据参数的位置动态赋值
for (int i = 0; i < parameterTypes.length; i++) {
Class<?> parameterType = parameterTypes[i];
if (parameterType == HttpServletRequest.class) {
paramValues[i] = req;
continue;
} else if (parameterType == HttpServletResponse.class) {
paramValues[i] = resp;
continue;
} else if (parameterType == String.class) {
// 提取方法中加了注解的参数
Annotation[][] pa = method.getParameterAnnotations();
for (int j = 0; j < pa.length; j++) {
for (Annotation a : pa[j]) {
if (a instanceof MyRequestParam) {
String paramName = ((MyRequestParam) a).value().trim();
if (!"".equals(paramName)) {
String paramValue = Arrays.toString(parameterMap.get(paramName))
.replaceAll("\\[|\\]", "")
.replaceAll("\\s", ",");
paramValues[i] = paramValue;
}
}
}
}
}
}
String beanName = method.getDeclaringClass().getName();
// 根据动态获取的参数去invoke method
method.invoke(IoC.get(beanName), paramValues);
}
运行演示
到此为止我们就实现了 mini-spring 的 2.0 版本。
2.0 版本在 1.0 基础上做了优化，但是还有很多工作要做，例如 HandlerMapping 还不能像 SpringMVC 一样支持正则，url 参数还不支持类型转换，在 3.0 版本中我们将继续优化，请看下篇 用 300 行代码手写提炼 Spring 核心原理 [3]。
参考
[1] 《Spring 5 核心原理与 30 个类手写实战》，谭勇德著。
