手写Spring框架(简朴实现)

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

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

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

完备的实当代码

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

1. package org.xtl.spring;
3. import org.dom4j.*;
4. import org.dom4j.io.SAXReader;
6. import java.io.InputStream;
7. import java.lang.reflect.Constructor;
8. import java.lang.reflect.Method;
9. import java.util.HashMap;
10. import java.util.List;
11. import java.util.Map;
13. /**
14. * ClassPathXmlApplicationContext 实现了一个简单的 Spring 风格的依赖注入容器。
15. * 它使用三级缓存来处理 Bean 的创建和依赖注入，以支持复杂的依赖关系和循环依赖。
16. */
17. public class ClassPathXmlApplicationContext implements ApplicationContext {
18.     // 一级缓存：存放完全初始化的单例 Bean
19.     private final Map<String, Object> singletonObjects = new HashMap<>();
20.    
21.     // 二级缓存：存放实例化但未完成所有属性注入的单例 Bean
22.     private final Map<String, Object> earlySingletonObjects = new HashMap<>();
23.    
24.     // 三级缓存：存放 Bean 工厂，用于延迟初始化和解决循环依赖
25.     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();
27.     /**
28.      * 构造函数，加载配置文件并初始化 Bean。
29.      *
30.      * @param configLocation 配置文件的位置
31.      */
32.     public ClassPathXmlApplicationContext(String configLocation) {
33.         try {
34.             // 读取配置文件
35.             InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
36.             SAXReader reader = new SAXReader();
37.             Document document = reader.read(is);
38.             Element root = document.getRootElement();
39.             List<Element> beanElements = root.elements("bean");
41.             // 第一次遍历：实例化 Bean 并将 Bean 工厂放入三级缓存
42.             for (Element beanEle : beanElements) {
43.                 String id = beanEle.attributeValue("id");
44.                 String className = beanEle.attributeValue("class");
45.                 Class<?> clazz = Class.forName(className);
46.                 Constructor<?> constructor = clazz.getDeclaredConstructor();
47.                 constructor.setAccessible(true);
49.                 // 使用 ObjectFactory 创建 Bean 实例
50.                 ObjectFactory<?> singletonFactory = () -> {
51.                     try {
52.                         return constructor.newInstance();
53.                     } catch (Exception e) {
54.                         throw new RuntimeException("Failed to create bean instance", e);
55.                     }
56.                 };
58.                 // 将工厂放入三级缓存
59.                 singletonFactories.put(id, singletonFactory);
60.             }
62.             // 第二次遍历：进行属性填充和依赖注入
63.             for (Element beanEle : beanElements) {
64.                 String id = beanEle.attributeValue("id");
65.                 Class<?> clazz = Class.forName(beanEle.attributeValue("class"));
66.                
67.                 // 从三级缓存获取 Bean 实例并将其放入 earlySingletonObjects
68.                 Object bean = getSingleton(id);
69.                
70.                 List<Element> propertyEles = beanEle.elements("property");
71.                 for (Element propertyEle : propertyEles) {
72.                     String propertyName = propertyEle.attributeValue("name");
73.                     String propertyValueStr = propertyEle.attributeValue("value");
74.                     String propertyRefStr = propertyEle.attributeValue("ref");
75.                     Object propertyValue = null;
77.                     // 获取属性类型
78.                     Class<?> propertyType = clazz.getDeclaredField(propertyName).getType();
79.                     if (propertyValueStr != null) {
80.                         // 将属性值转换为正确的类型
81.                         propertyValue = changeType(propertyType.getSimpleName(), propertyValueStr);
82.                     }
83.                     if (propertyRefStr != null) {
84.                         // 从 earlySingletonObjects 中获取属性值
85.                         propertyValue = earlySingletonObjects.get(propertyRefStr);
86.                     }
88.                     // 设置属性
89.                     String methodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
90.                     Method method = clazz.getDeclaredMethod(methodName, propertyType);
91.                     method.setAccessible(true);
92.                     method.invoke(bean, propertyValue);
93.                 }
95.                 // 将完全初始化的 Bean 放入一级缓存，并从二级缓存中移除
96.                 singletonObjects.put(id, bean);
97.                 earlySingletonObjects.remove(id);
98.                 singletonFactories.remove(id);
99.             }
100.         } catch (Exception e) {
101.             throw new RuntimeException("Failed to initialize the application context", e);
102.         }
103.     }
105.     /**
106.      * 从缓存中获取 Bean 实例。
107.      *
108.      * @param beanName Bean 的名称
109.      * @return Bean 实例
110.      */
111.     private Object getSingleton(String beanName) {
112.         // 从一级缓存中获取
113.         Object singleton = singletonObjects.get(beanName);
114.         if (singleton == null) {
115.             // 从二级缓存中获取
116.             singleton = earlySingletonObjects.get(beanName);
117.             if (singleton == null) {
118.                 // 从三级缓存中获取 Bean 工厂并创建实例
119.                 ObjectFactory<?> singletonFactory = singletonFactories.get(beanName);
120.                 if (singletonFactory != null) {
121.                     singleton = singletonFactory.getObject();
122.                     // 将实例放入二级缓存
123.                     earlySingletonObjects.put(beanName, singleton);
124.                     singletonFactories.remove(beanName);
125.                 }
126.             }
127.         }
128.         return singleton;
129.     }
131.     @Override
132.     public Object getBean(String name) {
133.         return getSingleton(name);
134.     }
136.     @Override
137.     @SuppressWarnings("unchecked")
138.     public <T> T getBean(String name, Class<T> requiredType) {
139.         Object bean = getBean(name);
140.         if (requiredType.isInstance(bean)) {
141.             return (T) bean;
142.         }
143.         throw new ClassCastException("Bean is not of required type: " + requiredType.getName());
144.     }
146.     /**
147.      * 将字符串转换为指定的类型。
148.      *
149.      * @param typeName 属性类型的名称
150.      * @param propertyValueStr 属性值的字符串表示
151.      * @return 转换后的属性值
152.      * @throws Exception 如果不支持该类型
153.      */
154.     public static Object changeType(String typeName, String propertyValueStr) throws Exception {
155.         Object propertyValue = null;
156.         switch (typeName) {
157.             case "byte", "Byte":
158.                 propertyValue = Byte.parseByte(propertyValueStr);
159.                 break;
160.             case "short", "Short":
161.                 propertyValue = Short.parseShort(propertyValueStr);
162.                 break;
163.             case "int", "Integer":
164.                 propertyValue = Integer.parseInt(propertyValueStr);
165.                 break;
166.             case "float", "Float":
167.                 propertyValue = Float.parseFloat(propertyValueStr);
168.                 break;
169.             case "double", "Double":
170.                 propertyValue = Double.parseDouble(propertyValueStr);
171.                 break;
172.             case "boolean", "Boolean":
173.                 propertyValue = Boolean.parseBoolean(propertyValueStr);
174.                 break;
175.             case "long", "Long":
176.                 propertyValue = Long.parseLong(propertyValueStr);
177.                 break;
178.             case "char", "Character":
179.                 propertyValue = propertyValueStr.charAt(0);
180.                 break;
181.             case "String":
182.                 propertyValue = propertyValueStr;
183.                 break;
184.             default:
185.                 throw new Exception("不支持该类型");
186.         }
187.         return propertyValue;
188.     }
190.     /**
191.      * ObjectFactory 接口用于创建 Bean 实例。
192.      *
193.      * @param <T> Bean 的类型
194.      */
195.     public interface ObjectFactory<T> {
196.         T getObject();
197.     }
198. }

复制代码

代码分析

• 构造函数：
  
  
  
  • 读取设置文件并剖析全部的Bean界说。
    
  • 将Bean工厂放入三级缓存（singletonFactories）。
    
  
  
• 第一次遍历：
  
  
  
  • 创建Bean的工厂并将其放入三级缓存，以延长Bean的实例化。
    
  
  
• 第二次遍历：
  
  
  
  • 从三级缓存中获取Bean实例，并将其放入二级缓存（earlySingletonObjects）。
    
  • 添补Bean的属性。如果属性是引用范例，从二级缓存中获取依赖Bean。
    
  
  
• 完成初始化：
  
  
  
  • 将完全初始化的Bean从二级缓存移至一级缓存（singletonObjects）。
    
  
  
• changeType方法：
  
  
  
  • 将属性值字符串转换为相应的范例（比方int、String等）。
    
  
  
• ObjectFactory接口：
  
  
  
  • 用于界说创建Bean实例的方法。
    
  
  

通过上述代码和分析，你可以实现一个简朴的三级缓存机制，处理处罚Bean的创建和依赖注入。这种实现方式可以有效地管理Bean的生命周期，并办理循环依赖等复杂题目。渴望这篇博客能资助你明白和实现三级缓存机制。