无法将类拆分为较小的类

Question

我很难把我的课分成更小的部分。我们的情况很糟糕，一个Dto持有30个不同的Dto。现在我们需要这个selectDto的映射，这也迫使我们创建30个不同的映射类。（我们在项目中也使用了mapstruct，这个场景不同于mapstruct可以处理的）

现在我的问题开始了:

我在相应的类中创建了所有映射。在基础selectDto中，我的构造函数中有26个映射器，这很可怕：

SonarLint:构造函数有26个参数，大于7个授权参数

我想出了如何分割这种情况的方法，但我找不到方法。有什么建议吗？

我的构造函数包含26个参数：

    AssignedSelectMapper(AssignedOpDtoMapper assignedOpDtoMapper,
        AssignedOrderDtoMapper assignedOrderDtoMapper
// many more constructor parameters
) {
        this.assignedOptionCodeDtoMapper = assignedOptionCodeDtoMapper;
        this.assignedOrderCriteriaDtoMapper = assignedOrderCriteriaDtoMapper;
        // all settings
}

我的公共函数映射，它为每个映射调用私有函数：

    public List<AssignedSelect> assignSelectFrom(SelectDto selectDto) {
        Objects.requireNonNull(selectionDto, "selectionDto can not be NULL");

        List<AssignedSelect> assignedSelects= new ArrayList<>();
        assignedSelects.addAll(this.mapOps(selectionDto.getOps()));
        assignedSelects.addAll(this.mapOra(selectionDto.getOra()));
        assignedSelects.addAll(this.mapOrs(selectionDto.getOrs()));
        assignedSelects.addAll(this.mapSs(selectionDto.getSs()));
        assignedSelects.addAll(this.mapDels(selectionDto.getDels()));
        assignedSelects.addAll(this.mapMs(selectionDto.getMs()));
        assignedSelects.addAll(this.mapBrs(selectionDto.getBrs()));
        assignedSelects.addAll(this.mapEqs(selectionDto.getEqs()));
        assignedSelects.addAll(this.mapPaints(selectionDto.getPaints()));
        assignedSelects.addAll(this.mapBas(selectionDto.getBas()));
// more ...
// and more...
return assignedSelects;
}

//我的私有函数的示例，它调用相应的映射器，其中我所有的私有函数都由不同类型的类组成，例如这里的OptionCodeDto。它们不从同一个接口/类扩展，也不能。

java prettyprint-override"> private List<AssignedSelectionCriteria> mapOps(List<OptionCodeDto> optionCodeDtos) {
        return this.assignedOpDtoMapper.mapCriterias(opDtos);
    }

//这是反向映射。我需要与映射返回类型不同的类

// this is my public function for mapping.
public void assignSelectionTo(SelectionDto selectionDto,
    List<AssignedSelectionCriteria> assignedSelectionCriterias) {

    setOptionCodes(selectionDto, copyCriterias);
    setOrderCriteria(selectionDto, copyCriterias);
    // many more
}

这是反向映射私有函数，每个映射类都返回不同类型的dto，例如OptionCodeDto，其中这些Dto都不是从同一个类扩展的。

private void setOptionCodes(SelectionDto selectionDto, List<AssignedSelectionCriteria> assignedSelectionCriterias) {
// this is where I have trouble, each mapping returns different Dto's
        List<OptionCodeDto> optionCodeDtos =
             this.assignedOptionCodeDtoMapper.mapAssignedCriterias(assignedSelectionCriterias;
        selectionDto.setOptionCodes(optionCodeDtos);
    }

Answer 1

有2个解决方案

1.通过所有作为1参数：

假设您在1个构造函数中传递30个参数（它们是DTO），然后生成一个主DTO，其中包含所有30个DTO，并将该DTO作为一个参数传递。

例如：

public class MasterDTO{

private ChildDto1 childDto1 ;
private ChildDto2 childDto2 ;
private ChildDto3 childDto3 ;
...
..
private ChildDto30 childDto30 ;
//public getter setter methds
}

通过30 DTOS的呼叫者等级

public class Caller{
  Functional fun = new Functional(masterDTO);

}

期望值为 30 DTOS 的功能类

class Functional{
  private ChildDto1 childDto1 ;
  private ChildDto2 childDto2 ;
  private ChildDto3 childDto3 ;
...
...

public Functional(MasterDTO masterDTO){
childDto1 = masterDTO.getChildDto1();
childDto2 = masterDTO.getChildDto2();
childDto3 = masterDTO.getChildDto3();

...
...

childDto30 = masterDTO.getChildDto30();
}

}

2. 使用设置器方法：

只传递7个元素作为构造函数的参数，然后使用对象和调用setter方法设置其余23个元素。

通过30 DTOS的呼叫者等级

public class Caller{
  Functional fun = new Functional(childDto1 ,childDto1 , ....childDto7 );
  fun.setChildDto8(childDtoValue8);
  fun.setChildDto9(childDtoValue9);
  fun.setChildDto10(childDtoValue10);
  ...
  ...
  fun.setChildDto30(childDtoValue30);


}

Answer 2

创建已分配的接口选择提供程序

interface AssignedSelectProvider
{
    List<AssignedSelect> getAssignedSelects();
}

每个映射器实现接口，每个私有方法移动到相关的类:

class AssignedOpDtoMapper implements AssignedSelectProvider
{
    public List<AssignedSelect> getAssignedSelects()
    {
        return mapOps(getOps());
    }
}

分配选择映射器获取构造函数中的提供程序列表，而不是 26 个参数：

class AssignedSelectMapper
{
    AssignedSelectMapper(List<AssignedSelectProvider> mappers)
    {
        //...
    }
}

26个参数减少到1个。

Answer 3

这就像是@Michaels答案的扩展。

界面的想法是个好主意。尽管在我看来，界面可以更改为更适合您的用例：

interface SelectDtoProcessor {
     void process(SelectDto dto, 
                  Consumer<? super Collection<? extends AssignedSelect>> action);
}

现在每个映射器都实现此接口：

class AssignedOpDtoMapper implements SelectDtoProcessor {
    @Override
    public void process(SelectDto dto, 
                        Consumer<? super Collection<? extends AssignedSelect>> action){
        List<OptionCodeDto> ops = dto.getOps();
        consumer.accept(mapCriterias(ops));
}

然后将所有这些< code >处理器注入到主类中:

private final List<SelectDtoProcessor> processors;

AssignedSelectMapper(List<SelectDtoProcessor> processors) {
    this.processors = processors;
}

最后迭代方法中的所有处理器：

public List<AssignedSelect> assignSelectFrom(SelectDto selectDto) {
    Objects.requireNonNull(selectionDto, "selectionDto can not be NULL");

    List<AssignedSelect> assignedSelects= new ArrayList<>();
    for(SelectDtoProcessor processor: processors) {
        processor.process(selectDto, assignedSelects::addAll);
    }
    return assignedSelects;
}