Android 之数据解析 - Json解析

最新推荐文章于 2025-09-25 09:19:44 发布

原创最新推荐文章于 2025-09-25 09:19:44 发布 · 814 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#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);