FastJson的使用心得

  本文为早前整理，参考文献已找不到，如有侵权请与我联系，添加参考链接。

一丶基本使用

1.1主要API

fastjson入口类是com.alibaba.fastjson.JSON，主要的API是JSON.toJSONString，和parseObject。

 package com.alibaba.fastjson;
 ​
 public abstract class JSON {
       public static final String toJSONString(Object object);
       public static final <T> T parseObject(String text, Class<T> clazz, Feature... features);
 }

序列化：

String jsonString = JSON.toJSONString(obj);

反序列化：

VO vo = JSON.parseObject("...", VO.class);

泛型反序列化：

import com.alibaba.fastjson.TypeReference;
​
List<VO> list = JSON.parseObject("...", new TypeReference<List<VO>>() {});

1.2基本使用

User 类：

 package json.fastjson.base;
 ​
 public class User {
 ​
     private Long id;
     private String name;
 ​
     public Long getId() {
         return id;
     }
 ​
     public void setId(Long id) {
         this.id = id;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     @Override
     public String toString() {
         return "User [id=" + id + ", name=" + name + "]";
     }
 }

Group 类：

 package json.fastjson.base;
 ​
 import java.util.ArrayList;
 import java.util.List;
 ​
 public class Group {
 ​
     private Long id;
     private String name;
     private List<User> users = new ArrayList<User>();
 ​
     public Long getId() {
         return id;
     }
 ​
     public void setId(Long id) {
         this.id = id;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public List<User> getUsers() {
         return users;
     }
 ​
     public void setUsers(List<User> users) {
         this.users = users;
     }
 ​
     public void addUser(User user) {
         users.add(user);
     }
 ​
     @Override
     public String toString() {
         return "Group [id=" + id + ", name=" + name + ", users=" + users + "]";
     }
 }

测试类：

 public class TestBase {
 ​
     public static void main(String[] args) {
         Group group = new Group();
         group.setId(0L);
         group.setName("admin");
 ​
         User guestUser = new User();
         guestUser.setId(2L);
         guestUser.setName("guest");
 ​
         User rootUser = new User();
         rootUser.setId(3L);
         rootUser.setName("root");
 ​
         group.addUser(guestUser);
         group.addUser(rootUser);
 ​
         List<User> userList = group.getUsers();
 ​
         // Group序列化
         String jsonString = JSON.toJSONString(group);
         System.out.println("Group序列化:" + jsonString);
 ​
         // Group反序列化
         jsonString = "{\"id\":0,\"name\":\"admin\",\"users\":[{\"id\":2,\"name\":\"guest\"},{\"id\":3,\"name\":\"root\"}]}";
         group = JSON.parseObject(jsonString, Group.class);
         System.out.println("Group反序列化:" + group);
 ​
         // List序列化
         jsonString = JSON.toJSONString(userList);
         System.out.println("List序列化:" + jsonString);
 ​
         // List泛型反序列化
         jsonString = "[{\"id\":2,\"name\":\"guest\"},{\"id\":3,\"name\":\"root\"}]";
         userList = JSON.parseObject(jsonString, new TypeReference<List<User>>() {});
         System.out.println("List反序列化:" + userList);
     }
 }
 结果:

 Group序列化:{"id":0,"name":"admin","users":[{"id":2,"name":"guest"},{"id":3,"name":"root"}]}
 Group反序列化:Group [id=0, name=admin, users=[User [id=2, name=guest], User [id=3, name=root]]]
 List序列化:[{"id":2,"name":"guest"},{"id":3,"name":"root"}]
 List反序列化:[User [id=2, name=guest], User [id=3, name=root]]

1.3测试时间

 public class TestDate {

     public static void main(String[] args) {

         User user = new User();
         user.setId(2L);
         user.setName("guest");
         user.setDate(new Date());

         // 序列化
         String jsonString = JSON.toJSONString(user);
         System.out.println("序列化:" + jsonString);

         // 序列化处理时间，方式一
         jsonString = JSON.toJSONStringWithDateFormat(user, "yyyy-MM-dd HH:mm:ss.SSS");
         System.out.println("序列化处理时间，方式一:" + jsonString);

         // 序列化处理时间，方式二：ISO-8601日期格式
         jsonString = JSON.toJSONString(user, SerializerFeature.UseISO8601DateFormat);
         System.out.println("序列化处理时间，方式二：ISO-8601日期格式:" + jsonString);

         // 序列化处理时间，方式三：全局修改日期格式
         JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd";
         jsonString = JSON.toJSONString(user, SerializerFeature.WriteDateUseDateFormat);
         System.out.println("序列化处理时间，方式三：全局修改日期格式:" + jsonString);

     }
 }

 测试结果

 序列化:{"date":1558595807672,"id":2,"name":"guest"}
 序列化处理时间，方式一:{"date":"2019-05-23 15:16:47.672","id":2,"name":"guest"}
 序列化处理时间，方式二：ISO-8601日期格式:{"date":"2019-05-23T15:16:47.672+08:00","id":2,"name":"guest"}
 序列化处理时间，方式三：全局修改日期格式:{"date":"2019-05-23","id":2,"name":"guest"}

1.4 JSONField 和 JSONType 介绍

• 一、JSONField 介绍 注意：1、若属性是私有的，必须有set*方法。否则无法反序列化。

 public @interface JSONField {
     // 配置序列化和反序列化的顺序，1.1.42版本之后才支持
     int ordinal() default 0;

      // 指定字段的名称
     String name() default "";

     // 指定字段的格式，对日期格式有用
     String format() default "";

     // 是否序列化
     boolean serialize() default true;

     // 是否反序列化
     boolean deserialize() default true;

 }

• 二、JSONField 配置方式 FieldInfo可以配置在getter/setter方法或者字段上。例如：

  • 2.1 配置在getter/setter上

   public class A {
         private int id;
  
         @JSONField(name="ID")
         public int getId() {return id;}
         @JSONField(name="ID")
         public void setId(int value) {this.id = id;}
  
    }

  • 2.2 配置在field上

    public class A {
      @JSONField(name="ID")
      private int id;
      public int getId() {return id;}
      public void setId(int value) {this.id = id;}
     }

• 三、使用format配置日期格式化

public class A {
      // 配置date序列化和反序列使用yyyyMMdd日期格式
      @JSONField(format="yyyyMMdd")
      public Date date;
 }

　　

• 四、使用serialize/deserialize指定字段不序列化

 public class A {
       @JSONField(serialize=false)
       public Date date;
  }

  public class A {
       @JSONField(deserialize=false)
       public Date date;
  }

• 五、使用ordinal指定字段的顺序

ordinal 默认值为 0

public static class VO {
    @JSONField(ordinal = 3)
    private int f0;

    @JSONField(ordinal = 2)
    private int f1;

    @JSONField(ordinal = 1)
    private int f2;

}

• 六、使用serializeUsing制定属性的序列化类

在fastjson 1.2.16版本之后，JSONField支持新的定制化配置serializeUsing，可以单独对某一个类的某个属性定制序列化，比如：

 public static class Model {
     @JSONField(serializeUsing = ModelValueSerializer.class)
     public int value;
 }

 public static class ModelValueSerializer implements ObjectSerializer {
     @Override
     public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType,
                       int features) throws IOException {
         Integer value = (Integer) object;
         String text = value + "元";
         serializer.write(text);
     }
 }

测试代码：

 Model model = new Model();
 model.value = 100;
 String json = JSON.toJSONString(model);
 Assert.assertEquals("{\"value\":\"100元\"}", json);

 JSONType和JSONField类似，但JSONType配置在类上，而不是field或者getter/setter方法上。这里就不再介绍了。

 public class User {

     @JSONField(name = "ID", ordinal = 3, serializeUsing = UserIDValueSerializer.class)
     private Long id;
     @JSONField(serialize = false)
     private String name;
     @JSONField(serialize = true, ordinal = 2)
     private String sex;

     @JSONField(deserialize = false)
     private String address;
     @JSONField(deserialize = true)
     private String phone;

     // 配置date序列化和反序列使用yyyyMMdd日期格式
     @JSONField(format = "yyyyMMdd", ordinal = 1)
     private Date date;

     public Long getId() {
         return id;
     }

     public void setId(Long id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public Date getDate() {
         return date;
     }

     public void setDate(Date date) {
         this.date = date;
     }

     public String getSex() {
         return sex;
     }

     public void setSex(String sex) {
         this.sex = sex;
     }

     public String getAddress() {
         return address;
     }

     public void setAddress(String address) {
         this.address = address;
     }

     public String getPhone() {
         return phone;
     }

     public void setPhone(String phone) {
         this.phone = phone;
     }}

     UserIDValueSerializer 类：

 package json.fastjson.JSONField;

 import java.io.IOException;
 import java.lang.reflect.Type;

 import com.alibaba.fastjson.serializer.JSONSerializer;
 import com.alibaba.fastjson.serializer.ObjectSerializer;

 public class UserIDValueSerializer implements ObjectSerializer {
     @Override
     public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
         //serializer:{"address":"杭州","phone":"18603396966","date":"20180125","sex":"男","ID":
         //object:100
         //fieldName:ID
         //fieldType:class java.lang.Long
         //features:0
         Long value = (Long) object;
         String text = value + "元";
         serializer.write(text);
     }
 }

测试类：

 package json.fastjson.JSONField;

 import java.util.Date;

 import com.alibaba.fastjson.JSON;

 public class TestJSONField {

     public static void main(String[] args) {
         User user = new User();
         user.setId(100L);
         user.setName("WaKengMaiNi");
         user.setSex("男");
         user.setAddress("杭州");
         user.setPhone("18603396966");
         user.setDate(new Date());

         // User序列化
         String jsonString = JSON.toJSONString(user);
         System.out.println("User序列化:" + jsonString);
     }

 }

输出结果：

User序列化:{"address":"杭州","phone":"18603396966","date":"20180125","sex":"男","ID":"100元"}

1.5 通过SerializeFilter定制序列化

PropertyPreFilter 根据PropertyName判断是否序列化； PropertyFilter 根据PropertyName和PropertyValue来判断是否序列化； NameFilter 修改Key，如果需要修改Key，process返回值则可； ValueFilter 修改Value； BeforeFilter 序列化时在最前添加内容； AfterFilter 序列化时在最后添加内容。

1.5.1 PropertyFilter

根据PropertyName和PropertyValue来判断是否序列化

 public class TestPropertyFilter {

     public static void main(String[] args) {
         PropertyFilter filter = new PropertyFilter() {

             @Override
             public boolean apply(Object source, String name, Object value) {

                 System.out.println("----------------source=" + source);
                 System.out.println("----------------name=" + name);
                 System.out.println("----------------value=" + value);
                 System.out.println("");
                 // 属性是id并且大于等于100时进行序列化
                 if ("id".equals(name)) {
                     long id = ((Long) value).longValue();
                     return id >= 100;
                 }
                 return false;
             }
         };

         User user = new User();
         user.setId(9L);
         user.setName("挖坑埋你");

         String jsonString = JSON.toJSONString(user, filter); // 序列化的时候传入filter
         System.out.println("序列化,id=9：" + jsonString + "\n");

         user.setId(200L);
         jsonString = JSON.toJSONString(user, filter); // 序列化的时候传入filter
         System.out.println("序列化,id=200：" + jsonString);
     }

 }
 测试结果

 ----------------source=User [id=9, name=挖坑埋你]
 ----------------name=id
 ----------------value=9

 ----------------source=User [id=9, name=挖坑埋你]
 ----------------name=name
 ----------------value=挖坑埋你

 序列化,id=9：{}

 ----------------source=User [id=200, name=挖坑埋你]
 ----------------name=id
 ----------------value=200

 ----------------source=User [id=200, name=挖坑埋你]
 ----------------name=name
 ----------------value=挖坑埋你

 序列化,id=200：{"id":200}

1.5.2 NameFilter 序列化时修改Key

 public class TestNameFilter {

     public static void main(String[] args) {
         User user = new User();
         user.setId(9L);
         user.setName("挖坑埋你");

         String jsonString = JSON.toJSONString(user); // 序列化的时候传入filter
         System.out.println("普通序列化：" + jsonString + "\n");

         NameFilter filter = new NameFilter() {

             @Override
             public String process(Object object, String name, Object value) {
                 System.out.println("----------------object=" + object);
                 System.out.println("----------------name=" + name);
                 System.out.println("----------------value=" + value);
                 System.out.println("");
                 // 属性是id是修改id的名字
                 if ("id".equals(name)) {
                     return name + "$";
                 }
                 return name;
             }
         };

         jsonString = JSON.toJSONString(user, filter); // 序列化的时候传入filter
         System.out.println("NameFilter序列化：" + jsonString + "\n");

         // fastjson内置一个PascalNameFilter，用于输出将首字符大写的Pascal风格
         jsonString = JSON.toJSONString(user, new PascalNameFilter()); // 序列化的时候传入filter
         System.out.println("PascalNameFilter序列化：" + jsonString + "\n");
     }

 }
 普通序列化：{"id":9,"name":"挖坑埋你"}

 ----------------object=User [id=9, name=挖坑埋你]
 ----------------name=id
 ----------------value=9

 ----------------object=User [id=9, name=挖坑埋你]
 ----------------name=name
 ----------------value=挖坑埋你

 NameFilter序列化：{"id$":9,"name":"挖坑埋你"}

 PascalNameFilter序列化：{"Id":9,"Name":"挖坑埋你"}

1.5.3 ValueFilter 序列化时修改Value

 public class TestValueFilter {

     public static void main(String[] args) {
         User user = new User();
         user.setId(9L);
         user.setName("挖坑埋你");

         String jsonString = JSON.toJSONString(user); // 序列化的时候传入filter
         System.out.println("普通序列化：" + jsonString + "\n");

         ValueFilter filter = new ValueFilter() {

             @Override
             public Object process(Object object, String name, Object value) {
                 System.out.println("----------------object=" + object);
                 System.out.println("----------------name=" + name);
                 System.out.println("----------------value=" + value);
                 System.out.println("");
                 // 属性是id时修改id的值
                 if ("id".equals(name)) {
                     long id = ((Long) value).longValue();
                     return id + "$";
                 }
                 return value;
             }
         };

         jsonString = JSON.toJSONString(user, filter); // 序列化的时候传入filter
         System.out.println("ValueFilter序列化：" + jsonString + "\n");
     }

 }
 测试结果：
 普通序列化：{"id":9,"name":"挖坑埋你"}

 ----------------object=User [id=9, name=挖坑埋你]
 ----------------name=id
 ----------------value=9

 ----------------object=User [id=9, name=挖坑埋你]
 ----------------name=name
 ----------------value=挖坑埋你

 ValueFilter序列化：{"id":"9$","name":"挖坑埋你"}

1.5.4 BeforeFilter 序列化时在最前添加内容

 public static void main(String[] args) {
         User user = new User();
         user.setId(9L);
         user.setName("挖坑埋你");

         String jsonString = JSON.toJSONString(user); // 序列化的时候传入filter
         System.out.println("普通序列化：" + jsonString + "\n");

         BeforeFilter filter = new BeforeFilter() {

             @Override
             public void writeBefore(Object object) {

                 System.out.println("----------------object=" + object);

                 User user = (User) object;
                 System.out.println(
                         "----------------User.id=" + user.getId() + " " + "User.name=" + user.getName() + "\n");
                 user.setName(user.getName() + "$$$");
             }
         };

         jsonString = JSON.toJSONString(user, filter); // 序列化的时候传入filter
         System.out.println(user);
         System.out.println("BeforeFilter序列化：" + jsonString + "\n");

     }
 测试结果

 普通序列化：{"id":9,"name":"挖坑埋你"}
 在序列化之前就修改值，这样拿到的是变化的。
 ----------------object=User [id=9, name=挖坑埋你]
 ----------------User.id=9 User.name=挖坑埋你

 User [id=9, name=挖坑埋你$$$]
 BeforeFilter序列化：{"id":9,"name":"挖坑埋你$$$"}

1.5.5 AfterFilter 序列化时在最后添加内容

 public static void main(String[] args) {
         User user = new User();
         user.setId(9L);
         user.setName("挖坑埋你");

         String jsonString = JSON.toJSONString(user); // 序列化的时候传入filter
         System.out.println("普通序列化：" + jsonString + "\n");

         AfterFilter filter = new AfterFilter() {

             @Override
             public void writeAfter(Object object) {

                 User user = (User) object;
                 System.out.println("------------User.id=" + user.getId() + " " + "User.name=" + user.getName() + "\n");
                 user.setName(user.getName() + "$$$");
             }
         };

         jsonString = JSON.toJSONString(user, filter); // 序列化的时候传入filter
         System.out.println("AfterFilter序列化：" + jsonString + "\n");
         System.out.println(user);

     }
 测试结果

 普通序列化：{"id":9,"name":"挖坑埋你"}

 ------------User.id=9 User.name=挖坑埋你

 AfterFilter序列化：{"id":9,"name":"挖坑埋你"}

 User [id=9, name=挖坑埋你$$$]

1.6 定制反序列化

1.6.1 使用 ExtraProcessor 处理多余字段

 public class VO {
     private int id;
     private Map<String, Object> attributes = new HashMap<String, Object>();

     public int getId() {
         return id;
     }

     public void setId(int id) {
         this.id = id;
     }

     public Map<String, Object> getAttributes() {
         return attributes;
     }

     @Override
     public String toString() {
         return "VO [id=" + id + ", attributes=" + attributes + "]";
     }
 }

 public class TestExtraProcessor {

     public static void main(String[] args) {

         ExtraProcessor processor = new ExtraProcessor() {
             public void processExtra(Object object, String key, Object value) {

                 System.out.println("---------------object = " + object);
                 System.out.println("---------------key = " + key);
                 System.out.println("---------------value = " + value);
                 System.out.println();

                 VO vo = (VO) object;
                 vo.setId(789);// 修改一下id值
                 vo.getAttributes().put(key, value);
             }
         };
         // 这里name和phone是多余的，在VO里没有
         VO vo = JSON.parseObject("{\"id\":123,\"name\":\"abc\",\"phone\":\"18603396954\"}", VO.class, processor);

         System.out.println("vo.getId() = " + vo.getId());
         System.out.println("vo.getAttributes().get(\"name\") = " + vo.getAttributes().get("name"));
         System.out.println("vo.getAttributes().get(\"phone\") = " + vo.getAttributes().get("phone"));
     }

 }
 测试结果：

 ---------------object = VO [id=123, attributes={}]
 ---------------key = name
 ---------------value = abc

 ---------------object = VO [id=789, attributes={name=abc}]
 ---------------key = phone
 ---------------value = 18603396954

 VO [id=789, attributes={phone=18603396954, name=abc}]
 vo.getId() = 789
 vo.getAttributes().get("name") = abc
 vo.getAttributes().get("phone") = 18603396954

1.6.2 使用ExtraTypeProvider 为多余的字段提供类型

 public class TestExtraTypeProvider {

     public static void main(String[] args) {

         ExtraProcessor processor = new MyExtraProcessor();

         VO vo = JSON.parseObject("{\"id\":123,\"value\":\"123456\"}", VO.class, processor);

         System.out.println("vo.getId() = " + vo.getId());
         System.out.println("vo.getAttributes().get(\"value\") = " + vo.getAttributes().get("value"));
         System.out.println("vo.getAttributes().get(\"value\").getClass() = " + vo.getAttributes().get("value").getClass());
         // value本应该是字符串类型的，通过getExtraType的处理变成Integer类型了。
     }

 }

 class MyExtraProcessor implements ExtraProcessor, ExtraTypeProvider {
     public void processExtra(Object object, String key, Object value) {
         VO vo = (VO) object;
         vo.getAttributes().put(key, value);
     }

     public Type getExtraType(Object object, String key) {

         System.out.println("---------------object = " + object);
         System.out.println("---------------key = " + key);
         System.out.println();

         if ("value".equals(key)) {
             return int.class;
         }
         return null;
     }
 };
 ---------------object = VO [id=123, attributes={}]
 ---------------key = value

 vo.getId() = 123
 vo.getAttributes().get("value") = 123456
 vo.getAttributes().get("value").getClass() = class java.lang.Integer

1.7 处理超大对象和超大JSON文本

1.7.1 超大JSON数组序列化

 public class TestHugeArraySerialize {

     public static void main(String[] args) throws IOException {
         JSONWriter writer = new JSONWriter(new FileWriter("hugeArray.json"));
         writer.startArray();
         for (int i = 0; i < 10; ++i) {
             writer.writeValue(new VO(i));
         }
         writer.endArray();
         writer.close();
     }

 }

运行结果

[{"attributes":{},"id":0},{"attributes":{},"id":1},{"attributes":{},"id":2},{"attributes":{},"id":3},{"attributes":{},"id":4},{"attributes":{},"id":5},{"attributes":{},"id":6},{"attributes":{},"id":7},{"attributes":{},"id":8},{"attributes":{},"id":9}]

1.7.2 超大JSON对象序列化

public class TestHugeObjectSerialize {

    public static void main(String[] args) throws IOException {

        JSONWriter writer = new JSONWriter(new FileWriter("hugeObject.json"));
        writer.startObject();
        for (int i = 0; i < 10; ++i) {
            writer.writeKey("x" + i);
            writer.writeValue(new VO(i));
        }
        writer.endObject();
        writer.close();
    }

}
运行结果

{"x0":{"attributes":{},"id":0},"x1":{"attributes":{},"id":1},"x2":{"attributes":{},"id":2},"x3":{"attributes":{},"id":3},"x4":{"attributes":{},"id":4},"x5":{"attributes":{},"id":5},"x6":{"attributes":{},"id":6},"x7":{"attributes":{},"id":7},"x8":{"attributes":{},"id":8},"x9":{"attributes":{},"id":9}}
1

1.7.3 超大JSON数组反序列化

 public class TestHugeArrayDeserialize {

     public static void main(String[] args) throws IOException {
         // 读入上面输出的文件
         JSONReader reader = new JSONReader(new FileReader("hugeArray.json"));
         reader.startArray();
         while (reader.hasNext()) {
             VO vo = reader.readObject(VO.class);
             System.out.println(vo);
         }
         reader.endArray();
         reader.close();
     }

 }
 VO [id=0, attributes={}]
 VO [id=1, attributes={}]
 VO [id=2, attributes={}]
 VO [id=3, attributes={}]
 VO [id=4, attributes={}]
 VO [id=5, attributes={}]
 VO [id=6, attributes={}]
 VO [id=7, attributes={}]
 VO [id=8, attributes={}]
 VO [id=9, attributes={}]

1.7.4 超大JSON对象反序列化

 public class TestHugeObjectDeserialize {

     public static void main(String[] args) throws IOException {
         // 读入上面输出的文件
         JSONReader reader = new JSONReader(new FileReader("hugeObject.json"));
         reader.startObject();
         while (reader.hasNext()) {
             String key = reader.readString();
             VO vo = reader.readObject(VO.class);
             System.out.println(key + "：" + vo);
         }
         reader.endObject();
         reader.close();
     }

 }
 x0：VO [id=0, attributes={}]
 x1：VO [id=1, attributes={}]
 x2：VO [id=2, attributes={}]
 x3：VO [id=3, attributes={}]
 x4：VO [id=4, attributes={}]
 x5：VO [id=5, attributes={}]
 x6：VO [id=6, attributes={}]
 x7：VO [id=7, attributes={}]
 x8：VO [id=8, attributes={}]
 x9：VO [id=9, attributes={}]

1.8 SerializerFeature特性的使用

名称	含义
QuoteFieldNames	输出key时是否使用双引号,默认为true
UseSingleQuotes	使用单引号而不是双引号,默认为false
WriteMapNullValue	是否输出值为null的字段,默认为false
WriteEnumUsingToString	Enum输出name()或者original,默认为false
UseISO8601DateFormat	Date使用ISO8601格式输出，默认为false
WriteNullListAsEmpty	List字段如果为null,输出为[],而非null
WriteNullStringAsEmpty	字符类型字段如果为null,输出为”“,而非null
WriteNullNumberAsZero	数值字段如果为null,输出为0,而非null
WriteNullBooleanAsFalse	Boolean字段如果为null,输出为false,而非null
SkipTransientField	如果是true，类中的Get方法对应的Field是transient，序列化时将会被忽略。默认为true
SortField	按字段名称排序后输出。默认为false
WriteTabAsSpecial	把\t做转义输出，默认为false不推荐设为true
PrettyFormat	结果是否格式化,默认为false
WriteClassName	序列化时写入类型信息，默认为false。反序列化是需用到
DisableCircularReferenceDetect	消除对同一对象循环引用的问题，默认为false
WriteSlashAsSpecial	对斜杠’/’进行转义
BrowserCompatible	将中文都会序列化为\uXXXX格式，字节数会多一些，但是能兼容IE 6，默认为false
WriteDateUseDateFormat	全局修改日期格式,默认为false。
DisableCheckSpecialChar	一个对象的字符串属性中如果有特殊字符如双引号，将会在转成json时带有反斜杠转移符。如果不需要转义，可以使用这个属性。默认为false
BeanToArray	将对象转为array输出

 public class TestNull {

     public static void main(String[] args) {

         // WriteNullListAsEmpty 将Collection类型字段的字段空值输出为[]
         // WriteNullStringAsEmpty 将字符串类型字段的空值输出为空字符串 ""
         // WriteNullNumberAsZero 将数值类型字段的空值输出为0
         // WriteNullBooleanAsFalse 将Boolean类型字段的空值输出为false

         Model obj = new Model();

         System.out.println("------------------加上参数------------------------------");
         String text = JSON.toJSONString(obj,
                 SerializerFeature.WriteNullListAsEmpty,
                 SerializerFeature.WriteNullStringAsEmpty,
                 SerializerFeature.WriteNullNumberAsZero,
                 SerializerFeature.WriteNullBooleanAsFalse,
                 SerializerFeature.WriteMapNullValue,
                 SerializerFeature.PrettyFormat);

         System.out.println(text + " \n");

         System.out.println("------------------不加参数------------------------------");
         text = JSON.toJSONString(obj,
                 SerializerFeature.PrettyFormat);

         System.out.println(text);
     }

 }

 class Model {
     public int iFull = 9;
     public int iEmpty;

     public Integer integerFull = 9;
     public Integer integerEmpty;

     public boolean bFull = true;
     public boolean bEmpty;

     public Boolean BFull = true;
     public Boolean BEmpty;

     public List<String> listFull = Arrays.asList("挖", "坑", "埋", "你");
     public List<String> listEmpty;

     public Map<String, String> mapFull = new HashMap<String, String>() {{put("a", "b");}};
     public Map<String, String> mapEmpty;

 }
 ------------------加上参数------------------------------
 {
     "BEmpty":false,
     "BFull":true,
     "bEmpty":false,
     "bFull":true,
     "iEmpty":0,
     "iFull":9,
     "integerEmpty":0,
     "integerFull":9,
     "listEmpty":[],
     "listFull":[
         "挖",
         "坑",
         "埋",
         "你"
     ],
     "mapEmpty":null,
     "mapFull":{
         "a":"b"
     }
 } 

 ------------------不加参数------------------------------
 {
     "BFull":true,
     "bEmpty":false,
     "bFull":true,
     "iEmpty":0,
     "iFull":9,
     "integerFull":9,
     "listFull":[
         "挖",
         "坑",
         "埋",
         "你"
     ],
     "mapFull":{
         "a":"b"
     }
 }