fastjson使用
作者：互联网
定义以下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