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 init(){
List personList = new ArrayList();
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
public class JSONObject extends JSON implements Map, Cloneable, Serializable, InvocationHandler {
private static final long serialVersionUID = 1L;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
private final Map map;
.... ...
}
同样我们可以把JSONArray当做一个List,可以把JSONArray看成JSONObject对象的一个集合。
public class JSONArray extends JSON implements List
此外,由于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 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
* @return
*/
public static T strToBean(String text, Class 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需无参构造
*
* @param str
* @param tClass
* @param
* @return
*/
public static T getJavaObject(String str, Class tClass) {
return JSON.toJavaObject(str2Json(str), tClass);
}
//-------------------------集合---------------------------------
/**
* 对象集合转json字符串
* @param list
* @param
* @return
*/
public static String listToJson(List list) {
return JSON.toJSONString(list);
}
/**
* json字符串转为数组
*
* @param text
* @param
* @return
*/
public static Object[] strToArray(String text) {
return strToArray(text, null);
}
/**
* json字符串转为对象数组
*
* @param text
* @param clazz
* @param
* @return
*/
public static Object[] strToArray(String text, Class clazz) {
return JSON.parseArray(text, clazz).toArray();
}
/**
* json字符串转为对象集合
*
* @param text
* @param clazz
* @param
* @return
*/
public static List strToList(String text, Class clazz) {
return JSON.parseArray(text, clazz);
}
/**
* json字符串转对象集合
* @param text
* @param clazz
* @param
* @return
*/
public static List jsonToList(String text, Class clazz) {
return JSONArray.parseArray(text, clazz);
}
/**
* json字符串转化为map
*
* @param str
* @return
*/
public static Map strToMap(String str) {
Map m = (Map) JSONObject.parseObject(str);
return m;
}
/**
* 将map转化为string
*
* @param map
* @return
*/
public static String mapToStr(Map map) {
return JSONObject.toJSONString(map);
}
/**
* JSON数组形式字符串转换为List<Map<String,String>>
* @param strArr
* @return
*/
public static List