java反射之获取枚举对象

项目中导入大量枚举对象，用来定义常量。随着带来一个问题，就是每个枚举类都需要通过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());;//短信和邮箱

    }

拓展与参考

1.获取变量的值

 public class Test {
     public static void main(String[] args) {
         //构造对象
         User user = new User();
         String strs[] ={"1","2","3"};
         user.setStrs(strs);

         Method[] methods = user.getClass().getMethods();
         for(Method m:methods){
             String methodNames= m.getName();
             if(methodNames.equals("getStrs")){
                 try {
                     Object obj =m.invoke(user, new Object[]{});
                     if(obj instanceof java.lang.String []){
                         String tempstrs [] =(String[]) obj;
                         for(String str:tempstrs){
                             System.out.println(str);
                         }
                     }
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 }
 class User{
     private String strs[];

     public String[] getStrs() {
         return strs;
     }

     public void setStrs(String[] strs) {
         this.strs = strs;
     }
 }

2.关于枚举的介绍（枚举无法通过newInstance来进行实力,本身构造就不能public，其实也就是规范）

http://whitesock.iteye.com/blog/728934

3.java反射获取注解

http://blog.csdn.net/lufeng20/article/details/8835135

http://blog.csdn.net/liyangbing315/article/details/5181381

4.使用反射+注解完成库表设计

http://blog.csdn.net/lufeng20/article/details/8730604

5.enum的使用，包含enumMap/enumSet

http://wenku.baidu.com/link?url=1y8U2qovo-oJkRmUBR_7sXkivFLxExzCW0J6hunDVcfIij08MX4RS45_eLptBGrujzS3q4tiGwsF4PmoGx032RBWj1IMmzOn6693B2YBVe_