Spring Boot中复杂状态映射枚举的替代实现方案咨询

针对你当前枚举类过于臃肿、维护困难的问题，以下是两种代码层面的替代方案，均无需依赖数据库：

方案一：Spring Boot @ConfigurationProperties 加载YAML配置 #

利用Spring Boot的配置绑定能力，将状态映射数据存放在YAML文件中，通过配置类加载后封装成服务类提供查询能力，完全解耦数据与业务逻辑。

1. 编写YAML配置文件（src/main/resources/status-mappings.yml） #

把所有系统状态的映射关系结构化存储：

status-mappings:
  entries:
    - system1: "Status1"
      system2: "status_1"
      system3: "STATUS_1"
      system4: "stat1"
    - system1: "Status2"
      system2: "status_2"
      system3: "STATUS_2"
      system4: "stat2"
    - system1: "Status3"
      system2: "status_3"
      system3: "STATUS_3"
      system4: "stat3"
    - system1: "Status4"
      system2: "status_4"
      system3: "STATUS_4"
      system4: "stat4"

2. 创建配置类绑定YAML数据 #

package com.foo;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;

@Component
@ConfigurationProperties(prefix = "status-mappings")
@Data
public class StatusMappingProperties {
    private List<StatusEntry> entries;

    @Data
    public static class StatusEntry {
        private String system1;
        private String system2;
        private String system3;
        private String system4;
    }
}

（注：如果不用Lombok，手动生成getter/setter即可）

3. 封装状态查询服务类 #

初始化时构建各种映射关系的Map，提供简洁的查询方法：

package com.foo;

import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

@Service
public class StatusMappingService {
    private final StatusMappingProperties properties;

    // 预构建各种查询映射
    private Map<String, String> system1ToSystem2;
    private Map<String, String> system1ToSystem3;
    private Map<String, String> system2ToSystem3;
    private Map<String, String> system2ToSystem4;

    public StatusMappingService(StatusMappingProperties properties) {
        this.properties = properties;
    }

    @PostConstruct
    public void initializeMappings() {
        system1ToSystem2 = new HashMap<>();
        system1ToSystem3 = new HashMap<>();
        system2ToSystem3 = new HashMap<>();
        system2ToSystem4 = new HashMap<>();

        properties.getEntries().forEach(entry -> {
            system1ToSystem2.put(entry.getSystem1(), entry.getSystem2());
            system1ToSystem3.put(entry.getSystem1(), entry.getSystem3());
            system2ToSystem3.put(entry.getSystem2(), entry.getSystem3());
            system2ToSystem4.put(entry.getSystem2(), entry.getSystem4());
            // 可按需添加更多映射
        });
    }

    // 查询方法示例
    public String getSystem2FromSystem1(String system1Status) {
        return Optional.ofNullable(system1ToSystem2.get(system1Status)).orElse(null);
    }

    public String getSystem3FromSystem1(String system1Status) {
        return Optional.ofNullable(system1ToSystem3.get(system1Status)).orElse(null);
    }

    public String getSystem3FromSystem2(String system2Status) {
        return Optional.ofNullable(system2ToSystem3.get(system2Status)).orElse(null);
    }

    public String getSystem4FromSystem2(String system2Status) {
        return Optional.ofNullable(system2ToSystem4.get(system2Status)).orElse(null);
    }
}

优势 #

• 数据与代码分离，新增/修改状态无需修改Java代码，仅需调整YAML文件
• 映射逻辑集中在服务类，避免枚举中大量重复的静态方法
• 支持多环境配置（开发/测试/生产环境可使用不同的YAML配置）

方案二：静态加载资源文件（非Spring绑定场景） #

如果不需要Spring的配置绑定能力，可直接读取classpath下的YAML/Properties文件，手动解析并构建映射：

示例代码（使用SnakeYAML解析YAML） #

1. 引入SnakeYAML依赖（Maven）：

<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
    <version>2.2</version>
</dependency>

2. 静态加载类：

package com.foo;

import org.yaml.snakeyaml.Yaml;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

public class StaticStatusMapping {
    private static final Map<String, String> system1ToSystem2 = new HashMap<>();

    static {
        try (InputStream inputStream = StaticStatusMapping.class.getClassLoader().getResourceAsStream("status-mappings.yml")) {
            Yaml yaml = new Yaml();
            Map<String, Object> data = yaml.load(inputStream);
            List<Map<String, String>> entries = (List<Map<String, String>>) ((Map<String, Object>) data.get("status-mappings")).get("entries");
            
            entries.forEach(entry -> {
                system1ToSystem2.put(entry.get("system1"), entry.get("system2"));
                // 构建其他映射
            });
        } catch (Exception e) {
            throw new RuntimeException("Failed to load status mappings", e);
        }
    }

    public static String getSystem2FromSystem1(String system1Status) {
        return system1ToSystem2.getOrDefault(system1Status, null);
    }
}

优势 #

• 无需依赖Spring环境，适合非Spring项目
• 同样实现数据与代码分离

对比原枚举方案的改进点 #

• 原枚举硬编码数据，修改需重新编译；新方案修改配置文件即可，无需重新编译
• 原枚举中大量重复的静态查询方法，新方案将映射逻辑集中管理，维护更方便
• 新方案支持多环境配置，枚举无法做到

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