Gson Serialization Cookbook

In questo articolo esamineremo gli scenari più comuni di serializzazione utilizzando la libreria Gson.

Iniziamo introducendo una semplice entità che useremo nei seguenti esempi:

public class SourceClass { private int intValue; private String stringValue; // standard getters and setters }

1. Serializzare un array di entità

Per prima cosa, serializziamo un array di oggetti con Gson:

@Test public void givenArrayOfObjects_whenSerializing_thenCorrect() { SourceClass[] sourceArray = {new SourceClass(1, "one"), new SourceClass(2, "two")}; String jsonString = new Gson().toJson(sourceArray); String expectedResult = "[{"intValue":1,"stringValue":"one"},{"intValue":2,"stringValue":"two"}]"; assertEquals(expectedResult, jsonString); }

2. Serializzare una raccolta di entità

Successivamente, facciamo lo stesso per una raccolta di oggetti:

@Test public void givenCollection_whenSerializing_thenCorrect() { Collection sourceCollection = Lists.newArrayList(new SourceClass(1, "one"), new SourceClass(2, "two")); String jsonCollection = new Gson().toJson(sourceCollection); String expectedResult = "[{"intValue":1,"stringValue":"one"},{"intValue":2,"stringValue":"two"}]"; assertEquals(expectedResult, jsonCollection); }

3. Modificare i nomi dei campi di un'entità durante la serializzazione

Successivamente, vediamo come possiamo modificare il nome del campo quando serializziamo un'entità.

Serializzeremo la nostra entità, contenente i campi intValue e stringValue in un json con otherIntValue e otherStringValue :

@Test public void givenUsingCustomSerializer_whenChangingNameOfFieldOnSerializing_thenCorrect() { SourceClass sourceObject = new SourceClass(7, "seven"); GsonBuilder gsonBuildr = new GsonBuilder(); gsonBuildr.registerTypeAdapter(SourceClass.class, new DifferentNameSerializer()); String jsonString = gsonBuildr.create().toJson(sourceObject); String expectedResult = "{"otherIntValue":7,"otherStringValue":"seven"}"; assertEquals(expectedResult, jsonString); }

Nota che stiamo usando un serializzatore personalizzato qui per cambiare il nome dei nostri campi:

public class DifferentNameSerializer implements JsonSerializer { @Override public JsonElement serialize (SourceClass src, Type typeOfSrc, JsonSerializationContext context) { String otherIntValueName = "otherIntValue"; String otherStringValueName = "otherStringValue"; JsonObject jObject = new JsonObject(); jObject.addProperty(otherIntValueName, src.getIntValue()); jObject.addProperty(otherStringValueName, src.getStringValue()); return jObject; } }

4. Ignorare un campo durante la serializzazione di un'entità

Ignoriamo ora completamente un campo quando si esegue la serializzazione:

@Test public void givenIgnoringAField_whenSerializingWithCustomSerializer_thenFieldIgnored() { SourceClass sourceObject = new SourceClass(7, "seven"); GsonBuilder gsonBuildr = new GsonBuilder(); gsonBuildr.registerTypeAdapter(SourceClass.class, new IgnoringFieldsSerializer()); String jsonString = gsonBuildr.create().toJson(sourceObject); String expectedResult = "{"intValue":7}"; assertEquals(expectedResult, jsonString); }

In modo simile all'esempio precedente, anche qui stiamo usando un serializzatore personalizzato:

public class IgnoringFieldsSerializer implements JsonSerializer { @Override public JsonElement serialize (SourceClass src, Type typeOfSrc, JsonSerializationContext context) { String intValue = "intValue"; JsonObject jObject = new JsonObject(); jObject.addProperty(intValue, src.getIntValue()); return jObject; } }

Si noti inoltre che molto probabilmente è necessario farlo nei casi in cui non è possibile modificare il codice sorgente dell'entità o se il campo deve essere ignorato solo in casi molto specifici. Altrimenti possiamo ignorare il campo più facilmente con un'annotazione diretta sulla classe entità.

5. Serializzare un campo solo se soddisfa una condizione personalizzata

Infine, analizziamo un caso d'uso più avanzato: vogliamo serializzare un campo solo se supera una specifica condizione personalizzata.

Ad esempio, serializziamo solo il valore int se è positivo e saltiamo semplicemente se è negativo:

@Test public void givenUsingCustomDeserializer_whenFieldNotMatchesCriteria_thenIgnored() { SourceClass sourceObject = new SourceClass(-1, "minus 1"); GsonBuilder gsonBuildr = new GsonBuilder(); gsonBuildr.registerTypeAdapter(SourceClass.class, new IgnoringFieldsNotMatchingCriteriaSerializer()); Gson gson = gsonBuildr.create(); Type sourceObjectType = new TypeToken() {}.getType(); String jsonString = gson.toJson(sourceObject, sourceObjectType); String expectedResult = "{"stringValue":"minus 1"}"; assertEquals(expectedResult, jsonString); }

Ovviamente stiamo usando anche un serializzatore personalizzato qui:

public class IgnoringFieldsNotMatchingCriteriaSerializer implements JsonSerializer { @Override public JsonElement serialize (SourceClass src, Type typeOfSrc, JsonSerializationContext context) { JsonObject jObject = new JsonObject(); // Criteria: intValue >= 0 if (src.getIntValue() >= 0) { String intValue = "intValue"; jObject.addProperty(intValue, src.getIntValue()); } String stringValue = "stringValue"; jObject.addProperty(stringValue, src.getStringValue()); return jObject; } }

E questo è tutto: 5 casi d'uso comuni di serializzazione con Gson .