FastJson的使用

使用maven導(dǎo)入依賴包

1. <!--下邊依賴跟aop沒關(guān)系，只是項目中用到了 JSONObject，所以引入fastjson-->
2. <dependency>
3. <groupId>com.alibaba</groupId>
4. <artifactId>fastjson</artifactId>
5. <version>1.2.70</version>
6. </dependency>

常用方法：

1.JSON.toJSONString(obejct) - java對象轉(zhuǎn)JSON字符串，

注意：

默認(rèn)情況下，如果int類型和boolean類型的屬性沒賦值的時候 (public boolean a; public int b;)，調(diào)用 JSON.toJSONString(obejct) 序列化后，a和b不會被過濾掉，而是返回boolean類型和int類型的默認(rèn)值 false和0。當(dāng)然其他類型如果沒有賦值，序列化時，會被過濾掉。

來看下例子就明白了

1. public class Test {
2. public static void main(String[] args) {
3. List<User> userList = new ArrayList<>();
4. User user = new User();
5. user.setName("123");
6. userList.add(user);
7. System.out.println(JSON.toJSONString(userList));
8. }
9. public static class User{
10. private String name;
11. private int age;
12. public boolean health;
13. public Date time;
14.  
15. public String getName() {
16. return name;
17. }
18.  
19. public void setName(String name) {
20. this.name = name;
21. }
22.  
23. public int getAge() {
24. return age;
25. }
26.  
27. public void setAge(int age) {
28. this.age = age;
29. }
30. }
31. }

先給name賦值，其他的都不賦值，結(jié)果time屬性被過濾掉了，如下：

再看下都不賦值的情況，結(jié)果name和time屬性都被過濾掉了，而int類型的age和boolean類型的health屬性取得時類型的默認(rèn)值：

2.JSON.parseObject(string, User.class) - JSON字符串轉(zhuǎn)java對象

（1）List集合轉(zhuǎn)JSON

1. @RestController
2. public class Json {
3.  
4. @RequestMapping(value = "/json")
5. public String json() throws Exception{
6. List<User> userList = new ArrayList<>();
7. userList.add(new User("1", "1", 20));
8. String res = JSON.toJSONString(userList);
9. return res;
10. }
11. }

（2）Map集合轉(zhuǎn)JSON

1. package com.lxc.Test;
2.  
3. import com.alibaba.fastjson.JSON;
4.  
5. import java.util.ArrayList;
6. import java.util.HashMap;
7. import java.util.List;
8. import java.util.Map;
9.  
10. public class Json {
11. public static void main(String[] args) {
12. Map<String, Object> userList = new HashMap<>();
13. for(int i = 0; i < 5; i ++) {
14. userList.put("user"+i, new User("name"+i, 20+i));
15. }
16. System.out.println("json:"+JSON.toJSONString(userList));
17. }
18. public static class User{
19. private String name;
20. private int age;
21.  
22. public User(String name, int age) {
23. this.name = name;
24. this.age = age;
25. }
26.  
27. public String getName() {
28. return name;
29. }
30.  
31. public void setName(String name) {
32. this.name = name;
33. }
34.  
35. public int getAge() {
36. return age;
37. }
38.  
39. public void setAge(int age) {
40. this.age = age;
41. }
42. }
43. }

反序列化

1.JSON轉(zhuǎn)Java對象 - JSON.perseObject()

1. public class Json {
2. public static void main(String[] args) {
3. String json = "{\"age\":20,\"name\":\"name0\"}";
4. System.out.println(JSON.parseObject(json, User.class)+"");
5. }
6. }

2.JSON轉(zhuǎn)Java集合 - JSON.perseArray()

1. public class Json {
2. public static void main(String[] args) {
3. String json = "[{\"age\":20,\"name\":\"name0\"}]";
4. List<User> userList = JSON.parseArray(json, User.class);
5. userList.forEach(System.out::println);
6. }
7. }

JSON.toJSONString() 參數(shù) - SerializerFeature枚舉常量

toJSONString 靜態(tài)方法參數(shù)有兩個：

參數(shù)一：要序列化的對象；
參數(shù)二：SerializerFeature 枚舉類型的可變參數(shù) ( 我們可以傳遞多個參數(shù) )，進行序列化時，我們可以定義特殊的需求。

1.SerializerFeature.WriteMapNullValue

對一個對象或者列表進行序列化時，默認(rèn)情況下如果屬性值為null，序列化后的結(jié)果會過濾掉其屬性,如果想保留其屬性值，可以使用 SerializerFeature.WriteMapNullValue。

1. public class Json {
2. public static void main(String[] args) {
3. User user = new User();
4. user.setAge(20);
5. String res = JSON.toJSONString(user, SerializerFeature.WriteMapNullValue);
6. System.out.println(res);
7. }
8. public static class User{
9. private String name = null;
10. private int age;
11.  
12. public String getName() {
13. return name;
14. }
15.  
16. public void setName(String name) {
17. this.name = name;
18. }
19.  
20. public int getAge() {
21. return age;
22. }
23.  
24. public void setAge(int age) {
25. this.age = age;
26. }
27.  
28. @Override
29. public String toString() {
30. return "User{" +
31. "name='" + name + '\'' +
32. ", age=" + age +
33. '}';
34. }
35. }
36. }

2.SerializerFeature.WriteNullStringAsEmpty

對一個對象或者列表進行序列,把屬性值為null的字段進行轉(zhuǎn)化為 "" 雙引號。

1. public class Json {
2. public static void main(String[] args) {
3. User user = new User();
4. user.setAge(20);
5. String res = JSON.toJSONString(user, SerializerFeature.WriteNullStringAsEmpty);
6. System.out.println(res);
7. }
8. }

3.SerializerFeature.WriteNullNumberAsZero

序列之后, 把屬性值為 null 的屬性轉(zhuǎn)化為 0，這個前提是此屬性是 int 類型的！

1. public class Json {
2. public static void main(String[] args) {
3. User user = new User();
4. user.setName("測試");
5. String res = JSON.toJSONString(user, SerializerFeature.WriteNullNumberAsZero);
6. System.out.println(res);
7. }
8. }

4.SerializerFeature.WriteNullBooleanAsFalse

序列之后, 把屬性值為 null 的屬性轉(zhuǎn)化為 false，這個前提是此屬性是 boolean 類型的！

1. @Data
2. public class User{
3. private String name;
4. private int age;
5. private boolean health;
6. }

5.SerializerFeature.WriteDateUseDateFormat

把時間戳序列化為正常的時間，默認(rèn)輸出JSON.toJSONString() 序列之后, 默認(rèn)輸出如下：

添加 SerializerFeature.WriteDateUseDateFormat  之后的效果：

1. @Data
2. public class User{
3. private String name;
4. private int age;
5. private Date birthday = new Date();
6. private boolean health;
7. }

6.SerializerFeature.PrettyFormat

序列化的數(shù)據(jù)縱向布局。

@JSonField() 注解

在序列化時，進行個性定制！該注解的作用于方法上，字段上、參數(shù)上，可在序列化和反序列化時進行特性功能定制。

1.注解屬性 name序列化后的名字（單獨序列化，對屬性名進行修改）

1. @JSONField(name="username")
2. private String name;

2.注解屬性 ordinal序列化后的順序（字段的排序）

1. @JSONField(ordinal = 1)
2. private String name;
3. @JSONField(ordinal = 2)
4. private int age;

3.注解屬性 format 序列化后的格式

1. @JSONField(format = "YYYY-MM-dd")
2. private Date birthday = new Date();

4.注解屬性 serialize 是否序列化該字段(默認(rèn)為true，如果false，當(dāng)字段值為null時，會被過濾掉)

5.使用serializeUsing來定制屬性的序列化類

什么意思呢，類似vue中的過濾器，可以單獨訂制處理類下的某個屬性：

第一步：編寫一個類A，實現(xiàn)ObjectSerializer 接口；
第二步：重寫write方法；
第三步：在需要定制化的屬性上邊 添加注解，@JSONField(serializeUsing = A.class)

具體實現(xiàn)如下：

1. public class Json {
2. public static void main(String[] args) {
3. List<User> userList = new ArrayList<>();
4. User user = new User();
5. user.setName("測試,");
6. userList.add(user);
7. System.out.println(JSON.toJSONString(userList));
8. }
9. public static class SerializeUsingFn implements ObjectSerializer {
10.  
11. @Override
12. public void write(JSONSerializer jsonSerializer, Object fieldValue, Object fieldName, Type fieldType, int i) throws IOException {
13. System.out.println(fieldValue); // 測試,
14. System.out.println(fieldName); // name
15. System.out.println(fieldType); // String
16. System.out.println(i); // 0
17. String name = (String) fieldValue; // 向下轉(zhuǎn)型，獲取到age屬性值
18. String filterName = name + "呵呵"; // 這里可以對name屬性進行定制化
19. jsonSerializer.write(filterName); // 調(diào)用write方法
20. }
21. }
22. public static class User{
23. @JSONField(serializeUsing = SerializeUsingFn.class)
24. private String name;
25. private int age;
26. public boolean health;
27. public Date time;
28.  
29. public String getName() {
30. return name;
31. }
32.  
33. public void setName(String name) {
34. this.name = name;
35. }
36.  
37. public int getAge() {
38. return age;
39. }
40.  
41. public void setAge(int age) {
42. this.age = age;
43. }
44. }
45. }

可以看到name字段值 被修改了后邊添加了 "呵呵" 倆字。

@JSONType() 注解

只能作用在類上，也是對類里邊的字段進行序列化

@JSONType()注解中的屬性

· includes 要序列化的字段（注意：如果字段上有 @serialize(true),如果沒有includes字段也不會被序列化），它是一個數(shù)組，源碼如下：

1. @Data
2. @JSONType(includes = {"name", "age"})
3. public class User{
4. private String name;
5. private int age;
6. private boolean health;
7. private Date birthday = new Date();
8. }

· orders序列化后的字段順序，也是一個數(shù)組，源碼如下：

1. @JSONType(includes = {"name","birthday", "health", "age"}, orders = {"age","name","birthday","health"})
2. public static class User{
3. private String name;
4. private int age;
5. private boolean health;
6. private Date birthday = new Date();
7. }

FastJson屬性名過濾器

過濾字段，通過 SimplePropertyPreFilter 過濾器，來過濾指定的屬性名，然后在轉(zhuǎn)JSON的時候，帶上過濾器參數(shù)即可。
例如，把下邊屬性health 過濾掉：

1. // userList = [{"age":20,"health":true,"name":"測試,呵呵","time":"2021-06-29 09:40:55"}]
2.  
3. SimplePropertyPreFilter filter = new SimplePropertyPreFilter();
4. // 下邊方法也很好理解：調(diào)用過濾器上邊的getExcludes排除字段的方法，什么字段需要排除呢：add() 添加需要排除的字段即可
5. filter.getExcludes().add("health");
6. System.out.println(JSON.toJSONString(userList, filter));

當(dāng)然，如果需要排除大量的字段，保留一個字段，可以使用：filter.getIncludes() .add("xxx") 方法，意思：只保留xxx屬性，其他的都會被過濾。

如果過濾或者添加多個字段，可以使用：addAll() 方法，參數(shù)必須是一個集合Collection 。

過濾多個字段：

1. SimplePropertyPreFilter filter = new SimplePropertyPreFilter();
2. List<String> r = new ArrayList<>() {
3. {
4. add("health");
5. add("name");
6. }
7. };
8. filter.getExcludes().addAll(r);
9. System.out.println(JSON.toJSONString(userList, filter));

暫時就這么多，項目中用到別的方法在記錄！

到此這篇關(guān)于淺談Java中FastJson的使用的文章就介紹到這了,更多相關(guān)FastJson的使用內(nèi)容請搜索服務(wù)器之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持服務(wù)器之家！

原文鏈接：https://blog.csdn.net/qq_42778001/article/details/118342878