Java 通过ModelMapper映射抽象类

我有这样一个简单的类结构，它有抽象类和子类。我希望使用将它们映射到目标类结构

我已经检查过了，其他与映射抽象类相关的问题中的任何解决方案都不能解决我的问题。并且在某种程度上与我想要实现的目标最接近，但在下面的场景中，它仍然失败

我从

ModelMapper

获得的验证消息是：

org.modelmapper.MappingException: ModelMapper mapping errors:

1) Failed to instantiate instance of destination 
com.mls.services.MapperTest$DestParent. Ensure that 
com.mls.services.MapperTest$DestParent has a non-private no-argument 
constructor.
...

我很清楚，DestParent类是抽象的，不能实例化

有什么办法可以让它工作吗

下面是一个测试源代码作为JUnit测试用例。如果我尝试修复此问题，则底部的断言失败或验证引发异常：

public class MapperTest {

  abstract static class SourceParent {}

  static class SourceSubA extends SourceParent {}

  static class SourceSubB extends SourceParent {}

  abstract static class DestParent {}

  static class DestSubA extends DestParent {}

  static class DestSubB extends DestParent {}

  static class Source {
    SourceParent item;

    public SourceParent getItem() {return item;}
    public void setItem(SourceParent item) {this.item = item;}
  }

  static class Dest {
    DestParent item;

    public DestParent getItem() {return item;}
    public void setItem(DestParent item) {this.item = item;}
  }

  @Test
  public void test() {
    ModelMapper modelMapper = new ModelMapper();

    TypeMap<Source, Dest> typeMap = modelMapper.createTypeMap(Source.class, Dest.class);

    // modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.LOOSE);

    modelMapper
        .createTypeMap(SourceSubA.class, DestParent.class)
        .setConverter(
            mappingContext -> modelMapper.map(mappingContext.getSource(), DestSubA.class));

    modelMapper
        .createTypeMap(SourceSubB.class, DestParent.class)
        .setConverter(
            mappingContext -> modelMapper.map(mappingContext.getSource(), DestSubB.class));

    typeMap.addMapping(Source::getItem, Dest::setItem);

    TypeMap<SourceParent, DestParent> itemTypeMap =
        modelMapper.createTypeMap(SourceParent.class, DestParent.class);
    itemTypeMap.include(SourceSubA.class, DestSubA.class);
    itemTypeMap.include(SourceSubB.class, DestSubB.class);

    Source source = new Source();
    source.item = new SourceSubB();
    Dest dest = modelMapper.map(source, Dest.class);
    modelMapper.validate();

    Assert.assertTrue(dest.item instanceof DestSubB);
  }
}

公共类映射测试{
抽象静态类SourceParent{}
静态类SourceSubA扩展了SourceParent{}
静态类SourceSubB扩展了SourceParent{}
抽象静态类DestParent{}
静态类DestSubA扩展DestParent{}
静态类destsub扩展DestParent{}
静态类源{
源父项；
public SourceParent getItem（）{return item；}
public void setItem（SourceParent item）{this.item=item；}
}
静态类Dest{
删除父项；
public DestParent getItem（）{return item；}
public void setItem（DestParent item）{this.item=item；}
}
@试验
公开无效测试（）{
ModelMapper ModelMapper=新的ModelMapper（）；
TypeMap TypeMap=modelMapper.createTypeMap（Source.class，Dest.class）；
//modelMapper.getConfiguration（）.setMatchingStrategy（MatchingStrategies.LOOSE）；
模型映射器
.createTypeMap（SourceSubA.class、DestParent.class）
.setConverter(
mappingContext->modelMapper.map（mappingContext.getSource（），DestSubA.class））；
模型映射器
.createTypeMap（SourceSubB.class，DestParent.class）
.setConverter(
mappingContext->modelMapper.map（mappingContext.getSource（），DestSubB.class））；
addMapping（Source:：getItem，Dest:：setItem）；
类型映射项类型映射=
createTypeMap（SourceParent.class，DestParent.class）；
itemTypeMap.include（SourceSubA.class、DestSubA.class）；
itemTypeMap.include（SourceSubB.class、DestSubB.class）；
Source Source=新源（）；
source.item=新的SourceSubB（）；
Dest Dest=modelMapper.map（源，Dest.class）；
modelMapper.validate（）；
Assert.assertTrue（dest.item instanceof DestSubB）；
}
}