如何在 Java 中从文件读取 JSON

简介

在现代软件开发中，JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式被广泛应用。在 Java 开发过程中，经常需要从文件中读取 JSON 数据，以便进行后续的业务逻辑处理。本文将深入探讨在 Java 中从文件读取 JSON 的相关知识，包括基础概念、使用方法、常见实践以及最佳实践。

目录

1. 基础概念
2. 使用方法
   • 使用原生 Java 类库（不推荐）
   • 使用第三方库 Jackson
   • 使用第三方库 Gson
3. 常见实践
   • 读取简单 JSON 文件
   • 读取复杂嵌套 JSON 文件
4. 最佳实践
   • 错误处理
   • 性能优化
5. 小结
6. 参考资料

基础概念

JSON 是一种基于文本的开放标准格式，它以易于阅读和编写的方式表示数据。JSON 数据结构主要有两种：对象（Object）和数组（Array）。对象是键值对的无序集合，用花括号 {} 包围；数组是值的有序集合，用方括号 [] 包围。

在 Java 中处理 JSON 数据，通常需要将 JSON 数据解析为 Java 对象，或者将 Java 对象转换为 JSON 格式。从文件读取 JSON 就是获取存储在文件中的 JSON 数据，并将其转换为 Java 可以处理的形式。

使用方法

使用原生 Java 类库（不推荐）

理论上可以使用原生 Java 类库如 java.io 和 java.util 来读取文件内容并手动解析 JSON，但这是一个非常繁琐且容易出错的过程。JSON 格式有特定的语法规则，手动解析需要编写大量的代码来处理各种情况，而且缺乏效率和准确性。因此，实际开发中很少使用这种方式，这里仅作简单示意：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadJSONWithNative {
    public static void main(String[] args) {
        StringBuilder jsonContent = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new FileReader("example.json"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                jsonContent.append(line);
            }
            // 这里只是获取了文件中的 JSON 字符串，并没有真正解析 JSON
            System.out.println(jsonContent.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用第三方库 Jackson

Jackson 是一个广泛使用的 JSON 处理库，它提供了丰富的 API 来处理 JSON 数据。首先需要在项目中添加 Jackson 的依赖（如果使用 Maven，在 pom.xml 中添加以下依赖）：

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

以下是使用 Jackson 从文件读取 JSON 并解析为 Java 对象的示例：

import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.File;
import java.io.IOException;

class Person {
    private String name;
    private int age;

    // Getters and Setters
    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 class ReadJSONWithJackson {
    public static void main(String[] args) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            Person person = objectMapper.readValue(new File("person.json"), Person.class);
            System.out.println("Name: " + person.getName());
            System.out.println("Age: " + person.getAge());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用第三方库 Gson

Gson 也是一个流行的 JSON 处理库，由 Google 开发。在项目中添加 Gson 依赖（Maven 依赖）：

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

使用 Gson 从文件读取 JSON 并解析为 Java 对象的示例：

import com.google.gson.Gson;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

class Book {
    private String title;
    private String author;

    // Getters and Setters
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

public class ReadJSONWithGson {
    public static void main(String[] args) {
        Gson gson = new Gson();
        try (BufferedReader reader = new BufferedReader(new FileReader("book.json"))) {
            Book book = gson.fromJson(reader, Book.class);
            System.out.println("Title: " + book.getTitle());
            System.out.println("Author: " + book.getAuthor());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

常见实践

读取简单 JSON 文件

假设我们有一个简单的 JSON 文件 person.json，内容如下：

{
    "name": "John Doe",
    "age": 30
}

上述使用 Jackson 和 Gson 的示例代码就是针对这种简单 JSON 文件的读取和解析。通过定义对应的 Java 类（如 Person 类），可以将 JSON 数据映射到 Java 对象的属性上。

读取复杂嵌套 JSON 文件

考虑一个更复杂的 JSON 文件 company.json：

{
    "companyName": "Acme Inc",
    "employees": [
        {
            "name": "Alice",
            "age": 25,
            "department": "Engineering"
        },
        {
            "name": "Bob",
            "age": 32,
            "department": "Sales"
        }
    ]
}

使用 Jackson 读取并解析这个复杂 JSON 文件的示例：

import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.File;
import java.io.IOException;

class Employee {
    private String name;
    private int age;
    private String department;

    // Getters and Setters
    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 getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }
}

class Company {
    private String companyName;
    private Employee[] employees;

    // Getters and Setters
    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    public Employee[] getEmployees() {
        return employees;
    }

    public void setEmployees(Employee[] employees) {
        this.employees = employees;
    }
}

public class ReadComplexJSONWithJackson {
    public static void main(String[] args) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            Company company = objectMapper.readValue(new File("company.json"), Company.class);
            System.out.println("Company Name: " + company.getCompanyName());
            for (Employee employee : company.getEmployees()) {
                System.out.println("Employee Name: " + employee.getName());
                System.out.println("Age: " + employee.getAge());
                System.out.println("Department: " + employee.getDepartment());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

最佳实践

错误处理

在读取 JSON 文件时，可能会遇到各种错误，如文件不存在、JSON 格式不正确等。应该在代码中添加适当的错误处理机制，而不是简单地打印堆栈跟踪信息。例如，可以自定义异常类并进行抛出和捕获处理，以便更好地管理错误情况。

import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.File;
import java.io.IOException;

class JSONReadingException extends Exception {
    public JSONReadingException(String message) {
        super(message);
    }
}

class Person {
    private String name;
    private int age;

    // Getters and Setters
    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 class ErrorHandlingBestPractice {
    public static void main(String[] args) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            Person person = readJSONFile(objectMapper, "person.json");
            System.out.println("Name: " + person.getName());
            System.out.println("Age: " + person.getAge());
        } catch (JSONReadingException e) {
            System.err.println("Error reading JSON file: " + e.getMessage());
        }
    }

    private static Person readJSONFile(ObjectMapper objectMapper, String filePath) throws JSONReadingException {
        try {
            return objectMapper.readValue(new File(filePath), Person.class);
        } catch (IOException e) {
            throw new JSONReadingException("Error reading file or parsing JSON: " + e.getMessage());
        }
    }
}

性能优化

对于大型 JSON 文件，性能优化非常重要。可以考虑以下几点： - 流处理：使用 Jackson 的 Streaming API 或 Gson 的 JsonReader 进行流处理，避免一次性将整个 JSON 文件加载到内存中。 - 对象复用：在解析 JSON 数据时，如果需要创建多个相同类型的对象，可以复用对象创建的逻辑，减少对象创建的开销。

小结

本文详细介绍了在 Java 中从文件读取 JSON 的相关知识，包括基础概念、使用原生 Java 类库（不推荐）以及第三方库（Jackson 和 Gson）的方法。通过常见实践示例展示了如何处理简单和复杂的 JSON 文件，并阐述了错误处理和性能优化的最佳实践。选择合适的 JSON 处理库以及遵循最佳实践可以提高代码的效率和可靠性，帮助开发者更好地处理 JSON 数据。

参考资料

• Jackson 官方文档
• Gson 官方文档
• JSON 官方网站