Springboot枚举自定义序列化

package xxxxxxxxxxxxx;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.module.SimpleModule;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Slf4j
@Configuration
public class JacksonConfig {

    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        module.addSerializer(Enum.class, new GenericEnumSerializer());
        mapper.registerModule(module);
        return mapper;
    }
    public static class GenericEnumSerializer extends JsonSerializer<Enum> {
        private static final Map<Class<? extends Enum<?>>, Field> enumFieldCache = new ConcurrentHashMap<>();
        @Override
        public void serialize(Enum anEnum, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
            jsonGenerator.writeStartObject();
            Class<?> enumClass = anEnum.getClass();
            try {
                jsonGenerator.writeStringField("key", anEnum.name());
                Field nameField = enumFieldCache.computeIfAbsent((Class<? extends Enum<?>>) enumClass, cls -> {
                    try {
                        Field field = cls.getDeclaredField("name");
                        field.setAccessible(true);
                        return field;
                    } catch (NoSuchFieldException e) {
                        log.warn("no 'name' field in enum class: {}", cls.getName());
                        return null;
                    }
                });
                if (nameField != null) {
                    String val = nameField.get(anEnum).toString();
                    jsonGenerator.writeStringField("value", val);
                }
            } catch (IllegalAccessException e) {
                log.warn("Cannot access 'name' field in enum class: {}", enumClass.getName());
            }
            jsonGenerator.writeEndObject();
        }
    }
}

 

 

 

{
  "name": "test",
  "test": {
    "key": "dev",
    "value": "开发"
  },
  "a": {
    "key": "A",
    "value": "A1"
  },
  "b": {
    "key": "X",
    "value": "X1"
  }
}

 

 

聚合全部的枚举到一个接口，一起返回

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.base.CaseFormat;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.Resource;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.reflections.Reflections;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

@Slf4j
@RestController
@RequestMapping("/api/enum")
@ConditionalOnProperty(value = "enums.package")
public class EnumController {


    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class Enums {
        private Map<String, Map<String, String>> map = new HashMap<>();
        private Map<String, List<Option>> list = new HashMap<>();
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class Option {
        private String label;
        private String value;
    }

    private static final Enums ENUMS = new Enums();

    @Resource
    private ObjectMapper objectMapper;

    @Value("${enums.package}")
    private String enumsPackage;

    @Value("${enums.getNameMethod}")
    private String enumGetNameMethod;

    @PostConstruct
    public void init() throws JsonProcessingException {
        if (ObjectUtils.isEmpty(enumsPackage)) {
            log.warn("enums.package is empty, failed to scan enums");
            return;
        }

        // Scan enums package and get all enums
        Reflections reflections = new Reflections(enumsPackage);
        Set<Class<? extends Enum>> enumClasses = reflections.getSubTypesOf(Enum.class);

        Map<String, Map<String, String>> allMap = enumClasses.stream()
                .collect(Collectors.toMap(
                        enumClass -> CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, enumClass.getSimpleName()),
                        enumClass -> getEnumMap(enumClass)
                ));

        Map<String, List<Option>> allList = enumClasses.stream()
                .collect(Collectors.toMap(
                        enumClass -> CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, enumClass.getSimpleName()),
                        enumClass -> getEnumOptions(enumClass)
                ));

        ENUMS.setMap(allMap);
        ENUMS.setList(allList);
        log.info("EnumsController init, enums: {}", objectMapper.writeValueAsString(ENUMS));

    }

    private Map<String, String> getEnumMap(Class<? extends Enum> enumClass) {
        Map<String, String> map = new HashMap<>();
        try {
            Method getNameMethod = enumClass.getMethod(enumGetNameMethod);
            for (Enum<?> enumConstant : enumClass.getEnumConstants()) {
                String name = (String) getNameMethod.invoke(enumConstant);
                map.put(enumConstant.name(), name);
            }
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            log.error("Failed to get enum map for class {}", enumClass.getSimpleName(), e);
        }
        return map;
    }

    private List<Option> getEnumOptions(Class<? extends Enum> enumClass) {
        List<Option> list = new ArrayList<>();
        try {
            Method getNameMethod = enumClass.getMethod(enumGetNameMethod);
            for (Enum<?> enumConstant : enumClass.getEnumConstants()) {
                String name = (String) getNameMethod.invoke(enumConstant);
                list.add(new Option(name, enumConstant.name()));
            }
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            log.error("Failed to get enum options for class {}", enumClass.getSimpleName(), e);
        }
        return list;
    }


    @GetMapping
    public CommonResponse<Enums> all() {
        return CommonResponse.success(ENUMS);
    }
}

 

		<dependency>
			<groupId>org.reflections</groupId>
			<artifactId>reflections</artifactId>
			<version>0.10.2</version>
		</dependency>

yaml中添加

enums:
  package: xxxxxxx.enums
  getNameMethod: getName