其他分享
首页 > 其他分享> > fastjson使用

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的作用对象(配置方式):

  1. Field
  2. 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