Spring 复杂的弹簧转换器与转换器内？

我有一个复杂的对象，需要嵌套的转换器，比如说我有B类，其中包括a的实例

 class A {
    ....
   }

   class B {
    A a;
    ....
   }

我为a编写了一个转换器，它可以转换成其他类，比如“AA”。 现在我需要编写一个转换器，将B转换为其他类。因为B里面有A。我需要把A转换成另一个东西“AA”。 我正在使用转换器模式。 看到这一点： 还有比这更好的方法吗？我不希望在自定义工厂类中初始化转换器

与BB类类似：

class BB {
  ....
  AA aa;
  ....
}

您可以简单地执行以下操作：

public BB convert(B b) {

  BB bb = new BB();
  bb.aa = new AToAAConverter().convert(b.a);
  ....

您仍然可以在

ConversionServiceFactoryBean

中注册

AtoaConverter

，类BB，如：

class BB {
  ....
  AA aa;
  ....
}

您可以简单地执行以下操作：

public BB convert(B b) {

  BB bb = new BB();
  bb.aa = new AToAAConverter().convert(b.a);
  ....

---

您仍然可以在

conversionservicecfactorybean

中注册

atoaconverter

，您可以这样做。创建一个转换器服务并注入一组声明的转换器bean。在某些情况下，您可能需要访问converterService。您可以使用@Lazy注释绕过循环引用。您可能需要@Primary让spring知道，如果存在其他ConversionService，您声明的converterService应该被注入优先级。在某些情况下，让转换器访问转换服务是有用的。通过将转换服务从电流转换器内部分派到正确的转换器，可以保持松散耦合。此外，这允许您从其他转换器重新使用常见的转换器，消除代码重复

/**
 * @author vsutskever 3/22/18
 **/
@Configuration
public class ConverterConfig {


  /**
   * Circular reference. This beans depends on Conversion service. Using @Lazy to resolve.
   * @param service
   * @return
   */
  @Bean
  public Converter dispositionMessageConverter(
      @Lazy ConversionService service){
    return new DispositionMessageRequestToOutgoingMessage(service);
  }

  /**
   * Circular reference. This beans depends on Conversion service. Using @Lazy to resolve.
   * @param service
   * @return
   */
  @Bean
  public Converter contentMessageRequestToOutgoingMessageConverter(
      @Lazy ConversionService service){
    return new ContentMessageRequestToOutgoingMessageConverter(service);
  }

  @Bean
  public Converter incomingRcsMessageToBaseMessageConverter(){
    return new IncomingRcsMessageToBaseMessageConverter();
  }

  @Bean
  public Converter contactToAddressConverter(){
    return new ContactToAddressConverter();
  }

  @Bean
  @Primary
  public ConversionService conversionService(List<Converter> converters){
    ConversionServiceFactoryBean factory = new ConversionServiceFactoryBean();
    factory.setConverters(new HashSet<>(converters));
    factory.afterPropertiesSet();
    return factory.getObject();
  }

}

/**
*@author vsutskever 3/22/18
**/
@配置
公共类转换器配置{
/**
*循环引用。此bean依赖于转换服务。使用@Lazy解析。
*@param服务
*@返回
*/
@豆子
公共转换器配置消息转换器(
@惰性转换（服务）{
返回新的DispositionMessageRequestToOutgoingMessage（服务）；
}
/**
*循环引用。此bean依赖于转换服务。使用@Lazy解析。
*@param服务
*@返回
*/
@豆子
公共转换器contentMessageRequestToOutgoingMessageConverter(
@惰性转换（服务）{
返回新的ContentMessageRequestToOutgoingMessageConverter（服务）；
}
@豆子
公共转换器输入RCSMessageToBaseMessageConverter（）{
返回新的IncomingRcsMessageToBaseMessageConverter（）；
}
@豆子
公共转换器触点到地址转换器（）{
将新联系人返回到地址转换器（）；
}
@豆子
@初级的
公共转换服务转换服务（列表转换器）{
ConversionServiceFactoryBean工厂=新的ConversionServiceFactoryBean（）；
setConverters（新HashSet（converters））；
factory.AfterPropertieSet（）；
返回factory.getObject（）；
}
}

您可以这样做。创建一个转换器服务并注入一组声明的转换器bean。在某些情况下，您可能需要访问converterService。您可以使用@Lazy注释绕过循环引用。您可能需要@Primary让spring知道，如果存在其他ConversionService，您声明的converterService应该被注入优先级。在某些情况下，让转换器访问转换服务是有用的。通过将转换服务从电流转换器内部分派到正确的转换器，可以保持松散耦合。此外，这允许您从其他转换器重新使用常见的转换器，消除代码重复

/**
 * @author vsutskever 3/22/18
 **/
@Configuration
public class ConverterConfig {


  /**
   * Circular reference. This beans depends on Conversion service. Using @Lazy to resolve.
   * @param service
   * @return
   */
  @Bean
  public Converter dispositionMessageConverter(
      @Lazy ConversionService service){
    return new DispositionMessageRequestToOutgoingMessage(service);
  }

  /**
   * Circular reference. This beans depends on Conversion service. Using @Lazy to resolve.
   * @param service
   * @return
   */
  @Bean
  public Converter contentMessageRequestToOutgoingMessageConverter(
      @Lazy ConversionService service){
    return new ContentMessageRequestToOutgoingMessageConverter(service);
  }

  @Bean
  public Converter incomingRcsMessageToBaseMessageConverter(){
    return new IncomingRcsMessageToBaseMessageConverter();
  }

  @Bean
  public Converter contactToAddressConverter(){
    return new ContactToAddressConverter();
  }

  @Bean
  @Primary
  public ConversionService conversionService(List<Converter> converters){
    ConversionServiceFactoryBean factory = new ConversionServiceFactoryBean();
    factory.setConverters(new HashSet<>(converters));
    factory.afterPropertiesSet();
    return factory.getObject();
  }

}

/**
*@author vsutskever 3/22/18
**/
@配置
公共类转换器配置{
/**
*循环引用。此bean依赖于转换服务。使用@Lazy解析。
*@param服务
*@返回
*/
@豆子
公共转换器配置消息转换器(
@惰性转换（服务）{
返回新的DispositionMessageRequestToOutgoingMessage（服务）；
}
/**
*循环引用。此bean依赖于转换服务。使用@Lazy解析。
*@param服务
*@返回
*/
@豆子
公共转换器contentMessageRequestToOutgoingMessageConverter(
@惰性转换（服务）{
返回新的ContentMessageRequestToOutgoingMessageConverter（服务）；
}
@豆子
公共转换器输入RCSMessageToBaseMessageConverter（）{
返回新的IncomingRcsMessageToBaseMessageConverter（）；
}
@豆子
公共转换器触点到地址转换器（）{
将新联系人返回到地址转换器（）；
}
@豆子
@初级的
公共转换服务转换服务（列表转换器）{
ConversionServiceFactoryBean工厂=新的ConversionServiceFactoryBean（）；
setConverters（新HashSet（converters））；
factory.AfterPropertieSet（）；
返回factory.getObject（）；
}
}

我在没有编写自定义转换服务的情况下找到了一个解决方案，请使用@Lazy annotation来解决周期依赖关系

配置

类类似于：

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    @Lazy
    private ConversionService mConversionService;

    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(aConverter());
        registry.addConverter(bConverter());
    }

    @Bean
    public AConverter aConverter() {
        return new AConverter();
    }

    @Bean
    public BConverter bConverter() {
        return new BConverter(mConversionService);
    }
}

AConverter

和

BConverter

都实现了

org.springframework.core.convert.converter.converter

，作为

AConverter

将类

A

转换为

AA

和

BConverter

将类

B

转换为另一个包含

A

的类

更新

WebConfig

构造函数中的Inject

ConversionService

更好，可以避免字段注入：

@Configuration
public class WebConfig implements WebMvcConfigurer {

    private final ConversionService mConversionService;

    @Autowired
    public WebConfig(@Lazy ConversionService conversionService) {
        mConversionService = conversionService;
    }
}

---

我找到了一个没有编写自定义转换服务的解决方案，使用@Lazy注释来解决循环依赖关系

配置

类类似于：

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    @Lazy
    private ConversionService mConversionService;

    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(aConverter());
        registry.addConverter(bConverter());
    }

    @Bean
    public AConverter aConverter() {
        return new AConverter();
    }

    @Bean
    public BConverter bConverter() {
        return new BConverter(mConversionService);
    }
}

AConverter

和

BConverter

都实现了

org.springframework.core.convert.converter.converter

，作为

AConverter

将类

A

转换为

AA

和

BConverter

将类

B

转换为另一个包含

A

的类

更新