Spring多域配置属性的Fallback实现优化方案咨询

问题背景 #

我有如下Spring配置属性：

myservice:
 domains:
  domain1:
    supplier:
      baseUrl:
      getEndpoint:
    customer:
      postEndpoint:
  domain2:
    supplier:
      baseUrl:
      getEndpoint:
      retryCount:
    customer:
      baseUrl:
      postEndpoint:
  fallbackDomain:
    supplier:
      baseUrl:
      getEndpoint:
      retryCount:
    customer:
      baseUrl:
      postEndpoint:

需求为：多个域（如domain1、domain2等）有各自配置，同时存在fallbackDomain；当特定域的属性不存在时，自动使用fallbackDomain的对应值。示例：

• 获取domain1的customer post端点：使用myservice.domains.domain1.customer.postEndpoint
• 获取domain1的supplier重试次数：因domain1无该属性，使用myservice.domains.fallbackDomain.supplier.retryCount

重要说明 #

域信息来自HTTP请求/线程上下文，每个请求可能变化，无法在应用启动时固定设置。当前使用Spring Boot 2.3.3和Spring 5.2.8，可考虑升级版本。

现有方案及问题 #

方案1：通过Environment获取属性 #

public <T> T getPropertyWithFallback(String nameTemplate, String domain, Class<T> clazz){
  return Optional.ofNullable(environment.getProperty(nameTemplate.format(domain), clazz))
  .orElse(environment.getProperty(nameTemplate.format("fallbackDomain"), clazz));
}
int count = getPropertyWithFallback("myservice.domains.%s.supplier.retryCount", "domain1", Integer.class);

缺点：

• 需手动维护属性字符串，易出现拼写错误
• 需记住%s模板约定
• 需手动指定属性类型
• 删除属性时需查找所有代码引用，维护难度大

方案2：使用@ConfigurationProperties #

@Component
@ConfigurationProperties(prefix = "myservice")
public class MyServiceConfigurationProperties {
  // 省略getter和setter
  private Map<String, Domain> domains;

  public static class Domain {
    private Supplier supplier;
    private Customer customer;
  }
  public static class Supplier {
    private String baseUrl;
    private String getEndpoint;
    private Integer retryCount;
  }
  public static class Customer {
    private String baseUrl;
    private String postEndpoint;
  }
}

优点：无需记忆属性名，类型自动绑定，便于维护域配置；但嵌套对象的fallback实现复杂：

尝试通过代理实现fallback：

private static class FallbackInvocationHandler implements InvocationHandler {
        private final Object primary;
        private final Object fallback;

        public FallbackInvocationHandler(Object primary, Object fallback) {
            this.primary = primary;
            this.fallback = fallback;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object result = method.invoke(primary, args);
            if (result == null) {
                result = method.invoke(fallback, args);
            }
            if (result != null && result.getClass().getPackage().getName().startsWith("no.eg.apps.pda6k.server.config")) {
                return Proxy.newProxyInstance(
                        result.getClass().getClassLoader(),
                        new Class[]{result.getClass()},
                        new FallbackInvocationHandler(result, method.invoke(fallback, args))
                );
            }
            return result;
        }
    }

  private <T> T getWithFallback(T value, T fallbackValue){
    if (value==null){
      return fallbackValue;
    }
    return (T) Proxy.newProxyInstance(
            value.getClass().getClassLoader(),
            new Class[]{value.getClass()},
            new FallbackInvocationHandler(value, fallbackValue)
  );
}
// 调用示例
  public Domain getDomainWithFallback(String domain){
     Domain value = domains.get(domain);
     Domain fallbackValue = domains.get("fallbackDomain");
     return getWithFallback(value, fallbackValue);
  }

问题：该实现对嵌套属性易出错，若fallbackDomain的子属性为空，需额外空检查，增加代码复杂度；新增属性时维护成本高。此外，customer和supplier结构重复，能否复用Java对象？

提问 #

是否存在比上述方案更优的实现方式？尽量不修改现有属性结构，若必要也可调整。

更优实现方案 #

1. 复用配置对象+手动属性合并（兼容现有版本） #

首先解决结构重复问题，统一复用EndpointConfig类：

public class EndpointConfig {
    private String baseUrl;
    private String getEndpoint;
    private String postEndpoint;
    private Integer retryCount;

    // 生成getter、setter及全参/无参构造函数
}

修改配置类，用复用的对象替代原有的Supplier、Customer类：

@Component
@ConfigurationProperties(prefix = "myservice")
public class MyServiceConfigurationProperties {
    private Map<String, DomainConfig> domains;

    public static class DomainConfig {
        private EndpointConfig supplier;
        private EndpointConfig customer;

        // 生成getter、setter
    }

    // 生成getter、setter
}

实现属性合并工具方法，在获取域配置时自动合并fallback值：

@Autowired
private MyServiceConfigurationProperties configProps;

public DomainConfig getMergedDomainConfig(String domain) {
    DomainConfig target = configProps.getDomains().getOrDefault(domain, new DomainConfig());
    DomainConfig fallback = configProps.getDomains().get("fallbackDomain");
    if (fallback == null) {
        return target;
    }

    // 合并supplier配置
    target.setSupplier(mergeEndpointConfig(target.getSupplier(), fallback.getSupplier()));
    // 合并customer配置
    target.setCustomer(mergeEndpointConfig(target.getCustomer(), fallback.getCustomer()));

    return target;
}

private EndpointConfig mergeEndpointConfig(EndpointConfig target, EndpointConfig fallback) {
    if (target == null) {
        return fallback;
    }
    if (fallback == null) {
        return target;
    }

    // 优先使用目标域的属性，为空则取fallback值
    EndpointConfig merged = new EndpointConfig();
    merged.setBaseUrl(Optional.ofNullable(target.getBaseUrl()).orElse(fallback.getBaseUrl()));
    merged.setGetEndpoint(Optional.ofNullable(target.getGetEndpoint()).orElse(fallback.getGetEndpoint()));
    merged.setPostEndpoint(Optional.ofNullable(target.getPostEndpoint()).orElse(fallback.getPostEndpoint()));
    merged.setRetryCount(Optional.ofNullable(target.getRetryCount()).orElse(fallback.getRetryCount()));

    return merged;
}

优势：

• 结构清晰，避免代理逻辑的空指针陷阱
• 复用配置对象，减少重复代码
• 新增属性时仅需在合并方法中添加对应逻辑，维护成本低
• 类型安全，编译期即可发现错误

2. 升级Spring Boot版本，利用Binder实现自动 fallback #

若能升级到Spring Boot 2.4+，可以借助Binder的自定义绑定逻辑，实现更优雅的属性 fallback：

@Autowired
private Binder binder;

public DomainConfig getDomainConfigWithFallback(String domain) {
    // 先绑定目标域配置
    DomainConfig target = binder.bind("myservice.domains." + domain, Bindable.of(DomainConfig.class))
            .orElse(new DomainConfig());
    // 绑定fallback配置
    DomainConfig fallback = binder.bind("myservice.domains.fallbackDomain", Bindable.of(DomainConfig.class))
            .orElse(new DomainConfig());

    // 合并逻辑同方案1，或借助BeanUtils.copyProperties实现空值不覆盖
    BeanUtils.copyProperties(fallback, target, getNullPropertyNames(target));
    return target;
}

// 获取对象中值为null的属性名，用于copyProperties时跳过
private String[] getNullPropertyNames(Object source) {
    final BeanWrapper src = new BeanWrapperImpl(source);
    PropertyDescriptor[] pds = src.getPropertyDescriptors();

    Set<String> emptyNames = new HashSet<>();
    for (PropertyDescriptor pd : pds) {
        Object srcValue = src.getPropertyValue(pd.getName());
        if (srcValue == null) {
            emptyNames.add(pd.getName());
        }
    }
    return emptyNames.toArray(new String[0]);
}

优势：

• 借助Spring原生工具简化合并逻辑
• 保留@ConfigurationProperties的类型安全和自动绑定特性

内容的提问来源于stack exchange，提问作者Loginus