配置管理 on pipo's site

Spring 中的 Bind

Thu, 22 Jan 2026 14:44:35 +0800

Bind 是什么？

Spring Boot 的 Bind 机制主要负责将 外部配置（如 application.yml、application.properties、环境变量等）绑定到 Java 对象 中。

外部配置绑定优先级：

命令行参数（java -jar app.jar --db.port=9000)
操作系统环境变量（export DB_PORT=9000)
jar 包外部的配置文件（/config/application.yaml)
jar 包内部的配置文件（resources/application.yml)

三种绑定方式

@Value

@Component
public class MyService {
    
    @Value("${app.name:default-app}")  // 支持默认值
    private String appName;
    
    @Value("${app.feature.enabled:false}")
    private boolean featureEnabled;
    
    @Value("#{systemProperties['user.home']}")  // SpEL 表达式
    private String userHome;
}

限制：

不支持 JSR-303 校验
不支持复杂对象绑定
不支持松散绑定
无法在配置文件中提示 IDE 支持

@ConfigurationProperties

@ConfigurationProperties( prefix = "") 外部配置文件：

myapp:
  name: 'myapp'
  server:
    host: 1.1.1.1
    port: 80
  security:
    username: admin
    password: 123

配置方式

@Data
@Component 
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
	// 必须要提供 getter setter，可以使用 Lombook 简化
	private String name;
	
	private ServerConfig server;
	
	private ServerSecurity security;
	
	//嵌套配置 创建类， 必须是 public static
	@Data
	public static class ServerConfig {
		private String host;
		private Long port;
	}
	
	@Data 
	public static class ServerSecurity {
		private String username; 
		private String password;
	}
	
}

使用方式

@Configuration
public class AppConfig {
	@Autowired
	private MyAppProperties properties;
}

prefix 的使用： prefix 填入要被装载的属性的前缀，如果有多个嵌套则可以 myapp.server.XXX.XXX 来装载对应层级下的属性
松散绑定： Spring 可以自动将配置属性的名词与定义的类中的名称进行自动映射支持的类型名称：
- kebab-case (烤肉串式): 全小写，单词间用连字符分隔，如 my-variable-name
- snake_case (蛇形): 全小写，单词间用下划线分隔，如 my_variable_name
- UPPERCASE (全大写): 全部大写，通常用于常量，如 MY_CONSTANT

JSR-303 校验：在类上添加 @Validated 开启校验

@NotNull
@Min()
@Max()
@NotBlank
@Email
@Size(min = )

@Data
@Component
@ConfigurationProperties(prefix = "myapp")
@Validated // <--- 开启第一层校验
public class MyAppProperties {
    @Valid // <--- 关键！告诉 Spring 钻进去校验内部属性
    private ServerConfig server;
    // ...
}

Binder API

使用 Binder API 读取 Environment 中的配置

Bind bind = Binder.get(environment);

读取单个值

// 读取单个值
String host = bind.bind("myapp.server.host", String.class).orElse("1.1.1.1");

读取单个值要写入完整的路径，并且使用点号分割

读取复杂类型 (List/Map)

如果在 application.yaml 里写了一个 List：

my-app:
  whitelist:
    - 192.168.1.1
    - 10.0.0.1

需要使用 Bindable 包装器处理范型

List<String> ips = 
binder.bind( "my-app.whitelist", Bindable.listOf(String.class) // <--- 关键！告诉 Binder 这是一个 List<String> ).orElse(Collections.emptyList());

如果是更复杂的比如

routes:  
  - id: "order-service"  
    path: "/api/order"  
    url: "http://localhost:8081"  
  - id: "user-service"  
    path: "/api/user"  
    url: "http://localhost:8082"
    
private List<Map<Object, Object>> routes = new ArrayList<>();

1.方法一
@SuppressWarnings("unchecked")  
List<Map<Object, Object>> routes = (List<Map<Object, Object>>) (List<?>)  
        binder.bind("gateway.routes", Bindable.listOf(Map.class))  
                .orElse(List.of());
2.方法二                  
List<?> routes = binder.bind("gateway.routes", Bindable.listOf(Map.class))  
        .orElse(List.of());

3.方法三
public class RouteConfig {
    private String id;
    private String path;
    private String url;
}

List<RouteConfig> routes = binder.bind("gateway.routes", 
        Bindable.listOf(RouteConfig.class))
        .orElse(List.of());

读取整个配置类

//后面的 XXX.class 是在告诉 “我要读取的是什么类型的配置请转换成这种类型 "
MyAppProperties properties = bind.bind("myapp", MyAppProperties.class).get();

创建本地 bind 并绑定

创建本地 bind 并添加配置

Binder binder = Binder.get(environment);

//添加 配置
1. 方法一
	MapConfigurationPropertySource source1 = new MapConfigurationPropertySource(map1);
	MapConfigurationPropertySource source2 = new MapConfigurationPropertySource(map2);
	
	Binder localBind = new Binder(source1, source2);
2. 方法二
	List<ConfigurationPropertySource> sources = new ArrayList<>();
	sources.add(new MapConfigurationPropertySource(map1));
	sources.add(new MapConfigurationPropertySource(map2));
	sources.add(new MapConfigurationPropertySource(map3));

	Binder localBind = new Binder(sources);

生产中建议

private Binder createLocalBinder(Map<String, Object>... configMaps) {
    List<ConfigurationPropertySource> sources = new ArrayList<>();
    
    for (Map<String, Object> map : configMaps) {
        if (map != null && !map.isEmpty()) {
            sources.add(new MapConfigurationPropertySource(map));
        }
    }
    
    return new Binder(sources);
}
// 使用
Binder localBind = createLocalBinder(legacyMap, otherMap, thirdMap);

将 bind 中的值绑定类

//RouteDefinition.java
@Data  
public class RouteDefinition {  
    private String id;  
  
    private String path;  
  
    private String url;  
}

Map<String, Object> legacyMap = new HashMap<>();  
legacyMap.put("id", "legacy-service-999");  
legacyMap.put("path", "/api/old");  
legacyMap.put("url", "http://192.168.1.100");  

//Bind 无法直接绑定 Map 需要转换
MapConfigurationPropertySource legacyConfigurationMap = new MapConfigurationPropertySource(legacyMap);  
Binder localBind = new Binder(legacyConfigurationMap);  

									//为什么这里是 "" 空字符串？
RouteDefinition legacyRoute = localBind.bind("", RouteDefinition.class).orElse(new RouteDefinition());  
System.out.println(legacyRoute);

prefix + 要注入的字段名 = key 此时 key 与字段名完全相同，所以使用空字符串如果 legacyMap 中 put 时 key 是 legacy.route.id 那么在将 source 中的属性绑定到 RouteDefinition 时 prefix = “legacy.route”

三种绑定方式对比

特性	@Value	@ConfigurationProperties	Binder API
使用场景	1-2 个简单配置	结构化配置、多个相关配置	动态绑定、运行时绑定
JSR-303 校验	❌ 不支持	✅ 支持（@Validated）	✅ 支持
松散绑定	❌ 不支持	✅ 支持	✅ 支持
复杂对象	❌ 不支持	✅ 支持（嵌套对象）	✅ 支持
IDE 元数据支持	❌ 无提示	✅ 有提示（spring-configuration-metadata.json）	❌ 无提示
类型安全	⚠️ 编译时不检查	✅ 强类型检查	✅ 强类型检查
集合类型	⚠️ 需要手动解析	✅ 自动绑定 List/Set/Map	✅ 自动绑定（需要 Bindable）
默认值	✅ `${prop:default}`	✅ 字段初始化或 @DefaultValue	✅ `.withDefaultValue()`
灵活性	低	中	高

优先使用 @ConfigurationProperties - 类型安全、IDE 支持、可校验
简单配置用 @Value - 如端口、开关等单个属性
动态配置用 Binder API - 如从数据库、Nacos 读取配置后绑定

Reference

Spring循环依赖解决

Thu, 27 Nov 2025 09:05:35 +0800

什么是依赖循环？

我们知道在 Spring 中依赖注入时的行为是：

如果当前 Bean 依赖其他 Bean，那么递归注入子 Bean
如果来源于配置文件，则从 Environment 中读取

这就导致了如果 A→B→C→A 成环互相依赖，就会不断递归陷入死循环。就像是死锁一样，互相等待彼此。

类比死锁的解决方案

我们可以借鉴解决死锁的方法来解决依赖循环：

破坏互斥条件：允许所有资源被共享，但这不适用于某些不能共享的资源（如打印机）
破坏不剥夺条件：当进程请求新资源未得到满足时，必须释放所有已占有的资源
破坏请求与保持条件：采用预先静态分配，即进程在运行前一次性申请所有所需资源
破坏循环等待条件：采用顺序资源分配，规定进程必须按照资源的编号顺序来申请

Spring 的选择：

Spring 选择的是破坏循环等待条件（或者说打破了"资源必须完全就绪才能被使用"的互斥条件），允许循环中的 Bean 在未完全初始化结束前，先拿到一个"半成品"引用，从而结束递归等待。

Spring 在哪里、通过什么方法解决了它？

Spring 通过在 Instantiation 之后提前暴露工厂对象，在 Populate 之前，加入到三级缓存，允许其他对象通过 ObjectFactory 获取到 bean。

三级缓存机制

级别	缓存名称	存放内容	作用
一级缓存	singletonObjects	完全初始化好的 Bean	存放成熟的单例 Bean
二级缓存	earlySingletonObjects	半成品的 Bean（提前代理）	解决循环依赖中的 AOP 代理单例问题
三级缓存	singletonFactories	ObjectFactory	延迟决策是否需要代理

具体流程

A 实例化 → 暴露工厂到三级缓存
    ↓
A 填充属性，需要 B
    ↓
B 实例化 → 暴露工厂到三级缓存
    ↓
B 填充属性，需要 A → 从三级缓存获取 A 的工厂 → 创建代理/获取原始对象 → 放入二级缓存
    ↓
B 完成 → 放入一级缓存
    ↓
A 继续填充 B（从一级缓存获取）→ A 完成 → 放入一级缓存

![[../pics/BeanDependencyLoop.png]]

为什么要三级缓存而不是二级？

如果去掉二级缓存会发生什么：

当非 AOP代理的对象注入属性时 B从三级缓存中 getbean获取到A,打破循环，此时B已经已经成熟，放入一级缓存，回到A的属性注入流程，查找一级缓存，发现B存在，完成注入。整体流程没有问题，也就是说在没有AOP代理时是可以的。
当有AOP代理时 B从三级缓存中 getbean获取到proxy012_A，把自身放入一级缓存，A又依赖C，C从三级缓存中获取proxy013_A，回到A，此时B和C拿到的是不同的A的代理对象，违反了单例原则。当加入了二级缓存，获取到proxy_A后会把代理对象放到二级缓存，其他依赖需要时拿到的是同一个代理对象。

为什么不直接在三级缓存中存放代理对象？

Spring 的设计初衷是 AOP 代理应当在 Bean 生命周期最后一步（初始化后）完成。但在 循环依赖 这种极端情况下，为了打破死锁，Spring 此时不得不妥协，允许在 实例化后、填充属性前 提前进行 AOP。

为什么提前暴露“空壳代理”没问题？

因为 Java 是 值传递（传递的是对象引用的地址）。

代理对象（Proxy）内部持有原始对象（Target）的引用。
虽然注入给别人时，原始对象还是“空的”，但随着生命周期继续，原始对象会被填充完好。
当真正调用代理对象方法时，内部委托的原始对象已经是成熟的了。

为什么要三级缓存总结：

三级缓存（ObjectFactory）：它的作用是 “延迟决策”。它存的是一个生成代理的工厂逻辑，而不是具体的对象。只有当循环依赖发生时，才去运行这个逻辑（打破原则）；否则，永远不运行（坚持原则）。Spring选的的是破坏不剥夺条件，允许循环中的Bean先拿到不成熟的Bean，结束递归。
二级缓存（EarlySingletonObjects）：它的作用是 “保持单例”。一旦三级缓存的工厂被执行，生成的代理对象（Proxy）必须放入二级缓存。因为 createProxy 每次都会产生新对象，如果有多个 Bean 依赖它，必须从二级缓存拿同一个 Proxy，保证全局唯一。

为什么构造器注入无法解决依赖循环？

在 Bean 的生命周期中 Instantiation 中如果使用的是构造器注入，会在此步骤直接注入依赖，但暴露工厂对象是在 Instantiation 结束后进行的，此时缓存中没有对象，无法获取到未成熟的Bean 。解决方法：使用懒加载 @Lazy，返回一个空壳，当真正需要该对象时才加载注入属性。

总结

问题	答案
Spring 如何解决循环依赖	三级缓存 + 提前暴露半成品对象
为什么需要三级缓存	三级缓存用于"延迟决策"是否需要代理，二级缓存用于保持代理单例
构造器注入为什么不支持	构造器注入发生在暴露工厂之前
推荐的注入方式	构造器注入（避免循环依赖）+ 必要时使用 @Lazy

Reference

聊透Spring循环依赖 - 掘金