It is not a good idea to judge the sample value of an enumeration based on '@JSONValue'

[jasonkung22]

Most company specifications for enumerations require that you interact with the value enumValue. And '@JsonValue' only affects the serialization of the response result during enumeration parsing. Here are some ways to enumerate serialization and deserialization in different scenarios:
1, SpringMvc configuration ConverterFactory, for requestHeader, requestPath, requestParam enumeration deserialization
2. Configure the '@JsonCreator' annotation on the enumeration method to deserialize the enumeration of requestBody
3. Configure the '@JsonValue' annotation on the enumeration property or method to serialize the enumeration in response

As you can see from the above, the enumeration parameter passing process is determined by a number of factors, not just the '@JsonValue' annotation.
If different companies have different requirements for passing enumerations, you are advised to add a unified switch configuration. For example, by default, enumValue is passed, and if the switch is turned on, enumName is passed. It is also possible to standardize the company's passing of enumeration parameters, rather than the passing of enumeration in different scenarios

ConverterFactory

@Configuration
public class MvcConfiguration implements WebMvcConfigurer {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverterFactory(new StringToUniversalEnumConverterFactory());
    }
}

public class StringToUniversalEnumConverterFactory implements ConverterFactory<String, UniversalEnum> {

    /**
     * 获取转换器
     * @param targetType 指定类型
     * @param <T>        指定类型
     * @return 指定类型值
     */
    @Override
    @SuppressWarnings("all")
    public <T extends UniversalEnum> Converter<String, T> getConverter(Class<T> targetType) {
        return new StringToUniversalEnum<>(targetType);
    }

    @SuppressWarnings("all")
    private static class StringToUniversalEnum<T extends UniversalEnum> implements Converter<String, T> {

        private final Class<T> targetType;

        public StringToUniversalEnum(Class<T> targetType) {
            this.targetType = targetType;
        }

        @Override
        public T convert(String enumValue) {
            if (enumValue == null || targetType == null) {
                return null;
            }

            for (T enumInstance : targetType.getEnumConstants()) {
                Integer id = enumInstance.getId();

                if (id == null) {
                    continue;
                }

                if (Objects.equals(enumValue, id.toString())) {
                    return enumInstance;
                }
            }

            return null;
        }
    }
}

'@JsonCreator' or '@JsonValue'

@Getter
@AllArgsConstructor
public enum TestEnum implements UniversalEnum {
    /**
     * 测试1
     */
    TEST1(1, "测试1"),
    /**
     * 测试2
     */
    TEST2(2, "测试2");

    @JsonValue
    private final Integer id;
    private final String text;
    private static final Map<Integer, TestEnum> VALUES = new HashMap<>();

    static {
        for (TestEnum enumObject : TestEnum.values()) {
            TestEnum.VALUES.put(enumObject.getId(), enumObject);
        }
    }

    @JsonCreator(mode = Mode.DELEGATING)
    public static TestEnum idValueOf(Integer id) {
        return TestEnum.VALUES.get(id);
    }
}

[jasonkung22]

This discussion has been amended at pr #977