Java - 枚举转换器的通用抽象类

Question

我有一些枚举是 name("String") 和 value("Integer") 对，当前在每个枚举中我必须为 Json Deserialize 实现一个 @JsonCreator 方法，输入可以是名称或值

//User Enum
public enum UserType {
   StakeHolder(1),...

   private static final Map<String, UserType> helper = ImmutableMap.<String, UserType>builder()
            .put(String.valueOf(StakeHolder.getValue()), StakeHolder)
            .put(StakeHolder.name(), StakeHolder)
            .build();

   @JsonCreator
   public static UserType jsonDeserialize(String json) {
        return helper.get(json);
   }
}

//Role Enum
public enum RoleType {
   Admin(1),...

   private static final Map<String, RoleType> helper = ImmutableMap.<String, RoleType>builder()
            .put(String.valueOf(Admin.getValue()), Admin)
            .put(Admin.name(), Admin)
            .build();

   @JsonCreator
   public static RoleType jsonDeserialize(String json) {
        return helper.get(json);
   }
}

但我想知道是否有任何方法可以创建一个可以实现整体枚举的抽象类，这是为了避免在我的每个枚举中始终实现类似的“重复”代码。当前的代码就像

public abstract class JsonDeserializeEnum<E extends Enum<E>> {
  // protected Enum<E> myEnums;
  // private static final Map<String, E> myEnumHelper; ???

  public JsonDeserializeEnum() {
    super();
    // how to loop through myEnums to do something like
    // for(E iterator : myEnums.value()) not work...myEnums is not a collection of enums?
    // myEnumHelper.put(String.valueOf(iterator.getValue()), (E) iterator);
    // myEnumHelper.put(iterator.name, (E) iterator);
  } 

  @JsonCreator
   public static E jsonDeserialize(String json) {
        return myEnumHelper.get(json);
   }
}

//then
public enum UserType implements JsonDeserializeEnum<UserType>{
    StakeHolder(1),...
}
public enum RoleType implements JsonDeserializeEnum<RoleType>{
    Admin(1),...
}

我在这里遇到了两个挑战，

1) 我想在我的抽象类中有一个初始化/构造函数，可以将所有可用的枚举加载到静态映射中（仅一次），例如，

调用UserType时，将所有用户类型枚举加载到静态映射中，然后从该映射中反序列化；调用RoleType时，将所有角色类型枚举加载到map中，然后从同一个map中反序列化

2）如果 No.1 是不可能的，那没关系，假设我是否会在我的抽象类中摆脱映射，但仍然使用我的每个枚举中定义的映射，我的抽象类是否知道并且可以使用我的枚举中定义的地图吗？

Answer 1

关键是使用JsonDeserializer。首先，您需要使用一个接口才能对所有枚举使用相同的代码：

public interface ValueEnum {
    String name();
    int value();
}

并在每个枚举中实现它

public enum EnumExample implements ValueEnum {

    Hello(1),
    World(2);

    public final int value;

    private EnumExample(int value) {
        this.value = value;
    }

    @Override
    public int value() {
        return value;
    }
}

（name() 已经被 Enum 实现了）

然后你可以将你的地图创建移动到一个单独的类（我使用java HashMap，你可以使用任何你喜欢的）

public class ValueEnumDeserializer<T extends ValueEnum> extends JsonDeserializer<T> {

    private final HashMap<String, T> map;

    public ValueEnumDeserializer(Class<T> c) {
        map = new HashMap<>();
        for (final T i : c.getEnumConstants()) {
            map.put(i.name(), i);
            map.put(String.valueOf(i.value()), i);
        }
    }

    @Override
    public T deserialize(JsonParser p, DeserializationContext ctxt)
            throws IOException, JsonProcessingException {
        return map.get(p.getText());
    }
}

然后，当您创建对象映射器时，您必须传递反序列化器

    final ObjectMapper mapper = new ObjectMapper();
    final SimpleModule module = new SimpleModule();
    module.addDeserializer(EnumExample1.class, new ValueEnumDeserializer<>(EnumExample1.class));
    module.addDeserializer(EnumExample2.class, new ValueEnumDeserializer<>(EnumExample2.class));
    module.addDeserializer(EnumExample3.class, new ValueEnumDeserializer<>(EnumExample3.class));
    mapper.registerModule(module);