Java枚举适配多值TYPE4的实现方案咨询

我有如下Java枚举类，此前所有枚举变量均为单值类型。但现在TYPE4需要支持TYPE_A、TYPE_B、TYPE_C三个可选值之一。我原本希望直接修改该枚举以适配TYPE4的需求，但考虑到仅存在一个多值类型，不确定是否需要改用映射对象而非枚举，恳请各位提供相关见解，谢谢。

public enum Record {
    TYPE1("TYPE1"),
    TYPE2("TYPE2"),
    TYPE3("TYPE3"),
    TYPE4_MULTI(TYPE_A or TYPE_B or TYPE_C); 

    private final String value;
    public static final Map<Record, String> enumMap = new EnumMap<Record, String>(
        Record.class);

    static {
        for (Record e : Record.values())
            enumMap.put(e, e.getValue());
    }

    Record(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

业务中，我使用该枚举在工厂类中确定需实例化的子类类型。每个子类自行声明其类型：

@Override
public String getType() {
    return Record.TYPE1.getValue();
}

工厂类预构建子类缓存的实现如下：

@Component
public class RecordProcessorFactory {

    @Autowired
    public RecordProcessorFactory(List<RecordProcessor> processors) {
        for (RecordProcessor recordProcessor : processors) {
            processorCache.put(recordProcessor.getType(), recordProcessor);
        }
    }

    private static final Map<String, RecordProcessor> processorCache = new HashMap<String, RecordProcessor>();

    public RecordProcessor getSyncProcessor(String type) {
        RecordProcessor service = processorCache.get(type);
        if(service == null) throw new RuntimeException("Unknown service type: " + type);
        return service;
    }
}

方案1：扩展枚举支持多值，最小改动现有代码 #

既然只有TYPE4需要多值，没必要直接放弃枚举。可以修改枚举的存储结构，把value从单个String改成Set<String>，同时保留单值场景的兼容逻辑：

import java.util.*;
import java.util.stream.Collectors;

public enum Record {
    TYPE1("TYPE1"),
    TYPE2("TYPE2"),
    TYPE3("TYPE3"),
    TYPE4_MULTI("TYPE_A", "TYPE_B", "TYPE_C"); 

    private final Set<String> values;
    public static final Map<String, Record> valueToEnumMap = new HashMap<>();

    static {
        for (Record e : Record.values()) {
            e.values.forEach(val -> valueToEnumMap.put(val, e));
        }
    }

    Record(String... values) {
        this.values = new HashSet<>(Arrays.asList(values));
    }

    public Set<String> getValues() {
        return Collections.unmodifiableSet(values);
    }

    // 兼容原有单值场景的方法
    public String getValue() {
        if (values.size() == 1) {
            return values.iterator().next();
        }
        throw new UnsupportedOperationException("This enum has multiple values");
    }

    // 根据字符串值获取对应的枚举
    public static Record fromValue(String value) {
        return valueToEnumMap.get(value);
    }
}

配套工厂类修改 #

@Component
public class RecordProcessorFactory {

    private static final Map<String, RecordProcessor> processorCache = new HashMap<>();

    @Autowired
    public RecordProcessorFactory(List<RecordProcessor> processors) {
        for (RecordProcessor recordProcessor : processors) {
            String type = recordProcessor.getType();
            Record recordEnum = Record.fromValue(type);
            if (recordEnum == Record.TYPE4_MULTI) {
                // 把TYPE_A、TYPE_B、TYPE_C都映射到同一个处理器
                recordEnum.getValues().forEach(val -> processorCache.put(val, recordProcessor));
            } else {
                processorCache.put(type, recordProcessor);
            }
        }
    }

    public RecordProcessor getSyncProcessor(String type) {
        RecordProcessor service = processorCache.get(type);
        if(service == null) throw new RuntimeException("Unknown service type: " + type);
        return service;
    }
}

这种方案的优势：

• 原有单值枚举的使用逻辑完全不受影响
• 仅需修改枚举和工厂类的少量代码，侵入性极低

方案2：改用映射对象（适合未来多值场景扩展） #

如果担心后续会出现更多多值类型需求，或者觉得枚举的多值逻辑不够直观，可以改用静态类+常量的方式：

import java.util.*;
import java.util.stream.Stream;

public class RecordType {
    private final Set<String> values;

    private RecordType(String... values) {
        this.values = new HashSet<>(Arrays.asList(values));
    }

    public static final RecordType TYPE1 = new RecordType("TYPE1");
    public static final RecordType TYPE2 = new RecordType("TYPE2");
    public static final RecordType TYPE3 = new RecordType("TYPE3");
    public static final RecordType TYPE4_MULTI = new RecordType("TYPE_A", "TYPE_B", "TYPE_C");

    private static final Map<String, RecordType> valueToTypeMap = new HashMap<>();

    static {
        Stream.of(TYPE1, TYPE2, TYPE3, TYPE4_MULTI)
              .forEach(type -> type.values.forEach(val -> valueToTypeMap.put(val, type)));
    }

    public Set<String> getValues() {
        return Collections.unmodifiableSet(values);
    }

    public String getValue() {
        if (values.size() == 1) {
            return values.iterator().next();
        }
        throw new UnsupportedOperationException("This type has multiple values");
    }

    public static RecordType fromValue(String value) {
        return valueToTypeMap.get(value);
    }
}

这种方式灵活性更高，但需要修改所有原有使用枚举的代码（比如Record.TYPE1改成RecordType.TYPE1），改动量比方案1大。

方案3：新增独立映射类（完全不改动原有枚举） #

如果完全不想修改原有枚举代码，可以新增一个映射类来处理多值逻辑：

// 原有枚举保持不变
public enum Record {
    TYPE1("TYPE1"),
    TYPE2("TYPE2"),
    TYPE3("TYPE3"),
    TYPE4_MULTI("TYPE4"); // 保留占位值

    private final String value;
    public static final Map<Record, String> enumMap = new EnumMap<>(Record.class);

    static {
        for (Record e : Record.values())
            enumMap.put(e, e.getValue());
    }

    Record(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

// 新增多值映射类
public class RecordMultiValue {
    public static final Set<String> TYPE4_VALUES = Set.of("TYPE_A", "TYPE_B", "TYPE_C");
    public static final Map<String, Record> VALUE_TO_RECORD = new HashMap<>();

    static {
        // 映射TYPE4的多值到枚举
        TYPE4_VALUES.forEach(val -> VALUE_TO_RECORD.put(val, Record.TYPE4_MULTI));
        // 映射原有单值枚举
        for (Record r : Record.values()) {
            if (!r.equals(Record.TYPE4_MULTI)) {
                VALUE_TO_RECORD.put(r.getValue(), r);
            }
        }
    }

    public static Record fromValue(String value) {
        return VALUE_TO_RECORD.get(value);
    }
}

然后修改工厂类的初始化逻辑，通过RecordMultiValue来关联多值和处理器即可。这种方式完全不侵入原有代码，但需要额外维护一个映射类。

• 仅单个临时多值需求：方案1最优，改动小且兼容原有逻辑
• 未来可能有更多多值场景：方案2更具扩展性
• 完全不能修改原有枚举：方案3是折中选择

内容的提问来源于stack exchange，提问作者Timothy Clotworthy