跳到主要内容

Java JSON解析

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，在现代Web应用中被广泛使用。作为一名Java开发者，掌握JSON数据的解析和生成是必不可少的技能，特别是在开发需要与RESTful API交互的应用程序时。

JSON简介​

JSON是一种基于文本的数据格式，具有易于阅读和编写的特点。它由两种结构组成：

  1. 名称/值对的集合：在各种语言中，这通常被理解为对象、记录、结构等
  2. 有序的值列表：大多数语言中，这被实现为数组、向量或列表等

JSON的基本语法示例：

{
  "name": "张三",
  "age": 25,
  "isStudent": false,
  "courses": ["Java", "Python", "数据库"],
  "address": {
    "city": "北京",
    "zipcode": "100000"
  }
}

Java 中的JSON处理库​

Java本身不提供内置的JSON处理功能，但有几个流行的第三方库可用于JSON操作：

  1. Jackson - 功能全面，性能高
  2. Gson - 由Google开发，使用简单
  3. org.json - 轻量级JSON库
  4. JSON-B - Java EE的标准JSON绑定API

下面我们将详细介绍如何使用这些库进行JSON处理。

使用Jackson处理JSON​

Jackson是Java中最受欢迎的JSON处理库之一，提供了全面的功能和高性能。

添加Jackson依赖​

首先，需要在项目中添加Jackson依赖：

对于Maven项目：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.3</version>
</dependency>

对于Gradle项目：

implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.3'

JSON解析为Java对象（反序列化）​

使用Jackson将JSON字符串转换为Java对象：

import com.fasterxml.jackson.databind.ObjectMapper;

// 首先定义一个Java类
public class Student {
    private String name;
    private int age;
    private boolean isStudent;
    private List<String> courses;
    private Address address;
    
    // 省略getter和setter方法
    
    public static class Address {
        private String city;
        private String zipcode;
        
        // 省略getter和setter方法
    }
}

// 然后使用ObjectMapper解析JSON
public class JacksonDemo {
    public static void main(String[] args) {
        try {
            String json = "{\"name\":\"张三\",\"age\":25,\"isStudent\":false,"
                + "\"courses\":[\"Java\",\"Python\",\"数据库\"],"
                + "\"address\":{\"city\":\"北京\",\"zipcode\":\"100000\"}}";
                
            ObjectMapper objectMapper = new ObjectMapper();
            Student student = objectMapper.readValue(json, Student.class);
            
            System.out.println("姓名: " + student.getName());
            System.out.println("年龄: " + student.getAge());
            System.out.println("城市: " + student.getAddress().getCity());
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果：

姓名: 张三
年龄: 25
城市: 北京

Java 对象转换为JSON（序列化）​

将Java对象转换为JSON字符串：

public class JacksonSerializeDemo {
    public static void main(String[] args) {
        try {
            // 创建对象
            Student student = new Student();
            student.setName("李四");
            student.setAge(22);
            student.setStudent(true);
            
            List<String> courses = new ArrayList<>();
            courses.add("Web开发");
            courses.add("数据结构");
            student.setCourses(courses);
            
            Address address = new Address();
            address.setCity("上海");
            address.setZipcode("200000");
            student.setAddress(address);
            
            // 转换为JSON
            ObjectMapper objectMapper = new ObjectMapper();
            String jsonString = objectMapper.writeValueAsString(student);
            
            System.out.println(jsonString);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果：

{"name":"李四","age":22,"student":true,"courses":["Web开发","数据结构"],"address":{"city":"上海","zipcode":"200000"}}
提示

为了使输出的JSON更加美观，你可以使用objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(student)，这会生成格式化的JSON字符串。

使用Gson处理JSON​

Gson是由Google开发的JSON处理库，以其简单直观的API而受到欢迎。

添加Gson依赖​

为项目添加Gson依赖：

对于Maven项目：

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.9.0</version>
</dependency>

对于Gradle项目：

implementation 'com.google.code.gson:gson:2.9.0'

使用Gson进行JSON解析​

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

public class GsonDemo {
    public static void main(String[] args) {
        // 创建Gson对象
        Gson gson = new Gson();
        
        // JSON字符串转Java对象
        String jsonString = "{\"name\":\"王五\",\"age\":30}";
        Student student = gson.fromJson(jsonString, Student.class);
        System.out.println("姓名: " + student.getName());
        
        // Java对象转JSON字符串
        Student newStudent = new Student();
        newStudent.setName("赵六");
        newStudent.setAge(28);
        String json = gson.toJson(newStudent);
        System.out.println(json);
        
        // 解析JSON数组
        String jsonArray = "[{\"name\":\"学生1\",\"age\":20},{\"name\":\"学生2\",\"age\":22}]";
        Type studentListType = new TypeToken<List<Student>>(){}.getType();
        List<Student> studentList = gson.fromJson(jsonArray, studentListType);
        
        for (Student s : studentList) {
            System.out.println(s.getName() + ": " + s.getAge());
        }
    }
}

输出结果：

姓名: 王五
{"name":"赵六","age":28}
学生1: 20
学生2: 22

使用org.json处理JSON​

org.json是一个轻量级的JSON处理库，是JSON官方参考实现的Java版本。

添加org.json依赖​

对于Maven项目：

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20220320</version>
</dependency>

对于Gradle项目：

implementation 'org.json:json:20220320'

使用org.json处理JSON​

import org.json.JSONArray;
import org.json.JSONObject;

public class OrgJsonDemo {
    public static void main(String[] args) {
        // 创建JSONObject
        JSONObject student = new JSONObject();
        student.put("name", "张三");
        student.put("age", 25);
        student.put("isGraduate", false);
        
        JSONArray courses = new JSONArray();
        courses.put("Java编程");
        courses.put("Web开发");
        
        student.put("courses", courses);
        
        // 输出JSON字符串
        String jsonString = student.toString();
        System.out.println(jsonString);
        
        // 解析JSON字符串
        String inputJson = "{\"name\":\"李四\",\"age\":22,\"courses\":[\"数据库\",\"操作系统\"]}";
        JSONObject parsedJson = new JSONObject(inputJson);
        
        String name = parsedJson.getString("name");
        int age = parsedJson.getInt("age");
        JSONArray parsedCourses = parsedJson.getJSONArray("courses");
        
        System.out.println("姓名: " + name);
        System.out.println("年龄: " + age);
        System.out.println("课程: ");
        
        for (int i = 0; i < parsedCourses.length(); i++) {
            System.out.println("- " + parsedCourses.getString(i));
        }
    }
}

输出结果：

{"name":"张三","age":25,"isGraduate":false,"courses":["Java编程","Web开发"]}
姓名: 李四
年龄: 22
课程: 
- 数据库
- 操作系统

实际应用场景​

RESTful API交互​

下面是一个使用Jackson与RESTful API交互的实例，模拟从API获取用户数据并处理：

import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URL;
import java.util.Arrays;
import java.util.List;

public class RestApiDemo {
    public static void main(String[] args) {
        try {
            // 创建ObjectMapper
            ObjectMapper mapper = new ObjectMapper();
            
            // 假设这是API的URL
            URL url = new URL("https://api.example.com/users");
            
            // 从API读取数据并解析为User对象数组
            User[] users = mapper.readValue(url, User[].class);
            List<User> userList = Arrays.asList(users);
            
            // 处理数据
            userList.forEach(user -> {
                System.out.println("用户ID: " + user.getId());
                System.out.println("用户名: " + user.getUsername());
                System.out.println("电子邮箱: " + user.getEmail());
                System.out.println("------------------------");
            });
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    static class User {
        private int id;
        private String username;
        private String email;
        
        // Getter和Setter方法
        // ...
    }
}
备注

上面的示例展示了从API获取数据的方式。在实际应用中，你可能需要使用HTTP客户端库（如HttpClient、OkHttp等）来处理HTTP请求。

配置文件处理​

使用JSON作为配置文件格式，并使用Gson读取：

import com.google.gson.Gson;
import java.io.FileReader;
import java.io.Reader;

public class ConfigReader {
    public static void main(String[] args) {
        try (Reader reader = new FileReader("config.json")) {
            // 创建Gson实例
            Gson gson = new Gson();
            
            // 解析配置文件
            AppConfig config = gson.fromJson(reader, AppConfig.class);
            
            // 使用配置信息
            System.out.println("应用名称: " + config.getAppName());
            System.out.println("版本: " + config.getVersion());
            System.out.println("数据库URL: " + config.getDatabase().getUrl());
            System.out.println("数据库用户名: " + config.getDatabase().getUsername());
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    static class AppConfig {
        private String appName;
        private String version;
        private DatabaseConfig database;
        
        // Getter和Setter方法
        // ...
        
        static class DatabaseConfig {
            private String url;
            private String username;
            private String password;
            
            // Getter和Setter方法
            // ...
        }
    }
}

配置文件config.json内容示例：

{
  "appName": "我的Java应用",
  "version": "1.0.0",
  "database": {
    "url": "jdbc:mysql://localhost:3306/mydb",
    "username": "root",
    "password": "password"
  }
}

JSON处理常见问题与解决方案​

1. 日期与时间格式处理​

在Jackson中处理日期格式：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import java.time.LocalDate;

public class DateHandling {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        
        // 注册JavaTimeModule，支持Java 8的日期类型
        mapper.registerModule(new JavaTimeModule());
        
        // 格式化日期输出
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        
        // 创建包含日期的对象
        Event event = new Event();
        event.setName("Java会议");
        event.setDate(LocalDate.of(2023, 5, 15));
        
        // 序列化
        String json = mapper.writeValueAsString(event);
        System.out.println(json);
        
        // 反序列化
        Event parsedEvent = mapper.readValue(json, Event.class);
        System.out.println("事件名称: " + parsedEvent.getName());
        System.out.println("事件日期: " + parsedEvent.getDate());
    }
    
    static class Event {
        private String name;
        private LocalDate date;
        
        // Getter和Setter方法
        // ...
    }
}

2. 处理复杂嵌套结构​

使用Gson处理嵌套的JSON数据：

import com.google.gson.Gson;
import java.util.List;

public class NestedJsonDemo {
    public static void main(String[] args) {
        String json = "{"
            + "\"company\":\"技术公司\","
            + "\"departments\":["
            + "  {\"name\":\"研发\",\"employees\":[{\"name\":\"张三\",\"position\":\"开发\"}]},"
            + "  {\"name\":\"测试\",\"employees\":[{\"name\":\"李四\",\"position\":\"QA\"}]}"
            + "]}";
            
        Gson gson = new Gson();
        Company company = gson.fromJson(json, Company.class);
        
        System.out.println("公司: " + company.getCompany());
        
        for (Department dept : company.getDepartments()) {
            System.out.println("部门: " + dept.getName());
            
            for (Employee emp : dept.getEmployees()) {
                System.out.println("  - " + emp.getName() + " (" + emp.getPosition() + ")");
            }
        }
    }
    
    static class Company {
        private String company;
        private List<Department> departments;
        
        // Getter和Setter方法
        // ...
    }
    
    static class Department {
        private String name;
        private List<Employee> employees;
        
        // Getter和Setter方法
        // ...
    }
    
    static class Employee {
        private String name;
        private String position;
        
        // Getter和Setter方法
        // ...
    }
}

JSON处理最佳实践​

  1. 选择合适的库：

    • 对于大多数项目，Jackson是一个很好的选择，因为它功能强大且性能优良
    • 如果需要简单易用的API，Gson是一个不错的选择
    • 对于轻量级应用，org.json是一个简单的选择

  2. 异常处理：

    try {
        ObjectMapper mapper = new ObjectMapper();
        User user = mapper.readValue(jsonString, User.class);
        // 处理用户对象
    } catch (JsonProcessingException e) {
        // 处理JSON解析异常
        log.error("JSON解析错误: " + e.getMessage());
    }

  3. 字段验证：

    JSONObject json = new JSONObject(jsonString);
    if (json.has("username")) {
        String username = json.getString("username");
        // 处理用户名
    } else {
        // 处理缺失字段的情况
    }

  4. 性能优化：

    • 对于多次使用的场景，重用ObjectMapper或Gson实例
    • 处理大型JSON文件时，考虑使用流式处理而不是一次性加载整个文件

总结​

在本教程中，我们学习了：

  1. JSON格式的基础知识
  2. 几个主要的Java JSON处理库：Jackson、Gson和org.json
  3. 如何将JSON解析为Java对象（反序列化）
  4. 如何将Java对象转换为JSON（序列化）
  5. 实际应用场景和最佳实践

JSON处理是现代Java应用开发中的重要技能，特别是在与Web服务和API交互时。通过掌握这些库和技术，你可以有效地处理各种复杂的JSON数据。

练习​

  1. 创建一个简单的学生管理系统，使用JSON文件存储学生信息，并实现添加、查询、修改和删除功能。
  2. 编写一个程序，从公开的API（如https://jsonplaceholder.typicode.com/users）获取JSON数据，并解析为Java对象。
  3. 实现一个配置管理器，可以读取和保存应用程序的JSON配置文件。

附加资源​

通过这些资源和练习，你可以进一步加深对Java JSON处理的理解和应用能力。