maven依赖导入

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>

fastjson基本样例1

Cat.java

package test;

class Cat {
    private String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Cat [color=" + color + "]";
    }

};

Master.java

package test;

import java.util.ArrayList;
import java.util.List;

//主人
class Master {
    private String name;
    private List<Cat> cats = new ArrayList<Cat>();

    public String getName() {
        return name;
    }

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

    public List<Cat> getCats() {
        return cats;
    }

    public void setCats(List<Cat> cats) {
        this.cats = cats;
    }

    @Override
    public String toString() {
        return "Master [name=" + name + ", cats=" + cats + "]";
    }

}

FastjsonDemo.java

package test;

import java.util.List;

import com.alibaba.fastjson.JSON;

class FastjsonDemo {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        cat1.setColor("white");

        Cat cat2 = new Cat();
        cat2.setColor("black");

        Master master = new Master();
        master.setName("bobo");
        master.getCats().add(cat1);
        master.getCats().add(cat2);

        // 主人对象转json串
        String masterJson = JSON.toJSONString(master);
        System.out.println("master json : " + masterJson);
        // json串转主人对象
        Master masterObj = JSON.parseObject(masterJson, Master.class);
        System.out.println("master object:" + masterObj);

        // 构建用户对象数组
        Cat[] cats = new Cat[2];
        cats[0] = cat1;
        cats[1] = cat2;
        // 数组转JSON串
        String jsonString2 = JSON.toJSONString(cats);
        System.out.println("array String:" + jsonString2);
        // JSON串转
        List<Cat> users2 = JSON.parseArray(jsonString2, Cat.class);
        System.out.println("array obj:" + users2);

    }
}

输出语句:

master json : {"cats":[{"color":"white"},{"color":"black"}],"name":"bobo"}
master object:Master [name=bobo, cats=[Cat [color=white], Cat [color=black]]]
array String:[{"color":"white"},{"color":"black"}]
array obj:[Cat [color=white], Cat [color=black]]

fastjson使用过程中特别声明

当你用以下语句得到jsonStr输出为空,即{}时. 要特别留意你的对象是否符合javaBean规范:

javaBean约定get,set方法的第4个字母一定要大写,不过google 的gson倒是不用(其实这反而不规范)

String jsonStr = JSON.toJSONString(master);

当初由于公司习惯字符串以c开头,时间以t开头,数值以n开头来定义属性,如cName,tCrtTm,nAge,导致我的eclipse自动生成的get,set方法变成如下(getcName不规范),找了半小时才发现这个问题.

错误属性cName:

package test;

//主人
class Master {
    private String cName;

    public String getcName() {
        return cName;
    }

    public void setcName(String cName) {
        this.cName = cName;
    }

}

正确属性name:

package test;

//主人
class Master {
    private String name;

    public String getName() {
        return name;
    }

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

}

fastjson基本样例2

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

public class test {
    public static void main(String[] args) {
        Map packet = new HashMap();
        Map requestHead = new HashMap();
        Map requestBody = new HashMap();
        Map base = new HashMap();
        List coverageList = new ArrayList();
        Map coverage1 = new HashMap();
        Map coverage2 = new HashMap();
        
        packet.put("requestHead",requestHead );
        packet.put("requestBody",requestBody );
        
        requestHead.put("userId", "userid1234");
        requestHead.put("password", "password1234");
        requestHead.put("serviceNo", "serviceNo1234");
        
        requestBody.put("base", base);
        
        base.put("basekey1", "value1");
        base.put("basekey2", "value2");
        base.put("basekey3", "value3");
        
        requestBody.put("coverage_list", coverageList);
        
        coverageList.add(coverage1);
        coverageList.add(coverage2);

        coverage1.put("coverageCode1", "value1");
        coverage1.put("coverageName1", "value1");
        coverage2.put("coverageCode2", "value2");
        coverage2.put("coverageName2", "value2");
        
        String jsonStr = JSON.toJSONString(packet,true);
        
        System.out.println("把map转换成json String后打印如下:");
        System.out.println(jsonStr);
        
        JSONObject jsonObj = JSON.parseObject(jsonStr);
        
        JSONObject requestHeadObj = jsonObj.getJSONObject("requestBody").getJSONObject("base");
        Set<Entry<String, Object>>  set = requestHeadObj.entrySet();
        System.out.println("jsonObj中requestBody>base节点下的各值如下:");
        for(Entry<String,Object> entry :set){
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
        
    }
}

不规则字段的映射

如果反/序列化时想做不种类型的映射,可以在get , set方法上加JSONField 不同name的特殊自理, 而不是在属性做做统一处理, 可参考 fastjson使用-- @JSONField使用【转】==>https://www.cnblogs.com/whatlonelytear/p/12302205.html

由于json中的key与bean中的属性不能匹配，因此在转换过程中出现了部分属性为null的情况。经过查看官方文档，发现可以使用@JSONField进行解释，但是并没有详细的使用说明。

@JSONField的作用对象:

1. Field
2. Setter 和 Getter方法

注：FastJson在进行操作时，是根据getter和setter的方法进行的，并不是依据Field进行。

Show me the code:

一、作用Field

@JSONField作用在Field时，其name不仅定义了输入key的名称，同时也定义了输出的名称。

参考自: FastJson中@JSONField注解使用==>https://www.cnblogs.com/softidea/p/5681928.html

另外在序列化反序列化日期格式时,可以同时使用fastjson 或jackson的注解

import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.fastjson.annotation.JSONField;

@Column(name = "BIRTHDAY")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@JSONField(format = "yyyy-MM-dd HH:mm:ss")
public Date getBirthday() {
    return birthday;
}

fastjson格式化输出

JSON.toJSONString(
retObject,
SerializerFeature.PrettyFormat,
SerializerFeature.WriteMapNullValue, 
SerializerFeature.WriteDateUseDateFormat);

JSON.toJSONString(retObject,true)

//在main方法中指定全局日期格式

    public void fastjsonInit() {
        //时间格式化
        JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";//原始默认就是该配置
        //是否输出值为null的字段,默认为false
        JSON.DEFAULT_GENERATE_FEATURE |= SerializerFeature.WriteMapNullValue.getMask();
        //数值字段如果为null,输出为0,而非null
        JSON.DEFAULT_GENERATE_FEATURE |= SerializerFeature.WriteNullNumberAsZero.getMask();
        //List字段如果为null,输出为[],而非null
        JSON.DEFAULT_GENERATE_FEATURE |= SerializerFeature.WriteNullListAsEmpty.getMask();
        //字符类型字段如果为null,输出为 "",而非null
        //JSON.DEFAULT_GENERATE_FEATURE |= SerializerFeature.WriteNullStringAsEmpty.getMask();

    }

因为源码中就是public的属性,所以直接改变即可

public abstract class JSON implements JSONStreamAware, JSONAware {
    public static TimeZone         defaultTimeZone      = TimeZone.getDefault();
    public static Locale           defaultLocale        = Locale.getDefault();
    public static String           DEFAULT_TYPE_KEY     = "@type";
    static final SerializeFilter[] emptyFilters         = new SerializeFilter[0];
    public static String           DEFFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static int              DEFAULT_PARSER_FEATURE;
    public static int              DEFAULT_GENERATE_FEATURE;

}

常用FastJSON的SerializerFeature特性及日期转换格式==>https://www.cnblogs.com/xd03122049/p/6079695.html

SerializerFeature.PrettyFormat:格式化输出
SerializerFeature.WriteMapNullValue:是否输出值为null的字段,默认为false
SerializerFeature.DisableCircularReferenceDetect:消除循环引用
SerializerFeature.WriteNullStringAsEmpty:将为null的字段值显示为""
WriteNullListAsEmpty：List字段如果为null,输出为[],而非null
WriteNullNumberAsZero：数值字段如果为null,输出为0,而非null
WriteNullBooleanAsFalse：Boolean字段如果为null,输出为false,而非null
SkipTransientField：如果是true，类中的Get方法对应的Field是transient，序列化时将会被忽略。默认为true
SortField：按字段名称排序后输出。默认为false
WriteDateUseDateFormat：全局修改日期格式,默认为false。JSON.DEFFAULT_DATE_FORMAT = “yyyy-MM-dd”;JSON.toJSONString(obj, SerializerFeature.WriteDateUseDateFormat);
BeanToArray：将对象转为array输出
QuoteFieldNames：输出key时是否使用双引号,默认为true
UseSingleQuotes：输出key时使用单引号而不是双引号,默认为false（经测试，这里的key是指所有的输出结果，而非key/value的key,而是key,和value都使用单引号或双引号输出）

fastjson设置指定日期属性的格式化==>https://blog.csdn.net/john1337/article/details/76277617

如果要被序列化的对象含有一个date属性或者多个date属性按照相同的格式序列化日期的话，那我们可以使用下面的语句实现：

1.JSONObject.DEFFAULT_DATE_FORMAT="yyyy-MM-dd";//设置日期格式
2.JSONObject.toJSONString(resultMap, SerializerFeature.WriteMapNullValue,SerializerFeature.DisableCircularReferenceDetect,
SerializerFeature.WriteDateUseDateFormat);

但是上面的解决方案面临一个问题，如果不满足上面的条件（多个date属性，而且需要按照不定的格式序列化这些日期属性），那么我们就需要另辟蹊径，使用fastjson的特性来完成：

@JSONField(format="yyyyMMdd")
    private Date date;
@JSONField(format="yyyy-MM-dd HH:mm:ss")
    private Date date1;

fastjson格式化后排序问题

//1、解析时增加不调整顺序参数
JSONObject jsonObj= JSONObject.parseObject(jsonStr, Feature.OrderedField);

//2、初始化json对象为有序对象：这样前后数据就可以保持时一致。
JSONObject retObj = new JSONObject(true);

gson

3、使用Gson解析
JsonObject returnData = new JsonParser().parse(replyString).getAsJsonObject();

常用json格式化工具类

public class JsonTool {

    public static final String prettyJson(String jsonString){
        String result = JSON.toJSONString(JSONObject.parse(jsonString), true);
        return result;
    }

    public static final String prettyJson(Object obj){
        String result = JSON.toJSONString(obj, true);
        return result;
    }
}