{"id":278,"date":"2026-09-28T15:45:00","date_gmt":"2026-09-28T13:45:00","guid":{"rendered":"https:\/\/grindloop.io\/blog\/?p=278"},"modified":"2026-09-27T16:41:02","modified_gmt":"2026-09-27T14:41:02","slug":"gson-null-fields-release-build","status":"publish","type":"post","link":"https:\/\/grindloop.ai\/blog\/gson-null-fields-release-build\/","title":{"rendered":"Why Gson Returns Null Fields Only in Your Release Build"},"content":{"rendered":"

Seeing Gson null fields only in the release build? If the model is a Kotlin data class, there are usually two problems stacked together. The first is R8. Gson finds fields by reflection. R8 renames or strips anything no keep rule protects. Since AGP 8.0, R8 runs in full mode by default. Full mode can also remove the class’s constructor and mark the class abstract. The second problem exists in debug too. That’s what makes the first one confusing. When a Kotlin class has no no-args constructor, Gson never calls your constructor at all. It allocates the object through JDK Unsafe<\/code>. Kotlin’s null checks and default values never run. A property typed String<\/code> can end up holding null<\/code>. Parsing succeeds. The crash lands later, wherever the field is first read. Adding @SerializedName<\/code> fixes the first bug but not the second. The fix has to cover both.<\/p>\n\n

A UserApi<\/code> returns the signed-in user from \/me<\/code> through Retrofit’s Gson converter. Everything works on the emulator. QA installs the release build. The profile screen crashes with a NullPointerException<\/code> on user.name.length<\/code>. But name<\/code> is declared as a non-null String<\/code>. The JSON on the wire is fine. What’s wrong?<\/p><\/blockquote>\n\n\n

data class User(\n    val id: Long,\n    val name: String,\n    val role: String = \"member\",\n)\n\ninterface UserApi {\n    @GET(\"me\")\n    suspend fun me(): User\n}\n\n\/\/ Retrofit.Builder()\n\/\/     .baseUrl(BASE_URL)\n\/\/     .addConverterFactory(GsonConverterFactory.create())\n\/\/     .build()<\/pre>\n\n\n
The response body is {\"id\": 42, \"name\": \"Arsam\"}<\/code>. There’s no role<\/code> key. That’s why the class gives it a default.<\/p>\n\n
Gson null fields start in the debug build<\/h2>\n\n
Start with debug, where R8 doesn’t run. Gson still skips the constructor, for reasons covered below. So role<\/code> comes back null<\/code>, not \"member\"<\/code>. That’s despite it being a non-null String<\/code> with a default. We ran this model through Gson 2.11.0 on the JVM and got User(id=42, name=Arsam, role=null)<\/code>. Nobody notices because the UI never reads role<\/code> on that screen. That’s the second bug, sitting in debug the whole time. Release is where the first bug arrives and turns it into a crash.<\/p>\n\n
Bug 1: R8 can’t see reflection, so it renames or deletes what Gson needs<\/h2>\n\n
Gson maps JSON keys to Java field names at runtime. R8 works at build time. Nothing in your code reads User.name<\/code> by that literal name. So R8 treats the name as free to change. Gson’s troubleshooting guide<\/a> describes the symptom. The app works in debug but fails in release. The fields end up with short random names like a<\/code> and b<\/code>. Once name<\/code> becomes b<\/code>, no JSON key matches it. Gson leaves every field at its JVM default. That’s 0<\/code> for the Long<\/code> and null<\/code> for both strings. R8’s compatibility mode stops here.<\/p>\n\n
Full mode goes further. The Android developer docs<\/a> confirm it. “R8 full mode has been the default since Android Gradle Plugin (AGP) 8.0.” The R8 compatibility FAQ<\/a> lists what changes. Keeping a class no longer keeps its default constructor. Classes created only through reflection need their own explicit keep rule. Only Gson ever creates User<\/code>. So from R8’s point of view, no code instantiates it. Gson’s guide names the result<\/a>. R8 can remove the no-args constructor and make the class abstract. Gson then refuses to build an abstract class. It throws a JsonIOException<\/code> that starts “Abstract classes can’t be instantiated!”<\/p>\n\n
That loud failure is the better outcome. The quiet one is where most people end up after their first search. They add -keep class User<\/code> and the crash goes away. Then the fields are all null<\/code>. A -keep<\/code> rule with no member block keeps the class, not its fields. The fields still get renamed.<\/p>\n\n
Bug 2: Gson never calls your Kotlin constructor<\/h2>\n\n
The second bug explains why the release failure is an NPE on a non-null type. You’d expect a clear parse error instead. A Kotlin constructor is where non-null parameters get checked. The Kotlin interop docs<\/a> cover this. Public functions that take non-null parameters get runtime null checks. If Gson called User(0, null, null)<\/code>, it would fail right there.<\/p>\n\n
Gson doesn’t call it. User<\/code> has no no-args constructor. Kotlin only generates one when every primary-constructor parameter has a default<\/a>. Here, id<\/code> and name<\/code> don’t. Gson’s guide describes the fallback<\/a>. When it can’t call a constructor, Gson “falls back to JDK Unsafe<\/code>.” The object is created without running the constructor or any initializers. Gson then writes whatever fields it can match into that raw object and returns it.<\/p>\n\n
Nothing ever enforces the non-null type on name<\/code>. The getter returns the field as-is. The first code that dereferences it throws, far from the parser. In debug, the only visible damage is role<\/code> losing its default. In release, R8 has also broken the name mapping. Every field goes null. The crash surfaces on whichever screen reads one first. The Gson report on Kotlin null-safety and default values<\/a> was filed in February 2020. It’s still open.<\/p>\n\n
Why @SerializedName<\/code> alone only fixes half<\/h2>\n\n
Since Gson 2.11.0<\/a> in May 2024, the Gson jar ships its own R8 rules. The release notes say you may need no extra config at all. That holds only if your classes have a no-args constructor and use @SerializedName<\/code>. The bundled rules file<\/a> keeps every field annotated with @SerializedName<\/code>. R8 may still rename the field. That no longer matters, because the annotation carries the JSON name. The file handles the constructor with a conditional rule. A class needs @SerializedName<\/code> fields and an existing no-args constructor. Only then does R8 keep that constructor.<\/p>\n\n
That rule has two conditions. The broken User<\/code> meets only one. Annotate the fields and the JSON mapping stops depending on the names R8 picks. So id<\/code> and name<\/code> parse correctly. But User<\/code> still has no no-args constructor. Gson still goes through Unsafe<\/code>. role<\/code> is still null<\/code>. The release crash disappears. The debug bug ships to production.<\/p>\n\n
The fix<\/h2>\n\n
If the project stays on Gson, fix both conditions in the model. Then make the Unsafe<\/code> fallback fail loudly instead of quietly.<\/p>\n\n\n
data class User(\n    @SerializedName(\"id\") val id: Long = 0,\n    @SerializedName(\"name\") val name: String = \"\",\n    @SerializedName(\"role\") val role: String = \"member\",\n)\n\nval gson = GsonBuilder()\n    .disableJdkUnsafe()\n    .create()<\/pre>\n\n\n
@SerializedName<\/code> lets Gson’s bundled rules keep the fields. The defaults give Kotlin a reason to generate a no-args constructor. That constructor is exactly what the bundled -if<\/code> rule keeps. With it, our JVM run returned role=member<\/code>. Gson’s own guide suggests disableJdkUnsafe()<\/code><\/a> to catch this early. Someone may later add a data class without defaults. It will then fail in a debug build with JsonIOException: Unable to create instance of class User; usage of JDK Unsafe is disabled<\/code>. It won’t wait for production. Gson versions older than 2.11.0 have no bundled rules. There you need the R8 FAQ’s -keepclassmembers<\/code> rule<\/a> yourself.<\/p>\n\n
The defaults have a cost. A default on name<\/code> means a response missing name<\/code> now parses as \"\"<\/code>. It no longer fails. That hides a broken response.<\/p>\n\n
The longer-term fix is to stop using a reflection-based parser for Android models. Gson’s troubleshooting guide<\/a> says “Gson is not recommended on Android due to the expectation of R8 optimization.” The Android full-mode docs<\/a> agree. “Avoid using Gson as it relies heavily on reflection.” kotlinx.serialization generates the serializer at compile time. There’s no field name for R8 to break and no constructor to skip.<\/p>\n\n\n
@Serializable\ndata class User(\n    val id: Long,\n    val name: String,\n    val role: String = \"member\",\n)\n\nval json = Json { ignoreUnknownKeys = true }\n\njson.decodeFromString<User>(\"\"\"{\"id\": 42, \"name\": \"Arsam\"}\"\"\")\n\/\/ User(id=42, name=Arsam, role=member)\n\njson.decodeFromString<User>(\"\"\"{\"id\": 42}\"\"\")\n\/\/ MissingFieldException: Field 'name' is required for type with serial name 'User',\n\/\/ but it was missing at path: $<\/pre>\n\n\n
A missing required field fails at parse time. A missing optional one gets its declared default. The kotlinx.serialization guide<\/a> covers both under optional and required properties. On the Retrofit side, the change is swapping the converter factory.<\/p>\n\n
The rule to remember<\/h2>\n\n
With a reflection-based parser, R8 decides whether your field names survive. Whether the constructor runs decides whether your null-safety does.<\/strong><\/p>\n\n