enum枚举类优化

在我们日常开发中枚举是无处不在的，如各种状态，各种类型等等经常都需要使用到枚举，也经常需要对枚举进行操作，如将枚举value->枚举name,并且鉴于系统稳健性考虑，其实也是需要对前端传来的枚举值进行校验是否为正确的枚举类，然而其实大部分系统的枚举类中都会有类似图中的代码，更有甚者会通过定于一个Map来实现类似操作，对于一个系统而言，动则几十上百个的枚举类，在每个类中都去实现类似重复冗余的代码，就有点那啥了啊哈哈，虽然cv大法很好用，但咱也是个有追求的程序员。

@Getter
@AllArgsConstructor
public enum DictCodeEnum {

    TRADE_MARKET_IB_NAME("IB", "IB"),
    TRADE_MARKET_SH_NAME("SH", "SH"),
    TRADE_MARKET_SZ_NAME("SZ", "SZ");

    private String dictIndex;
    private String dictCode;

    public static String getDictCode(String dictIndex) {
        for (DictCodeEnum c : DictCodeEnum.values()) {
            if (c.getDictIndex().equals(dictIndex)) {
                return c.dictCode;
            }
        }
        return "";
    }

    public static String getIgnoreDictCode(String dictIndex) {
        for (DictCodeEnum c : DictCodeEnum.values()) {
            if (c.getDictIndex().equalsIgnoreCase(dictIndex)) {
                return c.dictCode;
            }
        }
        return "";
    }
}

那有没有办法让所有枚举类只保留getter方法，去除其他重复冗余静态方法？
聪明的你们一定想到了类似面向接口编程的方式，我们可以先定义一个最简单的只有枚举value的接口，并让其支持泛型，因为有的枚举类并不需要枚举名且枚举value可能是String或Integer等，
接着我们可以在定义一个NameValueEnum接口让其继承前面的ValueEnum接口，这样就可以满足需要枚举value和枚举name的枚举类了。
有了以上两个接口，就可以覆盖大部分枚举类的需求了，接着就可以定义EnumUtils类的编写我们经常需要用到的重复冗余代码了。

1. 定义带有泛型的只有枚举value的接口

public interface ValueEnum<T> {

    /**
     * 获取枚举值
     * @return 枚举值
     */
    T getValue();

}

2. 定义一个NameValueEnum的接口，并让其继承ValueEnum接口

public interface NameValueEnum<T> extends ValueEnum<T> {

    /**
     * 获取枚举名称
     * @return 枚举名称
     */
     String getName();

}

3. 定义EnumUtils工具类

import org.springframework.util.StringUtils;

public class EnumUtils {

    /**
     * 判断枚举值是否合法有效
     *
     * @param enums 某个枚举的所有值
     * @param value 指定值
     * @param <T>
     * @return true:合法 false:非法
     */
    public static <T> boolean isExist(ValueEnum<T>[] enums, T value) {
        if (value == null) {
            return false;
        }
        for (ValueEnum<T> e : enums) {
            if (value.equals(e.getValue())) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断枚举值是否存在与指定枚举类中
     * @param enumClass 枚举类
     * @param value 枚举值
     * @param <E>   枚举类型
     * @param <V>   值类型
     * @return true:存在
     */
    public static <E extends Enum<? extends ValueEnum<V>>, V> boolean isExist(Class<E> enumClass, V value) {

        for (Enum<? extends ValueEnum<V>> e : enumClass.getEnumConstants()) {
            if (((ValueEnum<V>) e).getValue().equals(value)) {
                return true;
            }
        }
        return false;
    }

    /**
     *
     * @param enums
     * @param value
     * @param <T>
     * @return 枚举名称
     */
    public static <T> String getNameByValue(NameValueEnum<T>[] enums,T value){
        if (value == null) {
            return null;
        }
        for (NameValueEnum<T> e : enums) {
            if (value.equals(e.getValue())) {
                return e.getName();
            }
        }
        return null;
    }

    /**
     * 根据枚举名称获取对应的枚举值
     * @param enums 枚举列表
     * @param name  枚举名
     * @param <T>   枚举类型
     * @return      枚举值
     */
    public static <T> T getValueByName(NameValueEnum<T>[] enums,String name){
        if (StringUtils.isEmpty(name)) {
            return null;
        }
        for (NameValueEnum<T> e : enums) {
            if (name.equals(e.getName())) {
                return e.getValue();
            }
        }
        return null;
    }

    /**
     * 根据枚举值获取对应的枚举对象
     * @param enumClass 枚举class
     * @param value     枚举对象
     * @param <E>
     * @param <V>
     * @return
     */
    public static  <E extends Enum<? extends ValueEnum<V>>, V> E getEnumByValue(Class<E> enumClass, V value) {
        return getEnumByValue(enumClass.getEnumConstants(), value);
    }

    /**
     * 根据枚举值获取对应的枚举对象
     * @param enums     枚举列表
     * @param value
     * @param <E>
     * @param <V>
     * @return          枚举对象
     */
    private static <E extends Enum<? extends ValueEnum<V>>, V> E getEnumByValue(E[] enums, V value) {
        for (E e : enums) {
            if(((ValueEnum<V>) e).getValue().equals(value)){
                return e;
            }
        }
        return null;
    }
}

枚举类只要实现了上述接口，通过枚举类的values方法获取的所有枚举对象值都可以向上转型为接口类型数组，最后就是实践环节了。

4. 定义两种不同的枚举类，并让其实现NameValueEnum接口

//定义一个value为String的枚举类
public enum TestStrEnum implements NameValueEnum<String> {
    T1("01","String类型测试1"),
    T2("02","String类型测试2");

    private final String value;
    private final String name;

    TestStrEnum(String value,String name){
        this.name = name;
        this.value = value;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public String getValue() {
        return this.value;
    }
}

//定义一个value为Integer的枚举类
public enum TestIntEnum implements NameValueEnum<Integer> {
    T1(1,"Integer型测试1"),
    T2(2,"Integer类型测试2");

    private final Integer value;
    private final String name;

    TestIntEnum(Integer value, String name){
        this.name = name;
        this.value = value;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Integer getValue() {
        return this.value;
    }
}

5. 写单元测试，完美的全部运行成功

import org.junit.Assert;
import org.junit.Test;

public class EnumTest {

    @Test
    public void isExist(){
        Assert.assertTrue(EnumUtils.isExist(TestStrEnum.values(), "01"));
        Assert.assertFalse(EnumUtils.isExist(TestStrEnum.values(), "03"));

        Assert.assertTrue(EnumUtils.isExist(TestIntEnum.class, 1));
        Assert.assertFalse(EnumUtils.isExist(TestIntEnum.class, 3));
    }

    @Test
    public void getNameByValue(){
        String name = EnumUtils.getNameByValue(TestStrEnum.values(), "01");
        String name2 = EnumUtils.getNameByValue(TestIntEnum.values(), 2);
        System.out.println(name);
        System.out.println(name2);
    }

    @Test
    public void getValueByName(){
        String value = EnumUtils.getValueByName(TestStrEnum.values(), "String类型测试1");
        Integer value2 = EnumUtils.getValueByName(TestIntEnum.values(), "Integer类型测试2");
        System.out.println(value);
        System.out.println(value2);
    }

    @Test
    public void getEnumByValue(){
        TestStrEnum enumByValue = EnumUtils.getEnumByValue(TestStrEnum.class, "01");
        TestIntEnum enumByValue1 = EnumUtils.getEnumByValue(TestIntEnum.class, 2);
        System.out.println(enumByValue);
        System.out.println(enumByValue1);
    }

}