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_

巴特西

java反射之获取枚举对象

最新文章

热门文章