主页 / coding / 问题 / 79565803
Accepted
r-uu
Asked: 2025-04-10 13:41:57 +0800 CST

如何确保 MapStruct 使用带有 @ObjectFactory 注释的方法

  • 772

我希望将我的映射过程标准化，使其遵循特定的方案。因此，我引入了一些通用接口，它们有助于减少为新类型编写新映射器的工作量。以下是针对类型的接口：

import lombok.NonNull;

public interface MappableCyclic<IN extends MappableCyclic<IN, OUT>, OUT extends MappableCyclic<OUT, IN>>
{
    void beforeMapping(@NonNull IN in, @NonNull OUT out, @NonNull ReferenceCycleTracking context);
    void  afterMapping(@NonNull IN in, @NonNull OUT out, @NonNull ReferenceCycleTracking context);
}

ReferenceCycleTracking是 mapstruct 上下文的典型实现，用于避免在映射具有循环依赖关系的对象时出现无限递归。此外，还有一个用于映射器的通用父接口：

public interface MappableCyclicMapper<IN extends MappableCyclic<IN, OUT>, OUT extends MappableCyclic<OUT, IN>>
{
    @NonNull OUT map(@NonNull IN in, @NonNull @Context ReferenceCycleTracking context);

    @BeforeMapping default void beforeMapping(
            @NonNull                IN                     in,
            @NonNull @MappingTarget OUT                    out,
            @NonNull @Context       ReferenceCycleTracking context)
    {
        out.beforeMapping(out, in, context);
    }

    @AfterMapping default void afterMapping(
            @NonNull                IN               in,
            @NonNull @MappingTarget OUT              out,
            @NonNull @Context ReferenceCycleTracking context)
    {
        out.afterMapping(out, in, context);
    }

    @NonNull Class<OUT> outType();
    @NonNull OUT        create(IN in);

    /**
     * object factory should be called by mapstruct during generated {@link #map(MappableCyclic, ReferenceCycleTracking)}
     * implementation
     */
    @ObjectFactory default @NonNull OUT lookupOrCreate(@NonNull IN in, @NonNull ReferenceCycleTracking context)
    {
        OUT out = context.get(in, outType());
        if (out == null)
        {
            out = create(in);
            context.put(in, out);
        }
        return out;
    }
}

最后，这是我的两个可映射类型的映射器接口：

@Mapper interface Map_TaskGroup_EntityDTO_EntityJPA extends MappableCyclicMapper<TaskGroupEntityDTO, TaskGroupEntityJPA>
{
    Map_TaskGroup_EntityDTO_EntityJPA INSTANCE = Mappers.getMapper(Map_TaskGroup_EntityDTO_EntityJPA.class);

    @NonNull TaskGroupEntityJPA map(@NonNull TaskGroupEntityDTO input, @NonNull @Context ReferenceCycleTracking context);

    @Override default @NonNull Class<TaskGroupEntityJPA> outType() { return TaskGroupEntityJPA.class; }

    @Override default @NonNull TaskGroupEntityJPA create(TaskGroupEntityDTO in) { return new TaskGroupEntityJPA(in.name()); }

    @ObjectFactory
    @Override default @NonNull TaskGroupEntityJPA lookupOrCreate(
            @NonNull TaskGroupEntityDTO taskGroupEntityDTO, @NonNull ReferenceCycleTracking context)
    {
        return MappableCyclicMapper.super.lookupOrCreate(taskGroupEntityDTO, context);
    }
}

我预期 mapstruct 会使用@ObjectFactory父接口中提供的方法，但实际上并没有。因此，我尝试在上面的子接口中添加一个对象工厂方法来帮助 mapstruct。然而，mapstruct 生成的该接口的实现忽略了我的对象工厂方法：

    @Override
    public TaskGroupEntityJPA map(TaskGroupEntityDTO input, ReferenceCycleTracking context) {
        TaskGroupEntityJPA target = context.get( input, TaskGroupEntityJPA.class );
        if ( target != null ) {
            return target;
        }

        if ( input == null ) {
            return null;
        }

        String name = null;

        TaskGroupEntityJPA taskGroupEntityJPA = new TaskGroupEntityJPA( name );

        context.put( input, taskGroupEntityJPA );
        beforeMapping( input, taskGroupEntityJPA, context );

        afterMapping( input, taskGroupEntityJPA, context );

        return taskGroupEntityJPA;
    }

我如何确保我的对象工厂方法不再被忽略？

java

2 个回答

  1. 为对象工厂使用专用的抽象类。

    接口中的默认方法在 Java 中算是“可选的附加组件”。它们实际上并不像抽象类中的方法那样属于继承层次结构的一部分。因此，MapStruct 无法可靠地处理它们。它必须确定是否在生成的映射器中包含默认方法、复制逻辑，还是完全忽略它。这可能会导致一些奇怪的行为或不一致。

    如果有多个接口的默认方法相互重叠或冲突，情况会变得更加混乱。Java 本身无法很好地处理这种情况——它让程序员自行决定使用哪种实现。因此，当 MapStruct 尝试在这些场景下生成代码时，可能会因为歧义而陷入困境。

    当默认方法用于关键逻辑（例如对象创建或工厂逻辑@ObjectFactory）时，这个问题尤其严重。有时 MapStruct 会将它们包含在生成的映射器中，有时则不会——这很不可靠。另一方面，抽象类避免了所有这些混淆。它们被视为具体继承链的一部分，因此 MapStruct 在生成代码时始终知道要覆盖抽象方法还是调用具体方法。这确保了一切的一致性，尤其是对于循环映射或自定义对象工厂等复杂功能。

    简而言之，抽象类对于 MapStruct 来说更加可预测和可靠。它们不包含接口中默认方法可能引入的所有可选的、模糊的行为。

    下面的抽象基类

    import org.mapstruct.AfterMapping;
import org.mapstruct.BeforeMapping;
import org.mapstruct.Context;
import org.mapstruct.MappingTarget;

public abstract class AbstractMappableCyclicMapper<
        IN extends MappableCyclic<IN, OUT>,
        OUT extends MappableCyclic<OUT, IN>> {

    public abstract @NonNull OUT map(@NonNull IN in, @NonNull @Context ReferenceCycleTracking context);

    @BeforeMapping
    public void beforeMapping(
            @NonNull IN in,
            @NonNull @MappingTarget OUT out,
            @NonNull @Context ReferenceCycleTracking context) {
        out.beforeMapping(out, in, context);
    }

    @AfterMapping
    public void afterMapping(
            @NonNull IN in,
            @NonNull @MappingTarget OUT out,
            @NonNull @Context ReferenceCycleTracking context) {
        out.afterMapping(out, in, context);
    }

    protected abstract @NonNull Class<OUT> outType();

    protected abstract @NonNull OUT create(@NonNull IN in);

    @ObjectFactory
    public @NonNull OUT lookupOrCreate(@NonNull IN in, @NonNull @Context ReferenceCycleTracking context) {
        OUT out = context.get(in, outType());
        if (out == null) {
            out = create(in);
            context.put(in, out);
        }
        return out;
    }
}

    Mapper 实现

    import org.mapstruct.Context;
import org.mapstruct.Mapper;

@Mapper
public abstract class Map_TaskGroup_EntityDTO_EntityJPA
        extends AbstractMappableCyclicMapper<TaskGroupEntityDTO, TaskGroupEntityJPA> {

    @Override
    protected @NonNull Class<TaskGroupEntityJPA> outType() {
        return TaskGroupEntityJPA.class;
    }

    @Override
    protected @NonNull TaskGroupEntityJPA create(@NonNull TaskGroupEntityDTO in) {
        return new TaskGroupEntityJPA(in.name());
    }
}
    • 0
  2. Best Answer

    对象工厂方法未被考虑的原因并非因为它是接口中的“默认”方法，而是因为在我的示例中，“ReferenceCycleTracking”参数缺少“@Context”注解。

    • 0

相关问题