零散知识点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Service
public class UserService {
    
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final EmailService emailService;

    // 构造器注入 - 所有依赖都是 final
    public UserService(UserRepository userRepository, 
                      PasswordEncoder passwordEncoder,
                      EmailService emailService) {
        this.userRepository = userRepository;
        this.passwordEncoder = passwordEncoder;
        this.emailService = emailService;
    }
    
    // 业务方法...
}

1
2
3
4
5
6
7
public class SimpleDateFormat extends DateFormat {

}

public abstract class DateFormat extends Format {
    protected Calendar calendar;
}

1
com.mysql.cj.jdbc.Driver

1
ch.qos.logback.classic.servlet.LogbackServletContainerInitializer

1
2
3
4
5
6
7
8
9
10
11
12
13
# Logging Systems
org.springframework.boot.logging.LoggingSystemFactory=\
org.springframework.boot.logging.logback.LogbackLoggingSystem.Factory,\
org.springframework.boot.logging.log4j2.Log4J2LoggingSystem.Factory,\
org.springframework.boot.logging.java.JavaLoggingSystem.Factory

# PropertySource Loaders
org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader

...
...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class DefaultSingletonBeanRegistry {
    
    // 一级缓存：完整的单例Bean（已初始化完成）
    // 职责：提供最终可用的Bean实例
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    // 二级缓存：早期Bean引用（已创建但未初始化完成）
    // 职责：保证在创建过程中引用的一致性，避免重复创建
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
    
    // 三级缓存：Bean工厂
    // 职责：延迟创建早期引用，支持复杂的代理逻辑
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
// 以 A → B → C → A 的循环依赖为例，且A需要AOP代理

// 步骤1: 开始创建A
1. beforeSingletonCreation("serviceA") // 标记A正在创建
2. instance = createBeanInstance("serviceA") // 实例化A
3. addSingletonFactory("serviceA", () -> getEarlyBeanReference("serviceA", mbd, bean))
   // 三级缓存: {serviceA: ObjectFactory}
   // 二级缓存: {}
   // 一级缓存: {}

// 步骤2: A注入B，触发B的创建
4. populateBean("serviceA") → 发现需要B
5. getSingleton("serviceB") → 不存在，开始创建B

// 步骤3: 开始创建B  
6. beforeSingletonCreation("serviceB")
7. instance = createBeanInstance("serviceB") 
8. addSingletonFactory("serviceB", ...)
   // 三级缓存: {
   // serviceA: ObjectFactory, 
   // serviceB: ObjectFactory
   // }

// 步骤4: B注入C，触发C的创建
9. populateBean("serviceB") → 发现需要C
10. getSingleton("serviceC") → 不存在，开始创建C

// 步骤5: 开始创建C
11. beforeSingletonCreation("serviceC")
12. instance = createBeanInstance("serviceC")
13. addSingletonFactory("serviceC", ...)
    // 三级缓存: {
    // serviceA: ObjectFactory, 
    // serviceB: ObjectFactory, 
    // serviceC: ObjectFactory
    // }

// 步骤6: C注入A，触发获取A的早期引用
14. populateBean("serviceC") → 发现需要A
15. getSingleton("serviceA") 
    - 一级缓存: 无
    - 二级缓存: 无  
    - 三级缓存: 有ObjectFactory
16. singletonObject = singletonFactory.getObject() // 创建A的代理对象
17. earlySingletonObjects.put("serviceA", singletonObject) // 放入二级缓存
18. singletonFactories.remove("serviceA") // 移除三级缓存
    // 三级缓存: {
    // serviceB: ObjectFactory, 
    // serviceC: ObjectFactory
    // }

    // 二级缓存: {
    // serviceA: ProxyA
    // }

    // 一级缓存: {}

// 步骤7: C完成创建
19. initializeBean("serviceC")
20. addSingleton("serviceC", ...) // 放入一级缓存
    // 一级缓存: {
    // serviceC: CompleteC
    // }

// 步骤8: B完成创建  
21. B从一级缓存获取C，完成注入
22. initializeBean("serviceB")
23. addSingleton("serviceB", ...)
    // 一级缓存: {
    // serviceB: CompleteB, 
    // serviceC: CompleteC
    // }

// 步骤9: A完成创建
24. A从一级缓存获取B，完成属性注入
25. 执行initializeBean("serviceA") - 初始化回调(@PostConstruct等)
26. 在doCreateBean的最后阶段：
    
    // 检查是否有早期暴露的引用
    Object earlySingletonReference = getSingleton(beanName, false);
    if (earlySingletonReference != null) {
        // 如果初始化后对象没有被增强，就使用早期暴露的代理对象
        if (exposedObject == bean) {  // exposedObject是初始化后的对象，bean是原始对象
            exposedObject = earlySingletonReference;  // 使用二级缓存中的代理对象
        }
    }
    
27. addSingleton("serviceA", exposedObject) // 将最终对象放入一级缓存
    // 同时清理缓存：
    // - 从 singletonFactories 移除 (三级缓存)
    // - 从 earlySingletonObjects 移除 (二级缓存)  
    // - 添加到 singletonObjects (一级缓存)

// 最终状态：
// 一级缓存: {
// serviceA: ProxyA, 
// serviceB: CompleteB, 
// serviceC: CompleteC
// }
// 二级缓存: {}
// 三级缓存: {}

1
2
3
4
5
6
7
// 创建流程：
1. A开始创建，ObjectFactory放入三级缓存
2. B需要A → 调用ObjectFactory创建代理Proxy1
3. C需要A → 调用ObjectFactory创建代理Proxy2  
4. D需要A → 调用ObjectFactory创建代理Proxy3
5. 最终：B持有Proxy1，C持有Proxy2，D持有Proxy3
6. 三个代理对象不一致！

1
2
3
4
5
6
// 创建流程：
1. A开始创建，ObjectFactory放入三级缓存  
2. B需要A → 调用ObjectFactory创建代理Proxy1 → 放入二级缓存
3. C需要A → 从二级缓存直接获取Proxy1
4. D需要A → 从二级缓存直接获取Proxy1
5. 最终：B、C、D都持有同一个Proxy1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 一级缓存
	Object singletonObject = this.singletonObjects.get(beanName);
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 二级缓存
		singletonObject = this.earlySingletonObjects.get(beanName);
		if (singletonObject == null && allowEarlyReference) {
            // 同步代码块
			synchronized (this.singletonObjects) {
                // 三级缓存
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            }
        }
    }
}