Java动态生成枚举类型

缺乏、安全感 2022-05-21 00:19 149阅读 0赞

## 工具类 ##

import java.lang.reflect.AccessibleObject;
    import java.lang.reflect.Array;
    import java.lang.reflect.Field;
    import java.lang.reflect.Modifier;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    import sun.reflect.ConstructorAccessor;
    import sun.reflect.FieldAccessor;
    import sun.reflect.ReflectionFactory;
    
    public class DynamicEnumUtils { 
    
       private static ReflectionFactory reflectionFactory = ReflectionFactory.getReflectionFactory();
    
       private static void setFailsafeFieldValue(Field field, Object target, Object value) throws NoSuchFieldException,
               IllegalAccessException {
    
           // let's make the field accessible
           field.setAccessible(true);
    
           // next we change the modifier in the Field instance to
           // not be final anymore, thus tricking reflection into
           // letting us modify the static final field
           Field modifiersField = Field.class.getDeclaredField("modifiers");
           modifiersField.setAccessible(true);
           int modifiers = modifiersField.getInt(field);
    
           // blank out the final bit in the modifiers int
           modifiers &= ~Modifier.FINAL;
           modifiersField.setInt(field, modifiers);
    
           FieldAccessor fa = reflectionFactory.newFieldAccessor(field, false);
           fa.set(target, value);
       }
    
       private static void blankField(Class<?> enumClass, String fieldName) throws NoSuchFieldException,
               IllegalAccessException {
           for (Field field : Class.class.getDeclaredFields()) {
               if (field.getName().contains(fieldName)) {
                   AccessibleObject.setAccessible(new Field[] { field }, true);
                   setFailsafeFieldValue(field, enumClass, null);
                   break;
               }
           }
       }
    
       private static void cleanEnumCache(Class<?> enumClass) throws NoSuchFieldException, IllegalAccessException {
           blankField(enumClass, "enumConstantDirectory"); // Sun (Oracle?!?) JDK 1.5/6
           blankField(enumClass, "enumConstants"); // IBM JDK
       }
    
       private static ConstructorAccessor getConstructorAccessor(Class<?> enumClass, Class<?>[] additionalParameterTypes)
               throws NoSuchMethodException {
           Class<?>[] parameterTypes = new Class[additionalParameterTypes.length + 2];
           parameterTypes[0] = String.class;
           parameterTypes[1] = int.class;
           System.arraycopy(additionalParameterTypes, 0, parameterTypes, 2, additionalParameterTypes.length);
           return reflectionFactory.newConstructorAccessor(enumClass.getDeclaredConstructor(parameterTypes));
       }
    
       private static Object makeEnum(Class<?> enumClass, String value, int ordinal, Class<?>[] additionalTypes,
               Object[] additionalValues) throws Exception {
           Object[] parms = new Object[additionalValues.length + 2];
           parms[0] = value;
           parms[1] = Integer.valueOf(ordinal);
           System.arraycopy(additionalValues, 0, parms, 2, additionalValues.length);
           return enumClass.cast(getConstructorAccessor(enumClass, additionalTypes).newInstance(parms));
       }
    
       /** * Add an enum instance to the enum class given as argument * * @param <T> the type of the enum (implicit) * @param enumType the class of the enum to be modified * @param enumName the name of the new enum instance to be added to the class. */
       @SuppressWarnings("unchecked")
       public static <T extends Enum<?>> void addEnum(Class<T> enumType, String enumName, Class<?>[] additionalTypes, Object[] additionalValues) {
    
           // 0. Sanity checks
           if (!Enum.class.isAssignableFrom(enumType)) {
               throw new RuntimeException("class " + enumType + " is not an instance of Enum");
           }
    
           // 1. Lookup "$VALUES" holder in enum class and get previous enum instances
           Field valuesField = null;
           Field[] fields = enumType.getDeclaredFields();
           for (Field field : fields) {
               if (field.getName().contains("$VALUES")) {
                   valuesField = field;
                   break;
               }
           }
           AccessibleObject.setAccessible(new Field[] { valuesField }, true);
    
           try {
    
               // 2. Copy it
               T[] previousValues = (T[]) valuesField.get(enumType);
               List<T> values = new ArrayList<T>(Arrays.asList(previousValues));
    
               // 3. build new enum
               T newValue = (T) makeEnum(enumType, enumName, values.size(), additionalTypes, additionalValues);
    
               // 4. add new value
               values.add(newValue);
    
               // 5. Set new values field
               setFailsafeFieldValue(valuesField, null, values.toArray((T[]) Array.newInstance(enumType, 0)));
    
               // 6. Clean enum cache
               cleanEnumCache(enumType);
    
           } catch (Exception e) {
               throw new RuntimeException(e.getMessage(), e);
           }
       }
    }

## 测试 ##

/** * 季节特征，用作参数传递的列子 */
    public enum SeasonPattern {
    
        BEAR, HOT, WITHERED, SNOW;
    }
    
    /** * 季节 */
    public enum Season {
    
        SPRING("spring", SeasonPattern.BEAR), SUMMER("summer", SeasonPattern.HOT), AUTUMN(
                "autumn", SeasonPattern.WITHERED);
    
        private final String key;
        // 季节特征
        private final SeasonPattern sp;
        private Season(String key, SeasonPattern sp) {
            this.key = key;
            this.sp = sp;
        }
        public String getKey() {
            return this.key;
        }
        public SeasonPattern getSeasonPattern() {
            return sp;
        }
    }
    
    /** * 测试方法 */
    public class Main { 
    
        public static void main(String[] args) {
            System.out.println("原始数据：");
            for (Season season : Season.values()) {
                System.out.println(season);
            }
            System.out.println("-----------------------------");
            DynamicEnumUtils.addEnum(Season.class, "WINTER", new Class[] {
                    java.lang.String.class, SeasonPattern.class }, new Object[] {
                    "winter", SeasonPattern.SNOW });
            System.out.println("添加后的数据：");
            for (Season season : Season.values()) {
                System.out.println(season);
            }
            System.out.println("-----------------------------");
            Season season = Season.valueOf("WINTER");
            System.out.println("新添加的枚举类型可以正常使用：");
            System.out.println(season.name());
            System.out.println(season.getKey());
            System.out.println(season.getSeasonPattern());
        }
    }

![这里写图片描述][70]

[70]: /images/20220521/ac0a739f75c5406685a282f26eeb786c.png