Como ler arquivo JSON de um caminho relativo em Java

Introdução

No desenvolvimento Java moderno, o manuseio de JSON (JavaScript Object Notation) é uma habilidade fundamental. JSON é o padrão de fato para troca de dados em aplicações web e APIs devido ao seu formato legível por humanos e facilidade de análise por máquinas.

Este tutorial oferece um guia abrangente para ler e analisar arquivos JSON a partir de um caminho relativo em suas aplicações Java. Você aprenderá como configurar um projeto Maven com as dependências necessárias, criar e estruturar um arquivo JSON, lê-lo a partir de um caminho relativo e analisar seu conteúdo, incluindo dados complexos aninhados.

Ao final deste laboratório, você será proficiente no gerenciamento de dados JSON dentro de seus projetos Java, uma habilidade crítica para qualquer desenvolvedor que trabalhe com serviços web, APIs ou arquivos de configuração.

Configuração do Projeto e Criação do Arquivo JSON

Antes de podermos ler um arquivo JSON, precisamos configurar nosso ambiente de projeto e criar o próprio arquivo. Este laboratório utiliza o Apache Maven para gerenciar as dependências do projeto. A configuração inicial já criou uma estrutura de projeto Maven padrão para você.

Compreendendo a Estrutura do Projeto

No explorador de arquivos do WebIDE, à esquerda, você verá a seguinte estrutura dentro do diretório ~/project:

pom.xml: O arquivo Project Object Model (POM) para o Maven. Ele define as dependências do projeto e as configurações de build.
src/main/java: O diretório para seu código-fonte Java.
src/main/resources: O diretório para arquivos de recursos, como arquivos de configuração ou dados.

O arquivo pom.xml foi pré-configurado para incluir a biblioteca org.json, uma escolha popular para trabalhar com JSON em Java.

Criação do Arquivo de Dados JSON

Agora, vamos criar o arquivo JSON que leremos nas etapas subsequentes.

No explorador de arquivos do WebIDE, navegue até o diretório src/main/resources.
Clique com o botão direito na pasta resources e selecione "New File" (Novo Arquivo).
Nomeie o arquivo como data.json.
Abra o arquivo data.json recém-criado e adicione o seguinte conteúdo:

{
  "name": "John Doe",
  "age": 28,
  "email": "john.doe@example.com",
  "isEmployed": true,
  "address": {
    "street": "123 Main St",
    "city": "Anytown"
  },
  "skills": ["Java", "SQL", "JavaScript"]
}

Este arquivo JSON representa um perfil de usuário. Ele contém pares simples de chave-valor (como "name": "John Doe"), um objeto aninhado (address) e um array de strings (skills). Salve o arquivo após colar o conteúdo.

Você agora configurou com sucesso o projeto e criou o arquivo de dados JSON. Na próxima etapa, escreveremos código Java para ler e analisar este arquivo.

Leitura e Análise de um Arquivo JSON Simples

Com nosso arquivo JSON pronto, podemos agora escrever um programa Java para lê-lo. Usaremos um caminho relativo, que é uma prática comum para garantir que a aplicação seja portátil em diferentes ambientes.

Compreendendo Caminhos Relativos

Um caminho relativo é especificado a partir do diretório de trabalho atual. Ao executar um projeto Maven a partir do terminal, o diretório de trabalho é tipicamente a pasta raiz do projeto, que é ~/project em nosso caso. Portanto, o caminho relativo para nosso arquivo JSON é src/main/resources/data.json.

Criação do Leitor JSON Java

Vamos criar uma classe Java para ler o arquivo.

No explorador de arquivos do WebIDE, navegue até src/main/java/com/labex.
Clique com o botão direito na pasta com/labex e selecione "New File" (Novo Arquivo).
Nomeie o arquivo como JsonReader.java.
Abra o arquivo e adicione o seguinte código Java:

package com.labex;

import org.json.JSONObject;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class JsonReader {
    public static void main(String[] args) {
        try {
            // Define o caminho relativo para o arquivo JSON
            String filePath = "src/main/resources/data.json";
            System.out.println("Reading file from: " + filePath);

            // Lê o conteúdo do arquivo para uma string
            String content = new String(Files.readAllBytes(Paths.get(filePath)));

            // Cria um JSONObject a partir do conteúdo da string
            JSONObject jsonObject = new JSONObject(content);

            // Acessa e imprime os valores das chaves simples
            String name = jsonObject.getString("name");
            int age = jsonObject.getInt("age");
            boolean isEmployed = jsonObject.getBoolean("isEmployed");

            System.out.println("\n--- Parsed JSON Data ---");
            System.out.println("Name: " + name);
            System.out.println("Age: " + age);
            System.out.println("Is Employed: " + isEmployed);

        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Error parsing JSON: " + e.getMessage());
        }
    }
}

Explicação do Código

package com.labex;: Declara que esta classe pertence ao pacote com.labex, seguindo as convenções padrão do Java.
String filePath = "src/main/resources/data.json";: Define o caminho relativo para o nosso arquivo.
Files.readAllBytes(Paths.get(filePath)): Lê todo o conteúdo do arquivo para um array de bytes, que é então convertido para uma String.
new JSONObject(content): Analisa a string contendo os dados JSON em um JSONObject.
jsonObject.getString("name"): Recupera o valor da string associado à chave "name". Métodos semelhantes como getInt() e getBoolean() são usados para outros tipos de dados.

Compilando e Executando o Programa

Agora, vamos compilar e executar nosso código usando o Maven.

Abra o terminal no WebIDE.
Execute o seguinte comando para compilar e executar sua classe:

mvn compile exec:java -Dexec.mainClass="com.labex.JsonReader"

Você deverá ver a seguinte saída no terminal:

Reading file from: src/main/resources/data.json

--- Parsed JSON Data ---
Name: John Doe
Age: 28
Is Employed: true

Esta saída confirma que seu programa leu com sucesso o arquivo data.json a partir de seu caminho relativo e analisou suas propriedades básicas.

Tratamento de Dados JSON Complexos

Dados JSON do mundo real frequentemente contêm estruturas aninhadas, como objetos dentro de objetos ou arrays de valores. Nosso arquivo data.json inclui um objeto address aninhado e um array skills. Vamos expandir nosso conhecimento para analisar essas estruturas complexas.

Criação de um Analisador JSON Complexo

Criaremos uma nova classe para demonstrar a análise dessas partes mais complexas do arquivo JSON.

No explorador de arquivos do WebIDE, navegue até src/main/java/com/labex.
Crie um novo arquivo chamado ComplexJsonParser.java.
Adicione o seguinte código ao arquivo:

package com.labex;

import org.json.JSONArray;
import org.json.JSONObject;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class ComplexJsonParser {
    public static void main(String[] args) {
        try {
            String filePath = "src/main/resources/data.json";
            String content = new String(Files.readAllBytes(Paths.get(filePath)));
            JSONObject person = new JSONObject(content);

            System.out.println("--- Parsing Complex JSON Data ---");

            // Acessa o objeto aninhado 'address'
            JSONObject address = person.getJSONObject("address");
            String street = address.getString("street");
            String city = address.getString("city");

            System.out.println("\nAddress:");
            System.out.println("  Street: " + street);
            System.out.println("  City: " + city);

            // Acessa o array 'skills'
            JSONArray skills = person.getJSONArray("skills");
            System.out.println("\nSkills:");
            for (int i = 0; i < skills.length(); i++) {
                String skill = skills.getString(i);
                System.out.println("  - " + skill);
            }

        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Error parsing JSON: " + e.getMessage());
        }
    }
}

Explicação do Código

person.getJSONObject("address"): Este método recupera o objeto JSON aninhado associado à chave "address". Você pode então chamar métodos como getString() neste novo JSONObject.
person.getJSONArray("skills"): Este método recupera o array JSON associado à chave "skills".
skills.length(): Retorna o número de elementos no JSONArray.
skills.getString(i): Recupera o elemento string em um índice específico i dentro do JSONArray.

Compilando e Executando o Analisador

Vamos executar esta nova classe para ver a saída.

Abra o terminal no WebIDE.
Execute o seguinte comando:

mvn compile exec:java -Dexec.mainClass="com.labex.ComplexJsonParser"

A saída esperada é:

--- Parsing Complex JSON Data ---

Address:
  Street: 123 Main St
  City: Anytown

Skills:
  - Java
  - SQL
  - JavaScript

Isso demonstra sua capacidade de navegar e extrair dados de objetos e arrays aninhados dentro de uma estrutura JSON, uma habilidade crucial para lidar com feeds de dados complexos e respostas de API.

Criação de uma Utilitária JSON Reutilizável

No desenvolvimento de software, é uma boa prática escrever código reutilizável. Em vez de repetir a lógica de leitura de arquivos em cada classe que a necessita, podemos criar uma classe utilitária. Essa abordagem, conhecida como "Don't Repeat Yourself" (DRY), torna seu código mais limpo, mais fácil de manter e menos propenso a erros.

Criação da Classe `JsonUtils`

Vamos criar uma classe utilitária para encapsular a lógica de leitura de um arquivo JSON.

No WebIDE, crie um novo arquivo chamado JsonUtils.java dentro do diretório src/main/java/com/labex.
Adicione o seguinte código:

package com.labex;

import org.json.JSONObject;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class JsonUtils {

    /**
     * Lê um arquivo JSON de um caminho relativo e o analisa em um JSONObject.
     *
     * @param filePath O caminho relativo para o arquivo JSON.
     * @return Um JSONObject representando o conteúdo do arquivo.
     * @throws IOException se ocorrer um erro de I/O ao ler do arquivo.
     */
    public static JSONObject readJsonObjectFromFile(String filePath) throws IOException {
        String content = new String(Files.readAllBytes(Paths.get(filePath)));
        return new JSONObject(content);
    }
}

Esta classe contém um único método static, readJsonObjectFromFile. Um método static pertence à própria classe em vez de a uma instância, portanto, você pode chamá-lo diretamente usando o nome da classe (por exemplo, JsonUtils.readJsonObjectFromFile(...)) sem criar um objeto.

Utilizando a Classe Utilitária

Agora, vamos criar uma classe de aplicação principal que utiliza nossa nova utilitária.

No WebIDE, crie um novo arquivo chamado Main.java dentro do diretório src/main/java/com/labex.
Adicione o seguinte código a Main.java:

package com.labex;

import org.json.JSONObject;

public class Main {
    public static void main(String[] args) {
        try {
            // Usa a classe utilitária para ler o arquivo JSON
            JSONObject data = JsonUtils.readJsonObjectFromFile("src/main/resources/data.json");

            // Agora podemos trabalhar com o JSONObject como antes
            String name = data.getString("name");
            String city = data.getJSONObject("address").getString("city");

            System.out.println("--- Dados lidos usando JsonUtils ---");
            System.out.println("Name: " + name);
            System.out.println("City: " + city);
            System.out.println("\nJSON lido com sucesso usando JsonUtils.");

        } catch (Exception e) {
            System.out.println("Ocorreu um erro: " + e.getMessage());
        }
    }
}

Esta classe Main é muito mais limpa. Ela delega a tarefa de ler e analisar o arquivo para JsonUtils, focando apenas no que fazer com o JSONObject resultante.

Executando a Aplicação Principal

Finalmente, vamos executar nossa classe Main.

Abra o terminal no WebIDE.
Execute o seguinte comando:

mvn compile exec:java -Dexec.mainClass="com.labex.Main"

Você verá a seguinte saída:

--- Data read using JsonUtils ---
Name: John Doe
City: Anytown

Successfully read JSON using JsonUtils.

Ao criar uma classe utilitária, você tornou seu código mais modular e reutilizável, que é um princípio chave da engenharia de software eficaz.

Resumo

Neste laboratório, você adquiriu habilidades práticas para lidar com arquivos JSON em Java. Você progrediu da configuração básica para técnicas avançadas de análise, culminando na criação de código reutilizável.

Aqui está um resumo do que você aprendeu:

Configuração do Projeto: Você aprendeu como estruturar um projeto Maven e incluir bibliotecas externas como org.json para trabalhar com JSON.
Criação de Arquivo JSON: Você criou um arquivo JSON bem formado contendo vários tipos de dados, incluindo strings, números, booleanos, objetos aninhados e arrays.
Leitura de um Caminho Relativo: Você leu com sucesso um arquivo usando um caminho relativo, uma técnica que torna as aplicações mais portáteis.
Análise de JSON: Você usou a biblioteca org.json para analisar strings JSON em objetos JSONObject e JSONArray, permitindo que você acesse os dados programaticamente.
Tratamento de Estruturas Complexas: Você aprendeu como navegar por objetos JSON aninhados e iterar sobre arrays JSON para extrair dados complexos.
Reutilização de Código: Você aplicou o princípio DRY (Don't Repeat Yourself) criando uma classe JsonUtils para encapsular a lógica de leitura de arquivos, resultando em um código mais limpo e de fácil manutenção.

A capacidade de ler, analisar e manipular dados JSON é essencial para qualquer desenvolvedor Java envolvido em serviços web, integração de API ou configuração de aplicações. A base que você construiu neste laboratório será inestimável à medida que você enfrentar desafios de desenvolvimento mais complexos.

Como ler arquivo JSON de um caminho relativo em Java

Introdução

Configuração do Projeto e Criação do Arquivo JSON

Compreendendo a Estrutura do Projeto

Criação do Arquivo de Dados JSON

Leitura e Análise de um Arquivo JSON Simples

Compreendendo Caminhos Relativos

Criação do Leitor JSON Java

Explicação do Código

Compilando e Executando o Programa

Tratamento de Dados JSON Complexos

Criação de um Analisador JSON Complexo

Explicação do Código

Compilando e Executando o Analisador

Criação de uma Utilitária JSON Reutilizável

Criação da Classe JsonUtils

Utilizando a Classe Utilitária

Executando a Aplicação Principal

Resumo

Criação da Classe `JsonUtils`