【daily】Java枚举 - fastjson对enum的处理

目的

  1、枚举值转换成完全的json；

  2、对象中的枚举成员完全转换成json；

  3、枚举类的全部值转换成json；

 

枚举定义

public enum SongsEnum {
     SAFE_AND_SOUND(1,"Taylor Swift","Safe&Sound","2011-12-26")
    ,SHAKE_IT_OFF(2,"Taylor Swift","Shake It Off","2014-08-19")
    ,STYLE(3,"Taylor Swift","Style","2015-02-09")
    ,SOUND_OF_SILENCE(4,"Simon & Garfunkel","The Sound Of Silence","1966-01-17")
    ,BETTER_MAN(5,"Little Big Town","Better Man","2016-10-20")
    ,YESTERDAY_ONCE_MORE(6,"Carpenters","Yesterday Once More","1973-05-16")
    ;

    public final int index;
    public final String singer;
    public final String name;
    public final String date;

    private SongsEnum(int seq, String singer, String name, String date) {
        this.index = seq;
        this.singer = singer;
        this.name = name;
        this.date = date;
    }

    public int getIndex() { return index; }

    public String getSinger() { return singer; }

    public String getName() { return name; }

    public String getDate() { return date; }
}

 

一、枚举值转换json

期望结果：SongsEnum.SAFE_AND_SOUND -> {"date":"2011-12-26","index":1,"name":"Safe&Sound","singer":"Taylor Swift"}

## 默认调用结果

JSON.toJSONString(SongsEnum.SAFE_AND_SOUND) -> "SAFE_AND_SOUND"

JSON.toJSONString(SongsEnum.BETTER_MAN,SerializerFeature.WriteEnumUsingName) -> "BETTER_MAN"

JSON.toJSONString(SongsEnum.STYLE,SerializerFeature.WriteEnumUsingToString) -> "STYLE"

默认的使用fastjson转换enum,那么得到的enum json可能不是想要的.

(1) 重写enum的toString()

@Override
public String toString() {
  return "{'name':"+this.name+",'singer':"+this.singer+"}";
}

JSON.toJSONString(SongsEnum.STYLE,SerializerFeature.WriteEnumUsingToString) -> "{'name':Style,'singer':Taylor Swift}"

  虽然可以这样得到想要的结果,但相对来说太麻烦,每个enum类都要从写toString().

  (此种方式并没有研究，所以以上重写toString()的代码可能存在问题)

(2) fastjson的config设置

  fastjson提供的JSON.toJSONString(...)有很多重载的方法，例如：

    public static String toJSONString(Object object, SerializeConfig config, SerializerFeature... features)

  所以，fastjson可以通过设置SerializeConfig来配置enum的序列化。

public static void main(String[] args) {
    SerializeConfig config = new SerializeConfig();
    config.configEnumAsJavaBean(SongsEnum.class);
    String s = JSON.toJSONString(SongsEnum.SOUND_OF_SILENCE, config);
    System.out.println(s);
    // {"date":"1966-01-17","index":4,"name":"The Sound Of Silence","singer":"Simon & Garfunkel"}
}

二、对象中的枚举成员完全转换成json

public enum StatusEnum {
    STATUS_A(0,"状态A"),
    STATUS_B(1,"状态B"),
    STATUS_C(2,"状态C");

    public final int index;
    public final String status;

    StatusEnum(int i, String status) {
        this.index = i;
        this.status = status;
    }

    public int getIndex() { return index; }

    public String getStatus() { return status; }
}

class JavaBean{
    private String name;

    private SongsEnum song;

    private StatusEnum status;

    public JavaBean(String name,SongsEnum song,StatusEnum status){
        this.name = name;
        this.song = song;
        this.status = status;
    }

    //省略setter/getter
}

期望: {"name":"vegilyn","song":{"date":"2014-08-19","index":2,"name":"Shake It Off","singer":"Taylor Swift"},"status":{"index":1,"status":"状态B"}}

默认结果:

JSON.toJSONString(new JavaBean("vegilyn",SongsEnum.SHAKE_IT_OFF,StatusEnum.STATUS_B)) -> {"name":"vegilyn","song":"SHAKE_IT_OFF","status":"STATUS_B"}

可以看出此结果和目的1中的结果一样的，所以通过目的1的方式也可以解决。

SerializeConfig config = new SerializeConfig();

config.configEnumAsJavaBean(SongsEnum.class); // 配置enum转换
String s = JSON.toJSONString(new JavaBean("vegilyn",SongsEnum.SHAKE_IT_OFF,StatusEnum.STATUS_B),config);
System.out.println(s);
// {"name":"vegilyn","song":{"date":"2014-08-19","index":2,"name":"Shake It Off","singer":"Taylor Swift"},"status":"STATUS_B"}

SerializeConfig config = new SerializeConfig();
config.configEnumAsJavaBean(SongsEnum.class,StatusEnum.class); // 配置enum转换 
String s = JSON.toJSONString(new JavaBean("vegilyn",SongsEnum.SHAKE_IT_OFF,StatusEnum.STATUS_B),config);
System.out.println(s);
// {"name":"vegilyn","song":{"date":"2014-08-19","index":2,"name":"Shake It Off","singer":"Taylor Swift"},"status":{"index":1,"status":"状态B"}}

特别枚举数组转换的json：(注意重复值的json值)

public static void main(String[] args) {
    SongsEnum[] songsEnums = {SongsEnum.BETTER_MAN, SongsEnum.SAFE_AND_SOUND, SongsEnum.BETTER_MAN};
    SerializeConfig config = new SerializeConfig();
    config.configEnumAsJavaBean(SongsEnum.class);

    System.out.println(JSON.toJSONString(songsEnums,config));

}

// [{"date":"2016-10-20","index":5,"name":"Better Man","singer":"Little Big Town"},{"date":"2011-12-26","index":1,"name":"Safe&Sound","singer":"Taylor Swift"},{"$ref":"$[0]"}]

 

三、枚举类的全部值转换成json

期望结果：

[
    {"index": 1, "singer": "Taylor Swift", "name": "Safe&Sound", "date": "2011-12-26"},
    {"index": 2, "singer": "Taylor Swift", "name": "Shake It Off", "date": "2014-08-19"},
    {"index": 3, "singer": "Taylor Swift", "name": "Style", "date": "2015-02-09"},
    {"index": 4, "singer": "Simon & Garfunkel", "name": "The Sound Of Silence", "date": "1966-01-17"},
    {"index": 5, "singer": "Little Big Town", "name": "Better Man", "date": "2016-10-20"},
    {"index": 6, "singer": "Carpenters", "name": "Yesterday Once More", "date": "1973-05-16"}
]

实现代码：

 public static void main(String[] args) {
        SongsEnum[] values = SongsEnum.values();
        List<SongsEnum> songsEnums = new ArrayList<SongsEnum>();
        for (SongsEnum value : values) {
            songsEnums.add(value);
        }

        SerializeConfig config = new SerializeConfig();
        config.configEnumAsJavaBean(SongsEnum.class);

        System.out.println(JSON.toJSONString(songsEnums, config));
    }

以上能达到想要的效果，但是，每个enum类都要重复写以上代码。所以，利用反射来写一个公共的方法。

 public static String toJson(Class<? extends Enum> enumClass) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Method methodValues = enumClass.getMethod("values");
        Object invoke = methodValues.invoke(null);
        int length = java.lang.reflect.Array.getLength(invoke);
        List<Object> values = new ArrayList<Object>();
        for (int i=0; i<length; i++) {
            values.add(java.lang.reflect.Array.get(invoke, i));
        }

        SerializeConfig config = new SerializeConfig();
        config.configEnumAsJavaBean(enumClass);

        return JSON.toJSONString(values,config);
    }

public static void main(String[] args) {
        try {
            System.out.println(EnumJsonUtil.toJson(StatusEnum.class));
            // [{"index":0,"status":"状态A"},{"index":1,"status":"状态B"},{"index":2,"status":"状态C"}]
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

 

四、扩展：fastjson如何得到enum的field定义。

通过jdk反射机制得到的field。

public static void main(String[] args) {
  Field[] fields = SongsEnum.class.getFields();
  for (Field field : fields) {
    System.out.println(field.getName());
  }
}

SAFE_AND_SOUND
SHAKE_IT_OFF
STYLE
SOUND_OF_SILENCE
BETTER_MAN
YESTERDAY_ONCE_MORE
index
singer
name
date

如上，如果是通过jdk反射机制得到class的filed。会发现得到了不想要的结果，ex: SAFE_AND_SOUND 、SHAKE_IT_OFF 等。

想得到的field其实只想要: index、singer、name、date。

当然也可以自己分析，然后过滤出自己想要的class的field。

但下面看下fastjson中怎么得到enum中期望的field。(fastjson版本：1.2.31)

(1) 跟踪代码:  new SerializeConfig().configEnumAsJavaBean(enumClass)

public void configEnumAsJavaBean(Class<? extends Enum>... enumClasses) {
        for (Class<? extends Enum> enumClass : enumClasses) {
            put(enumClass, createJavaBeanSerializer(enumClass));
        }
    }

 private final ObjectSerializer createJavaBeanSerializer(Class<?> clazz) {
        SerializeBeanInfo beanInfo = TypeUtils.buildBeanInfo(clazz, null, propertyNamingStrategy, fieldBase);
        if (beanInfo.fields.length == 0 && Iterable.class.isAssignableFrom(clazz)) {
            return MiscCodec.instance;
        }

        return createJavaBeanSerializer(beanInfo);
    }

public class SerializeBeanInfo {

    protected final Class<?> beanType;
    protected final String   typeName;
    protected final JSONType jsonType;

    protected final FieldInfo[] fields;
    protected final FieldInfo[] sortedFields;

    protected int               features;

    public SerializeBeanInfo(Class<?> beanType, //
                             JSONType jsonType, //
                             String typeName, //
                             int features,
                             FieldInfo[] fields, //
                             FieldInfo[] sortedFields
                             ){
        this.beanType = beanType;
        this.jsonType = jsonType;
        this.typeName = typeName;
        this.features = features;
        this.fields = fields;
        this.sortedFields = sortedFields;
    }

}

可以看到SerializeBeanInfo 中定义的有 fields 。

(很好奇为什么定义成 protected , TyoeUtils.buildBeanInfo(...)是public的,返回的SerializeBeanInfo 也是public。

但是，SerializeBeanInfo. fields却是protected 的。

导致我知道fastjson中有这么一个util方法，可以得到我想要的enum信息（更确切的是可以得到class的信息）。

但是，最后我并不能直接在我的代码中使用SerializeBeanInfo。)。

通过debug可以看到SerializeBeanInfo对象的属性，就是我想要的结果。

接着进去看TyoeUtils.buildBeanInfo(...)的实现：

   public static SerializeBeanInfo buildBeanInfo(Class<?> beanType //
            , Map<String, String> aliasMap //
            , PropertyNamingStrategy propertyNamingStrategy //
            , boolean fieldBased //
    ) {

        JSONType jsonType = beanType.getAnnotation(JSONType.class);

        // fieldName,field ，先生成fieldName的快照，减少之后的findField的轮询
         Map<String, Field> fieldCacheMap = new HashMap<String, Field>();
        ParserConfig.parserAllFieldToCache(beanType, fieldCacheMap);

        List<FieldInfo> fieldInfoList = fieldBased
                ? computeGettersWithFieldBase(beanType, aliasMap, false, propertyNamingStrategy) //
                : computeGetters(beanType, jsonType, aliasMap, fieldCacheMap, false, propertyNamingStrategy);

    // 省略...

}

执行computeGetters(...)的结果：

 public static List<FieldInfo> computeGetters(Class<?> clazz, //
                                                 JSONType jsonType, //
                                                 Map<String, String> aliasMap, //
                                                 Map<String, Field> fieldCacheMap, //
                                                 boolean sorted, //
                                                 PropertyNamingStrategy propertyNamingStrategy //
    ) {
        Map<String, FieldInfo> fieldInfoMap = new LinkedHashMap<String, FieldInfo>();

        for (Method method : clazz.getMethods()) {
            String methodName = method.getName();
            int ordinal = 0, serialzeFeatures = 0, parserFeatures = 0;
            String label = null;

            if (Modifier.isStatic(method.getModifiers())) { continue; }  // 跳过static method

            if (method.getReturnType().equals(Void.TYPE)) { continue; }

            if (method.getParameterTypes().length != 0) { continue; }

            if (method.getReturnType() == ClassLoader.class) { continue; }

            if (method.getName().equals("getMetaClass")
                && method.getReturnType().getName().equals("groovy.lang.MetaClass")) {
                continue;
            }

            JSONField annotation = method.getAnnotation(JSONField.class);

            if (annotation == null) {
                annotation = getSuperMethodAnnotation(clazz, method);
            }

            if (annotation != null) {
                if (!annotation.serialize()) { continue; }

                ordinal = annotation.ordinal();
                serialzeFeatures = SerializerFeature.of(annotation.serialzeFeatures());
                parserFeatures = Feature.of(annotation.parseFeatures());

                if (annotation.name().length() != 0) {
                    String propertyName = annotation.name();

                    if (aliasMap != null) {
                        propertyName = aliasMap.get(propertyName);
                        if (propertyName == null) {
                            continue;
                        }
                    }

                    FieldInfo fieldInfo = new FieldInfo(propertyName, method, null, clazz, null, ordinal,
                                                        serialzeFeatures, parserFeatures, annotation, null, label);
                    fieldInfoMap.put(propertyName, fieldInfo);
                    continue;
                }

                if (annotation.label().length() != 0) {
                    label = annotation.label();
                }
            }

            if (methodName.startsWith("get")) {
                if (methodName.length() < 4) { continue; }

                if (methodName.equals("getClass")) { continue;}

                if (methodName.equals("getDeclaringClass") && clazz.isEnum()) { continue; }

                char c3 = methodName.charAt(3);

                String propertyName;
                if (Character.isUpperCase(c3) //
                    || c3 > 512 // for unicode method name
                ) {
                   if (compatibleWithJavaBean) {
                        propertyName = decapitalize(methodName.substring(3));
                    } else {
                        propertyName = Character.toLowerCase(methodName.charAt(3)) + methodName.substring(4);
                    }
                    propertyName = getPropertyNameByCompatibleFieldName(fieldCacheMap, methodName,  propertyName,3);
                } else if (c3 == '_') {
                    propertyName = methodName.substring(4);
                } else if (c3 == 'f') {
                    propertyName = methodName.substring(3);
                } else if (methodName.length() >= 5 && Character.isUpperCase(methodName.charAt(4))) {
                    propertyName = decapitalize(methodName.substring(3));
                } else {
                    continue;
                }

                boolean ignore = isJSONTypeIgnore(clazz, propertyName);

                if (ignore) {
                    continue;
                }
                //假如bean的field很多的情况一下，轮询时将大大降低效率
                Field field = ParserConfig.getFieldFromCache(propertyName, fieldCacheMap);

                if (field == null && propertyName.length() > 1) {
                    char ch = propertyName.charAt(1);
                    if (ch >= 'A' && ch <= 'Z') {
                        String javaBeanCompatiblePropertyName = decapitalize(methodName.substring(3));
                        field = ParserConfig.getFieldFromCache(javaBeanCompatiblePropertyName, fieldCacheMap);
                    }
                }

                JSONField fieldAnnotation = null;
                if (field != null) {
                    fieldAnnotation = field.getAnnotation(JSONField.class);

                    if (fieldAnnotation != null) {
                        if (!fieldAnnotation.serialize()) {
                            continue;
                        }

                        ordinal = fieldAnnotation.ordinal();
                        serialzeFeatures = SerializerFeature.of(fieldAnnotation.serialzeFeatures());
                        parserFeatures = Feature.of(fieldAnnotation.parseFeatures());

                        if (fieldAnnotation.name().length() != 0) {
                            propertyName = fieldAnnotation.name();

                            if (aliasMap != null) {
                                propertyName = aliasMap.get(propertyName);
                                if (propertyName == null) {
                                    continue;
                                }
                            }
                        }

                        if (fieldAnnotation.label().length() != 0) {
                            label = fieldAnnotation.label();
                        }
                    }
                }

                if (aliasMap != null) {
                    propertyName = aliasMap.get(propertyName);
                    if (propertyName == null) {
                        continue;
                    }
                }

                if (propertyNamingStrategy != null) {
                    propertyName = propertyNamingStrategy.translate(propertyName);
                }

                FieldInfo fieldInfo = new FieldInfo(propertyName, method, field, clazz, null, ordinal, serialzeFeatures, parserFeatures,
                                                    annotation, fieldAnnotation, label);
                fieldInfoMap.put(propertyName, fieldInfo);
            }

            if (methodName.startsWith("is")) {
                if (methodName.length() < 3) {
                    continue;
                }

                if (method.getReturnType() != Boolean.TYPE
                        && method.getReturnType() != Boolean.class) {
                    continue;
                }

                char c2 = methodName.charAt(2);

                String propertyName;
                if (Character.isUpperCase(c2)) {
                    if (compatibleWithJavaBean) {
                        propertyName = decapitalize(methodName.substring(2));
                    } else {
                        propertyName = Character.toLowerCase(methodName.charAt(2)) + methodName.substring(3);
                    }
                    propertyName = getPropertyNameByCompatibleFieldName(fieldCacheMap, methodName,  propertyName,2);
                } else if (c2 == '_') {
                    propertyName = methodName.substring(3);
                } else if (c2 == 'f') {
                    propertyName = methodName.substring(2);
                } else {
                    continue;
                }

                Field field = ParserConfig.getFieldFromCache(propertyName,fieldCacheMap);

                if (field == null) {
                    field = ParserConfig.getFieldFromCache(methodName,fieldCacheMap);
                }

                JSONField fieldAnnotation = null;
                if (field != null) {
                    fieldAnnotation = field.getAnnotation(JSONField.class);

                    if (fieldAnnotation != null) {
                        if (!fieldAnnotation.serialize()) {
                            continue;
                        }

                        ordinal = fieldAnnotation.ordinal();
                        serialzeFeatures = SerializerFeature.of(fieldAnnotation.serialzeFeatures());
                        parserFeatures = Feature.of(fieldAnnotation.parseFeatures());

                        if (fieldAnnotation.name().length() != 0) {
                            propertyName = fieldAnnotation.name();

                            if (aliasMap != null) {
                                propertyName = aliasMap.get(propertyName);
                                if (propertyName == null) {
                                    continue;
                                }
                            }
                        }

                        if (fieldAnnotation.label().length() != 0) {
                            label = fieldAnnotation.label();
                        }
                    }
                }

                if (aliasMap != null) {
                    propertyName = aliasMap.get(propertyName);
                    if (propertyName == null) {
                        continue;
                    }
                }

                if (propertyNamingStrategy != null) {
                    propertyName = propertyNamingStrategy.translate(propertyName);
                }

                //优先选择get
                if (fieldInfoMap.containsKey(propertyName)) {
                    continue;
                }

                FieldInfo fieldInfo = new FieldInfo(propertyName, method, field, clazz, null, ordinal, serialzeFeatures, parserFeatures,
                                                    annotation, fieldAnnotation, label);
                fieldInfoMap.put(propertyName, fieldInfo);
            }
        } // for methods end

        // for methods ： 优先通过定义的method来获取FieldInfo。

        // 然后，才通过Fields得到没有定义类似getXXX的field。

        Field[] fields = clazz.getFields();
        computeFields(clazz, aliasMap, propertyNamingStrategy, fieldInfoMap, fields);

        return getFieldInfos(clazz, sorted, fieldInfoMap);
    }

如果枚举中的: index、singer、name、date。没有定义getter方法，那么fieldInfoMap在for methods end之后是empty的。

并且经过测试发现, 如果class中定义了:  public final static String testName = "test";
只有提供了 : public String getTestName(){return testName;} 才会被fastjson转换。注：不能是public static方法。（原因看上面的源码）

或者 定义成 public final String testName = "test"; (但明显没有static的含义所在，原因看下面源码)

 

private static void computeFields(
            Class<?> clazz, //
            Map<String, String> aliasMap, //
            PropertyNamingStrategy propertyNamingStrategy, //
            Map<String, FieldInfo> fieldInfoMap, //
            Field[] fields) {

        for (Field field : fields) {
            if (Modifier.isStatic(field.getModifiers())) { // 如果是static 修饰的field 跳过。
                continue;
            }

            JSONField fieldAnnotation = field.getAnnotation(JSONField.class); // fastjson提供的注解

            int ordinal = 0, serialzeFeatures = 0, parserFeatures = 0;
            String propertyName = field.getName();
            String label = null;
            if (fieldAnnotation != null) {
                if (!fieldAnnotation.serialize()) {
                    continue;
                }

                ordinal = fieldAnnotation.ordinal();
                serialzeFeatures = SerializerFeature.of(fieldAnnotation.serialzeFeatures());
                parserFeatures = Feature.of(fieldAnnotation.parseFeatures());

                if (fieldAnnotation.name().length() != 0) {
                    propertyName = fieldAnnotation.name();
                }

                if (fieldAnnotation.label().length() != 0) {
                    label = fieldAnnotation.label();
                }
            }

            if (aliasMap != null) { // 别名定义
                propertyName = aliasMap.get(propertyName);
                if (propertyName == null) {
                    continue;
                }
            }

            if (propertyNamingStrategy != null) {
                propertyName = propertyNamingStrategy.translate(propertyName);
            }

            if (!fieldInfoMap.containsKey(propertyName)) {// map中不存在该field的FieldInfo, 则创建一个
                FieldInfo fieldInfo = new FieldInfo(propertyName, null, field, clazz, null, ordinal, serialzeFeatures, parserFeatures,
                                                    null, fieldAnnotation, label);
                fieldInfoMap.put(propertyName, fieldInfo);
            }
        }
    }

所以，根据枚举的特性。ex: SAFE_AND_SOUND 、SHAKE_IT_OFF 等。在enum中的定义都是 public static final ...

并且在methods中也不存在getXXX。

如果，我在enum中定义一个method： getSAFE_AND_SOUND(),则field中会出现。