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类的编写我们经常需要用到的重复冗余代码了。

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

public interface ValueEnum {

    
    T getValue();

}

定义一个NamevalueEnum的接口，并让其继承ValueEnum接口

public interface NamevalueEnum extends ValueEnum {

    
     String getName();

}

定义EnumUtils工具类

import org.springframework.util.StringUtils;

public class EnumUtils {

    
    public static  boolean isExist(ValueEnum[] enums, T value) {
        if (value == null) {
            return false;
        }
        for (ValueEnum e : enums) {
            if (value.equals(e.getValue())) {
                return true;
            }
        }
        return false;
    }

    
    public static >, V> boolean isExist(Class enumClass, V value) {

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

    
    public static  String getNameByValue(NamevalueEnum[] enums,T value){
        if (value == null) {
            return null;
        }
        for (NamevalueEnum e : enums) {
            if (value.equals(e.getValue())) {
                return e.getName();
            }
        }
        return null;
    }

    
    public static  T getValueByName(NamevalueEnum[] enums,String name){
        if (StringUtils.isEmpty(name)) {
            return null;
        }
        for (NamevalueEnum e : enums) {
            if (name.equals(e.getName())) {
                return e.getValue();
            }
        }
        return null;
    }

    
    public static  >, V> E getEnumByValue(Class enumClass, V value) {
        return getEnumByValue(enumClass.getEnumConstants(), value);
    }

    
    private static >, V> E getEnumByValue(E[] enums, V value) {
        for (E e : enums) {
            if(((ValueEnum) e).getValue().equals(value)){
                return e;
            }
        }
        return null;
    }
}

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

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

//定义一个value为String的枚举类
public enum TestStrEnum implements NamevalueEnum {
    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 {
    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;
    }
}

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

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);
    }

}