如何使用mapstruct将枚举转换为POJO？

Question

如何使用mapstruct并且不使用自定义实现将枚举转换为POJO？

e.g。

enum Type {
  T1, T2;

  private String description;

  private Type(String description) {
      this.description = description;
  }

  public String getDescription() { return this.description; }
}

喜欢POJO

class TypeDto {
   private Type code;
   private String description;
}

FYI， 我使用MapStruct 1.1.0.Final。

Answer 1

MapStruct无法为您自动处理。只需手动实现映射。 MapStruct的目的不是为您处理每个映射案例，而是自动执行常见的80％并让您自己处理更具异国情调的案例。

Answer 2

您无法直接从枚举转换为对象。

您需要创建一个TypeMapper和一个实现来处理转换。

TypeConversion

public class TypeConversion {
    public static void main(String[] args) {
        TypeDto t1 = TypeMapper.INSTANCE.typeToTypeDto(Type.T1);
        TypeDto t2 = TypeMapper.INSTANCE.typeToTypeDto(Type.T2);

        System.out.println(t1);
        System.out.println(t2);
    }
}

类型

public enum Type {
    T1("T-One"),
    T2("T-Two");

    private final String description;

    private Type(String description) {
        this.description = description;
    }

    public String getDescription() {
        return this.description;
    }
}

TypeDto

public class TypeDto {
    private String description;

    public TypeDto() {
        this("");
    }

    public TypeDto(String description) {
        this.description = description;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    @Override
    public String toString() {
        return String.format("TypeDto { \"description\": \"%s\" }", description);
    }
}

TypeMapper

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;

@Mapper
public interface TypeMapper {
    TypeMapper INSTANCE = Mappers.getMapper(TypeMapper.class);

    @Mapping(source = "description", target = "description")
    TypeDto typeToTypeDto(Type type);
 }

TypeMapperImpl

public class TypeMapperImpl implements TypeMapper {
    @Override
    public TypeDto typeToTypeDto(Type type) {
        if (type == null) {
            return null;
        }

        return new TypeDto(type.getDescription());
    }
}

您可以通过创建通用映射器来重复使用此映射器。

EnumMapper

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;

@Mapper
public interface EnumMapper<T, U extends Enum<?>> {
    @Mapping(target = "description")
    T enumToObject(U type);
 }

EnumMapperImpl

public abstract class EnumMapperImpl<T, U extends Enum<?>> implements EnumMapper<T, U> {
    @Override
    public T enumToObject(U type) {
        if (type == null) {
            return null;
        }

        return convert(type);
    }

    protected abstract T convert(U type);
}

然后你可以在你的TypeMapper中使用它。

TypeMapper

import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;

@Mapper
public interface TypeMapper extends EnumMapper<TypeDto, Type> {
    TypeMapper INSTANCE = Mappers.getMapper(TypeMapper.class);
}

TypeMapperImpl

public class TypeMapperImpl extends EnumMapperImpl<TypeDto, Type> implements TypeMapper {
    @Override
    protected TypeDto convert(Type type) {
        return new TypeDto(type.getDescription());
    }   
}

Answer 3

我现在用它

default TypeDto typeToTypeDto(Type type) {
    return new TypeDto(type.name(), type.getName());
}

由于缺乏其他解决方案。