JAVA反射获取所有枚举
定义枚举接口
枚举类
获取所有枚举
输出

定义枚举接口
public interface BaseEnum {
    /**
     * 获取枚举值
     * @returnint
     */
    Integer getValue();

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

枚举类
@Getter
public enum TestEnum implements BaseEnum {
    TEST1("name1",1),
    TEST2("name1",2),
    TEST3("name1",3);

    private String name;
    private Integer value;

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

}

获取所有枚举
    public static void test4(){

        Reflections reflections = new Reflections("com.xxx.modules");

        Set<Class<? extends BaseEnum>> monitorClasses = reflections.getSubTypesOf(BaseEnum.class);

        System.out.println("size:"+monitorClasses.size());
        monitorClasses.forEach(m->{
            try {
                System.out.println("name:"+m.getSimpleName());
                BaseEnum[] enumConstants = m.getEnumConstants();

                for (BaseEnum anEnum : enumConstants) {
                    System.out.println("enumName:"+anEnum+"  value:"+anEnum.getValue()+"  name:"+anEnum.getName());
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }

输出

定义枚举接口

public interface BaseEnum {
    /**
     * 获取枚举值
     * @returnint
     */
    Integer getValue();

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


枚举类

@Getter
public enum TestEnum implements BaseEnum {
    TEST1("name1",1),
    TEST2("name1",2),
    TEST3("name1",3);

    private String name;
    private Integer value;

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

}


获取所有枚举

    public static void test4(){

        Reflections reflections = new Reflections("com.xxx.modules");

        Set<Class<? extends BaseEnum>> monitorClasses = reflections.getSubTypesOf(BaseEnum.class);

        System.out.println("size:"+monitorClasses.size());
        monitorClasses.forEach(m->{
            try {
                System.out.println("name:"+m.getSimpleName());
                BaseEnum[] enumConstants = m.getEnumConstants();

                for (BaseEnum anEnum : enumConstants) {
                    System.out.println("enumName:"+anEnum+"  value:"+anEnum.getValue()+"  name:"+anEnum.getName());
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }


输出

java中常用的枚举方法有values和valueof
valueOf方法会把一个String类型的名称转变成枚举项，也就是在枚举项中查找字面值和该参数相等的枚举项。
values是获取所有的枚举项
package HtppClient1.EnumUtil;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.springframework.util.ReflectionUtils;
import com.sun.org.apache.bcel.internal.generic.IfInstruction;
enum TestEnums {
weirenzheng(0, "0、未认证；", 16, -1, 0),
onceTime(1, "上月支付1次及以下；", 8, 0, 1),
towTimes(2, "上月支付1-2次", 12, 1, 2),
threeTimes(3, "上月支付3-4次；", 16, 3, 4),
fiveTimes(4, "上月支付5-7次", 20, 4, 7),
sixTimes(5, "上月支付7次以上", 24, 7, Integer.MAX_VALUE);
public int code;//排序
public String desc;//描述
public int score;//分值
public int lower;//最低次数
public int high;//最高次数
TestEnums() {
}
TestEnums(int code, String desc, int score, int lower, int high) {
this.code = code;
this.desc = desc;
this.score = score;
this.lower = lower;
this.high = high;
}
public int getCode() {
return code;
}
public String getDesc() {
return desc;
}
public int getScore() {
return score;
}
public int getLower() {
return lower;
}
public int getHigh() {
return high;
}
/**
* 根据code返回枚举值
* @param Code
* @return
*/
public static TestEnums   getEumByCode(int Code){
for(TestEnums testEnums: TestEnums.values()) {
if(testEnums.getCode()==Code) {
return testEnums;
}
}
return null;
}
/**
* 根据序号获取枚举数组中的值，序号必须从0开始
* @param key
* @return
* @throws IllegalAccessException
* @throws IllegalArgumentException
* @throws InvocationTargetException
* @throws InstantiationException
*/
public static ListgetEumByKey(int Code) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
ListenumList=getEumValueList();
ListenumList1=new ArrayList();
for(TestEnums testEnums: TestEnums.values()) {
if(testEnums.getCode()==Code) {
Class> clazz=testEnums.getClass();
// 获取所有常量
Object object = clazz.getEnumConstants()[Code];
Field[]  filedFields=clazz.getFields();
for (Field field : filedFields) {
field.setAccessible(true);
Object sssObject=field.get(object);
if(enumList.contains(field.getName())) {
continue;
}else {
if(sssObject!=null)
enumList1.add((T) sssObject);
}
}
return enumList1;
}
}
return null;
}
/**
* 获取枚举值常量列表
* @param Code
* @return
*/
public static ListgetEumValueList() {
Listlist=new ArrayList();
for(Object object:TestEnums.values()) {
list.add(object.toString());
}
return list;
}
/**
* 传入方法名称  values是值 ，field是 字段mingcheng
* @param * @param enumType
* @param value
* @param field
* @return
* @throws Exception
*/
public static > T getEnumOnValue(ClassenumType, String value, String field) throws Exception {
for (Object obj : enumType.getEnumConstants()) {
Method m = obj.getClass().getDeclaredMethod("values", null);
Object[] results = (Object[]) m.invoke(obj, null);
for (Object result : results) {
Field codeField = result.getClass().getDeclaredField(field);
ReflectionUtils.makeAccessible(codeField);
String fileValue = String.valueOf(ReflectionUtils.getField(codeField, result));
if (fileValue.equals(value)) {
return (T) result;
}
}
}
return null;
}
}
test代码：
import java.util.List;
/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args ) throws Exception
{
TestEnums testEnums = TestEnums.getEnumOnValue(TestEnums.class, "1", "code");
Listlist=TestEnums.getEumByKey(1);
for (Object string : list) {
System.out.println(":"+string);
}
}
}

由于项目的发展，枚举也是越来越多，为了方便前端直接取值，而不是每一次增加枚举给说一次，就写了一个根据枚举包名+类名获取所有的枚举值的接口；具体方法如下：

一、我返回的一个List<Map<String,Object>>的对象，传入的是枚举的包名+类名

   如果确定了枚举的包名，其实也可以直接传入枚举的类名就可以了

/**
     * 根据枚举的字符串获取枚举的值
     *
     * @param className 包名+类名
     * @return
     * @throws Exception
     */
    public static List<Map<String, Object>> getAllEnumByClassName(String className) throws Exception {
        // 1.得到枚举类对象
        Class<Enum> clz = (Class<Enum>) Class.forName(className);
        // 2.得到所有枚举常量
        Object[] objects = clz.getEnumConstants();
        Method getCode = clz.getMethod("getCode");
        Method getMessage = clz.getMethod("getMessage");
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        Map<String, Object> map = null;
        for (Object obj : objects) {
            map = new HashMap<String, Object>();
            map.put("code", getCode.invoke(obj));
            map.put("message", getMessage.invoke(obj));
            list.add(map);
        }
        return list;
    }

二、和第一个方法基本一样，就是中途获取的常量为枚举


/**
 * 根据枚举的字符串获取枚举的值
 *
 * @param className 包名+类名
 * @return
 * @throws Exception
 */
public static List<Map<String, Object>> getAllEnum(String className) throws Exception {
    // 得到枚举类对象
    Class<Enum> clazz = (Class<Enum>) Class.forName(className);
    List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
    //获取所有枚举实例
    Enum[] enumConstants = clazz.getEnumConstants();
    //根据方法名获取方法
    Method getCode = clazz.getMethod("getCode");
    Method getMessage = clazz.getMethod("getMessage");
    Map<String, Object> map = null;
    for (Enum enum1 : enumConstants) {
        map = new HashMap<String, Object>();
        //执行枚举方法获得枚举实例对应的值
        map.put("code", getCode.invoke(enum1));
        map.put("message", getMessage.invoke(enum1));
        list.add(map);
    }
    return list;
}                                                                                                         



比如：我有一个枚举是这样子的：



在页面上通过接口，传入当前包名+类名获取得劲结果如下：



以上就是通过反射获取枚举值的方法，当然，还有别的方法，因为反射也不止这样一种