Java 代码   

1. public void writeStringWithDoubleQuote(String text) {  
2. //null 处理，直接追加 null 字符即可，不需要双引号  
3.         int len = text.length();  
4.         int newcount = count + len + 2;// 初始计算长度为字符串长度 + 2（即双引号）  
5. // 初步扩容计算  
6.    
7.         int start = count + 1;  
8.         int end = start + len;  
9.         buf[count] = ''\"'';// 追加起始双引号  
10.         text.getChars(0, len, buf, start);  
11.         count = newcount;// 初步定 count 值  
12. /** 以下代码为处理特殊字符 */  
13.         for (int i = start; i < end; ++i) {  
14.             char ch = buf[i];  
15.             if (ch == ''\b'' || ch == ''\n'' || ch == ''\r'' || ch == ''\f'' || ch == ''\\'' || ch == ''/'' || ch == ''"'') {// 判断是否为特殊字符  
16. // 这里需要修改 count 值，以及扩容判断，省略之  
17.                 System.arraycopy(buf, i + 1, buf, i + 2, end - i - 1);// 数据移位，从当前处理点往后移  
18.                 buf[i] = ''\\'';// 追加特殊字符标记  
19.                 buf[++i] = replaceChars[(int) ch];// 追加原始的特殊字符为 \b 写为 b，最终即为 \\b 的形式，而不是 \\\b  
20.                 end++;  
21.             }  
22.         }  
23.    
24.         buf[newcount - 1] = ''\"'';// 转出结尾双引号  
25.     }  

    在处理字符串上，特殊的即在特殊字符上。因为在输出时，要输出时要保存字符串的原始模式，如 \"的格式，要输出时，要输出为 \ +" 的形式，而不能直接输出为 \"，后者在输出时就直接输出为"，而省略了 \，这在 js 端是会报错的。

    总结：

    在针对输出优化时，主要利用了最有效率的手段进行处理。如针对数字和 boolean 时的处理方式。同时，在处理字符串时，也采取了先处理最常用字符，再处理特殊字符的形式。在针对某些经常碰到的场景时，使用了联合处理的手段（如 writeIntAndChar)，而不再是分开处理。
    整个处理的思想，即是在处理单个数据时，采取最优方式；在处理复合数据时，避免扩容计算；尽量使用 jdk 中的方法，以避免重复轮子（可能轮子更慢）。

    下一篇，从数据处理过程对源码进行分析，同时解析其中针对性能优化的处理部分。

alibaba fastjson (json 序列化器) 序列化部分源码解析 - 2 - 性能优化 B

 前面讲了进行对象解析的两个方面，并讲了针对 outWriter 将不同类型的数据信息写到 buf 字符数组。本篇讲解对象解析的过程，即如何将不同类型的对象解析成 outWriter 所需要的序列信息。并考虑其中的性能优化。

 取得解析器    
    首先我们需要取得指定对象的 json 序列化器，以便使用特定的序列化器来序列化对象。因此，需要有一个方法来取得相对应的序列化器。在 fastjson 中，使用了一个类似 map 的结构来保存对象类型和及对应的解析器。对于对象类型，在整个 fastjson 中，分为以下几类：

    1    基本类型以及其包装类型，字符串
    2    基本类型数组以及包装类型数组
    3    Atomic 类型
    4    JMX 类型
    5    集合类型以及子类
    6    时间类型
    7    json 类型
    8    对象数组类型
    9    javaBean 类型

    对于第 1,2,3,4 类型，在 fastjson 中使用了一个全局的单态实例来保存相对应的解析器；第 5 类型，处理集合类型，对于集合类型及其，由于其处理逻辑均是一样，所以只需要针对子类作一些的处理，让其返回相对应的集合类型解析器即可；第 6 类型，时间处理器，将时间转化为类似 yyyy-MM-ddTHH:mm:ss.SSS 的格式；第 7 类型，处理 fastjson 专有 jsonAwre 类型；第 8 类型，处理对象的数组形式，即处理数组时，需要考虑数组中的统一对象类型；第 9, 即处理我们最常使用的对象，javaBean 类型，这也是在项目中解析得最多的类型。

 

    我们要看一下相对应的取解析器的方法，即类 JsonSerializer.getObjectWriter (Class<?> clazz) 方法，参考其中的实现：

Java 代码   

1. public ObjectSerializer getObjectWriter(Class<?> clazz) {  
2.         ObjectSerializer writer = mapping.get(clazz);  
3.         if (writer == null) {  
4.             if (Map.class.isAssignableFrom(clazz)) {  
5.                 mapping.put(clazz, MapSerializer.instance);  
6.             } else if (List.class.isAssignableFrom(clazz)) {  
7.                 mapping.put(clazz, ListSerializer.instance);  
8.             } else if (Collection.class.isAssignableFrom(clazz)) {  
9.                 mapping.put(clazz, CollectionSerializer.instance);  
10.             } else if (Date.class.isAssignableFrom(clazz)) {  
11.                 mapping.put(clazz, DateSerializer.instance);  
12.             } else if (JSONAware.class.isAssignableFrom(clazz)) {  
13.                 mapping.put(clazz, JSONAwareSerializer.instance);  
14.             } else if (JSONStreamAware.class.isAssignableFrom(clazz)) {  
15.                 mapping.put(clazz, JSONStreamAwareSerializer.instance);  
16.             } else if (clazz.isEnum()) {  
17.                 mapping.put(clazz, EnumSerializer.instance);  
18.             } else if (clazz.isArray()) {  
19.                 Class<?> componentType = clazz.getComponentType();  
20.                 ObjectSerializer compObjectSerializer = getObjectWriter(componentType);  
21.                 mapping.put(clazz, new ArraySerializer(compObjectSerializer));  
22.             } else if (Throwable.class.isAssignableFrom(clazz)) {  
23.                 mapping.put(clazz, new ExceptionSerializer(clazz));  
24.             } else {  
25.                 mapping.put(clazz, new JavaBeanSerializer(clazz));  
26.             }  
27.             writer = mapping.get(clazz);  
28.         }  
29.         return writer;  
30.     }  

 

首先，取对象解析器是由一个类型为 JSONSerializerMap 的对象 mapping 中取。之所以使用此类型，这是性能优化的一部分，此类型并不是一个完整的 map 类型，只是实现了一个类似 map 的操作的类型。其内部并没有使用基于 equals 的比较方式，而是使用了 System.identityHashCode 的实现。对于一个对象，其 identityHashCode 的值是定值，而对于一个类型，在整个 jvm 中只有一个，因此这里使用基于 class 的 identityHashCode 是可以了，也避免了使用 class 的 euqlas 来进行比较。
    接着再根据每一个类型从 mapping 中取出相对应的解析器。首先从继承而来的全局解析器取得解析器，如果对象不属于第 1,2,3,4 类型，而开始进入以下的 if else 阶段。
    我们从上面的源码中，可以看出解析器主要分为两个部分，一个是与解析类型相关的，一个是无关的。比如对于第 5,6,7 类型，其中最 5 类型是集合类型，由于不知道集合类型中的具体类型（因为存在继承关系），所以类型无关。对于第 8,9 类型，其中第 8 类型为对象数组类型，对于对象数组，数组中的每一个对象的类型都是确定的，且整个数组只有一种类型，因此可以确定其类型，这时候就要使用类型相关解析器了，对于第 9 类型，需要使用解析对象的类型来确定相对应的 javaBean 属性，因此是类型相关。
    另外一个确定解析器的过程当中，使用了映射机制，即将当前解析器与对应的类型映射起来，以便下一次时使用。对于集合类型及子类型，由于当前类型并不是确定的 List 或 Collection 类型，因此将当前类型与集合解析器映射起来。对于对象类型，需要将当前类型传递给相对应的解析器，以确定具体的属性。

    解析过程
    
    解析方法由统一的接口所定义，每个不同的解析器只需要实际这个方法并提供各自的实现即可。此方法为 write (JSONSerializer serializer, Object object)，由 ObjectSerializer 提供。带两个参数，第一个参数，即为解析的起点类 jsonSerializer，此类封装了我们所需要的 outWriter 类，需要时只需要从此类取出即可。第二个参数为我们所要解析的对象，在各个子类进行实现时，可将此对象通过强制类型转换，转换为所需要的类型即可。
    具体的解析过程根据不同的数据类型不所不同，对于第 1,2 类型，由于在 outWriter 中均有相对应的方法，所以在具体实现时，只需要调用相应的 outWriter 方法即可，而不需要作额外的工作。比如对于字符串解析器，它的解析过程如下所示：

Java 代码   

1. SerializeWriter out = serializer.getWrier();  
2.         String value = (String) object;  
3.         if (serializer.isEnabled(SerializerFeature.UseSingleQuotes)) {  
4.             out.writeStringWithSingleQuote(value);  
5.         } else {  
6.             out.writeStringWithDoubleQuote(value);  
7.         }  

 

    即首先，取得输出时所需要的 outWriter，然后再根据配置决定是输出单引号 + 字符串还是双引号 + 字符串。

    而对于其它并没有由 outWriter 所直接支持的类型而言，解析过程就相对于复杂一些。但是总的逻辑还是基于以下逻辑：

1.         基于数据类型特点输出所特有的字符包装内容
2.         基于数据类型特点转换为 outWriter 所能识别的内容
3.         逐步解析，将对象解析产生的字符数组输出到 outWriter 中

    只需此三步，即可完美的解析一个对象。因此，我们可以参考其中的一个具体实现，并讨论其中的具体优化措施。
    在取得解析器方法 getObjectWriter (Class<?> clazz) 中，我们可以看到，对于集合类型中的 Collection 和 List,fastjson 是分开进行解析的。即两者在解析时在细微处有着不一样的实现。两者的区别在于 List 是有序的，可以根据下标对元素进行访问，对于常用 List 实现，ArrayList, 使用下标访问子元素的价格为 O1。这就是在 fastJson 中采取的一点优化措施，详细看以下实现代码：

Java 代码   

1. public final void write(JSONSerializer serializer, Object object) throws IOException {  
2.         SerializeWriter out = serializer.getWrier();// 取得输出器  
3.         List<?> list = (List<?>) object;// 强制转换为所需类型  
4.    
5.         final int size = list.size();  
6.         int end = size - 1;// 此处定义为 size-1，是因为对最后一位有特殊处理  
7. // 空集合判断，省略之  
8.         out.append(''['');// 集合前缀包装  
9. /** 以下代码使用 get (X) 方法访问下标，实现代码对于 ArrayList 实现有好处，对于 LinkedList 是否有好处，还待考虑 */  
10.         for (int i = 0; i < end; ++i) {  
11.             Object item = list.get(i);  
12.             // 空值判断  
13.                 Class<?> clazz = item.getClass();  
14.                 if (clazz == Integer.class) {// 针对 Integer.class 特殊优化，使用 outWriter 自带方法  
15.                     out.writeIntAndChar(((Integer) item).intValue(), '','');  
16.                 } else if (clazz == Long.class) {// 针对 Long.class 特殊优化，使用 outWriter 自带方法  
17.                     long val = ((Long) item).longValue();  
18.                     out.writeLongAndChar(val, '','');  
19.                 } else {  
20.                     serializer.write(item);// 递归调用，写集合内元素  
21.                     out.append('','');// 间隔符  
22.                 }  
23.         }  
24.    
25. /** 以下代码为最后一位优化，当为最后一位时，不再需要输出间隔符，而是输出后缀包装符 
26. 这里即在处理时，直接输出后缀，与前面输出间隔符相对应 */  
27.         Object item = list.get(end);  
28.             Class<?> clazz = item.getClass();  
29.    
30.             if (clazz == Integer.class) {  
31.                 out.writeIntAndChar(((Integer) item).intValue(), '']'');  
32.             } else if (clazz == Long.class) {  
33.                 out.writeLongAndChar(((Long) item).longValue(), '']'');  
34.             } else {  
35.                 serializer.write(item);  
36.                 out.append('']'');  
37.             }  
38.     }  

 

    以下实现与 collection 相比不同的即在于处理中间元素与末尾元素的区别。相对于 Collection，就不能使用以上的方法了，在实现上，就只能先输出前缀，再一个一个地处理里面的元素，最后输出后缀。此实现如下所示：

Java 代码   

1. public void write(JSONSerializer serializer, Object object) throws IOException {  
2.         SerializeWriter out = serializer.getWrier();  
3.         Collection<?> collection = (Collection<?>) object;  
4.         out.append(''['');  
5.         boolean first = true;  
6.         for (Object item : collection) {  
7.             if (!first) {out.append('','');}  
8.             first = false;  
9.    
10.             Class<?> clazz = item.getClass();  
11.             //Integer.class 和 Long.class 特殊处理  
12.             serializer.write(item);  
13.         }  
14.         out.append('']'');  
15.     }  

 

    以上代码就是通常最常见的实现了。

    相对于集合类型实现，map 实现和 javaBean 实现相对来说，稍微复杂了一点。主要是输出 key 和 value 的问题。在 fastjson 中，key 输出表现为使用 outWriter 的 writeKey 来进行输出，value 输出则同样使用常规的输出。按照我们先前所说的逻辑，首先还是输出包装字符内容，即 {，在末尾输出}。然后，再根据每个 key-value 映射特点，采取相对应的输出方式。
    当然，对于 map 类型输出和 javaBean 输出还是不一样的。两者可以互相转换，但 fastjson 在输出时还是采取了不一样的输出方式。那么，我们以源代码来查看相应的实现：

Java 代码   

1. public void write(JSONSerializer serializer, Object object) throws IOException {  
2.         SerializeWriter out = serializer.getWrier();  
3.         Map<?, ?> map = (Map<?, ?>) object;  
4.         out.write(''{'');// 前缀  
5.    
6.         Class<?> preClazz = null;// 缓存前一个 value 类型和相对应的解析器，减少类型判断解析  
7.         ObjectSerializer preWriter = null;  
8.    
9.         boolean first = true;  
10.         for (Map.Entry<?, ?> entry : map.entrySet()) {  
11. // 此处有删除，即根据 nameFilter 和 valueFilter 针对 key-value 作转换处理  
12.             if (!first) {out.write('','');}// 输出间隔符  
13.    
14.             serializer.writeFieldName(key);// 输出字段名 + 冒号  
15.             first = false;  
16.    
17.             Class<?> clazz = value.getClass();  
18.             if (clazz == preClazz) {// 此处即细节优化内容，直接使用前一个解析器，避免再次从 jsonSerializer 中查找  
19.                 preWriter.write(serializer, value);  
20.             } else {  
21. /** 此处则就需要从 jsonSerializer 中查找解析器，并输出了 */  
22.                 preClazz = clazz;  
23.                 preWriter = serializer.getObjectWriter(clazz);  
24.                 preWriter.write(serializer, value);  
25.             }  
26.         }  
27.         out.write(''}'');// 后缀  
28.     }  

 

    由上可以看出，map 的实现还是按照我们常用的思路在进行。在性能优化处，采取了两个优化点，一是输出字段时，并不直接输出字段名，而是采取字段 + 冒号的方式一起输出，减少 outWriter 扩容计算。二是在查找 value 解析器时，尽量使用前一个 value 的解析器，避免重复查找。
    相比 map，javaBean 的实现就相对更复杂。javaBean 输出并不是采取 key-value 的方式，而是采取类似 fieldSerializer 的输出方式，即将属性名和值，组合成一个字段，一起进行输出。当然输出时还是先输出字段名，再输出值的实现。那么对于 javaBean 实现，首先要取得当前对象类型的所有可以输出的类型。
    在 fastjson 实现中，并没有采取 javaBean 属性的读取方式，而是采取了使用 getXXX 和 isXXX 方法的读取模式，来取得一个类型的可读取属性。作为性能优化的一部分，读取属性的操作结果被缓存到了 getter 缓存器中。其实，并不是缓存到了 getter 缓存器中，只是该类型的 javaBean 序列化器对象被缓存到了 jsonSerializer 的对象类型 - 序列化器映射中。对于同一个类型，就不需要再次解析该类型的属性了。
    有了相对应的字段，那么在实现时，就按照相应的字段进行输出即可。以下为实现代码：

Java 代码   

1. public void write(JSONSerializer serializer, Object object) throws IOException {  
2.         SerializeWriter out = serializer.getWrier();  
3.             out.append(''{'');// 前缀  
4.    
5.             for (int i = 0; i < getters.length; ++i) {  
6.                 FieldSerializer getter = getters[i];// 取属性解析器  
7.                 Object propertyValue = getter.getPropertyValue(object);// 取值  
8. // 省略中间 nameFilter 和 valueFilter 过滤处理  
9.                 if (commaFlag) {out.append('','');}// 间隔符  
10. // 省略 nameFilter 和 valueFilter 过滤之后的输出处理  
11.                getter.writeProperty(serializer, propertyValue);// 使用字段解析器输出内容  
12.             }  
13.             out.append(''}'');// 后缀  
14.     }  

 

    由上可见，javaBean 的输出实际上和 map 输出差不多。只不过这里又把属性的解析和输出封装了一层。在使用字段解析器（由 FieldSerializer 标识）输出字段值时，实际上也是先输出字段名 + 冒号，再输出字段值。这里就不再详细叙述。

    总结

    在整个解析过程中，更多的是根据对象类型查找到对象解析器，再使用对象解析器序列化对象的过程。在这中间，根据不同的对象采取不同的解析，并在实现中采取部分优化措施，以尽量地提高解析效率，减少中间运算。减少中间运算，是在解析过程中采取的最主要的优化办法。实际上，最主要的优化措施还是体现在 outWriter 中对于数据的处理上。此处更多的是设计模式的使用，以实现繁多的对象的解析。
    整个 fastjson 的序列化部分，就到此为止。单就笔者而言，在查看源代码的时候，也发现了一些问题，可能是作者未考虑的问题，或者是实际中未遇到。但在版本升级过程中，也渐渐地对功能进行了增强，比如对于 @JsonField 注解的使用，NameFilter 和 ValueFilter 的使用，使 fastjson 越来越符合业务系统的需要。如果可以，笔者会将其用到笔者所在的项目中，而不再重复发明轮子：)

Alibaba fastjson 序列化与反序列化

fastjson在官网的定义号称最小最快 多态的json序列化工具。fastjson采用独创的算法，将parse的速度提升到极致，超过所有json库，包括曾经号称最快的jackson。并且还超越了google的二进制协议protocol buf。

JSON这个类是fastjson API的入口，主要的功能都通过这个类提供。下面是这个类的重要几个方法介绍：

package com.alibaba.fastjson;

public abstract class JSON {
    // 将Java对象序列化为JSON字符串，支持各种各种Java基本类型和JavaBean
    public static String toJSONString(Object object,SerializerFeature... features);


    // 将Java对象序列化为JSON字符串，返回JSON字符串的utf-8 bytes
    public static byte[] toJSONBytes(Object object,SerializerFeature... features);


    // 将Java对象序列化为JSON字符串，写入到Writer中
    public static void writeJSONString(Writer writer,Object object,SerializerFeature... features);


    // 将Java对象序列化为JSON字符串，按UTF-8编码写入到OutputStream中
    public static final int writeJSONString(OutputStream os,// 
                                            Object object,// 
                                            SerializerFeature... features);
}

package com.alibaba.fastjson;


public abstract class JSON {
    // 将JSON字符串反序列化为JavaBean
    public static <T> T parSEObject(String jsonStr,Class<T> clazz,Feature... features);


    // 将JSON字符串反序列化为JavaBean
    public static <T> T parSEObject(byte[] jsonBytes,// UTF-8格式的JSON字符串
                                    Class<T> clazz,Feature... features);


    // 将JSON字符串反序列化为泛型类型的JavaBean
    public static <T> T parSEObject(String text,TypeReference<T> type,Feature... features);


    // 将JSON字符串反序列为JSONObject
    public static JSONObject parSEObject(String text);
}

Demo

import com.alibaba.fastjson.*;

JSONObject jsonObj = JSON.parSEObject(jsonStr);

import com.alibaba.fastjson.JSON;


Model model = JSON.parSEObject(jsonStr,Model.class);

import com.alibaba.fastjson.JSON;


Type type = new TypeReference<List<Model>>() {}.getType(); 
List<Model> list = JSON.parSEObject(jsonStr,type);

import com.alibaba.fastjson.JSON;


Model model = ...; 
String jsonStr = JSON.toJSONString(model);

import com.alibaba.fastjson.JSON;


Model model = ...; 
byte[] jsonBytes = JSON.toJSONBytes(model);

import com.alibaba.fastjson.JSON;


Model model = ...; 
OutputStream os;
JSON.writeJSONString(os,model);

import com.alibaba.fastjson.JSON;


Model model = ...; 
Writer writer = ...;
JSON.writeJSONString(writer,model);

总结：

更多关于fastjson的知识可以去w3c去了解：https://www.w3cschool.cn/fastjson/

alibaba fastjson(json序列化器)序列化部分源码解析- Java综合

本文copy自http://www.flydmeng.com/index.php/code/alibaba-fastjson-json-serializer-chapter-source-analyse-one-global-analyse.html

fastjson官方地址: http://code.alibabatech.com/wiki/display/FastJSON/Home
从javaeye上看到了阿里一位人士写的fastjson，特别是其中如何将java对象序列化成json字符串这段。笔者比较关注，因为在笔者的项目中就用了一个json序列化器(造的轮子)。就下载下来看了一看，先不说和笔者所用的轮子有何区别，单就用了一个简单的测试器，来测试一下两者的处理速度。测试代码就不贴了，简单地说下测试结果。在jvm充分优化的情况下（for循环执行了很多次之后）,笔者所使用的java序列化器处理速度不是很均匀，在结尾有短暂的变化（可能与虚拟机回收有关系）；而fastjson在后面的处理过程当中，一般很均匀（后来发现与使用的buf分配方式有关）。最主要的区别莫在于，fastjson的速度那是不能对比了。
经过分析源码之后，发现fastjson在处理json优化上面还是下了很大的工夫的。笔者准备从以下几个方面对fastjson作一个简单的解析，也让使用fastjson的同学对fastjson有一个简单的认识。
1 总体分析 分析json序列化的总体思路和解析过程
2 性能分析A 针对字符生产部分(即outWriter)对不同类型数据的处理和与性能相关处理部分
3 性别分析B 针对序列化过程部分(即objectSerializer)对不同类型的序列化过程处理和与性能相关处理部分
4 对象解析分析 对javaBean解析部分和针对字段输出部分的处理和解析
源码分析基于1.0.5版本。

总体分析，首先上图，即fastjson的总体处理思想，其实也是所有json序列化器需要考虑的问题。

在这里，需要考虑的主要有两个部分，一是临时保存在序列化过程中用于储存数据的容器，二是处理对象序列化的序列化器。
在fastjson中，保存数据的容器使用了wirter，字符输出流，而且是自实现的一个字符输出流。相对原来的writer，追加了很多需要输出的信息的实现，比如输出一个字符串，输出一个字符，输出一个long类型数据等。而处理对象序列化的序列化器，而使用了责任链模式和工厂模式，将不同类型的java对象分散到不同的序列化器当中。而每个序列化器只处理与自身类型相对应的数据信息，这样就避免了在处理时，各种情况交织在一块，逻辑混乱的问题。
下面就源码本身作一个分析，其中结合两个部分进行分析。

代码分析部分

首先，将一个对象序列化json字符串调用的是JSON对象的toJSONString方法，这里调用的是无参数方法。(注：本文不分析采用vistor实现json序列化代码的部分)。具体代码如下所示：

第一行，新产生的一个数据保存器，储存在序列化过程中产生的数据；第二行，产生统一的json序列化器，其中使用了outWriter，此类即json序列化的统一处理器；第三行，调用序列化方法开始序列化对象，以产生json字符串信息；第四行，返回已经储存的json信息。