fastjson使用

2022-04-27 17:00:51 阅读：186 来源： 互联网

标签：fastjson return String Doe dateOfBirth JSON 使用 public

定义以下Person JavaBean:

@Data
public class Person {
	
    @JSONField(name="age", serialize=false)
    private int age;

    @JSONField(name="lastName", ordinal = 2)
    private String lastName;

    @JSONField(name="firstName", ordinal = 1)
    private String firstName;

    @JSONField(name="dateOfBirth", format="dd/MM/yyyy", ordinal = 3)
    private Date dateOfBirth;
	
    @JSONCreator
    public Person(int age, String lastName, String firstName, Date dateOfBirth) {
        this.age = age;
        this.lastName = lastName;
        this.firstName = firstName;
        this.dateOfBirth = dateOfBirth;
    }
}

一、JSONField

package com.alibaba.fastjson.annotation;

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

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

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

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

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

1. @JSONField的作用对象(配置方式):

Field
Setter和Getter方法

1. 配置在field上

public class A {
    @JSONField(name="ID")
    private int id;

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

2. 配置在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;}
}

注意：FastJson在进行操作时，是根据getter和setter的方法进行的，并不是依据Field进行。
注意：若属性是私有的，必须有set方法。否则无法反序列化。

2. 使用format配置日期格式化

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

3. 使用serialize/deserialize指定字段不序列化

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

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

4. 使用ordinal指定字段的顺序

默认fastjson序列化一个java bean，是根据fieldName的字母序进行序列化的，你可以通过ordinal指定字段的顺序。这个特性需要1.1.42以上版本。

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

    @JSONField(ordinal = 2)
    private int f1;

    @JSONField(ordinal = 1)
    private int f2;
}

二、将Java对象转换为JSON格式

public static List<Person> init(){
    List<Person> personList = new ArrayList<Person>();
    personList.add(new Person(15, "John", "Doe", new Date()));
    personList.add(new Person(20, "Janette", "Doe", new Date()));
    return personList;
}

1. JSON.toJSONString()

可以使用JSON.toJSONString()将Java对象转换为JSON对象：

public class test {

    @Test
    public void toJsonString() {
        String jsonOutput = JSON.toJSONString(init());
    }
}

输出结果为：

[{
    "age":"15",
    "firstName":"Doe",
    "lastName":"Jhon",
    "dateOfBirth":"19/07/2016"
},{
    "age":"20",
    "firstName":"Doe",
    "lastName":"Janette",
    "dateOfBirth":"19/07/2016"
}]

2. JSONObject.fromObject()

public class test {

    @Test
    public void toJsonString() {
        JSONObject json = JSONObject.fromObject(obj);//将java对象转换为json对象
    }
}

FastJson还支持BeanToArray序列化功能：

String jsonOutput= JSON.toJSONString(listOfPersons, SerializerFeature.BeanToArray);

输出结果为：

[[
    15,
    1469003271063,
    "John",
    "Doe"
],[
    20,
    1469003271063,
    "Janette",
    "Doe"
]]

三、创建JSON对象

创建JSON对象非常简单，只需使用JSONObject（fastJson提供的json对象）和JSONArray（fastJson提供json数组对象）对象即可。

我们可以把JSONObject当成一个Map<String,Object>来看，只是JSONObject提供了更为丰富便捷的方法，方便我们对于对象属性的操作。我们看一下源码。

public class JSONObject extends JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {
    private static final long serialVersionUID = 1L;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    private final Map<String, Object> map;

    .... ...
}

同样我们可以把JSONArray当做一个List<Object>，可以把JSONArray看成JSONObject对象的一个集合。

public class JSONArray extends JSON implements List<Object>, Cloneable, RandomAccess, Serializable {
    private static final long serialVersionUID = 1L;
    private final List<Object> list;
    protected transient Object relatedArray;
    protected transient Type componentType;

    ... ...
}

此外，由于JSONObject和JSONArray继承了JSON，所以说也可以直接使用两者对JSON格式字符串与JSON对象及javaBean之间做转换，不过为了避免混淆我们还是使用JSON。

@Test
public void crateJsonArray() throws ParseException {
    JSONArray jsonArray = new JSONArray();
    for (int i = 0; i < 2; i++) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("age", 10);
        jsonObject.put("firstName", "Doe " + i);
        jsonObject.put("dateOfBirth", "2016/12/12 12:12:12");
        jsonArray.add(jsonObject);
    }
    String jsonOutput = jsonArray.toJSONString();
}

输出结果为：

[{
    "age":"10",
    "dateOfBirth":"2016/12/12 12:12:12",
    "firstName":"Doe 0"
},{
    "age":"10",
    "dateOfBirth":"2016/12/12 12:12:12",
    "firstName":"Doe 1"
}]

使用@JSONCreator

如果JavaBean没有缺省构造函数，可以使用@JSONCreator指定构造函数来创建对象

@JSONCreator
public Person(int age, String lastName, String firstName, Date dateOfBirth) {
    this.age = age;
    this.lastName = lastName;
    this.firstName = firstName;
    this.dateOfBirth = dateOfBirth;
}

其他

String remarkText = "'{'\"order\":'{'\"orderNo\":\"{0}\",\"goodsFutureName\":\"{1}\",\"payMethod\":\"{2}\",\"tradeType\":\"{3}\"'}',\"channelFee\":\"{4}\",\"refundTransactionMasterID\":\"{5}\"'}'";return MessageFormat.format(remarkText, orderNo, goodsFutureName, payMethod, tradeType, channelFee, refundTransactionMasterID);

四、JSON字符串与Java对象转换

JSON字符串转换为Java对象

现在我们已经学会了如何创建JSON对象，以及如何将Java对象转换为JSON字符串，接下来我们就需要了解如何解析JSON：

@Test
public void jsonToObject() {
    Person person = new Person(20, "John", "Doe", new Date());
	
    String jsonObject = JSON.toJSONString(person);
    Person newPerson = JSON.parseObject(jsonObject, Person.class);

    Person person1 = JSONObject.toJavaObject(jsonObject, Person.class);
	
    assertEquals(newPerson.getAge(), 0); // 如果我们设置系列化为 false
    assertEquals(newPerson.getFirstName(), listOfPersons.get(0).getFirstName());
	
    //json格式的字符串转成JSONObject
    JSONObject object = JSON.parseObject(resp);
	    
    //list字符串 转换成java对象 
    String jsonObjectList = JSON.toJSONString(init());
    List<Person> personList = JSON.parseArray(jsonObjectList, Person.class);
}

我们可以使用JSON.parseObject()将JSON字符串转换为Java对象。

注意反序列化时为对象时，必须要有默认无参的构造函数，否则会报异常:

com.alibaba.fastjson.JSONException: default constructor not found.

以下是简单的实例测试：

Person [age=20, firstName=John, lastName=Doe, dateOfBirth=Wed Jul 20 08:51:12 WEST 2016]

@JSONField deserialize 可选项可以指定字段不反序列化。

@JSONField(name = "dateOfBirth", deserialize=false)
private Date dateOfBirth;

输出结果为：

Person [age=20, firstName=John, lastName=Doe, dateOfBirth=null]

五、使用ContextValueFilter配置JSON转换

在某些场景下，对Value做过滤，需要获得所属JavaBean的信息，包括类型、字段、方法等。在fastjson-1.2.9中，提供了ContextValueFilter，类似于之前版本提供的ValueFilter，只是多了BeanContext参数可用。

@Test
public void givenContextFilter_whenJavaObject_thanJsonCorrect() {
    ContextValueFilter valueFilter = new ContextValueFilter () {
        public Object process(BeanContext context, Object object, String name, Object value) {
            if (name.equals("dateOfBirth")) {
                return "NOT TO DISCLOSE";
            }
            if (value.equals("John")) {
                return ((String) value).toUpperCase();
            } else {
                return null;
            }
        }
    };
    String jsonOutput = JSON.toJSONString(listOfPersons, valueFilter);
}

以上实例中我们隐藏了dateOfBirth字段，并过滤名字不包含John的字段：

[{
    "FIRSTNAME":"JOHN",
    "LASTNAME":"DOE",
    "dateOfBirth":"NOT TO DISCLOSE"
}]

六、使用NameFilter和SerializeConfig

NameFilter: 序列化时修改Key。
SerializeConfig ：内部是个map容器主要功能是配置并记录每种Java类型对应的序列化类。

@Test
public void givenSerializeConfig_whenJavaObject_thanJsonCorrect() {
    NameFilter formatName = new NameFilter() {
        public String process(Object object, String name, Object value) {
            return name.toLowerCase().replace(" ", "_");
        }
    };

    SerializeConfig.getGlobalInstance().addFilter(Person.class,  formatName);
    String jsonOutput = JSON.toJSONStringWithDateFormat(listOfPersons, "yyyy-MM-dd");
}

实例中我们声明了formatName过滤器使用NameFilter匿名类来处理字段名称。新创建的过滤器与Person类相关联，然后添加到全局实例，它是SerializeConfig类中的静态属性。

现在我们可以轻松地将对象转换为JSON格式。

注意我们使用的是toJSONStringWithDateFormat()而不是toJSONString()，它可以更快速的格式化日期。

输出结果：

[{  
    "full_name":"John Doe",
    "date_of_birth":"2016-07-21"
},{  
    "full_name":"Janette Doe",
    "date_of_birth":"2016-07-21"
}]

FastJsonUtils

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.JSONLibDataFormatSerializer;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

public class FastJsonUtils extends JSON implements Serializable {

    private static final SerializeConfig config;

    static {
        config = new SerializeConfig();
        // 使用和json-lib兼容的日期输出格式
        config.put(java.util.Date.class, new JSONLibDataFormatSerializer());
        // 使用和json-lib兼容的日期输出格式
        config.put(java.sql.Date.class, new JSONLibDataFormatSerializer());
    }

    /**
     * 输出空置字段
     */
    private static final SerializerFeature[] features = {SerializerFeature.WriteMapNullValue,
            // list字段如果为null，输出为[]，而不是null
            SerializerFeature.WriteNullListAsEmpty,
            // 数值字段如果为null，输出为0，而不是null
            //SerializerFeature.WriteNullNumberAsZero,
            // Boolean字段如果为null，输出为false，而不是null
            SerializerFeature.WriteNullBooleanAsFalse,
            // 字符类型字段如果为null，输出为""，而不是null
            SerializerFeature.WriteNullStringAsEmpty
    };

    public static JSONObject getJson() {
        return new JSONObject();
    }

    public static JSONArray getJsonArray() {
        return new JSONArray();
    }

    /**
     * 类转json字符串 时间复杂化处理,并且会打印空属性
     *
     * @param object
     * @return {"firstName":"Doe","lastName":"John","dateOfBirth":"19/09/2021"}
     */
    public static String objToJsonStrWithCF(Object object) {
        return JSON.toJSONString(object, config, features);
    }

    /**
     * 类转json字符串
     * 时间复杂化处理,空属性不会打印
     *
     * @param object
     * @return {"firstName":"Doe","lastName":"John","dateOfBirth":"19/09/2021"}
     */
    public static String objToJsonStrWithC(Object object) {
        return JSON.toJSONString(object, config);
    }

    /**
     * 类转json字符串
     * 会打印对象中所有的属性,没值的直接为空
     *
     * @param object
     * @return {"firstName":"Doe","lastName":"John","dateOfBirth":"19/09/2021"}
     */
    public static String objToJsonStrWithF(Object object) {
        return JSON.toJSONString(object, features);
    }

    /**
     * 类转json字符串
     * 会打印对象中所有的属性,没值的直接为空
     *
     * @param object
     * @return {"firstName":"Doe","lastName":"John","dateOfBirth":"19/09/2021"}
     */
    public static String objToJsonStr(Object object) {
        return JSON.toJSONString(object);
    }

    /**
     * 推荐使用
     * 类转json字符串  只打印对象中有值的,没有值的不打印
     *
     * @param object
     * @return
     */
    public static String obj2JsonStr(Object object) {
        ParserConfig.getGlobalInstance().setAsmEnable(false);
        return JSON.toJSONString(object, features);
    }

    /**
     * json字符串转为object类
     *
     * @param text
     * @return
     */
    public static Object strToBean(String text) {
        return JSON.parse(text);
    }

    /**
     * json字符串转bean
     * 注意:部分格式转换可能有错误
     * -- 比如:日期 dd/MM/yyyy格式 转换成javaBean会出错
     *
     * @param text
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T strToBean(String text, Class<T> clazz) {
        return JSON.parseObject(text, clazz);
    }

    /**
     * 将string转化为序列化的json字符串
     *
     * @return
     */
    public static Object strToJson(String text) {
        return JSON.parse(text);
    }

    /**
     * str转json
     * @param text
     * @return
     */
    public static JSONObject str2Json(String text) {
        return JSONObject.parseObject(text);
    }
	    
    /**
     * str转json
     * Feature.OrderedField防止乱序
     * @param text
     * @return
     */
    public static JSONObject str2Json2(String text) {
        return JSON.parseObject(text, Feature.OrderedField);
    }

    /**
     * 转换JSON字符串为对象
     *
     * @param str
     * @param clazz
     * @return
     */
    public static Object strToObject(String str, Class<?> clazz) {
        return JSONObject.parseObject(str, clazz);
    }

    /**
     * str转java 对象
     * 注意：Class<T>需无参构造
     *
     * @param str
     * @param tClass
     * @param <T>
     * @return
     */
    public static <T> T getJavaObject(String str, Class<T> tClass) {
        return JSON.toJavaObject(str2Json(str), tClass);
    }

    //-------------------------集合---------------------------------

    /**
     * 对象集合转json字符串
     * @param list
     * @param <T>
     * @return
     */
    public static <T> String listToJson(List<T> list) {
        return JSON.toJSONString(list);
    }

    /**
     * json字符串转为数组
     *
     * @param text
     * @param <T>
     * @return
     */
    public static <T> Object[] strToArray(String text) {
        return strToArray(text, null);
    }

    /**
     * json字符串转为对象数组
     *
     * @param text
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> Object[] strToArray(String text, Class<T> clazz) {
        return JSON.parseArray(text, clazz).toArray();
    }

    /**
     * json字符串转为对象集合
     *
     * @param text
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> List<T> strToList(String text, Class<T> clazz) {
        return JSON.parseArray(text, clazz);
    }
    /**
     * json字符串转对象集合
     * @param text
     * @param clazz
     * @param <T>
     * @return
     */ 
    public static <T> List<T> jsonToList(String text, Class<T> clazz) {
        return JSONArray.parseArray(text, clazz);
    }

    /**
     * json字符串转化为map
     *
     * @param str
     * @return
     */
    public static <K, V> Map<K, V> strToMap(String str) {
        Map<K, V> m = (Map<K, V>) JSONObject.parseObject(str);
        return m;
    }

    /**
     * 将map转化为string
     *
     * @param map
     * @return
     */
    public static <K, V> String mapToStr(Map<K, V> map) {
        return JSONObject.toJSONString(map);
    }

    /**
     * JSON数组形式字符串转换为List＜Map＜String,String＞＞
     * @param strArr
     * @return
     */
    public static List<Map<String, String>> strArrToListMap(String strArr) {
        //第一种方式
        List<Map<String, String>> listObjectFir = (List<Map<String, String>>) JSONArray.parse(strArr);
        System.out.println("利用JSONArray中的parse方法来解析json数组字符串");
        for (Map<String, String> mapList : listObjectFir) {
            for (Map.Entry entry : mapList.entrySet()) {
                System.out.println(entry.getKey() + "  " + entry.getValue());
            }
        }

        //第二种方式
        List<Map<String, String>> listObjectSec = JSONArray.parseObject(strArr, List.class);
        System.out.println("利用JSONArray中的parseObject方法并指定返回类型来解析json数组字符串");
        for (Map<String, String> mapList : listObjectSec) {
            for (Map.Entry entry : mapList.entrySet()) {
                System.out.println(entry.getKey() + "  " + entry.getValue());
            }
        }

        //第三种方式
        JSONArray listObjectThir = JSONArray.parseArray(strArr);
        System.out.println("利用JSONArray中的parseArray方法来解析json数组字符串");
        for (Object mapList : listObjectThir) {
            for (Object entry : ((Map) mapList).entrySet()) {
                System.out.println(((Map.Entry) entry).getKey() + "  " + ((Map.Entry) entry).getValue());
            }
        }

        //第四种方式
        List listObjectFour = JSONArray.parseArray(strArr, Map.class);
        System.out.println("利用JSONArray中的parseArray方法并指定返回类型来解析json数组字符串");
        for (Object mapList : listObjectFour) {
            for (Object entry : ((Map) mapList).entrySet()) {
                System.out.println(((Map.Entry) entry).getKey() + "  " + ((Map.Entry) entry).getValue());
            }
        }

        //第五种方式
        JSONArray listObjectFifth = JSONObject.parseArray(strArr);
        System.out.println("利用JSONObject中的parseArray方法来解析json数组字符串");
        for (Object mapList : listObjectFifth) {
            for (Object entry : ((Map) mapList).entrySet()) {
                System.out.println(((Map.Entry) entry).getKey() + "  " + ((Map.Entry) entry).getValue());
            }
        }

        //第六种方式
        List listObjectSix = JSONObject.parseArray(strArr, Map.class);
        System.out.println("利用JSONObject中的parseArray方法并指定返回类型来解析json数组字符串");
        for (Object mapList : listObjectSix) {
            for (Object entry : ((Map) mapList).entrySet()) {
                System.out.println(((Map.Entry) entry).getKey() + "  " + ((Map.Entry) entry).getValue());
            }
        }

        //第七种方式
        JSONArray listObjectSeven = JSON.parseArray(strArr);
        System.out.println("利用JSON中的parseArray方法来解析json数组字符串");
        for (Object mapList : listObjectSeven) {
            for (Object entry : ((Map) mapList).entrySet()) {
                System.out.println(((Map.Entry) entry).getKey() + "  " + ((Map.Entry) entry).getValue());
            }
        }

        //第八种方式
        List listObjectEigh = JSONObject.parseArray(strArr, Map.class);
        System.out.println("利用JSON中的parseArray方法并指定返回类型来解析json数组字符串");
        for (Object mapList : listObjectEigh) {
            for (Object entry : ((Map) mapList).entrySet()) {
                System.out.println(((Map.Entry) entry).getKey() + "  " + ((Map.Entry) entry).getValue());
            }
        }
        return listObjectFir;
    }

    public static List<Person> initList() {
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person(15, "John", "Doe", new Date()));
        personList.add(new Person(20, "Janette", "Doe", new Date()));
        return personList;
    }

    public static Person initJson() {
        return new Person(15, null, "Doe", new Date());
    }

    public static void main(String[] args) {
        Person person = initJson();
        System.out.println("objToJsonStrWithCF:" + objToJsonStrWithCF(person));
        System.out.println("objToJsonStrWithF:" + objToJsonStrWithF(person));
        System.out.println("objToJsonStrWithC:" + objToJsonStrWithC(person));
        System.out.println("objToJsonStr:" + objToJsonStr(person));
        System.out.println("obj2JsonStr:" + obj2JsonStr(person));
        String s = objToJsonStrWithCF(person);
        System.out.println("strToBean:" + JSON.toJSONString(strToBean(s)));
        System.out.println("strToBean:" + JSON.toJSONString(strToBean(s, Person.class)));

        System.out.println("-------list-----------");
        String jsonList = JSON.toJSONString(initList());
        System.out.println("listToJson:" + JSON.toJSONString(listToJson(initList())));
        System.out.println("strToArray:" + JSON.toJSONString(strToArray(jsonList)));
        System.out.println("strToObject:" + strToObject(s, Person.class));
        System.out.println("getJavaObject:" + getJavaObject(s, Person.class));
        System.out.println("strToList:" + strToList(jsonList, Person.class));
        System.out.println("jsonToList:" + JSON.toJSONString(jsonToList(JSON.toJSONString(strToArray(jsonList)), Person.class)));

        System.out.println("------map-----------");
        System.out.println("strToMap:" + strToMap(s));
        System.out.println("mapToStr:" + mapToStr(strToMap(s)));

        //objToJsonStrWithCF:{"age":15,"firstName":"Doe","lastName":"","dateOfBirth":"2021-09-19"}
        //objToJsonStrWithF:{"age":15,"firstName":"Doe","lastName":"","dateOfBirth":"2021-09-19"}
        //objToJsonStrWithC:{"age":15,"firstName":"Doe","dateOfBirth":"2021-09-19"}
        //objToJsonStr:{"age":15,"firstName":"Doe","dateOfBirth":"2021-09-19"}
        //obj2JsonStr:{"age":15,"firstName":"Doe","lastName":"","dateOfBirth":"2021-09-19"}
        //strToBean:{"firstName":"Doe","lastName":"","dateOfBirth":"2021-09-19","age":15}
        //strToBean:{"age":15,"firstName":"Doe","lastName":"","dateOfBirth":"2021-09-19"}
        //-------list-----------
        //listToJson:"[{\"age\":15,\"firstName\":\"Doe\",\"lastName\":\"John\",\"dateOfBirth\":\"2021-09-19\"},{\"age\":20,\"firstName\":\"Doe\",\"lastName\":\"Janette\",\"dateOfBirth\":\"2021-09-19\"}]"
        //strToArray:[{"firstName":"Doe","lastName":"John","dateOfBirth":"2021-09-19","age":15},{"firstName":"Doe","lastName":"Janette","dateOfBirth":"2021-09-19","age":20}]
        //strToObject:Person(age=15, lastName=, firstName=Doe, dateOfBirth=Sun Sep 19 00:00:00 CST 2021)
        //getJavaObject:Person(age=15, lastName=, firstName=Doe, dateOfBirth=Sun Sep 19 00:00:00 CST 2021)
        //strToList:[Person(age=15, lastName=John, firstName=Doe, dateOfBirth=Sun Sep 19 00:00:00 CST 2021), Person(age=20, lastName=Janette, firstName=Doe, dateOfBirth=Sun Sep 19 00:00:00 CST 2021)]
        //jsonToList:[{"age":15,"firstName":"Doe","lastName":"John","dateOfBirth":"2021-09-19"},{"age":20,"firstName":"Doe","lastName":"Janette","dateOfBirth":"2021-09-19"}]
        //------map-----------
        //strToMap:{"firstName":"Doe","lastName":"","dateOfBirth":"2021-09-19","age":15}
        //mapToStr:{"firstName":"Doe","lastName":"","dateOfBirth":"2021-09-19","age":15}
    }
}

标签：fastjson,return,String,Doe,dateOfBirth,JSON,使用,public
来源： https://www.cnblogs.com/ciel717/p/16190639.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

fastjson使用

一、JSONField

1. @JSONField的作用对象(配置方式):

1. 配置在field上

2. 配置在getter/setter上

2. 使用format配置日期格式化

3. 使用serialize/deserialize指定字段不序列化

4. 使用ordinal指定字段的顺序

二、将Java对象转换为JSON格式

1. JSON.toJSONString()

2. JSONObject.fromObject()

FastJson还支持BeanToArray序列化功能：

三、创建JSON对象

使用@JSONCreator

其他

四、JSON字符串与Java对象转换

JSON字符串转换为Java对象

五、使用ContextValueFilter配置JSON转换

六、使用NameFilter和SerializeConfig

FastJsonUtils