Android JSON与对象转换工具类：支持复杂数据结构
在实际开发中，我们经常需要处理复杂的对象，这些对象可能包含基本字段、嵌套对象、List、Map 等数据结构。以下是一个完整的工具类封装，支持复杂对象的序列化（对象转JSON）和反序列化（JSON转对象），并处理常见的数据类型。
复杂对象与JSON转换工具类（基于Gson）
- 添加Gson依赖
在 build.gradle 中添加Gson依赖：
复杂对象与JSON转换工具类（基于Gson）
2. 添加Gson依赖
在 build.gradle 中添加Gson依赖：
- 工具类实现
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;
public class JsonUtil {
private static final Gson gson = new GsonBuilder()
.setPrettyPrinting() // 格式化输出
.serializeNulls() // 序列化空值
.create();
/**
* 将对象转换为JSON字符串
*
* @param object 需要转换的对象
* @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> List中元素的类型
* @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);
}
/**
* 将对象转换为格式化的JSON字符串（便于阅读）
*
* @param object 需要转换的对象
* @return 格式化后的JSON字符串
*/
public static String toPrettyJson(Object object) {
return gson.toJson(object);
}
}
- 复杂对象示例
3.1 定义数据模型
import java.util.List;
import java.util.Map;
public class User {
private String name;
private int age;
private String email;
private Address address; // 嵌套对象
private List<String> hobbies; // List字段
private Map<String, String> metadata; // Map字段
// 必须有无参构造函数
public User() {}
public User(String name, int age, String email, Address address, List<String> hobbies, Map<String, String> metadata) {
this.name = name;
this.age = age;
this.email = email;
this.address = address;
this.hobbies = hobbies;
this.metadata = metadata;
}
// Getter和Setter方法
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;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public List<String> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
public Map<String, String> getMetadata() {
return metadata;
}
public void setMetadata(Map<String, String> metadata) {
this.metadata = metadata;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", email='" + email + '\'' +
", address=" + address +
", hobbies=" + hobbies +
", metadata=" + metadata +
'}';
}
}
class Address {
private String city;
private String zipCode;
// 必须有无参构造函数
public Address() {}
public Address(String city, String zipCode) {
this.city = city;
this.zipCode = zipCode;
}
// Getter和Setter方法
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getZipCode() {
return zipCode;
}
public void setZipCode(String zipCode) {
this.zipCode = zipCode;
}
@Override
public String toString() {
return "Address{" +
"city='" + city + '\'' +
", zipCode='" + zipCode + '\'' +
'}';
}
}
3.2 对象转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);
String json = JsonUtil.toJson(user);
System.out.println(json);
// 输出：
// {
// "name": "John",
// "age": 25,
// "email": "john@example.com",
// "address": {
// "city": "New York",
// "zipCode": "10001"
// },
// "hobbies": ["Reading", "Traveling"],
// "metadata": {
// "role": "admin",
// "department": "IT"
// }
// }
3.3 JSON转对象
String json = "{\"name\":\"John\",\"age\":25,\"email\":\"john@example.com\"," +
"\"address\":{\"city\":\"New York\",\"zipCode\":\"10001\"}," +
"\"hobbies\":[\"Reading\",\"Traveling\"]," +
"\"metadata\":{\"role\":\"admin\",\"department\":\"IT\"}}";
User user = JsonUtil.fromJson(json, User.class);
System.out.println(user);
// 输出：
// User{name='John', age=25, email='john@example.com', address=Address{city='New York', zipCode='10001'}, hobbies=[Reading, Traveling], metadata={role=admin, department=IT}}
3.4 JSON转List
String json = "[{\"name\":\"John\",\"age\":25,\"email\":\"john@example.com\"}," +
"{\"name\":\"Alice\",\"age\":30,\"email\":\"alice@example.com\"}]";
List<User> userList = JsonUtil.fromJsonToList(json, User.class);
System.out.println(userList);
// 输出：
// [User{name='John', age=25, email='john@example.com'}, User{name='Alice', age=30, email='alice@example.com'}]
3.5 JSON转Map
String json = "{\"role\":\"admin\",\"department\":\"IT\"}";
Map<String, String> metadata = JsonUtil.fromJsonToMap(json);
System.out.println(metadata);
// 输出：
// {role=admin, department=IT}
- 扩展功能
4.1 自定义序列化与反序列化
如果需要处理复杂的数据类型（如日期、枚举等），可以通过 GsonBuilder 注册自定义的序列化器和反序列化器。
Gson gson = new GsonBuilder()
.registerTypeAdapter(Date.class, new DateSerializer()) // 自定义日期序列化
.registerTypeAdapter(Date.class, new DateDeserializer()) // 自定义日期反序列化
.create();
4.2 排除字段
使用 @Expose 注解控制字段的序列化和反序列化。
public class User {
@Expose
private String name;
@Expose(serialize = false) // 仅反序列化，不序列化
private int age;
private String email; // 不参与序列化和反序列化
}
4.3 处理空值
通过 GsonBuilder 配置是否序列化空值。
Gson gson = new GsonBuilder()
.serializeNulls() // 序列化空值
.create();
- 总结
通过封装基于Gson的工具类，可以轻松处理复杂对象的序列化和反序列化，包括：
基本字段。
嵌套对象。
List 和 Map 等集合类型。
该工具类适用于大多数Android开发场景，特别是与后端API交互时的数据解析和封装。如果需要更复杂的功能（如自定义序列化、排除字段等），可以通过 GsonBuilder 进一步扩展。