三级缓存 singletonFactories 源码

在 Spring Framework 中，singletonFactories 是一个用于存储单例 Bean 工厂对象的缓存。在初次获取一个单例 Bean 的时候，Spring Framework 会先从 singletonObjects 缓存中查找，如果没有找到，就会从 singletonFactories 缓存中查找相应的 Bean 工厂对象，并通过工厂对象创建 Bean 实例并存储到 singletonObjects 缓存中。下面是 singletonFactories 的源码：

/**
 * Cache of singleton factories: bean name to ObjectFactory.
 */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();

在这个 Map 中，键是 Bean 名称，值是 ObjectFactory 对象，用于创建相应的 Bean 实例。通过使用 ObjectFactory，Spring 可以避免在容器启动时就创建所有的 Bean 实例，从而达到延迟初始化的目的，提高了系统的性能。

相关问题

singletonFactories 源码

这里是一个使用单例工厂模式的示例代码：

public interface Singleton {
    void doSomething();
}

public class SingletonImpl implements Singleton {
    private static volatile SingletonImpl instance;

    private SingletonImpl() {
        // private constructor
    }

    public static SingletonImpl getInstance() {
        if (instance == null) {
            synchronized (SingletonImpl.class) {
                if (instance == null) {
                    instance = new SingletonImpl();
                }
            }
        }
        return instance;
    }

    @Override
    public void doSomething() {
        // do something here
    }
}

public class SingletonFactory {
    private static Map<String, Singleton> singletonMap = new HashMap<>();

    public static Singleton getInstance(String className) {
        Singleton singleton = singletonMap.get(className);
        if (singleton == null) {
            try {
                singleton = (Singleton) Class.forName(className).newInstance();
                singletonMap.put(className, singleton);
            } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return singleton;
    }
}

在上面的示例中，`Singleton` 接口定义了一个 `doSomething` 方法，`SingletonImpl` 类是 `Singleton` 接口的实现类，使用 double-checked locking 方式实现了单例模式。`SingletonFactory` 类是单例工厂类，通过反射动态创建对象并缓存在 `singletonMap` 中，以便在需要的时候直接返回已经创建好的对象。使用方式如下：

Singleton singleton1 = SingletonFactory.getInstance("com.example.SingletonImpl");
singleton1.doSomething();

Singleton singleton2 = SingletonFactory.getInstance("com.example.SingletonImpl");
singleton2.doSomething();

System.out.println(singleton1 == singleton2); // true

注意，这里的 `SingletonImpl` 类必须要有一个无参的构造方法，否则在 `Class.forName(className).newInstance()` 时会出现异常。

springbean三级缓存

Spring框架中的Bean实例化过程中，涉及到三级缓存的概念。这三级缓存用于解决循环依赖的问题。

第一级缓存是singletonObjects，它是一个ConcurrentHashMap类型的缓存，用于存放完全初始化好的单例Bean。当Spring创建一个Bean时，会将其放入第一级缓存。

第二级缓存是earlySingletonObjects，它也是一个ConcurrentHashMap类型的缓存，用于存放提前曝光（尚未完全初始化）的单例Bean。在创建完Bean并且完成属性注入后，会将其放入第二级缓存。

第三级缓存是singletonFactories，它是一个ConcurrentHashMap类型的缓存，用于存放ObjectFactory，即获取Bean实例的方法。当从第二级缓存中获取不到Bean时，会调用ObjectFactory的getObject方法去创建Bean，并将其放入第三级缓存。

总的来说，三级缓存的作用是在Bean实例化过程中解决循环依赖问题。当出现循环依赖时，Spring会通过提前曝光尚未完全初始化的Bean来解决依赖关系，最终完成Bean的创建和初始化工作。