阿里巴巴fastjson的简单使用

简介：

 　　fastjson是阿里巴巴的开源JSON解析库，它可以解析JSON格式的字符串，支持将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。

接口与类的关系图：

 源码：

public interface JSONAware {

    /**
     * @return JSON text
     */
    String toJSONString();
}

 

public interface JSONStreamAware {

    /**
     * write JSON string to out.
     */
    void writeJSONString(Appendable out) throws IOException;
}

相关注解：

在FastJson中，@JSONField 注解用于控制JSON序列化和反序列化时的行为。下面是该注解中各个属性的含义

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
public @interface JSONField {
    // 属性序号，用于指定属性在JSON中的顺序，默认为0。
    int ordinal() default 0;

    // 属性在JSON中的名称，用于指定属性在JSON中的字段名，默认为空字符串，表示使用属性名作为JSON字段名
    String name() default "";
    
    // 属性的时间字段格式化，用于指定属性在JSON中的格式，默认为空字符串
    String format() default "";

    // 是否进行序列化，默认为true，表示对该属性进行序列化
    boolean serialize() default true;

    // 是否进行反序列化，默认为true，表示对该属性进行反序列化
    boolean deserialize() default true;

    // 序列化时的特性，可以指定多个序列化特性，默认为空数组
    SerializerFeature[] serialzeFeatures() default {};

    // 反序列化时的特性，可以指定多个反序列化特性，默认为空数组
    Feature[] parseFeatures() default {};

    // 标签，用于指定属性在JSON中的标签，默认为空字符串
    String label() default "";

    // 是否直接将属性值作为JSON字段，默认为false
    boolean jsonDirect() default false;

    // 定属性的自定义序列化器，默认为 Void.class 表示不使用自定义序列化器
    Class<?> serializeUsing() default Void.class;

    // 指定属性的自定义反序列化器，默认为 Void.class 表示不使用自定义反序列化器。
    Class<?> deserializeUsing() default Void.class;

    // 备选名称数组，用于指定属性在JSON中的备选名称，默认为空数组
    String[] alternateNames() default {};

    // 是否进行解包操作，默认为false
    boolean unwrapped() default false;

    // 默认值，用于指定属性的默认值，默认为空字符串
    String defaultValue() default "";
}

JSON序列化 和 JSON反序列化 

1、JSON序列化【Java对象转换为JSON格式的字符串】

在JSON序列化过程中，Java对象会被转换为符合JSON格式的字符串。
在这个过程中，Java对象的字段（属性）会被映射到JSON对象的键值对中。

通常，字段的值会根据其类型进行相应的转换：
基本数据类型（如整数、浮点数、布尔值）会直接转换为对应的JSON数据类型。
字符串类型会被包裹在双引号中。
集合类和数组会被转换为JSON数组。
对象类型会递归地进行序列化，直到所有字段都被转换为JSON格式。

2、JSON反序列化【JSON格式的字符串转换为Java对象】

在JSON反序列化过程中，JSON格式的字符串会被解析并转换为对应的Java对象。
在这个过程中，JSON对象的键值对会被映射到Java对象的字段（属性）中。

通常，JSON数据类型会根据其特征被转换为相应的Java数据类型：
JSON对象会被转换为Java对象。
JSON数组会被转换为Java集合或数组。
字符串类型会被转换为Java的字符串。
数字类型会被转换为Java的整数或浮点数。
布尔值类型会被转换为Java的布尔值。

常用API：

 

String text = JSON.toJSONString(obj); //序列化
VO vo = JSON.parseObject("{...}", VO.class); //反序列化

public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本 
public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本 
public static final Object toJSON(Object javaObject);  //将JavaBean转换为JSONObject或者JSONArray。

public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray 
public static final JSONObject parseObject(String text)； // 把JSON文本parse成JSONObject 
public static final <T> T parseObject(String text, Class<T> clazz); // 把JSON文本parse为JavaBean 
public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray 
public static final <T> List<T> parseArray(String text, Class<T> clazz); //把JSON文本parse成JavaBean集合 

 

比较：

　　SerializeWriter：相当于StringBuffer

　　JSONArray：相当于List<Object>

　　JSONObject：相当于Map<String, Object>

　　JSON反序列化没有真正数组，本质类型都是List<Object>

 

一、Springboot整合FastJSON使用案例

准备阶段

1、准备实体类

import lombok.Data;

import java.util.Date;

@Data
public class User {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private Date createTime;
}

 

2、配置maven依赖 lombok

<!--lombok-->
<dependency>
       <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.24</version>
</dependency>

3、配置maven依赖 fastjson

<!--fastJson-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.2.78</version>
</dependency>

简单使用与结果演示

1、JSON序列化 

支持各种java基本类型和java对象

案例一：java对象

    @Test
    void contextLoads() {
        User user = new User();
        user.setId(1);
        user.setName("张3");
        user.setAge(20);
        user.setSex("男");
        user.setCreateTime(new Date());

        System.out.println("设置数据: "+user);

        String s = JSON.toJSONString(user);
        System.out.println("JSON序列化: "+s);
    }

 

运行结果：

设置数据: User(id=1, name=张3, age=20, sex=男, createTime=Wed Mar 27 12:33:09 AWST 2024)
JSON序列化: {"age":20,"createTime":171151398958,"id":1,"name":"张3","sex":"男"}

 

时间字段加注解后：

@JSONField(format="yyyy年MM月dd日 HH:mm:ss:SSS")
private Date createTime;

JSON序列化: {"age":20,"createTime":"2021年03月27日 12:42:08:122","id":1,"name":"张3","sex":"男"}

 

@JSONField(format="yyyy-MM-dd HH:mm:ss:SSS")
private Date createTime;

JSON序列化: {"age":20,"createTime":"2021-03-27 12:44:12:289","id":1,"name":"张3","sex":"男"}

 

@JSONField(format="yyyyMMdd HH:mm:ss:SSS")
private Date createTime;

JSON序列化: {"age":20,"createTime":"20240327 12:45:15:630","id":1,"name":"张3","sex":"男"}

 

 

案例二：集合

    @Test
    void testa(){
        List<User> list = new ArrayList<>();

        for (int i = 0; i < 3; i++) {
            User user = new User();
            user.setId(1+i);
            user.setName("张"+i);
            user.setAge(20+i);
            user.setSex(i%2==0 ? "男":"女");
            user.setCreateTime(new Date());
            list.add(user);
        }

        String s = JSON.toJSONString(list);

        System.out.println("JSON序列化: "+s);
    }

 

运行结果：

JSON序列化: 
[
　　{"age":20,"createTime":"20240327 13:35:27:419","id":1,"name":"张0","sex":"男"},
　　{"age":21,"createTime":"20240327 13:35:27:419","id":2,"name":"张1","sex":"女"},
　　{"age":22,"createTime":"20240327 13:35:27:419","id":3,"name":"张2","sex":"男"}
]

 

 

 

2、JSON反序列化

案例一：JSON字符串

    @Test
    void testb(){
        String jsonString = "{\"age\":20,\"createTime\":171151398958,\"id\":1,\"name\":\"张3\",\"sex\":\"男\"}";
        User user = JSON.parseObject(jsonString, User.class);
        
        System.out.println(user);
    }

 

运行结果:

User(id=1, name=张3, age=20, sex=男, createTime=Thu Jun 05 06:03:18 AWST 1975)

 

 案例二：集合

    @Test
    void testc(){
        String json = "[{\"age\":20,\"createTime\":\"20240327 13:35:27:419\",\"id\":1,\"name\":\"张0\",\"sex\":\"男\"},{\"age\":21,\"createTime\":\"20240327 13:35:27:419\",\"id\":2,\"name\":\"张1\",\"sex\":\"女\"},{\"age\":22,\"createTime\":\"20240327 13:35:27:419\",\"id\":3,\"name\":\"张2\",\"sex\":\"男\"}]";
        
        // 将 JSON 字符串转换为 user 对象数组
        User[] users = JSON.parseObject(json, User[].class);

        // 打印转换后的对象数组
        for (User user : users) {
            System.out.println(user);
        }
    }

 

运行结果：

User(id=1, name=张0, age=20, sex=男, createTime=Wed Mar 27 13:35:27 AWST 2024)
User(id=2, name=张1, age=21, sex=女, createTime=Wed Mar 27 13:35:27 AWST 2024)
User(id=3, name=张2, age=22, sex=男, createTime=Wed Mar 27 13:35:27 AWST 2024)

 

 

3、将JSON字符串转成JSONObject

String jsonString = "{\"age\":22,\"name\":\"小明\",\"sex\":\"男\"}";
Object parse = JSON.parse(jsonString);
System.out.println(parse);

运行结果：

运行结果： {"age":22,"name":"小明","sex":"男"}

 

 4、JSONObject 构建JSON格式

JSONObject json = new JSONObject();
json.put("aa", "11");
json.put("bb", "22");
json.put("cc", "33");
String jsonStr = json.toString();
System.out.println(jsonStr);
// {"aa":"11","bb":"22","cc":"33"}    
    
System.out.println(JSONObject.parseObject(jsonStr).get("aa"));
// 11

String o = "{'area':{'area':'1','pagetype':'home'},'pagetype':'home'}";
System.out.println(((Map) JSONObject.parseObject(o).get("area")).get("area"));
// 1
String text = JSON.toJSONString(o);
Map<String, Object> userMap = 
        JSON.parseObject(o, new TypeReference<Map<String, Object>>() {});
System.out.println(((Map) userMap.get("area")).get("NotExsit"));
// null

System.out.println(JSON.toJSONString((Map) userMap.get("area")));
// {"area":"1","pagetype":"home"}

 

 

二、相关注解

注解名称	作用范围	属性值
@JSONField	方法、字段、参数	ordinal：控制字段的输出顺序
		name：指定字段的名称
		format：指定字段的输出格式，只对日期格格式有用
		serialize：指定字段是否序列化
		deserialize：指定字段是否反序列化
		serialzeFeatures
		parseFeatures
		label
		jsonDirect：当你有一个字段是字符串类型，里面是json格式数据，你希望直接输入，而不是经过转义之后再输出。
		serializeUsing
		deserializeUsing
		alternateNames：反序列化时配置多个不同的字段名称
		unwrapped
		defaultValue

使用案例

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;

import java.util.Date;

@Data
public class FastJsonEntity {
    @JSONField(name="name",ordinal=1)
    private String name;

    @JSONField(name="name",ordinal=2,serialize=true)
    private Integer age;

    private String sex;

    @JSONField(name="name",ordinal=3,format="dd/MM/yyyy")
    private Date bir;

    @JSONField(name="name",ordinal=4,format="ddMMyyyy")
    private Date dateOfBirth;
}

 

三、开发中自定义工具类

   /**
     * Object 转 JSON
     */public String a(Object o) {
        if (o instanceof Integer || o instanceof Long || o instanceof Float || o instanceof Double || o instanceof String || o instanceof Boolean) {
            return String.valueOf(o);
        }
        return JSON.toJSONString(o);
    }

    /**
     * JSON 转 Object
     */public <T> T b(String json, Class<T> clazz) {
        return JSON.parseObject(json, clazz);
    }

    /**
     * JSON 转 Object List
     */public <T> List<T> c(String value, Class<T> tClass) {
        return JSON.parseArray(value, tClass);
    }