手写Spring框架(简单实现)

Spring风格的三级缓存管理：一个简单实现示例

在实现一个简单的Spring风格的依赖注入容器时，我们通常需要处理Bean的生命周期，包括实例化、属性注入以及完全初始化。为了处理复杂的依赖关系和循环依赖问题，我们可以使用三级缓存机制。本文将介绍如何实现这种机制，并展示相应的代码示例。

三级缓存的概念

一级缓存（singletonObjects）：存储完全初始化的单例Bean。
二级缓存（earlySingletonObjects）：存储实例化但尚未完成所有属性注入的Bean。
三级缓存（singletonFactories）：存储Bean工厂，用于延迟初始化和解决循环依赖。

完整的实现代码

以下是一个实现三级缓存的简单容器的代码示例。这个实现使用了dom4j库来解析XML配置文件，创建和管理Bean的生命周期。

package org.xtl.spring;import org.dom4j.*;
import org.dom4j.io.SAXReader;import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;/*** ClassPathXmlApplicationContext 实现了一个简单的 Spring 风格的依赖注入容器。* 它使用三级缓存来处理 Bean 的创建和依赖注入，以支持复杂的依赖关系和循环依赖。*/
public class ClassPathXmlApplicationContext implements ApplicationContext {// 一级缓存：存放完全初始化的单例 Beanprivate final Map<String, Object> singletonObjects = new HashMap<>();// 二级缓存：存放实例化但未完成所有属性注入的单例 Beanprivate final Map<String, Object> earlySingletonObjects = new HashMap<>();// 三级缓存：存放 Bean 工厂，用于延迟初始化和解决循环依赖private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();/*** 构造函数，加载配置文件并初始化 Bean。** @param configLocation 配置文件的位置*/public ClassPathXmlApplicationContext(String configLocation) {try {// 读取配置文件InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);SAXReader reader = new SAXReader();Document document = reader.read(is);Element root = document.getRootElement();List<Element> beanElements = root.elements("bean");// 第一次遍历：实例化 Bean 并将 Bean 工厂放入三级缓存for (Element beanEle : beanElements) {String id = beanEle.attributeValue("id");String className = beanEle.attributeValue("class");Class<?> clazz = Class.forName(className);Constructor<?> constructor = clazz.getDeclaredConstructor();constructor.setAccessible(true);// 使用 ObjectFactory 创建 Bean 实例ObjectFactory<?> singletonFactory = () -> {try {return constructor.newInstance();} catch (Exception e) {throw new RuntimeException("Failed to create bean instance", e);}};// 将工厂放入三级缓存singletonFactories.put(id, singletonFactory);}// 第二次遍历：进行属性填充和依赖注入for (Element beanEle : beanElements) {String id = beanEle.attributeValue("id");Class<?> clazz = Class.forName(beanEle.attributeValue("class"));// 从三级缓存获取 Bean 实例并将其放入 earlySingletonObjectsObject bean = getSingleton(id);List<Element> propertyEles = beanEle.elements("property");for (Element propertyEle : propertyEles) {String propertyName = propertyEle.attributeValue("name");String propertyValueStr = propertyEle.attributeValue("value");String propertyRefStr = propertyEle.attributeValue("ref");Object propertyValue = null;// 获取属性类型Class<?> propertyType = clazz.getDeclaredField(propertyName).getType();if (propertyValueStr != null) {// 将属性值转换为正确的类型propertyValue = changeType(propertyType.getSimpleName(), propertyValueStr);}if (propertyRefStr != null) {// 从 earlySingletonObjects 中获取属性值propertyValue = earlySingletonObjects.get(propertyRefStr);}// 设置属性String methodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);Method method = clazz.getDeclaredMethod(methodName, propertyType);method.setAccessible(true);method.invoke(bean, propertyValue);}// 将完全初始化的 Bean 放入一级缓存，并从二级缓存中移除singletonObjects.put(id, bean);earlySingletonObjects.remove(id);singletonFactories.remove(id);}} catch (Exception e) {throw new RuntimeException("Failed to initialize the application context", e);}}/*** 从缓存中获取 Bean 实例。** @param beanName Bean 的名称* @return Bean 实例*/private Object getSingleton(String beanName) {// 从一级缓存中获取Object singleton = singletonObjects.get(beanName);if (singleton == null) {// 从二级缓存中获取singleton = earlySingletonObjects.get(beanName);if (singleton == null) {// 从三级缓存中获取 Bean 工厂并创建实例ObjectFactory<?> singletonFactory = singletonFactories.get(beanName);if (singletonFactory != null) {singleton = singletonFactory.getObject();// 将实例放入二级缓存earlySingletonObjects.put(beanName, singleton);singletonFactories.remove(beanName);}}}return singleton;}@Overridepublic Object getBean(String name) {return getSingleton(name);}@Override@SuppressWarnings("unchecked")public <T> T getBean(String name, Class<T> requiredType) {Object bean = getBean(name);if (requiredType.isInstance(bean)) {return (T) bean;}throw new ClassCastException("Bean is not of required type: " + requiredType.getName());}/*** 将字符串转换为指定的类型。** @param typeName 属性类型的名称* @param propertyValueStr 属性值的字符串表示* @return 转换后的属性值* @throws Exception 如果不支持该类型*/public static Object changeType(String typeName, String propertyValueStr) throws Exception {Object propertyValue = null;switch (typeName) {case "byte", "Byte":propertyValue = Byte.parseByte(propertyValueStr);break;case "short", "Short":propertyValue = Short.parseShort(propertyValueStr);break;case "int", "Integer":propertyValue = Integer.parseInt(propertyValueStr);break;case "float", "Float":propertyValue = Float.parseFloat(propertyValueStr);break;case "double", "Double":propertyValue = Double.parseDouble(propertyValueStr);break;case "boolean", "Boolean":propertyValue = Boolean.parseBoolean(propertyValueStr);break;case "long", "Long":propertyValue = Long.parseLong(propertyValueStr);break;case "char", "Character":propertyValue = propertyValueStr.charAt(0);break;case "String":propertyValue = propertyValueStr;break;default:throw new Exception("不支持该类型");}return propertyValue;}/*** ObjectFactory 接口用于创建 Bean 实例。** @param <T> Bean 的类型*/public interface ObjectFactory<T> {T getObject();}
}

代码说明

构造函数：
- 读取配置文件并解析所有的Bean定义。
- 将Bean工厂放入三级缓存（singletonFactories）。
第一次遍历：
- 创建Bean的工厂并将其放入三级缓存，以延迟Bean的实例化。
第二次遍历：
- 从三级缓存中获取Bean实例，并将其放入二级缓存（earlySingletonObjects）。
- 填充Bean的属性。如果属性是引用类型，从二级缓存中获取依赖Bean。
完成初始化：
- 将完全初始化的Bean从二级缓存移至一级缓存（singletonObjects）。
changeType方法：
- 将属性值字符串转换为相应的类型（例如int、String等）。
ObjectFactory接口：
- 用于定义创建Bean实例的方法。