一、前言

最近老大说要新增一个试用广告的功能,我巴拉巴拉的从之前推送广告那里将代码cv过来,然后跟老大说搞定了!过一会老大说返回的json格式不对!于是乎我瞧了瞧:

{
    "adsArea1":{
        "adsMaterials":[
            {
                "animType":"99",
                "materialName":"b6d767d2f8ed5d21a44b0e5886680cb9.jpg",
                "materialType":"0",
                "materialUrl":"http://xxx/059492d7-66f1-4052-891a-c512f957342d22.jpg",
                "playTime":5,
                "sort":1
            }],
          "areaDirection":"",
           "areaId":"3721",
           "areaType":"0",
           "createBy":"",// 空值
           "createDate":"",// 空值
           "deleteFlg":"",// 空值
           "height":800,
           "id":"418",
           "materialList":"",// 空值
           "playSettingList":"",// 空值
           "updateBy":"",
           "updateDate":"",// 空值
           "width":1280,
           "x":0,
           "y":0},
           
            ···
}       

咋看一下,感觉没什么问题啊?然后他说之前返给我的格式不是这样的,没有这些中间的这些空值,那好吧,我看了下以往的推送历史记录里,确实是没有的,那返回的是一样的对象怎么就没有了呢?
仔细看了下,在推送的时候,保存在推送历史表里的记录是转成json字符串存储起来的 String json = JSON.toJSONString(pushAdvertisementDto);
而存在表里的数据则没有null值。而我现在直接返回的是对象。
那么问题就出在这里了~

二、直击源码

点进去JSON.class里面进去看toJSONString(pushAdvertisementDto)方法 发现可以带上一些参数:

图片描述

让我们来看看SerializerFeature是一个什么东西吧:

图片描述

在网上搜索了一下名词解释:

图片描述

就是这个东西默认是false的,默认不输出null值的字段,如果想携带该字段,那么用这个方法就可以了:
JSON.toJSONString(Object object, SerializerFeature.WriteMapNullValue)

问题到这里就已经知道是为什么了,返回的数据没有经过FastJSON转换,因为用的是@RestController,我默认返回的对象传回去安卓那里也是json格式,但是里面的字段不对,因为业务原因就只定义了一个 PushAdvertisementDto对象返回,所以在这里用FastJSON转一下再返回就可以了。

我们接着往下看:
JSON.toJSONString()本质还是调的这个方法:

public static String toJSONString(Object object, int defaultFeatures, SerializerFeature... features) {
    SerializeWriter out = new SerializeWriter((Writer)null, defaultFeatures, features); // 1

    String var5;
    try {
        JSONSerializer serializer = new JSONSerializer(out); 
        serializer.write(object);// 2
        var5 = out.toString(); 
    } finally {
        out.close();
    }

    return var5;
}

1.如果我们要输出为null值的字段,则SerializerFeature.WriteMapNullValue会被传到SerializerWriter这里做了一个初始化

public SerializeWriter(Writer writer, int defaultFeatures, SerializerFeature... features) {
    this.writer = writer;
    this.buf = (char[])bufLocal.get();
    if (this.buf != null) {
        bufLocal.set((Object)null);
    } else {
        this.buf = new char[2048];
    }

    int featuresValue = defaultFeatures;
    SerializerFeature[] var5 = features; 
    int var6 = features.length;

    for(int var7 = 0; var7 < var6; ++var7) {
        SerializerFeature feature = var5[var7];
        featuresValue |= feature.getMask();
    }

    this.features = featuresValue;
    this.computeFeatures();
}

2.让我们跟进来serializer.write(object); 里面看一看:

public final void write(Object object) {
    if (object == null) {
        this.out.writeNull();
    } else {
        Class<?> clazz = object.getClass();
        ObjectSerializer writer = this.getObjectWriter(clazz);

        try {
            writer.write(this, object, (Object)null, (Type)null, 0);// 在这里做了写的操作
        } catch (IOException var5) {
            throw new JSONException(var5.getMessage(), var5);
        }
    }
}

跟进去writer.write(this, object, (Object)null, (Type)null, 0);

public interface ObjectSerializer {
    void write(JSONSerializer var1, Object var2, Object var3, Type var4, int var5) throws IOException;
}

发现是个可拓展的接口,让我们看看ObjectSerializer具体的实现类JavaBeanSerializer,这里代码比较长,虽然重点关注的代码比较少,但是还是完整的贴出来:

public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
    SerializeWriter out = serializer.out;
    if (object == null) {
        out.writeNull();
    } else if (!this.writeReference(serializer, object, features)) {
        FieldSerializer[] getters;
        if (out.sortField) {
            getters = this.sortedGetters;
        } else {
            getters = this.getters;
        }

        SerialContext parent = serializer.context;
        serializer.setContext(parent, object, fieldName, this.beanInfo.features, features);
        boolean writeAsArray = this.isWriteAsArray(serializer, features);

        try {
            char startSeperator = writeAsArray ? 91 : 123;
            char endSeperator = writeAsArray ? 93 : 125;
            
            out.append((char)startSeperator);// 这里开始拼接输出
            
            if (getters.length > 0 && out.isEnabled(SerializerFeature.PrettyFormat)) {
                serializer.incrementIndent();
                serializer.println();
            }

            boolean commaFlag = false;
            if ((this.beanInfo.features & SerializerFeature.WriteClassName.mask) != 0 || serializer.isWriteClassName(fieldType, object)) {
                Class<?> objClass = object.getClass();
                if (objClass != fieldType) {
                    this.writeClassName(serializer, object);
                    commaFlag = true;
                }
            }

            char seperator = commaFlag ? 44 : 0;
            boolean directWritePrefix = out.quoteFieldNames && !out.useSingleQuotes;
            char newSeperator = this.writeBefore(serializer, object, (char)seperator);
            commaFlag = newSeperator == ',';
            boolean skipTransient = out.isEnabled(SerializerFeature.SkipTransientField);
            boolean ignoreNonFieldGetter = out.isEnabled(SerializerFeature.IgnoreNonFieldGetter);

            for(int i = 0; i < getters.length; ++i) {
                FieldSerializer fieldSerializer = getters[i];
                Field field = fieldSerializer.fieldInfo.field;
                FieldInfo fieldInfo = fieldSerializer.fieldInfo;
                String fieldInfoName = fieldInfo.name;
                Class<?> fieldClass = fieldInfo.fieldClass;
                if ((!skipTransient || field == null || !fieldInfo.fieldTransient) && (!ignoreNonFieldGetter || field != null) && this.applyName(serializer, object, fieldInfo.name) && this.applyLabel(serializer, fieldInfo.label)) {
                    Object propertyValue;
                    try {
                        propertyValue = fieldSerializer.getPropertyValue(object);
                    } catch (InvocationTargetException var32) {
                        if (!out.isEnabled(SerializerFeature.IgnoreErrorGetter)) {
                            throw var32;
                        }

                        propertyValue = null;
                    }

                    if (this.apply(serializer, object, fieldInfoName, propertyValue)) {
                        String key = this.processKey(serializer, object, fieldInfoName, propertyValue);
                        Object originalValue = propertyValue;
                        propertyValue = this.processValue(serializer, fieldSerializer.fieldContext, object, fieldInfoName, propertyValue);
                        if (propertyValue != null || writeAsArray || fieldSerializer.writeNull || out.isEnabled(SerializerFeature.WriteMapNullValue)) {
                            if (propertyValue != null && out.notWriteDefaultValue) {
                                Class<?> fieldCLass = fieldInfo.fieldClass;
                                if (fieldCLass == Byte.TYPE && propertyValue instanceof Byte && (Byte)propertyValue == 0 || fieldCLass == Short.TYPE && propertyValue instanceof Short && (Short)propertyValue == 0 || fieldCLass == Integer.TYPE && propertyValue instanceof Integer && (Integer)propertyValue == 0 || fieldCLass == Long.TYPE && propertyValue instanceof Long && (Long)propertyValue == 0L || fieldCLass == Float.TYPE && propertyValue instanceof Float && (Float)propertyValue == 0.0F || fieldCLass == Double.TYPE && propertyValue instanceof Double && (Double)propertyValue == 0.0D || fieldCLass == Boolean.TYPE && propertyValue instanceof Boolean && !(Boolean)propertyValue) {
                                    continue;
                                }
                            }

                            if (commaFlag) {
                                out.write(44);
                                if (out.isEnabled(SerializerFeature.PrettyFormat)) {
                                    serializer.println();
                                }
                            }

                            if (key != fieldInfoName) {
                                if (!writeAsArray) {
                                    out.writeFieldName(key, true);
                                }

                                serializer.write(propertyValue);
                            } else if (originalValue != propertyValue) {
                                if (!writeAsArray) {
                                    fieldSerializer.writePrefix(serializer);
                                }

                                serializer.write(propertyValue);
                            } else {
                                if (!writeAsArray) {
                                    if (directWritePrefix) {
                                        out.write(fieldInfo.name_chars, 0, fieldInfo.name_chars.length);
                                    } else {
                                        fieldSerializer.writePrefix(serializer);
                                    }
                                }

                                if (!writeAsArray) {
                                    if (fieldClass == String.class) {
                                        if (propertyValue == null) {
                                            if ((out.features & SerializerFeature.WriteNullStringAsEmpty.mask) == 0 && (fieldSerializer.features & SerializerFeature.WriteNullStringAsEmpty.mask) == 0) {
                                                out.writeNull();
                                            } else {
                                                out.writeString("");
                                            }
                                        } else {
                                            String propertyValueString = (String)propertyValue;
                                            if (out.useSingleQuotes) {
                                                out.writeStringWithSingleQuote(propertyValueString);
                                            } else {
                                                out.writeStringWithDoubleQuote(propertyValueString, '\u0000');
                                            }
                                        }
                                    } else {
                                        fieldSerializer.writeValue(serializer, propertyValue);
                                    }
                                } else {
                                    fieldSerializer.writeValue(serializer, propertyValue);
                                }
                            }

                            commaFlag = true;
                        }
                    }
                }
            }

            this.writeAfter(serializer, object, (char)(commaFlag ? ',' : '\u0000'));
            if (getters.length > 0 && out.isEnabled(SerializerFeature.PrettyFormat)) {
                serializer.decrementIdent();
                serializer.println();
            }

            out.append((char)endSeperator); // 结束拼接
            
        } catch (Exception var33) {
            String errorMessage = "write javaBean error";
            if (object != null) {
                errorMessage = errorMessage + ", class " + object.getClass().getName();
            }

            if (fieldName != null) {
                errorMessage = errorMessage + ", fieldName : " + fieldName;
            }

            if (var33.getMessage() != null) {
                errorMessage = errorMessage + ", " + var33.getMessage();
            }

            throw new JSONException(errorMessage, var33);
        } finally {
            serializer.context = parent;
        }
    }
}

我们挑重点的看,这里我们关注out.append( )代码就可以了,中间大致就是判断一些前文说的SerializerFeature.WriteMapNullValue等条件。

跟进去out.append( )方法,在最后调用wirte方法将值付给this.buf 和this.count:

public void write(int c) {
    int newcount = this.count + 1;
    if (newcount > this.buf.length) {
        if (this.writer == null) {
            this.expandCapacity(newcount);
        } else {
            this.flush();
            newcount = 1;
        }
    }

    this.buf[this.count] = (char)c;
    this.count = newcount;
}

再回到前面的var5 = out.toString( );SerializeWriter重写toString方法最后返回转换好的json字符串。到这里整个json转换流程就已经结束了。

三、结语

虽然只是一开始只是json格式的一个小问题,花了挺长的时间观看源码,但是感觉收获还是很大的,也很值。因为个人水平原因也不是全能看懂。。中间很长的那段源码大致就是用反射获取要转成json的对象的属性和值,然后中间经过一些条件判断,通过输出流拼接字符输出字符串。

如文中有不对的地方,欢迎指出一起讨论 ~

关于SerializerFeature名词解释源自:https://blog.csdn.net/u010246...


小哥
12 声望2 粉丝

虚心学习