如何使用ModelMapper根据源值而不是其类型创建条件转换器？

Question

我正在尝试使用ModelMapper将实体映射到DTO。当@JoinCollie未加载（延迟加载）时，问题就出现了。ModelMapper尝试访问延迟加载实体的属性，然后抛出LazyLaunalizationException。

我已经有了解决这个问题的策略，但我找不到一个ModelMapper功能来满足我的需要。

我需要做的是：对于每个未加载的实体，我将使用工厂创建一个新的目标对象。如果加载了对象，则必须应用默认映射。

以下示例是一个ModelMapper功能，如果它不提供源代码（仅提供源代码类型），它将完全符合我的需要：

public static class MyConverter implements ConditionalConverter<Object, Object> {

    private EntityManager em;

    public MyConverter(EntityManager em) {
        this.em = em;
    }

    @Override
    public MatchResult match(Class<?> sourceType, Class<?> destinationType) {
        Object source = null; // I need the source instead of its type.
        PersistenceUnitUtil persistenceUnitUtil = em.getEntityManagerFactory().getPersistenceUnitUtil();
        return persistenceUnitUtil.isLoaded(source) ? MatchResult.NONE : MatchResult.FULL;
    }

    @Override
    public Object convert(MappingContext<Object, Object> context) {
        return LazyEntityProxyFactory.factory(context.getSource(), context.getDestinationType()); // Creates the target object
    }
}

你们有什么ModelMapper功能可以提供我需要的吗。或者是黑客？

*Obs：我研究了ModelMapper的代码，注意到当ConditionalConverter。匹配称为上下文已经存在，因此它拥有源。如果ModelMapper也有一个ConditionalContextConverter接口，该接口在match方法中传递上下文，该怎么办？只是一个想法。

Answer 1

我刚刚找到了我需要的！秘诀是检查父实体的属性。之后，我能够利用默认映射，如果需要，还可以使用我自己的工厂。

这是我的ConditionalConverter：

public static class MyConverter implements ConditionalConverter<Object, Object> {

    private EntityManager em;

    public MyConverter(EntityManager em) {
        this.em = em;
    }

    @Override
    public MatchResult match(Class<?> sourceType, Class<?> destinationType) {
        return MatchResult.FULL;
    }

    @Override
    public Object convert(MappingContext<Object, Object> context) {
        Object source = context.getSource();
        Object destination = context.getMappingEngine().createDestination(context);

        try {
            Field[] sourceFields = context.getSourceType().getDeclaredFields();
            Field[] destinationFields = context.getDestinationType().getDeclaredFields();
            for (Field sourceField : sourceFields) {
                sourceField.setAccessible(true);
                for (Field destinationField : destinationFields) {
                    destinationField.setAccessible(true);
                    if (sourceField.getName().equals(destinationField.getName())) {
                        Object sourceFieldValue = sourceField.get(source);

                        PersistenceUnitUtil persistenceUnitUtil = em.getEntityManagerFactory().getPersistenceUnitUtil();
                        if (persistenceUnitUtil.isLoaded(sourceFieldValue)) {
                            MappingContext<?, ?> myContext = context.create(sourceFieldValue, destinationField.getType());
                            Object destinationValue = context.getMappingEngine().map(myContext);
                            destinationField.set(destination, destinationValue);
                        } else {
                            // Here is your factory call;
                            destinationField.set(destination, SomeFactory.factory(sourceFieldValue, destinationField.getType()));
                        }
                        break;
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return destination;
    }
}