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_