第三章 EnumUtil根据值获取枚举对象

Posted 2020-08-17 jian.xiao

　　

　　项目中使用枚举类的好处这里不再赘述，在使用枚举值时，通常需要根据值来获取枚举对象，下面介绍两种实现方案：

1.在枚举类中定义方法实现

　　首先给出如下性别枚举类：　　

public enum SexEnum {
  MAN("M", "男"),
  WOMAN("F", "女");

  private String code;
  private String desc;

  SexEnum(String code, String desc) {
    this.code = code;
    this.desc = desc;
  }

  public String getCode() {
    return code;
  }

  public void setCode(String code) {
    this.code = code;
  }

  public String getDesc() {
    return desc;
  }

  public void setDesc(String desc) {
    this.desc = desc;
  }

}

View Code

　　现在需要根据code的值获取枚举对象，简单直接的办法是在该枚举类中定义如下方法：

  public static SexEnum getSexEnumByCode(String code){
    for(SexEnum sexEnum : SexEnum.values()){
      if(StringUtils.equals(code, sexEnum.getCode())){
        return sexEnum;
      }
    }
    return null;
  }

View Code

　　以这种方案实现时，需要在每个枚举类中都定义类似上述结构的方法。当项目中的枚举类较多时，显得代码冗余。

 

2.利用反射实现

　　首先介绍本方案的实现方式，再来介绍具体代码实现:

　　1).定义一个EnumMessage接口，然后每个枚举类实现此接口;

　　2).定义常量保存枚举类所在包名，以及接口全路径;

　　3).在程序启动时，读取枚举类所在包下的所有枚举类的File文件，在从file文件信息中获取每个枚举类的全路径类名集合A;

　　4).遍历A集合，利用反射获取每个类的class对象，再判断该类是否实现了EnumMessage接口;

　　5).对于实现了EnumMessage接口的枚举类，遍历该枚举类的所有对象，保存Map<Object, EnumMessage>的集合映射;

　　6).对枚举类保存Map<Class, Map<Object, EnumMessage>>的映射集合。

　　至此完成了启动的初始化工作。下面给出上述过程的代码实现:

　　定义接口EnumMessage:

package com.example.myFirstProject.service;

public interface EnumMessage {
    Object getValue();
}

View Code

　　枚举类SexEnum实现此接口:　

package com.example.myFirstProject.enums;

import com.example.myFirstProject.service.EnumMessage;
import org.apache.commons.lang3.StringUtils;

public enum SexEnum implements EnumMessage {
  MAN("M", "男"),
  WOMAN("F", "女");

  private String code;
  private String desc;

  SexEnum(String code, String desc) {
    this.code = code;
    this.desc = desc;
  }

  public String getCode() {
    return code;
  }

  public void setCode(String code) {
    this.code = code;
  }

  public String getDesc() {
    return desc;
  }

  public void setDesc(String desc) {
    this.desc = desc;
  }

  @Override
  public Object getValue() {
    //此处需要根据枚举对象的哪个属性返回枚举对象，就return该属性
    return code;
  }

}

View Code

　　Constant类定义了常量保存枚举类所在包名和接口全路径，以及Map的初始化工作:

 1 package com.example.myFirstProject.common;
 2 
 3 import com.example.myFirstProject.service.EnumMessage;
 4 import com.example.myFirstProject.util.PackageUtil;
 5 import java.lang.reflect.Method;
 6 import java.util.ArrayList;
 7 import java.util.HashMap;
 8 import java.util.List;
 9 import java.util.Map;
10 
11 public class Constant {
12 
13   /**
14    * 枚举类包名集合
15    */
16   public static List<String> pathList = initPackagePathList();
17   /**
18    * 枚举接口类全路径
19    */
20   public final static String ENUM_MESSAGE_PATH = "com.example.myFirstProject.service.EnumMessage";
21 
22   /**
23    * 枚举类对应的全路径集合
24    */
25   public static final List<String> ENUM_OBJECT_PATH = PackageUtil.getPackageClasses(pathList, true);
26 
27   /**
28    * 存放单个枚举对象 map常量定义
29    */
30   private static Map<Object, EnumMessage> SINGLE_ENUM_MAP = null;
31 
32   /**
33    * 所有枚举对象的 map
34    */
35   public static final Map<Class, Map<Object, EnumMessage>> ENUM_MAP = initialEnumMap(true);
36 
37   private static List<String> initPackagePathList() {
38     List<String> list = new ArrayList<>();
39     list.add("com.example.myFirstProject.enums");
40     return list;
41   }
42 
43   static {
44     System.out.println("类被加载时，先初始化各个静态变量，再执行static块。" +
45             "所以不能在这里执行pathList的add操作(\\"com.example.myFirstProject.enums\\")。");
46   }
47   /**
48    * 加载所有枚举对象数据
49    *
50    * @param isFouceCheck 是否强制校验枚举是否实现了EnumMessage接口,若为false则没有实现接口的枚举类也会被加载
51    */
52   private static Map<Class, Map<Object, EnumMessage>> initialEnumMap(boolean isFouceCheck) {
53     Map<Class, Map<Object, EnumMessage>> ENUM_MAP = new HashMap<>();
54     try {
55       for (String classname : ENUM_OBJECT_PATH) {
56         Class<?> cls = null;
57         cls = Class.forName(classname);
58         Class<?>[] iter = cls.getInterfaces();
59         boolean flag = false;
60         if (isFouceCheck) {
61           for (Class cz : iter) {
62             if (cz.getName().equals(ENUM_MESSAGE_PATH)) {
63               flag = true;
64               break;
65             }
66           }
67         }
68         if (flag == isFouceCheck) {
69           SINGLE_ENUM_MAP = new HashMap<>();
70           initialSingleEnumMap(cls);
71           ENUM_MAP.put(cls, SINGLE_ENUM_MAP);
72         }
73 
74       }
75     } catch (Exception e) {
76 
77     }
78     return ENUM_MAP;
79   }
80 
81   /**
82    * 加载每个枚举对象数据
83    */
84   private static void initialSingleEnumMap(Class<?> cls) throws Exception {
85     Method method = cls.getMethod("values");
86     EnumMessage inter[] = (EnumMessage[]) method.invoke(null, null);
87     for (EnumMessage enumMessage : inter) {
88       SINGLE_ENUM_MAP.put(enumMessage.getValue(), enumMessage);
89     }
90   }
91 
92 
93 }

View Code

　　PackageUtil工具类主要完成根据枚举类所在包名获取该package下所有class的全路径名称的工作：

 1 package com.example.myFirstProject.util;
 2 
 3 import java.io.File;
 4 import java.util.ArrayList;
 5 import java.util.List;
 6 
 7 public class PackageUtil {
 8 
 9   /**
10    * 返回包下所有的类
11    *
12    * @param packagePathList   包名全路径集合
13    * @param classWithPath 返回全路径开关 true 自动带上包名 false 只返回类名
14    * @return List<String> 包下所有的类
15    */
16   public static List<String> getPackageClasses(List<String> packagePathList, boolean classWithPath) {
17     List<String> result = new ArrayList<>();
18     for(String packagePath : packagePathList) {
19       List<String> classNames = getClassName(packagePath);
20       String path = classWithPath ? packagePath + "." : "";
21       for (String className : classNames) {
22         //className:com.example.myFirstProject.enums.SexEnum
23         result.add(path + className.substring(className.lastIndexOf(".") + 1));
24       }
25     }
26     return result;
27   }
28 
29   /**
30    * 获取该报名全路径下的所有class全路径集合
31    * @param packageName 包名全路径
32    * @return
33    */
34   private static List<String> getClassName(String packageName) {
35     //根据报名获取该package的系统路径
36     String filePath = ClassLoader.getSystemResource("").getPath() + packageName.replace(".", "\\\\");
37     // filePath: /D:/workspace-git/springbootlearning/target/classes/com\\example\\myFirstProject\\enums
38     List<String> fileNames = getClassName(filePath, null);
39     return fileNames;
40   }
41 
42   /**
43    * 获取filePath文件夹下的所有class的全路径集合
44    * @param filePath
45    * @param className
46    * @return
47    */
48   private static List<String> getClassName(String filePath, List<String> className) {
49     List<String> myClassName = new ArrayList<>();
50     File file = new File(filePath);
51     File[] childFiles = file.listFiles();
52     for (File childFile : childFiles) {
53       if (childFile.isDirectory()) {
54         //递归获取该文件夹下的子文件夹里的所有文件
55         myClassName.addAll(getClassName(childFile.getPath(), myClassName));
56       } else {
57         String childFilePath = childFile.getPath();
58         //childFilePath:  D:\\workspace-git\\springbootlearning\\target\\classes\\com\\example\\myFirstProject\\enums\\SexEnum.class
59         childFilePath = childFilePath.substring(childFilePath.indexOf("\\\\classes") + 9, childFilePath.lastIndexOf("."));
60         childFilePath = childFilePath.replace("\\\\", ".");
61         myClassName.add(childFilePath);
62       }
63     }
64 
65     return myClassName;
66   }
67 
68 }

View Code

　　定义EnumUtil，提供根据值获取枚举对象的入口方法：　

 1 package com.example.myFirstProject.util;
 2 
 3 import com.example.myFirstProject.common.Constant;
 4 import com.example.myFirstProject.service.EnumMessage;
 5 
 6 public class EnumUtil {
 7 
 8     /**
 9      * 获取value返回枚举对象
10      * @param value
11      * @param clazz
12      * */
13     public static <T extends EnumMessage>  T getEnumObject(Object value, Class<T> clazz){
14         return (T) Constant.ENUM_MAP.get(clazz).get(value);
15     }
16     
17 }

View Code

　　最后编写测试语句:

　　System.out.println(EnumUtil.getEnumObject("M", SexEnum.class));　　//MAN

　　至此该方案实现了根据枚举对象的值"M"获取枚举类对象"MAN"。

 

　　注意：关于static变量的加载时机:

　　当在EnumUtil中调用Constant的静态变量ENUM_MAP时，Constant类被加载，Conatant类中的pathList,ENUM_OBJECT_PATH,ENUM_MAP被按顺序加载，即先执行了Conatant的initPackagePathList()方法，再执行了PackageUtil的getPackageClasses(pathList, true)方法

最后在 public static final Map<Class, Map<Object, EnumMessage>> ENUM_MAP = initialEnumMap(true)被调用时，ENUM_OBJECT_PATH已经有值。

 

　　附：类被加载的时机：　　

　　1、用Class.forName()显示加载的时候;

　　2、实例化一个类的时候;

　　3、调用类的静态方法的时候;

　　4、调用类的静态变量的时候;