项目中导入大量枚举对象，用来定义常量。随着带来一个问题，就是每个枚举类都需要通过key来获取对应枚举的需求。

  public enum ExamType {
      CRAFT(1, "草稿"), 
      PASSING(2, "待审核"); 
      private int value; 
      private String typeName; 
   
      ExamType(int value, String typeName) { 
          this.value = value; 
         this.typeName = typeName;
      }
      //通过value获取对应的枚举对象
       public static ExamType getExamType(int value) {
          for (ExamType examType : ExamType.values()) {
              if (value == examType.getValue()) {
                  return examType;
              }
          }
          return null;
     }
      
  
  }

随着项目的增大，可能存在很多枚举对象都需要，可能都需要去实现一样的方式，就存在了代码冗余的问题，可惜enum对象又不不能继承其他类(默认Enum)所以考虑说使用反射来替代之前的方式。为了方便，将代码写带一个类中

 //接口类 
  public interface EnumMessage { 
      Integer getValue() ; 
      String getMessage(); 
 } 
   
  //枚举类 
  public enum AccountStatus implements EnumMessage { 
      Init(0,"初始化"),
      Ready(1,"正常"),
      ChangePassword(2,"需要修改密码"),
      Frozen(4,"冻结"),
      Disabled(64,"禁用"),
      ;
      private final Integer _code;
      private final String _message;
      AccountStatus(Integer code,String message){
          _code=code;
         _message=message;
      }
      @Override
     public Integer getValue() { return _code;}
      @Override
      public String getMessage() { return _message; }
  }
  
  
  public enum AuditNotifyStatus implements EnumMessage {
      Sms(2,"短信"),
      Mail(4,"邮箱"),
      SmsAndMail(6,"短信和邮箱"),
      ;
      private final Integer _code;
      private final String _message;
      AuditNotifyStatus(Integer code,String message){
          _code=code;
          _message=message;
      }
     @Override
      public Integer getValue() { return _code;}
     @Override
      public String getMessage() { return _message; }
  }

常量类

  public class Constant { 
   
   
      /** 
       * 枚举类对应的包路径 
      */ 
      public final static String PACKAGE_NAME = "com.lwx.util.reflex.enums"; 
      /** 
       * 枚举接口类全路径
       */
      public final static String ENUM_MESSAGE_PATH=PACKAGE_NAME+".EnumMessage";
  
      /**
       * 枚举类对应的全路径集合
      */
      public static final List<String> ENUM_OBJECT_PATH = PackageUtil.getPackageClasses(PACKAGE_NAME, true);
  
      /**
       * 存放单个枚举对象 map常量定义
       */
     private static Map<Integer, EnumMessage> SINGLE_ENUM_MAP = null;
      /**
    * 所有枚举对象的 map
      */
    public static final Map<Class, Map<Integer, EnumMessage>> ENUM_MAP = initialEnumMap(true);
 
  
   /**静态初始化块*/
      static {
  
     }
  
      /**
       * 加载所有枚举对象数据
       * @param  isFouceCheck 是否强制校验枚举是否实现了EnumMessage接口
       *
      * */
      private static Map<Class, Map<Integer, EnumMessage>> initialEnumMap(boolean isFouceCheck){
          Map<Class, Map<Integer, EnumMessage>> ENUM_MAP = new HashMap<Class, Map<Integer, EnumMessage>>();
         try {
              for (String classname : ENUM_OBJECT_PATH) {
                  Class<?> cls = null;
                  cls = Class.forName(classname);
                  Class <?>[]iter=cls.getInterfaces();
                 boolean flag=false;
                  if(isFouceCheck){
                      for(Class cz:iter){
                          if(cz.getName().equals(ENUM_MESSAGE_PATH)){
                             flag=true;
                             break;
                         }
                     }
                  }
                  if(flag==isFouceCheck){
                       SINGLE_ENUM_MAP = new HashMap<Integer, EnumMessage>();
                     initialSingleEnumMap(cls);
                      ENUM_MAP.put(cls, SINGLE_ENUM_MAP);
                  }
 
             }
          } catch (Exception e) {
             
          }
          return ENUM_MAP;
      }
 
      /**
       * 加载每个枚举对象数据
       * */
      private static void  initialSingleEnumMap(Class<?> cls )throws Exception{
          Method method = cls.getMethod("values");
          EnumMessage inter[] = (EnumMessage[]) method.invoke(null, null);
          for (EnumMessage enumMessage : inter) {
              SINGLE_ENUM_MAP.put(enumMessage.getValue(), enumMessage);
          }
      }
  
  
  }

工具包类

public class PackageUtil {    /**
     * 返回包下所有的类
     * @param packagePath 包名
     * @return List<String> 包下所有的类
     * */
    public static  List<String> getPackageClasses(String packagePath){        return getPackageClasses(packagePath,false);
    }    /**
     * 返回包下所有的类
     * @param packagePath 包名全路径
     * @param classWithPath 返回全路径开关 true 自动带上包名
     * @return List<String> 包下所有的类
     * */
    public static  List<String> getPackageClasses(String packagePath,boolean classWithPath){

        List<String> classNames = getClassName(packagePath);
        List<String>result =new ArrayList<String>(classNames.size());
        String path =classWithPath?packagePath+".":"";        for (String className : classNames) {
            result.add(path+className.substring(className.lastIndexOf(".")+1));
        }        return result;
    }    private static List<String> getClassName(String packageName) {
        String filePath = ClassLoader.getSystemResource("").getPath() + packageName.replace(".", "\\");  
        List<String> fileNames = getClassName(filePath, null);  
        return fileNames;  
    }  
  
    private static List<String> getClassName(String filePath, List<String> className) {  
        List<String> myClassName = new ArrayList<String>();  
        File file = new File(filePath);  
        File[] childFiles = file.listFiles();  
        for (File childFile : childFiles) {  
            if (childFile.isDirectory()) {  
                myClassName.addAll(getClassName(childFile.getPath(), myClassName));  
            } else {  
                String childFilePath = childFile.getPath();  
                childFilePath = childFilePath.substring(childFilePath.indexOf("\\classes") + 9, childFilePath.lastIndexOf("."));  
                childFilePath = childFilePath.replace("\\", ".");  
                myClassName.add(childFilePath);  
            }  
        }  
  
        return myClassName;  
    }  

}

核心的获取枚举对象的类

  public class EnumUtil { 
   
   
      /** 
       * 获取value返回枚举对象 
       * @param value 
       * @param clazz 
       * */ 
      public static <T extends  EnumMessage>  T getEnumObject(int value,Class<T> clazz){
         return (T)Constant.ENUM_MAP.get(clazz).get(value);
      }
  
  
  }

测试

    
    public static void main(String[] args) {
        
        
        System.out.println(EnumUtil.getEnumObject(2, AuditNotifyStatus.class).getMessage());;//短信
        System.out.println(EnumUtil.getEnumObject(6, AuditNotifyStatus.class).getMessage());;//短信和邮箱
        
        
    }

                                                                                                                            --友情转载