您好,欢迎访问Java技术研习社|JSON解析专题|实战演练

Java解析JSON对象数组:深度解析与实战指南

全面掌握Gson、Jackson、Fastjson三大主流库的JSON对象数组解析技术,从基础原理到高级技巧,一文吃透。

⚡ JSON对象数组基础原理与核心概念

〈1〉什么是JSON对象数组?

JSON对象数组(JSON Object Array)是由多个JSON对象组成的有序集合,其标准格式以方括号包裹,每个对象以逗号分隔,典型结构如下:

[ {"id":1,"name":"张三","score":92}, {"id":2,"name":"李四","score":88}, {"id":3,"name":"王五","score":95} ]

该结构在Web开发中极为常见,如RESTful API返回的用户列表、商品清单、日志记录等。Java中需将其解析为List<User>、User[]等集合类型。

〈2〉JSON对象数组 vs JSON对象 vs JSON数组

三者关系易混淆,需厘清:

  • JSON对象:键值对集合,用花括号包裹 → {"name":"Java","version":"17"}
  • JSON数组:值的有序集合,用方括号包裹 → [1,2,3,"abc"]
  • JSON对象数组:数组元素为JSON对象 → [{"a":1},{"b":2}](即对象的集合)

在Java中,解析JSON对象数组需明确目标类型:是Object[]?List<Map>?还是List<POJO>?选择不同,解析方式与性能差异显著。

〈3〉Java解析流程全景图

标准解析流程分为三步:

  1. 获取JSON字符串:来自HTTP响应、文件读取或内存变量
  2. 构建解析器实例:如Gson、ObjectMapper、JSON
  3. 调用反序列化方法:指定目标类型,完成转换

关键点在于:目标类型必须与JSON结构严格匹配,否则抛JsonSyntaxException或UnrecognizedPropertyException。

⚙️ Gson库深度解析JSON对象数组

基础用法
泛型处理
高级技巧

〈1〉最简解析示例:List<User>

首先定义POJO:

public class User { private int id; private String name; private int score; // 构造器、getter/setter、toString省略 }

解析代码:

import com.google.gson.Gson; import com.google.gson.reflect.TypeToken; import java.lang.reflect.Type; import java.util.List; Gson gson = new Gson(); String json = "[{\"id\":1,\"name\":\"张三\",\"score\":92},{\"id\":2,\"name\":\"李四\",\"score\":88}]"; Type listType = new TypeToken>(){}.getType(); List users = gson.fromJson(json, listType); System.out.println(users.get(0).getName()); // 输出:张三

注意:TypeToken是Gson处理泛型的关键,因Java泛型擦除,必须显式声明new TypeToken<List<User>>(){}.getType()。

〈2〉解析为数组 vs 解析为List

两种方式对比如下:

特性解析为数组解析为List
语法gson.fromJson(json, User[].class)gson.fromJson(json, new TypeToken<List<User>>(){}.getType())
类型安全✅✅
可变性不可变长度动态增删
内存效率略优略低(ArrayList扩容)

推荐:业务中优先用List,因接口返回长度不确定;仅在固定长度场景用数组。

〈1〉嵌套JSON对象数组解析

实际场景常含嵌套结构:

[ { "id": 101, "course": "Java", "students": [ {"name":"张三","score":92}, {"name":"李四","score":88} ] }, { "id": 102, "course": "Spring", "students": [ {"name":"王五","score":95} ] } ]

对应POJO:

public class Course { private int id; private String course; private List students; // getter/setter } public class Student { private String name; private int score; // getter/setter }

解析代码:

String json = "..."; // 上述JSON字符串 Type type = new TypeToken<List<Course>>(){}.getType(); List<Course> courses = gson.fromJson(json, type); System.out.println(courses.get(0).getStudents().get(1).getName()); // 李四

〈2〉处理未知字段:serializeNulls & lenient

若JSON含Java类无对应字段,Gson默认忽略;但若需保留原始字段,可配置:

Gson gson = new GsonBuilder() .serializeNulls() // 序列化null值 .setLenient() // 宽松模式(允许非标准JSON) .create();

注意:setLenient()仅影响解析器行为,不改变目标类型匹配逻辑。

〈1〉自定义反序列化器(JsonDeserializer)

当JSON字段名与Java不一致(如snake_case→camelCase),或需特殊转换:

public class UserDeserializer implements JsonDeserializer<User> { @Override public User deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException { JsonObject obj = json.getAsJsonObject(); User user = new User(); user.setId(obj.get("user_id").getAsInt()); // 映射user_id→id user.setName(obj.get("full_name").getAsString()); user.setScore(obj.get("score").getAsInt()); return user; } }

注册方式:

Gson gson = new GsonBuilder() .registerTypeAdapter(User.class, new UserDeserializer()) .create();

〈2〉性能优化:预解析为JsonArray

超大JSON(如10万+条记录)时,避免一次性加载整个对象树:

JsonParser parser = new JsonParser(); JsonArray array = parser.parse(json).getAsJsonArray(); List users = new ArrayList<>(array.size()); for (JsonElement elem : array) { users.add(gson.fromJson(elem, User.class)); }

优势:可边解析边处理,降低内存峰值;劣势:代码冗余,适合高阶优化。

⚡ Jackson库:企业级JSON处理首选

〈1〉核心组件概览

  • ObjectMapper:核心类,负责序列化与反序列化
  • JsonNode:动态树模型,适合结构不确定场景
  • Module:扩展机制(如JavaTimeModule支持LocalDate)
基础用法
树模型
性能对比

〈1〉标准解析示例

import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; ObjectMapper mapper = new ObjectMapper(); String json = "[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]"; List<User> users = mapper.readValue(json, new TypeReference<List<User>>(){}); System.out.println(users.get(1).getName()); // 李四

注意:Jackson默认使用TypeReference替代Gson的TypeToken,语义更清晰。

〈2〉解析为JsonNode树结构

当JSON结构动态(如API返回字段不固定):

JsonNode root = mapper.readTree(json); for (JsonNode node : root) { System.out.println(node.get("name").asText() + " - " + node.get("score").asInt()); }

优势:无需POJO;劣势:无法利用编译期类型检查。

〈1〉动态字段处理

处理含动态键的JSON(如时间戳键):

{ "2023-01-01": {"count":10}, "2023-01-02": {"count":15} }

解析方式:

Map<String, Stats> stats = mapper.readValue(json, new TypeReference<Map<String, Stats>>(){});

若无法预知键名,可遍历JsonNode的fieldNames()。

〈2〉字段映射注解

用注解解决字段名不匹配:

public class User { @JsonProperty("user_id") private int id; @JsonProperty("full_name") private String name; @JsonIgnore private String temp; // 忽略序列化 }

〈1〉性能测试对比(10万条数据)

// 测试环境:JDK 17, i7-12700H // Jackson(默认配置):平均28ms // Gson:平均42ms // Fastjson(1.2.83):平均18ms(但存在安全风险!)

结论:Fastjson最快,但2022年曝出远程代码执行漏洞(CVE-2022-25845),企业级项目慎用。

〈2〉流式解析(Streaming API)

超大JSON(如GB级)时,用JsonParser逐字段解析:

JsonParser parser = mapper.getFactory().createParser(json); while (parser.nextToken() != JsonToken.END_ARRAY) { JsonNode node = mapper.readTree(parser); // 处理单个对象 }

内存占用极低,适合日志流处理。

⚡ Fastjson:高吞吐量的双刃剑

⚠️ 警告:Fastjson 1.x存在多个高危漏洞,推荐升级至fastjson2(包名com.alibaba.fastjson2)。
基础用法
安全配置

〈1〉快速解析

import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.TypeReference; String json = "[{\"id\":1,\"name\":\"张三\"}]"; List<User> users = JSON.parseObject(json, new TypeReference<List<User>>(){});

特点:语法简洁,性能高;缺点:类型推断易出错,需显式指定TypeReference。

〈2〉自动类型转换

Fastjson支持智能类型识别:

Object obj = JSON.parse(json); // 返回JSONArray List<Map> list = JSON.parseArray(json, Map.class); // 显式指定元素类型

但若JSON含混合类型(如[1,"abc",{}]),解析时易抛ClassCastException。

〈1〉启用安全解析器(1.x)

import com.alibaba.fastjson.parser.Feature; import com.alibaba.fastjson.parser.ParserConfig; ParserConfig config = ParserConfig.getGlobalInstance(); config.setSafeMode(true); // 全局安全模式 JSON.parseObject(json, User.class, Feature.SafeMode);

安全模式会禁用@type字段,防止反序列化任意类。

〈2〉Fastjson2推荐配置

fastjson2原生支持安全模式,且性能提升30%:

import com.alibaba.fastjson2.JSON; import com.alibaba.fastjson2.JSONObject; String json = "[{\"id\":1,\"name\":\"张三\"}]"; List<User> users = JSON.parseArray(json, User.class); // 或使用JSONObject(非线程安全,需每次new) JSONObject.parseObject(json, new TypeReference<List<User>>(){});

⚙️ Spring Boot集成JSON对象数组解析

〈1〉默认Jackson配置

Spring Boot默认使用Jackson,Controller自动转换:

@RestController public class UserController { @PostMapping("/users") public List<User> handleUsers(@RequestBody List<User> users) { return users; // 自动序列化为JSON数组 } }

前端发送[{"id":1,"name":"张三"}],Spring自动转为List<User>。

〈2〉自定义ObjectMapper

解决时区、空值、命名策略问题:

@Configuration public class JacksonConfig { @Bean @Primary public ObjectMapper objectMapper() { ObjectMapper mapper = new ObjectMapper(); mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); // 忽略null mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE); // snake_case mapper.registerModule(new JavaTimeModule()); // 支持LocalDateTime return mapper; } }

⚡ Android端适配JSON对象数组

〈1〉OkHttp + Gson解析网络响应

OkHttpClient client = new OkHttpClient(); Request request = new Request.Builder() .url("https://api.example.com/users") .build(); try (Response response = client.newCall(request).execute()) { String json = response.body().string(); Gson gson = new Gson(); Type listType = new TypeToken<List<User>>(){}.getType(); List<User> users = gson.fromJson(json, listType); }

注意:网络请求需在子线程,避免ANR。

〈2〉Room数据库嵌套JSON

Android Room支持JSON列,适合存储动态结构:

@Entity public class Article { @PrimaryKey public int id; public String title; @TypeConverters(JsonConverter.class) public List<Comment> comments; // 自动序列化为JSON } @TypeConverter public class JsonConverter { @TypeConverter public String fromList(List<Comment> list) { return new Gson().toJson(list); } @TypeConverter public List<Comment> toString(String json) { return new Gson().fromJson(json, new TypeToken<List<Comment>>(){}.getType()); } }

⚠️ 高频问题与避坑指南

2023-05-12

〈1〉异常:JsonSyntaxException: Expected BEGIN_OBJECT but was BEGIN_ARRAY

原因:用解析JSONObject的方法解析JSONArray。

正确方式:

// 错误 gson.fromJson(json, User.class); // 正确 gson.fromJson(json, new TypeToken<List<User>>(){}.getType());
2023-08-24

〈2〉异常:UnrecognizedPropertyException: Unrecognized field "user_id"

原因:JSON含Java类无字段(如user_id)。

解决方案:

  • Gson:忽略未知字段(默认行为)
  • Jackson:关闭FAIL_ON_UNKNOWN_PROPERTIES
ObjectMapper mapper = new ObjectMapper(); mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
2024-01-10

〈3〉内存溢出(OOM):超大JSON解析

现象:解析10万+条记录时OutOfMemoryError。

解决:

  • 分页请求API(每次1000条)
  • 用流式解析(Gson的JsonReader,Jackson的JsonParser)

📊 三大库横向对比(2024年版)

特性GsonJacksonFastjson2
默认线程安全✅✅✅
泛型支持需TypeToken需TypeReference类型推断强
性能(10万条)42ms28ms18ms
安全风险低低中(1.x高危)
Android兼容优需ProGuard配置需混淆规则
社区支持活跃极活跃阿里维护

💡 推荐策略与最佳实践

〈1〉企业级项目建议

  • 后端服务:优先选Jackson(Spring生态集成好,安全稳定)
  • Android端:Gson(体积小,泛型支持佳)
  • 高性能场景:Fastjson2(需严格安全审计)

〈2〉代码规范建议

  • 避免在公共API中返回Map,用POJO保证结构稳定
  • JSON字段变更时,同步更新POJO并加版本注释
  • 关键解析处加try-catch,记录日志便于排查

〈3〉测试用例模板

@Test public void testParseUserList() throws Exception { String json = "[{\"id\":1,\"name\":\"张三\",\"score\":92}]"; Gson gson = new Gson(); Type type = new TypeToken<List<User>>(){}.getType(); List<User> users = gson.fromJson(json, type); assertEquals(1, users.size()); assertEquals("张三", users.get(0).getName()); }

网友还关心:JSON对象数组高频问题

〈1〉如何处理JSON对象数组中的null值?

场景:API返回[{"id":1,"name":null}],但Java类中name为非空类型。

解决方案:

  • Gson:用@SerializedName+自定义反序列化器
  • Jackson:配置ObjectMapper忽略null
  • 统一约定:后端返回""而非null

〈2〉如何按对象数组中的某个字段排序?

解析后用Java 8 Stream:

List<User> users = ...; users.sort(Comparator.comparing(User::getScore).reversed()); // 按分数降序

〈3〉JSON对象数组与JSON数组的区别?

关键差异:

  • JSON对象数组:数组元素是对象 → [{"a":1},{"b":2}]
  • JSON数组:数组元素是原始值 → [1,2,3]

Java解析时,前者用List<POJO>,后者用List<Integer>。

〈4〉如何合并两个JSON对象数组?

示例:合并list1和list2:

List<User> merged = Stream.concat(list1.stream(), list2.stream()) .collect(Collectors.toList());

注意:若需去重,加.distinct()(需重写User.equals())。

〈5〉如何动态添加字段到JSON对象数组?

用Jackson的JsonNode:

ArrayNode array = (ArrayNode) mapper.readTree(json); for (JsonNode node : array) { ((ObjectNode)node).put("status", "active"); } String updatedJson = mapper.writeValueAsString(array);