如何使用@oneToMany 映射包含其他对象的对象

Question

给定如下定义的 Source 类：

class Person{
    private String name;
    private int age;
    @OneToMany(fetch = FetchType.LAZY, mappedBy = "peroson")
    List<Phone> phones
    // getters and setters
}

以及如下定义的电话类：

class Phone{
        private Long id;
        private String phoneNumber;
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "person")
        private Person person;
        // getters and setters
    }

和 DTO 对象：

class PersonDTO{
        private String name;
        private int age;
        List<PhoneDTO> phones
        // getters and setters
    }

class PhoneDTO{
            private Long id;
            private String phoneNumber;
            private PersonDTO person;
            // getters and setters
        }

我有一个界面：

@Mapper(uses={PersonMapper.class})
interface PhoneMapper{
    PhoneDTO toDto(Phone source);
    Phone toEntity(PhoneDTO source);
}

 @Mapper(uses={PhoneMapper.class})
    interface PersonMapper{
        PersonDTO toDto(Person source);
        Person toEntity(PersonDTO source);
    }

当我使用PeronMapper 或PhoneMapper 时，会出现递归调用，因为PersonMapper 使用PhoneMapper 和PersonMapper 使用PhoneMapper。

如何解决？

Answer 1

有很多方法可以避免递归。

第一个选项：

通过在您的一个映射器中显式忽略来避免

第二个选项：

使用@Context 并编写您自己的备忘录。在 mapstruct 示例 repo 中有一个示例 mapstruct-mapping-with-cycles。

这个想法是有一个@Context

public class CycleAvoidingMappingContext {
    private Map<Object, Object> knownInstances = new IdentityHashMap<Object, Object>();

    @BeforeMapping
    public <T> T getMappedInstance(Object source, @TargetType Class<T> targetType) {
        return (T) knownInstances.get( source );
    }

    @BeforeMapping
    public void storeMappedInstance(Object source, @MappingTarget Object target) {
        knownInstances.put( source, target );
    }
}

然后将此上下文的实例传递给您的映射器：

@Mapper(uses={PersonMapper.class})
interface PhoneMapper{
    PhoneDTO toDto(Phone source, @Context CycleAvoidingContext context);
    Phone toEntity(PhoneDTO source, @Context CycleAvoidingContext context);
}

@Mapper(uses={PhoneMapper.class})
interface PersonMapper{
    PersonDTO toDto(Person source, @Context CycleAvoidingContext context);
    Person toEntity(PersonDTO source, @Context CycleAvoidingContext context);
}

当然CycleAvoidingMappingContext 可以有更多指定的来源，而不仅仅是Object。例如，您可以为Person 和PersonDTO 设置一个。如何实现它取决于您。

编辑：

当映射器之间存在循环依赖时，唯一的解决方案是使用依赖注入框架。默认 MapStruct Mappers 工厂不支持循环。