Gson — vad är det, JSON-bibliotek för Java och Kotlin

Vad är Gson

Gson — är ett Java-bibliotek utvecklat av Google för att konvertera objekt till JSON-representation och tillbaka. Det använder reflektion för att analysera klassernas struktur, vilket möjliggör arbete utan förkonfiguration. Gson stöder godtyckliga Java-objekt, samlingar, arrayer, generics och nästlade klasser. Biblioteket kräver inga annotationer för grundläggande användning, men tillhandahåller dem för finjustering. Den största nackdelen med reflektion är minskad prestanda vid initiering och omöjlighet att optimera vid kompilering, vilket är särskilt märkbart vid kallstart av en Android-applikation vid deserialisering av hundratals modeller. Trots detta förblir Gson ett pålitligt val för de flesta projekt tack vare stabilitet och omfattande dokumentation.

Historia och plats i ekosystemet

Gson släpptes av Google 2008 och blev snabbt de facto-standard för JSON i Android-applikationer. Innan Moshi och kotlinx.serialization kom förblev Gson det enda populära valet för Kotlin-projekt. Enkel anslutning — att lägga till ett beroende i build.gradle — och avsaknaden av obligatoriska annotationer gjorde Gson populärt bland utvecklare på alla nivåer.

// Lägga till Gson i build.gradle
dependencies {
    implementation 'com.google.code.gson:gson:2.10.1'
}

// Grundläggande användning
data class User(
    val id: Int,
    val name: String,
    val email: String
)

val gson = Gson()
val user = User(1, "John", "john@test.com")
val json = gson.toJson(user)
println(json) // {"id":1,"name":"John","email":"john@test.com"}

Förutom grundläggande serialisering tillhandahåller Gson GsonBuilder för att konfigurera beteende: datumformatering, inaktivering av HTML-escaping, nyckelregister och anpassade instanser. GsonBuilder tillåter också registrering av anpassade JsonSerializer och JsonDeserializer för typer som biblioteket inte kan bearbeta automatiskt. Flexibiliteten i konfigurationen gör GsonBuilder till ett oumbärligt och användbart verktyg när man anpassar biblioteket till specifika projektkrav inom modern Android-utveckling.

Grundläggande operationer toJson och fromJson

toJson konverterar ett Java-objekt till en JSON-sträng genom att analysera dess fält via reflektion. Som standard inkluderar Gson alla fält utom transient och static. Metoden stöder alla typer: primitiver, objekt, samlingar och arrayer. fromJson utför omvänd konvertering, tar emot en JSON-sträng och klass för målobjektet, och returnerar en instans med ifyllda fält.

Konvertera objekt till JSON

Vid serialisering går Gson rekursivt igenom alla fält i objektet, inklusive nästlade. Cirkulära referenser leder till StackOverflowError, så de måste uteslutas via @Expose-annotationen eller en anpassad adapter. För samlingar bevarar Gson elementens typ, men vid deserialisering av en lista med generics krävs TypeToken för att bevara information om typen.

// data class med nästlat objekt
data class Address(
    val city: String,
    val street: String
)

data class Employee(
    val id: Int,
    val name: String,
    val address: Address
)

val gson = Gson()
val employee = Employee(1, "Alice",
    Address("New York", "5th Ave"))

// Serialisering till JSON
val json = gson.toJson(employee)

// Deserialisering från JSON
val jsonString = """
{"id":2,"name":"Bob","address":{"city":"London","street":"Baker St"}}
"""
val parsed = gson.fromJson(jsonString, Employee::class.java)

Annotationer och konfiguration

Gson tillhandahåller en uppsättning annotationer för att hantera serialiseringsprocessen. @SerializedName anger namnet på JSON-nyckeln som skiljer sig från fältnamnet. @Expose hanterar inkludering av fältet i serialisering: Gson skapat via GsonBuilder.excludeFieldsWithoutExposeAnnotation() kommer endast att bearbeta fält med @Expose. @Since och @Until styr versionshantering av fält.

@SerializedName och @Expose

Annotationen @SerializedName löser problemet med namnmismatch: servern kan använda snake_case, medan camelCase används i koden. Annotationen accepterar ett värde och valfria alternativ för bakåtkompatibilitet. @Expose gör det möjligt att dölja känsliga fält (lösenord, token) från serialisering genom att markera dem som @Expose(serialize = false). Förutom inkludering och exkludering kan @Expose kombineras med GsonBuilder.excludeFieldsWithoutExposeAnnotation för att skapa en vitlista över fält, vilket hjälper till att kontrollera attackytan vid serialisering av objekt med många fält.

// Modell med Gson-annotationer
data class UserResponse(
    @SerializedName("user_id")
    val userId: Int,

    @SerializedName("full_name",
        alternate = [Alternative("name")])
    val fullName: String,

    @Expose(serialize = false)
    val password: String
)

// Gson med @Expose-filter
val gson = GsonBuilder()
    .excludeFieldsWithoutExposeAnnotation()
    .setPrettyPrinting()
    .create()

val user = UserResponse(1, "John", "secret123")
println(gson.toJson(user))
// {"user_id":1,"full_name":"John"} — password excluded

Arbete med generics

Problemet med generics i Java och Kotlin ligger i att typer raderas under kompilering. När Gson deserialiserar List<User> känner det inte till elementets typ och returnerar List<Map<String, Any>>. För att bevara information om typen tillhandahåller Gson TypeToken — en abstrakt klass som fångar typparametern via en anonym klass. Utan TypeToken skulle utvecklaren manuellt behöva konvertera varje element från Map till måltypen, vilket leder till omfattande kod och prestandaförlust.

TypeToken för listor

TypeToken löser problemet med typradering. Utvecklaren skapar en anonym ättling till TypeToken med önskad typparameter, och Gson använder informationen från klassignaturen för korrekt deserialisering. TypeToken fungerar också med Map, Set och alla andra parametriserade typer, inklusive nästlade generics. Speciellt för Map<String, List<User>> krävs en TypeToken med fullständig signatur av den nästlade typen, annars deserialiserar Gson värdena som List<Map<String, Any>> istället för List<User>.

// TypeToken för deserialisering av lista
data class Product(
    val id: Int,
    val title: String,
    val price: Double
)

val jsonArray = """
[
    {"id":1,"title":"Phone","price":599.0},
    {"id":2,"title":"Laptop","price":1299.0}
]
"""

val gson = Gson()
val listType = object : TypeToken<List<Product>>() {}
val products: List<Product> =
    gson.fromJson(jsonArray, listType.type)

// Anpassad deserialiserare
class LocalDateAdapter :
    JsonDeserializer<LocalDate> {

    override fun deserialize(
        json: JsonElement,
        typeOfT: java.lang.reflect.Type,
        context: JsonDeserializationContext
    ): LocalDate {
        return LocalDate.parse(json.asString)
    }
}

För anpassad serialiseringslogik stöder Gson gränssnitten JsonSerializer och JsonDeserializer. De registreras via GsonBuilder.registerTypeAdapter() och möjliggör bearbetning av typer som biblioteket inte kan serialisera automatiskt: Java 8-datum, Enum med icke-standardvärden eller tredjepartsklasser utan tillgång till källkod. Vid implementering av en adapter är det viktigt att övervaka prestanda: anrop av reflektion inuti en anpassad adapter upphäver fördelarna med manuell hantering, därför föredras direkta anrop av metoder och fält. I Gson-ekosystemet finns också modulen gson-extras som tillhandahåller adaptrar för vanliga typer som UUID, Optional och Joda-Time-datumtyper.

Konfiguration via GsonBuilder

GsonBuilder tillhandahåller dussintals metoder för finjustering av serialisering. setPrettyPrinting lägger till indrag och nya rader i utdata-JSON för läsbarhet. disableHtmlEscaping inaktiverar escapning av HTML-tecken i strängar. setDateFormat ställer in datumformat, vilket är kritiskt vid arbete med servrar som använder icke-standard tidsrepresentation. setLenient aktiverar ett tolerant parsningsläge som ignorerar vissa JSON-formateringsfel. addDeserializationExclusionStrategy möjliggör programmatisk uteslutning av fält från deserialisering baserat på anpassade strategier. För felsökning är metoden setPrettyPrinting användbar i kombination med loggning — den gör JSON-svar läsbara i loggar och förenklar sökning efter avvikelser.

En viktig funktion hos GsonBuilder är hantering av fältversionshantering via @Since- och @Until-annotationerna. Utvecklaren anger objektversionen via setVersion, och Gson inkluderar eller utesluter automatiskt fält beroende på deras versionsannotation. Detta är användbart vid API-evolution, när samma modell används för olika versioner av serverprotokollet. GsonBuilder stöder också registrering av TypeAdapterFactory för global bearbetning av typfamiljer och complexMapKeySerialization för korrekt arbete med komplexa Map-nycklar.