手写Spring框架(简单实现)

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

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

三级缓存的概念

1. 一级缓存（singletonObjects）：存储完全初始化的单例Bean。
2. 二级缓存（earlySingletonObjects）：存储实例化但尚未完成所有属性注入的Bean。
3. 三级缓存（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 {
    // 一级缓存：存放完全初始化的单例 Bean
    private final Map<String, Object> singletonObjects = new HashMap<>();
    
    // 二级缓存：存放实例化但未完成所有属性注入的单例 Bean
    private 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 实例并将其放入 earlySingletonObjects
                Object 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;
    }

    @Override
    public 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();
    }
}

代码说明

1. 构造函数：

   • 读取配置文件并解析所有的Bean定义。
   • 将Bean工厂放入三级缓存（singletonFactories）。

2. 第一次遍历：

   • 创建Bean的工厂并将其放入三级缓存，以延迟Bean的实例化。

3. 第二次遍历：

   • 从三级缓存中获取Bean实例，并将其放入二级缓存（earlySingletonObjects）。
   • 填充Bean的属性。如果属性是引用类型，从二级缓存中获取依赖Bean。

4. 完成初始化：

   • 将完全初始化的Bean从二级缓存移至一级缓存（singletonObjects）。

5. changeType方法：

   • 将属性值字符串转换为相应的类型（例如int、String等）。

6. ObjectFactory接口：

   • 用于定义创建Bean实例的方法。

通过上述代码和说明，你可以实现一个简单的三级缓存机制，处理Bean的创建和依赖注入。这种实现方式可以有效地管理Bean的生命周期，并解决循环依赖等复杂问题。希望这篇博客能帮助你理解和实现三级缓存机制。