fastjson源码分析3-toJSONString

2021SC@SDUSC

这是我们要分析的方法，通过该方法，可以将object转换为一个json形式的字符串

public static String toJSONString(Object object) {
        return toJSONString(object, emptyFilters);
    }

它的方法体中调用了一个重载方法，多了一个参数emptyFilters，这是一个在JSON类头部声明的SerializeFilter的一个空数组，这个SerializeFilter是一个空接口，在serialize这个包中，我们查看它的uml类图可以看到

有多个后缀是Filter的类都是实现了这个接口，也就是说这个数组里面的东西可以利用多态机制增加实现了这个接口的所有类型，这里的代码使用符合了依赖倒置的使用原则，使用层使用SerializeFilter这个接口，实现层的具体类仅需实现这个接口，更改使用端的内容或者是具体实现类（实现了接口的类）不用去改动另一端的代码。

然后我们再接着来看它调用的重载方法

 public static String toJSONString(Object object, SerializeFilter[] filters, SerializerFeature... features) {
        return toJSONString(object, SerializeConfig.globalInstance, filters, null, DEFAULT_GENERATE_FEATURE, features);
    }

我们对第二个参数做出一个说明，SerializeConfig.globalInstance这个全局有且仅有一个的实例就是SerializeConfig对象，这种方法有点类似于单例模式，源码中的写法是这样的：

 public final static SerializeConfig                   globalInstance  = new SerializeConfig();

针对SerializeConfig 这个类来说，官方的说法是这个类用于循环检测引用，具体这个类内部是干什么的我暂时还没有搞清楚，我们后续的分析会继续分析这个类。

我们再来看看再次调用的重载函数都传入了哪些参数：

public static String  toJSONString(Object object, // 
                                      SerializeConfig config, // 
                                      SerializeFilter[] filters, // 
                                      String dateFormat, //
                                      int defaultFeatures, // 
                                      SerializerFeature... features)

前三个参数之前已经说过了，第四个是格式，第五个暂时还不清楚它是干什么的，但是我们可以通过它在函数里面是怎么调用的来判断它的作用；下面是函数的方法体：

public static String  toJSONString(Object object, // 
                                      SerializeConfig config, // 
                                      SerializeFilter[] filters, // 
                                      String dateFormat, //
                                      int defaultFeatures, // 
                                      SerializerFeature... features) {
        SerializeWriter out = new SerializeWriter(null, defaultFeatures, features);

        try {
            JSONSerializer serializer = new JSONSerializer(out, config);
            
            if (dateFormat != null && dateFormat.length() != 0) {
                serializer.setDateFormat(dateFormat);
                serializer.config(SerializerFeature.WriteDateUseDateFormat, true);
            }

            if (filters != null) {
                for (SerializeFilter filter : filters) {
                    serializer.addFilter(filter);
                }
            }

            serializer.write(object);

            return out.toString();
        } finally {
            out.close();
        }
    }

我们可以看到，形式参数的第四个和第五个都在SerializeWriter这个类的构造方法中使用，那么接下来我们来看看这个构造方法：

public SerializeWriter(Writer writer, int defaultFeatures, SerializerFeature... features){
        this.writer = writer;

        buf = bufLocal.get();

        if (buf != null) {
            bufLocal.set(null);
        } else {
            buf = new char[2048];
        }

        int featuresValue = defaultFeatures;
        for (SerializerFeature feature : features) {
            featuresValue |= feature.getMask();
        }
        this.features = featuresValue;

        computeFeatures();
    }

SerializeWriter这个类继承了Writer类；
在它的构造方法中，将defaultFeatures这个形式参数赋值给了一个int，接下来用for循环对它与features中的每一个特征做了 “ |=”运算，我们这里先来介绍一下“|="运算

" |="在java中的含义是按位或，举个例子：
5的二进制：0101
4的二进制：0100
那么按照按位或的思想（每一位都采用逻辑运算或）：
0101
0100
———
0101 = 5，最终按位或的结果应该是5.
我们来测试一下：

		int a = 5;
        int b = 4;
        a |= b;
        System.out.println(a);

运行的结果如下：

其次为了说清楚这个方法到底在干什么我们需要进到枚举类SerializerFeature看看getMask方法：

SerializerFeature(){
        mask = (1 << ordinal());
    }

    public final int mask;

    public final int getMask() {
        return mask;
    }

可以看到，当我们调用枚举类中的元素时，mask被赋值1左移（<<在java中是左移的意思）ordinal()位，ordinal()为枚举类中该元素的序号

public enum enumTest {
        Winter,
        Summer,
        Fall,
        Spring;
        enumTest(){mask = (1 << ordinal());}
        public final int mask;
        public final int getMask() {
        return mask;
    }
}

比如在这个简单的枚举类示例中winter的序号是0，那么winter的mask值就是1左移0位还是1；
summer的序号是1，那么summer的mask值就是1转换成二进制左移1位，就是10，也就是十进制的2；
Fall的序号是2，那么Fall的mask值就是1左移两位就是100，也就是十进制的4，以此类推；

回到我们的源码中来，我们就是通过mask去获取枚举类SerializerFeature的值，然后与featuresValue按位或。

那么，这个featuresValue的初始值是多少呢？我们来看看传入的值：

 public static String toJSONString(Object object, SerializeFilter[] filters, SerializerFeature... features) {
        return toJSONString(object, SerializeConfig.globalInstance, filters, null, DEFAULT_GENERATE_FEATURE, features);
    }

这里传入的DEFAULT_GENERATE_FEATURE有一个静态代码块给它赋值：

static {
        int features = 0;
        features |= SerializerFeature.QuoteFieldNames.getMask();
        features |= SerializerFeature.SkipTransientField.getMask();
        features |= SerializerFeature.WriteEnumUsingName.getMask();
        features |= SerializerFeature.SortField.getMask();

        DEFAULT_GENERATE_FEATURE = features;

        config(IOUtils.DEFAULT_PROPERTIES);
    }

我利用Junit测试单元跑出了这个初始值

转换成二进制为：110000010001；
用这个初始值去按位或每个枚举值中的mask，最终获得一个features存为全局变量，然后在computeFeatures()这个方法中去使用，我们来具体看看这个方法：

protected void computeFeatures() {
        quoteFieldNames = (this.features & SerializerFeature.QuoteFieldNames.mask) != 0;
        useSingleQuotes = (this.features & SerializerFeature.UseSingleQuotes.mask) != 0;
        sortField = (this.features & SerializerFeature.SortField.mask) != 0;
        disableCircularReferenceDetect = (this.features & SerializerFeature.DisableCircularReferenceDetect.mask) != 0;
        beanToArray = (this.features & SerializerFeature.BeanToArray.mask) != 0;
        writeNonStringValueAsString = (this.features & SerializerFeature.WriteNonStringValueAsString.mask) != 0;
        notWriteDefaultValue = (this.features & SerializerFeature.NotWriteDefaultValue.mask) != 0;
        writeEnumUsingName = (this.features & SerializerFeature.WriteEnumUsingName.mask) != 0;
        writeEnumUsingToString = (this.features & SerializerFeature.WriteEnumUsingToString.mask) != 0;

        writeDirect = quoteFieldNames //
                      && (this.features & nonDirectFeatures) == 0 //
                      && (beanToArray || writeEnumUsingName)
                      ;

        keySeperator = useSingleQuotes ? '\'' : '"';

        browserSecure = (this.features & SerializerFeature.BrowserSecure.mask) != 0;

        final long S0 = 0x4FFFFFFFFL, S1 = 0x8004FFFFFFFFL, S2 = 0x50000304ffffffffL;
         sepcialBits = browserSecure
                ? S2
                : (features & SerializerFeature.WriteSlashAsSpecial.mask) != 0 ? S1 : S0;
    }

至于上面的对应的枚举类中的变量，在JSON类全部初始化为boolean值，通过与feature与的逻辑运算，来判断这些枚举值是否存在，可以说是非常巧妙了；
分析到这块，先停一下，我们发现，分析形参传入的值是否存在的时候，这里用了"|="得到feature，然后在利用&去判断该值是否存在，这种方式比直接用循环加if的方式要快，这一块也说明了为什么fastjson要更快一点，好了，今天就先分析到这里，剩下的我们下篇文章再接着 分析。