Converti stringa in oggetto JSON in Java

Per utilizzare testo JSON in Java, analizzalo con una libreria JSON. L’analisi produce un albero JSON specifico della libreria che puoi ispezionare dinamicamente; la mappatura del testo su una classe Java produce invece un oggetto tipizzato. Le tre opzioni qui presentate sono org.json, Gson e Jackson. Ognuna richiede la propria dipendenza. Scegli un albero quando vuoi ispezionare i campi dinamicamente, oppure mappa il testo su una classe Java quando la forma dei dati è nota e i campi tipizzati sono utili.

Usa JSONObject per convertire una stringa in un oggetto JSON in Java

La libreria JSON-java (org.json) analizza una stringa oggetto con new JSONObject(json). Per Maven, aggiungi org.json:json:20201115 all’interno dell’elemento <dependencies> di pom.xml. Il costruttore restituisce un JSONObject; leggi i membri stringa e interi con getString("name") e getInt("age"). Queste chiamate restituiscono valori Java, mentre il JSONObject rimane la rappresentazione in memoria dell’oggetto JSON propria della libreria. Recupera i membri per chiave, perché l’ordine dei membri di un oggetto non è una proprietà semantica affidabile.

L’esempio completo qui sotto usa new JSONObject(json) per analizzare l’esempio condiviso {"name":"John","age":30}, legge e stampa entrambi i campi e gestisce JSONException:

import org.json.JSONException;
import org.json.JSONObject;

public class StringToJsonObjectWithJsonOrg {
    public static void main(String[] args) {
        String json = "{\"name\":\"John\",\"age\":30}";
        try {
            JSONObject object = new JSONObject(json);
            System.out.println("name: " + object.getString("name"));
            System.out.println("age: " + object.getInt("age"));
        } catch (JSONException e) {
            System.err.println("Invalid JSON: " + e.getMessage());
        }
    }
}

name: John
age: 30

A confronto, anche l’esempio qui sotto, che utilizza solo il JDK, estrae i due campi dell’esempio e ne stampa i valori, usando solo un’espressione regolare. È limitato a questa forma di input piatta; non analizza né convalida JSON generale. L’input è dichiarato in main, quindi salva lo snippet come StringToJsonObject.java e compilalo con un JDK.

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringToJsonObject {
    public static void main(String[] args) {
        String json = "{\"name\":\"John\",\"age\":30}";
        Pattern field = Pattern.compile("\\\"(name|age)\\\"\\s*:\\s*(?:\\\"([^\\\"]*)\\\"|(\\d+))");
        Matcher matcher = field.matcher(json);
        Map<String, String> values = new LinkedHashMap<>();
        while (matcher.find()) {
            String value = matcher.group(2) != null ? matcher.group(2) : matcher.group(3);
            values.put(matcher.group(1), value);
        }
        System.out.println("name: " + values.get("name"));
        System.out.println("age: " + values.get("age"));
    }
}

name: John
age: 30

Questa espressione regolare copre solo i membri stringa e interi mostrati. Non convalida la sintassi JSON e non gestisce correttamente virgolette con escape, strutture nidificate, array o altri valori JSON. Usa JSONObject o un altro parser per l’input dell’applicazione e verifica che i membri richiesti esistano e abbiano i tipi previsti prima di leggerli. Cattura JSONException intorno all’analisi e alle letture tipizzate, in modo che il chiamante possa segnalare un errore di analisi o di accesso a un valore, o riprendersi da esso.

Usa Google Gson per convertire una stringa in un oggetto JSON in Java

Gson può analizzare il testo in un albero JSON oppure mapparlo direttamente su una classe Java. Per ispezionare i campi senza definire una classe, aggiungi com.google.code.gson:gson:2.8.6 all’interno dell’elemento <dependencies> di Maven. Analizza un albero con JsonParser.parseString(json).getAsJsonObject(), quindi leggi i membri con object.get("name").getAsString() e object.get("age").getAsInt(). Questo restituisce un albero JsonObject, non un’istanza di una classe di dominio.

L’esempio completo qui sotto analizza lo stesso esempio in un JsonObject, legge e stampa entrambi i campi e gestisce gli errori di analisi:

import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonParser;

public class StringToJsonObjectWithGson {
    public static void main(String[] args) {
        String json = "{\"name\":\"John\",\"age\":30}";
        try {
            JsonObject object = JsonParser.parseString(json).getAsJsonObject();
            System.out.println("name: " + object.get("name").getAsString());
            System.out.println("age: " + object.get("age").getAsInt());
        } catch (JsonParseException | IllegalStateException e) {
            System.err.println("Invalid JSON: " + e.getMessage());
        }
    }
}

name: John
age: 30

Se i dati hanno una forma nota e i campi tipizzati sono utili, definisci una classe User con i campi String name e int age, quindi chiama new Gson().fromJson(json, User.class) per produrre un User. Per serializzare quell’istanza di nuovo in testo JSON, chiama new Gson().toJson(user). GsonBuilder.setPrettyPrinting() configura la formattazione durante la serializzazione; non cambia l’albero analizzato né il valore Java. Gestisci JsonParseException per i problemi di analisi, quindi convalida i campi richiesti, perché un JSON valido può comunque omettere dati di cui il tuo programma ha bisogno.

Usa Jackson per convertire una stringa in un oggetto JSON

Il modello ad albero di Jackson è utile quando devi selezionare i campi dinamicamente. Aggiungi com.fasterxml.jackson.core:jackson-databind:2.11.3 all’interno dell’elemento <dependencies> di Maven. L’artefatto jackson-databind fornisce l’API ad albero ObjectMapper e porta con sé Jackson core come dipendenza. Chiama new ObjectMapper().readTree(json) per analizzare il testo in un JsonNode, la rappresentazione ad albero JSON di Jackson. Leggi i valori dell’esempio con node.get("name").asText() e node.get("age").asInt(); usa il membro corrispondente per ogni valore.

L’esempio completo qui sotto usa ObjectMapper.readTree(json), legge e stampa entrambi i campi e gestisce l’eccezione controllata JsonProcessingException:

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class StringToJsonObjectWithJackson {
    public static void main(String[] args) {
        String json = "{\"name\":\"John\",\"age\":30}";
        try {
            JsonNode node = new ObjectMapper().readTree(json);
            System.out.println("name: " + node.get("name").asText());
            System.out.println("age: " + node.get("age").asInt());
        } catch (JsonProcessingException e) {
            System.err.println("Invalid JSON: " + e.getMessage());
        }
    }
}

name: John
age: 30

readTree può sollevare l’eccezione controllata JsonProcessingException, quindi gestiscila dove avviene l’analisi. Verifica inoltre che ogni nodo richiesto esista e abbia il tipo previsto prima di usare accessori comodi come asText() o asInt(). In caso contrario, un membro mancante o di tipo diverso può produrre un valore non adatto all’applicazione, anche quando il documento JSON stesso è stato analizzato correttamente.

Tutte e tre le librerie analizzano testo JSON, ma i loro tipi di albero e le loro API differiscono: JSONObject, JsonObject e JsonNode. Un documento malformato fallisce durante l’analisi, e la classe e il messaggio dell’eccezione dipendono dalla libreria scelta. La sola analisi non garantisce che i campi richiesti siano presenti né che i valori abbiano i tipi che la tua applicazione si aspetta, quindi convalidali prima dell’uso. L’esempio con espressione regolare che usa solo il JDK è limitato all’esempio piatto mostrato; usa una delle API di libreria con dipendenza per l’input JSON generale.