目录
parseObject(String text, Class clazz)
parseArray(String text, Class clazz)
toJavaList(JSONArray jsonArray)
是什么
阿里巴巴开发的开源JSON解析库，由Java语言编写，它主要被设计用于将 Java 对象与 JSON 数据进行相互转换。
PS：它是一个专注于JSON格式的Java库。Fastjson的主要功能包括JSON序列化和反序列化，即可以将Java对象转换为JSON格式的字符串，也可以将JSON字符串转换为Java对象。
依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.83</version><!--这里以1.2.83为例-->
</dependency>PS：某些版本可能存在安全漏洞，因此在使用时需要确保使用的是最新且已修复漏洞的版本。
核心类
JSON
工具类，提供了一系列的静态方法来序列化和反序列化JSON（对象和数组）字符串和Java对象之间的转换。
常用方法
toJSONString(Object object)
作用：将Java对象序列化为JSON格式的对象或数组字符串。
返回值：序列化后的JSON格式的对象或数组字符串。
示例：
User user = new User();
user.setName("张三");
user.setAge(25);
// 将对象转为JSON格式的对象字符串
String jsonString = JSON.toJSONString(user);
List<User> userList = new ArrayList<>();
userList.add(new User("王二", 25));
userList.add(new User("张三", 30));
userList.add(new User("李四", 35));
// 将集合对象转为JSON格式的数组字符串
String jsonArrayString = JSON.toJSONString(userList); parseObject(String text)
作用：将JSON文本解析为JSONObject
返回值：反序列化后的JSONObject对象
示例：
String jsonString = "{\"name\":\"Alice\",\"age\":25}";
JSONObject jsonObject = JSON.parseObject(jsonString);parseObject(String text, Class<T> clazz)
作用：将JSON对象字符串反序列化为Java对象（JavaBean）。
返回值：反序列化后的Java对象。
示例：
String jsonString = "{\"name\":\"Alice\",\"age\":25}";
User user = JSON.parseObject(jsonString, User.class);PS：User 类中的字段名称必须与 JSON 字符串中的键名称相匹配，否则无法正确映射。
parseArray(String text)
作用：将JSON格式的数组字符串反序列化为集合，不需要指定集合中元素的类型。
返回值：反序列化后的Java集合，集合中的元素类型为Object类型。
示例：
String jsonText = "[{\"name\": \"Alice\", \"age\": 25},{\"name\": \"Bob\", \"hobby\": \"swimming\"},\"Hello, World!\"]";
List<Object> objectList = JSON.parseArray(jsonText);PS：这种方法在你不知道或者不关心数组中元素的具体类型时非常有用。
parseArray(String text, Class<T> clazz)
作用：将JSON格式的数组字符串反序列化为Java中的集合对象，需要指定集合中元素的类型。
返回值：反序列化后的Java集合，集合中元素的类型为指定的类型。
示例：
String jsonString = "[{\"name\":\"张三\",\"age\":25},{\"name\":\"李四\",\"age\":30}]";
List<User> userList = JSON.parseArray(jsonString, User.class);补充：将JSON字符串反序列化为Java中的数组
说明：fastJson中JSON类并没有直接提供一个将 JSON 字符串转换为 Java 数组的方法，但可以先将 JSON 数组字符串转换为 JSONArray，然后从中提取数据并转换为 Java 数组。
示例：
String jsonString = "[\"Alice\", \"Bob\", \"Charlie\"]";
// 使用 parseArray 方法将 JSON 数组字符串转换为 JSONArray
JSONArray jsonArray = JSON.parseArray(jsonString);
// 将 JSONArray 转换为 Java 数组
String[] names = new String[jsonArray.size()];
for (int i = 0; i < jsonArray.size(); i++) {
names[i] = jsonArray.getString(i);
} isValid(String text)
作用：验证JSON字符串的有效性。
返回值：返回值为boolean类型，JSON字符串有效返回true，否则返回false。
示例：
String validJson = "{\"name\":\"Alice\",\"age\":25}";
String invalidJson = "This is not JSON";
boolean isValid = JSON.isValid(validJson); // true
boolean isInvalid = JSON.isValid(invalidJson); // falseJSONObject
用于处理JSON对象的类。继承自JSON类，并且实现了Map<String，Object>接口，数据结构为键值对的形式（通过键获取值）。
import com.alibaba.fastjson.JSONObject;
public class FastJsonExample {
public static void main(String[] args) {
String jsonString = "{\"name\":\"John\",\"age\":30,\"married\":false}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
String name = jsonObject.getString("name");
int age = jsonObject.getIntValue("age");
boolean married = jsonObject.getBoolean("married");
System.out.println("Name: " + name + ", Age: " + age + ", Married: " + married);
}
}常用方法
特别说明：因fastJson主要是为了处理序列化和反序列化，对于Map接口的方法实现可能在方法内直接调用其它Map实现类的方法。但对于我们使用者来说，无需太过关注底层实现（fastjson是开源的，可能在不同版本底层实现会有所不同）。
put(String key, Object value)
作用：添加（或修改）一个键值对。
返回值：先前的值（Object类型），如果键已经存在则返回该键对应的旧值，否则返回null。
示例：
Object previousValue = jsonObject.put("name", "John");remove(Object key)
作用：移除指定的键及其对应的值，如果键不存在则返回null。
返回值：移除的键对应的值（Object类型）。
示例：
Object removedValue = jsonObject.remove("keyName"); get(String key)
作用：根据给定的键（key）获取对应的值（value）。如果键不存在，则返回null。
返回值：具体键对于的值（Object类型）。
示例：
Object value = jsonObject.get("keyName");get***系列
作用：提供了类型安全的方法来获取特定类型的值。如果键不存在或值无法转换为请求的类型，这些方法将抛出异常。
返回值：根据调用的get***的方法获取特定类型的值。
示例：
// 根据给定key获取对象中的String
String strValue = jsonObject.getString("keyName");
// 根据给定key获取对象中的Integer
Integer intValue = jsonObject.getInteger("keyName");
// 其它Java的类型就不再举例...
// 根据给定key获取对象中的JSONObject
JSONObject subObj = jsonObject.getJSONObject("subKeyName");
// 根据给定key获取对象中的JSONArray
JSONArray array = jsonObject.getJSONArray("arrayKeyName");KeySet()
作用：获取所有键集合。
返回值：Set集合类型的键集合。
示例：
Set<String> keySet = jsonObject.keySet();
// 遍历 keySet
for (String key : keySet) {
System.out.println("Key: " + key);
// 你也可以同时获取并打印对应的值
Object value = jsonObject.get(key);
System.out.println("Value: " + value);
}size()
作用：获取JSONObject中键值对的数量。
返回值：键值对的数量。
示例：
int size = jsonObject.size();containsKey(Object key)
作用：判断JSONObject是否包含指定的键。
返回值：一个boolean值。
示例：
boolean contains = jsonObject.containsKey("keyName");containsValue(Object value)
作用：判断JSONObject是否包含指定的值（此方法可能需要遍历整个JSONObject，因此效率可能较低）。
返回值：一个boolean值。
示例：
boolean contains = jsonObject.containsValue(someValue);clear()
作用：移除JSON对象中的所有键值对。
返回值：无。
示例：
jsonObject.clear();toJSONString()
作用：将JSONObject对象转换为JSON格式的字符串。
返回值：转换后JSON字符串。
示例：
String jsonString = jsonObject.toJSONString();JSONArray
用于处理JSON数组的类，继承自JSON类，并且实现了List<Object>接口，数据结构为集合的形式（通过下标获取值）。
常用方法
add(Object value)
作用：
返回值：
示例：
jsonArray.add("element");get***系列
作用：获取数组中的元素。
返回值：根据调用的方法返回对应类型的数据。
示例：
// getJSONObject(int index) 说明：返回指定索引处的元素，并将其作为 JSONObject 对象。
JSONArray jsonArray = new JSONArray("[{\"name\":\"Alice\"},{\"name\":\"Bob\"}]");
JSONObject jsonObject = jsonArray.getJSONObject(0);
String name = jsonObject.getString("name"); // Alice
// getJSONArray(int index) 说明：返回指定索引处的元素，并将其作为 JSONArray 对象（如果元素本身是一个数组）。
JSONArray jsonArray = new JSONArray("[[1,2,3],[4,5,6]]");
JSONArray innerArray = jsonArray.getJSONArray(0);
int firstElement = innerArray.getInt(0); // 1
// get(int index) 说明：返回指定索引处的元素，并将其作为 Object 对象。需要自己将其转换为适当的类型。
JSONArray jsonArray = new JSONArray("[\"Alice\",\"Bob\",3]");
Object element = jsonArray.get(2);
if (element instanceof Integer) {
int number = (Integer) element; // 3
}
JSONArray jsonArray = new JSONArray("[\"Alice\", 30, 25.5, true, 10000000000L]");
// 使用 getString 方法获取字符串
String stringValue = jsonArray.getString(0);
System.out.println("String value at index 0: " + stringValue); // 输出: Alice
// 使用 getInt 方法获取整数
int intValue = jsonArray.getInt(1);
System.out.println("Int value at index 1: " + intValue); // 输出: 30
// 使用 getDouble 方法获取双精度浮点数
double doubleValue = jsonArray.getDouble(2);
System.out.println("Double value at index 2: " + doubleValue); // 输出: 25.5
// 使用 getBoolean 方法获取布尔值
boolean booleanValue = jsonArray.getBoolean(3);
System.out.println("Boolean value at index 3: " + booleanValue); // 输出: true
// 使用 getLong 方法获取长整型数
long longValue = jsonArray.getLong(4);
System.out.println("Long value at index 4: " + longValue); // 输出: 10000000000length()
作用：获取JSONArray中元素的数量。
返回值：JSONArray中元素的数量。
示例：
JSONArray jsonArray = new JSONArray("[{\"name\":\"Alice\"},{\"name\":\"Bob\"}]");
int size = jsonArray.length();toJSONString()
作用：将JSONArray转换为JSON字符串。
返回值：转换后JSON字符串。
示例：
String jsonString = jsonArray.toJSONString(); toArray()
作用：将JSONArray转换为Java数组。
返回值：转换后的Object数组。
示例：
Object[] objects = jsonArray.toArray();toJavaList(JSONArray jsonArray)
作用：将JSONArray转换为Java集合。
返回值：转换后的Java List。
示例：
List<Object> list = (List<Object>) JSONArray.toJavaList(jsonArray);注解
注解（Annotation）是一种用于为Java代码提供元数据的机制，它允许开发者在编译时为类、方法、变量等添加额外的信息，这些信息可以在运行时通过反射机制获取。fastjson提供了几种特定的注解，用于控制JSON序列化和反序列化的行为。
1. fastjson中的注解
fastjson主要提供了以下几种注解：
@JSONType：用于JavaBean上，可以规定哪些字段需要忽略或者需要包含，以及配置特性。@JSONField：用于JavaBean的具体字段或者方法上，可以修改某个属性的输出名称，规定其支持序列化或者反序列化与否以及规定序列化顺序。@JSONCreator：用于构造方法上，标识这个构造方法是用于反序列化的。@JSONPOJOBuilder：用于构建者模式（Builder Pattern）的类上，标识这个类是用于构建JavaBean的。
2. 注解的作用
- 控制序列化和反序列化的行为：通过注解，可以指定哪些字段需要被序列化或反序列化，哪些字段需要被忽略。
- 自定义字段名称：在JSON和JavaBean之间映射时，可以使用注解来指定字段的别名。
- 指定序列化顺序：可以通过注解来指定字段的序列化顺序。
- 支持复杂的JSON结构：例如，对于嵌套的JSON对象或数组，可以使用注解来指导fastjson如何正确地解析它们。
3. 注解的具体参数说明
以@JSONField为例，其主要参数包括：
name：用于指定序列化后的JSON字段名或反序列化时的JSON字段名。例如：@JSONField(name="project_name")。format：当字段类型为Date时，用于指定日期时间的格式化字符串。serialize：用于指定该字段是否参与序列化。当值为false时，该字段不会被序列化到JSON中。deserialize：用于指定该字段是否参与反序列化。当值为false时，该字段在反序列化时不会被赋值。serialzeFeatures：这是一个SerializerFeature类型的枚举数组，用于指定该字段的序列化特性。例如，@JSONField(serialzeFeatures=SerializerFeature.WriteMapNullValue)表示当该字段的值为null时，仍然会将其序列化到JSON中。
请注意，以上参数并非@JSONField的全部参数，fastjson的注解还提供了许多其他功能和选项，可以根据具体需求进行配置。此外，@JSONType、@JSONCreator和@JSONPOJOBuilder等注解也有各自特定的参数和用法。建议查阅fastjson的官方文档或相关教程以获取更详细的信息。
具体使用示例
无需了解，快速上手使用。
JSON格式的数据主要由两种结构组成：对象和数组。这两种结构可以嵌套使用，形成复杂的JSON数据。
常见JSON格式数据组成
// 对象中包含数组
{
"name": "John",
"age": 30,
"cars": [
"Ford",
"BMW",
"Fiat"
]
}
// 数组包含对象
[
{
"id": 1,
"name": "Apple",
"price": 5.99
},
{
"id": 2,
"name": "Banana",
"price": 2.99
}
]
//对象包含数组和对象
{
"person": {
"name": "Alice",
"age": 25,
"address": {
"street": "123 Main St",
"city": "Wonderland"
},
"phones": [
"123-456-7890",
"987-654-3210"
]
}
}
//数组包含数组和对象
[
{
"name": "Group 1",
"members": [
"Alice",
"Bob"
],
"activities": [
"Hiking",
"Camping"
]
},
{
"name": "Group 2",
"members": [
"Charlie",
"David"
],
"activities": [
"Swimming",
"Cycling"
]
}
]以下为常见类型对象与JSON格式字符串之间的转换示例
Java对象转换为JSON字符串
示例(序列化)代码如下所示：
import com.alibaba.fastjson.JSON;
public class Main {
public static void main(String[] args) {
// 创建要序列化的对象
User user = new User("John", "Doe");
// 使用fastjson进行序列化
String jsonStr = JSON.toJSONString(user);
System.out.println(jsonStr);
}
}
class User {
private String firstName;
private String lastName;
public User() {}
public User(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
// Getters and setters
}输出结果：{"firstName":"John","lastName":"Doe"}
Java集合转为JSON字符串
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
public class Main {
public static void main(String[] args) {
// 定义一个集合并添加元素
List<Integer> array = new ArrayList<>();
array.add(50);
array.add(60);
array.add(7);
// 创建一个 JSONObject 来存储这些数据
JSONObject jsonObject = new JSONObject();
JSONArray intArrayJson = new JSONArray();
intArrayJson.addAll(array);
jsonObject.put("intArrayKey", intArrayJson);
System.out.println(jsonObject);
}
}输出结果：
{"intArrayKey":[50,60,7]}
JSON字符串转换为Java对象
示例(反序列化)代码如下所示：
import com.alibaba.fastjson.JSON;
public class Main {
public static void main(String[] args) {
// 定义包含JSON数据的字符串
String jsonStr = "{\"firstName\":\"John\", \"lastName\":\"Doe\"}";
// 使用fastjson进行反序列化
User user = JSON.parseObject(jsonStr, User.class);
System.out.println(user.getFirstName());
System.out.println(user.getLastName());
}
}
class User {
private String firstName;
private String lastName;
public User() {}
public User(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
// Getters and setters
}输出结果：
John
Doe
JSON字符串转为集合<T>
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import java.util.List;
public class Main {
public static void main(String[] args) {
String jsonString = "[{\"name\":\"Alice\"},{\"name\":\"Bob\"}]";
// 解析 JSON 字符串为 User 对象的列表
List<User> userList = JSON.parseObject(jsonString, new TypeReference<List<User>>() {});
// 打印解析后的 User 对象列表
for (User user : userList) {
System.out.println(user.getName());
}
}
}
// User 类的定义
class User {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}输出结果：
Alice
Bob
PS：TypeReference 指定目标类型的泛型信息。
获取JSON字符串中(字符串,数值)
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
public class Main {
public static void main(String[] args) {
// JSON字符串
String jsonStr = "{\"name\":\"John\", \"age\":30}";
// 将JSON字符串转换为JSON对象
JSONObject jsonObj = JSON.parseObject(jsonStr);
// 通过键名获取值
String name = jsonObj.getString("name");
int age = jsonObj.getIntValue("age");
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}输出结果：
Name: John
Age: 30
获取JSON字符串(字符串,数组)
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSONArray;
public class Main {
public static void main(String[] args) {
// JSON字符串,数组
String jsonStr = "{\"firstName\":\"John\", \"lastName\":\"Doe\" ," +
"\"array\":[\"唱\",\"跳\",\"rap\"]}";
// 将JSON字符串转换为JSON对象
JSONObject jsonObj = JSON.parseObject(jsonStr);
// 通过键名获取值
String firstName = jsonObj.getString("firstName");
String lastName = jsonObj.getString("lastName");
JSONArray jsonArray = jsonArray.getJSONArray("array");
for (int i = 0; i < jsonArray.size(); i++) {
Object value = jsonArray.get(i);
System.out.println(value);
}
System.out.println(firstName);
System.out.println(lastName);
}
}输出结果：
唱
跳
rap
John
Doe
获取JSON对象中(数组-包含多个json对象)
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSONArray;
public class Main {
public static void main(String[] args) {
// JSON数组-多个json对象
String jsonStr = "{\"array\":[{\"name\":\"张三\",\"sex\":\"男\"}," +
"{\"name\":\"李四\",\"sex\":\"女\"}]}";
// 将JSON字符串转换为JSON对象
JSONObject jsonObj = JSON.parseObject(jsonStr);
// 通过键名获取值
JSONArray jsonArray = jsonArray.getJSONArray("array");
for (int i = 0; i < jsonArray.size(); i++) {
JSONObject json = JSON.parseObject(jsonArray.get(i).toString());
String name = json.getString("name");
String sex = json.getString("sex");
System.out.println(name);
System.out.println(sex);
}
}
}输出结果：
张三
男
李四
女
相关链接
JSON是什么？以及JSON结构的说明。
序列化和反序列
扫一扫
7826
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
