Android 之 数据解析 - Json解析

 Gson

基于Gson封装的工具类及使用示例，支持复杂数据结构（嵌套对象、泛型集合等），并包含详细注释和最佳实践

 ​​一、依赖配置​​

在项目的 build.gradle 中添加依赖：

dependencies {
implementation 'com.google.code.gson:gson:2.10.1'
}

二、基本使用

1.工具类封装

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

/**
* Gson工具类（线程安全）
* 功能：对象与JSON互转、泛型集合处理、格式化输出
*/
public class GsonUtils {
// 单例模式 + 自定义配置（格式化/序列化空值）
private static final Gson GSON = new GsonBuilder()
.setPrettyPrinting() // 格式化JSON（便于阅读）
.serializeNulls() // 序列化null值字段
.create();

/**
* 对象转JSON字符串
* @param object Java对象
* @return JSON字符串
*/
public static String toJson(Object object) {
return GSON.toJson(object);
}

/**
* JSON字符串转对象
* @param json JSON字符串
* @param clazz 目标对象的Class
* @param <T> 目标类型
* @return 解析后的对象
*/
public static <T> T fromJson(String json, Class<T> clazz) {
return GSON.fromJson(json, clazz);
}

/**
* JSON转List（支持泛型）
* @param json JSON字符串
* @param clazz List元素的Class
* @param <T> 元素类型
* @return 解析后的List
*/
public static <T> List<T> fromJsonToList(String json, Class<T> clazz) {
Type type = TypeToken.getParameterized(List.class, clazz).getType();
return GSON.fromJson(json, type);
}

/**
* JSON转Map（支持泛型）
* @param json JSON字符串
* @return 解析后的Map
*/
public static <K, V> Map<K, V> fromJsonToMap(String json) {
Type type = new TypeToken<Map<K, V>>() {}.getType();
return GSON.fromJson(json, type);
}
}

2.使用示例（含复杂数据结构）

public class User {
private String name;
private int age;
private Address address; // 嵌套对象
private List<String> hobbies; // List字段
private Map<String, String> metadata; // Map字段

// 必须有无参构造方法（Gson反序列化需要）[2](@ref)
public User() {}

// Getter/Setter方法省略（实际开发中需补充）
}

public class Address {
private String city;
private String zipCode;

public Address() {}
// Getter/Setter省略
}

3. 序列化（对象 → JSON）

// 构建复杂对象
Address address = new Address("New York", "10001");
List<String> hobbies = Arrays.asList("Reading", "Traveling");
Map<String, String> metadata = new HashMap<>();
metadata.put("role", "admin");
metadata.put("department", "IT");

User user = new User("John", 25, "john@example.com", address, hobbies, metadata);

// 转换为JSON（格式化输出）
String json = GsonUtils.toJson(user);
System.out.println(json);

4.输出结果​​

{
"name": "John",
"age": 25,
"email": "john@example.com",
"address": {
"city": "New York",
"zipCode": "10001"
},
"hobbies": ["Reading", "Traveling"],
"metadata": {
"role": "admin",
"department": "IT"
}
}

5. 反序列化（JSON → 对象）​

// JSON字符串转对象
String json = "{\\"name\\":\\"Alice\\",\\"age\\":30,\\"address\\":{\\"city\\":\\"Paris\\"}}";
User user = GsonUtils.fromJson(json, User.class);
System.out.println(user.getAddress().getCity()); // 输出：Paris

// JSON转List（泛型支持）
String listJson = "[{\\"name\\":\\"Bob\\"}, {\\"name\\":\\"Charlie\\"}]";
List<User> userList = GsonUtils.fromJsonToList(listJson, User.class);
System.out.println(userList.size()); // 输出：2

// JSON转Map
String mapJson = "{\\"key1\\":\\"value1\\", \\"key2\\":\\"value2\\"}";
Map<String, String> map = GsonUtils.fromJsonToMap(mapJson);
System.out.println(map.get("key2")); // 输出：value2

6.日常使用

1.定制工具类

public final class JSONUtils {
//解析jsonobject,以{}开头和结尾
public static <T> T parseJSON(String jsonStr, Class<T> t) {
Gson gson = new Gson();
T bean = gson.fromJson(jsonStr, t);
return bean;
}

/**
* //jsonarry,以[]开头和结尾
* @param response
* @param type
* Type type = new TypeToken< ArrayList<实体类名>>() { }.getType();
// *
* @return
*/
public static <T> T parseJSONArray(String response, Type type) {
Gson gson = new Gson();
T data = gson.fromJson(response, type);
return data;
}
//把map转为String,很少用
public static <T> String mapToJson(Map<String, T> map) {
Gson gson = new Gson();
String jsonStr = gson.toJson(map);
return jsonStr;
}

}

2.Java Bean

public class Man {

/**
* name : 张三
* age : 18
*/

private String name;
private int age;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}

2.准备字符串数据

{"error_code":10005,"reason":"应用未审核超时，请提交认证"}

3.解析字符串数据

Man man = JSONUtils.parseJSON(ST, Man.class);
//获得错误码
int error_code = man.getError_code();
//错误原因
String reason = man.getReason();

4.准备数组数据
[
{
"name": "张三",
"age": 18
},
{
"name": "李四",
"age": 19
}
]

5.解析数组数据

Type type = new TypeToken<ArrayList<Man>>() { }.getType();
//获得了一个Man(类名)的集合
ArrayList<Man> first = JSONUtils.parseJSONArray(st, type);
//获得第一个人的年龄
int age = first.get(0).getAge();
Log.e("888", ""+age);
打印下是18岁哦！

注意导包导这个，不然会出错
import java.lang.reflect.Type;
import com.google.gson.reflect.TypeToken;

Jackson

 ​​一、依赖配置​​

在项目的 build.gradle 中添加依赖：

//jackson-databind：核心库（自动包含jackson-core和jackson-annotations）
//jackson-datatype-jsr310：支持LocalDateTime等Java 8日期类型

dependencies {
implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2'
implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.15.2'
}

二、基本使用

1.工具类封装

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import java.text.SimpleDateFormat;
import java.util.List;
import java.util.Map;

public class JacksonUtil {
private static final ObjectMapper mapper = new ObjectMapper();

static {
// 基础配置
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); // 忽略未知字段[6](@ref)
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); // 忽略null字段[7](@ref)
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")); // 统一日期格式

// 注册Java 8日期模块
mapper.registerModule(new JavaTimeModule());
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); // 禁用时间戳格式[7](@ref)
}

// 对象 → JSON字符串
public static String toJson(Object obj) {
try {
return mapper.writeValueAsString(obj);
} catch (JsonProcessingException e) {
throw new RuntimeException("JSON序列化失败", e);
}
}

// JSON字符串 → 对象
public static <T> T toObject(String json, Class<T> clazz) {
try {
return mapper.readValue(json, clazz);
} catch (JsonProcessingException e) {
throw new RuntimeException("JSON反序列化失败", e);
}
}

// JSON字符串 → 复杂集合（如List<User>）
public static <T> List<T> toList(String json, Class<T> elementClass) {
try {
return mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, elementClass));
} catch (JsonProcessingException e) {
throw new RuntimeException("JSON转List失败", e);
}
}

// JSON字符串 → 嵌套结构（如Map<String, List<Order>>）
public static <T> T toComplexObject(String json, TypeReference<T> typeRef) {
try {
return mapper.readValue(json, typeRef);
} catch (JsonProcessingException e) {
throw new RuntimeException("复杂结构转换失败", e);
}
}
}

2.基础对象转换​

// 定义实体类
public class User {
private String name;
private Integer age;
private LocalDateTime createTime;
// Getter/Setter省略
}

// 序列化对象 → JSON
User user = new User("张三", 25, LocalDateTime.now());
String json = JacksonUtil.toJson(user);
// 输出: {"name":"张三","age":25,"createTime":"2025-08-03 14:30:00"} [3](@ref)

// 反序列化 JSON → 对象
User parsedUser = JacksonUtil.toObject(json, User.class);
System.out.println(parsedUser.getName()); // 输出: 张三

3.集合处理

// List序列化
List<User> userList = Arrays.asList(
new User("李四", 30, null),
new User("王五", 28, LocalDateTime.now())
);
String listJson = JacksonUtil.toJson(userList);
// 输出: [{"name":"李四","age":30},{"name":"王五","age":28,"createTime":"2025-08-03 14:35:00"}]

// List反序列化
List<User> parsedList = JacksonUtil.toList(listJson, User.class);

4. 工具类方法总结

fastjson

 ​​一、依赖配置​​

在项目的 build.gradle 中添加依赖：

//jackson-databind：核心库（自动包含jackson-core和jackson-annotations）
//jackson-datatype-jsr310：支持LocalDateTime等Java 8日期类型

dependencies {
implementation 'com.alibaba:fastjson:2.0.39'
}

二、基本使用

1.工具类封装

import com.alibaba.fastjson2.*;
import com.alibaba.fastjson2.filter.Filter;
import java.util.List;

public class FastJsonUtil {
private static final ParserConfig SAFE_PARSER_CONFIG;

static {
// 安全配置：启用安全模式，禁止反序列化任意类 [7](@ref)
SAFE_PARSER_CONFIG = new ParserConfig();
SAFE_PARSER_CONFIG.setSafeMode(true);

// 可选：设置白名单（仅允许指定包下的类）[7](@ref)
SAFE_PARSER_CONFIG.addAccept("com.yourpackage.model.");
}

// 对象 → JSON 字符串（默认配置）
public static String toJson(Object obj) {
return JSON.toJSONString(obj);
}

// 对象 → JSON 字符串（自定义配置）
public static String toJson(Object obj, JSONWriter.Feature… features) {
return JSON.toJSONString(obj, features);
}

// JSON 字符串 → 对象（安全模式）
public static <T> T toBean(String json, Class<T> clazz) {
return JSON.parseObject(json, clazz, SAFE_PARSER_CONFIG);
}

// JSON 字符串 → 泛型集合（如 List<User>）
public static <T> List<T> toList(String json, Class<T> clazz) {
return JSON.parseArray(json, clazz, SAFE_PARSER_CONFIG);
}

// JSON 字符串 → 复杂嵌套结构（如 Map<String, List>）
public static <T> T toComplexType(String json, TypeReference<T> typeRef) {
return JSON.parseObject(json, typeRef, SAFE_PARSER_CONFIG);
}
}

2. ​​基础对象转换

// 定义实体类
public class User {
@JSONField(name = "user_name") // 自定义字段名 [6,7](@ref)
private String name;

@JSONField(serialize = false) // 忽略序列化 [6](@ref)
private String password;

@JSONField(format = "yyyy-MM-dd") // 日期格式化 [7](@ref)
private Date birthDate;

// Getter/Setter 省略
}

// 序列化对象 → JSON
User user = new User("张三", "123456", new Date());
String json = FastJsonUtil.toJson(user);
// 输出：{"user_name":"张三","birthDate":"2025-08-03"}

// 反序列化 JSON → 对象
User parsedUser = FastJsonUtil.toBean(json, User.class);
System.out.println(parsedUser.getName()); // 输出：张三

3. ​​集合处理​

// List 序列化与反序列化
List<User> userList = Arrays.asList(
new User("李四", null, null),
new User("王五", "abc", new Date())
);
String listJson = FastJsonUtil.toJson(userList, JSONWriter.Feature.PrettyFormat);

List<User> parsedList = FastJsonUtil.toList(listJson, User.class);