Spring Boot：不同Service类中同类型多Bean方法的合理性咨询

现有两个用于发起HTTP调用获取JSON响应的Service类，当前使用ResourceConverter将JSON响应转换为POJO，存在以下疑问：

1. 当前的实现方式是否恰当？
2. 两个独立类各自定义返回ResourceConverter类型的Bean（因需传入不同的POJO类参数无法共用），这种在不同类中定义同类型多个Bean的做法是否属于最佳实践？

@Service
public class TestClient {

   @Bean
   private ResourceConverter getTestResponseConverter(){
      ObjectMapper mapper = new ObjectMapper();
      mapper.configure(DeserializationFeature.ALLOW_UNKNOWN_PROPERTIES, true);
      ResourceConverter converter = new ResourceConverter(mapper,TestResponse.class);
      return converter;
   }

   private TestResponse getTestResponse(){
       // okhttp调用获取JSON，此处为简化写法
       String responseBodyString = okhttp.call(request);
       JSONAPIDocument<TestResponse> testDocument = getTestResponseConverter().readDocument(responseBodyString, TestResponse.class);
       return testDocument.get();
   }

}

@Service
public class DummyClient {

   @Bean
   private ResourceConverter getDummyResponseConverter(){
      ObjectMapper mapper = new ObjectMapper();
      mapper.configure(DeserializationFeature.ALLOW_UNKNOWN_PROPERTIES, true);
      ResourceConverter converter = new ResourceConverter(mapper,DummyResponse.class);
      return converter;
   }

   private DummyResponse getDummyResponse(){
       // okhttp调用获取JSON，此处为简化写法
       String responseBodyString = okhttp.call(request);
       JSONAPIDocument<DummyResponse> dummyDocument = getDummyResponseConverter().readDocument(responseBodyString, DummyResponse.class);
       return dummyDocument.get();
   }

}

一、当前实现的核心问题 #

• Bean定义无效：@Bean方法不能是private修饰，Spring无法扫描私有方法生成容器管理的Bean，每次调用getXXXConverter()都会创建新实例，既浪费资源也违背Spring Bean的设计初衷。
• 代码冗余严重：两个Converter的ObjectMapper配置完全重复，后续修改配置（如添加反序列化规则）需要在两处同步修改，维护成本高。
• 同类型Bean无标识：即使将@Bean改为public，两个ResourceConverter Bean没有明确的名称或限定符，后续注入时会出现歧义，Spring无法判断该注入哪个实例。

二、优化方案与最佳实践 #

1. 抽离全局ObjectMapper配置 #

单独创建配置类，定义通用的ObjectMapper Bean，避免重复配置：

@Configuration
public class JsonApiConfig {
    @Bean
    public ObjectMapper jsonApiObjectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.configure(DeserializationFeature.ALLOW_UNKNOWN_PROPERTIES, true);
        // 可在此添加全局配置，如日期格式化、模块注册等
        return mapper;
    }
}

2. 集中定义ResourceConverter Bean #

在统一配置类中创建两个ResourceConverter Bean，通过名称区分：

@Configuration
public class ResourceConverterConfig {
    private final ObjectMapper jsonApiObjectMapper;

    // 构造方法注入全局ObjectMapper
    public ResourceConverterConfig(ObjectMapper jsonApiObjectMapper) {
        this.jsonApiObjectMapper = jsonApiObjectMapper;
    }

    @Bean("testResponseConverter")
    public ResourceConverter testResponseConverter() {
        return new ResourceConverter(jsonApiObjectMapper, TestResponse.class);
    }

    @Bean("dummyResponseConverter")
    public ResourceConverter dummyResponseConverter() {
        return new ResourceConverter(jsonApiObjectMapper, DummyResponse.class);
    }
}

3. 在Client类中注入专属Converter #

修改Client类，移除内部的Bean方法，通过限定符注入对应Converter：

@Service
public class TestClient {
    private final ResourceConverter testResponseConverter;

    // 构造方法注入（推荐，利于测试与依赖清晰）
    public TestClient(@Qualifier("testResponseConverter") ResourceConverter testResponseConverter) {
        this.testResponseConverter = testResponseConverter;
    }

    private TestResponse getTestResponse() {
        String responseBodyString = okhttp.call(request);
        JSONAPIDocument<TestResponse> testDocument = testResponseConverter.readDocument(responseBodyString, TestResponse.class);
        return testDocument.get();
    }
}

@Service
public class DummyClient {
    private final ResourceConverter dummyResponseConverter;

    public DummyClient(@Qualifier("dummyResponseConverter") ResourceConverter dummyResponseConverter) {
        this.dummyResponseConverter = dummyResponseConverter;
    }

    private DummyResponse getDummyResponse() {
        String responseBodyString = okhttp.call(request);
        JSONAPIDocument<DummyResponse> dummyDocument = dummyResponseConverter.readDocument(responseBodyString, DummyResponse.class);
        return dummyDocument.get();
    }
}

4. 可选：封装通用转换工具类 #

如果多个Client的转换逻辑一致，可封装工具类简化代码：

@Component
public class JsonApiConverterUtil {
    private final ObjectMapper objectMapper;

    public JsonApiConverterUtil(ObjectMapper jsonApiObjectMapper) {
        this.objectMapper = jsonApiObjectMapper;
    }

    public <T> T convertToPojo(String json, Class<T> clazz) {
        ResourceConverter converter = new ResourceConverter(objectMapper, clazz);
        JSONAPIDocument<T> document = converter.readDocument(json, clazz);
        return document.get();
    }
}

之后Client类可直接注入工具类使用：

@Service
public class TestClient {
    private final JsonApiConverterUtil converterUtil;

    public TestClient(JsonApiConverterUtil converterUtil) {
        this.converterUtil = converterUtil;
    }

    private TestResponse getTestResponse() {
        String responseBodyString = okhttp.call(request);
        return converterUtil.convertToPojo(responseBodyString, TestResponse.class);
    }
}

三、核心最佳实践总结 #

• 职责分离：Bean定义统一放在@Configuration类中，Service类专注于HTTP调用等业务逻辑。
• 配置复用：相同的基础配置（如ObjectMapper）抽离为全局Bean，避免重复代码。
• 同类型Bean标识：多个同类型Bean必须通过名称或限定符区分，避免注入歧义。
• 优先构造注入：相比字段注入，构造方法注入更利于单元测试，也符合Spring依赖注入的设计规范。

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