Max Nagl

TypedJsonAdapter for Moshi

posted in Utils on March 10, 2021

TypedJsonAdapter helps you to parse JSON:API or similar JSON files with type fields.

The Problem

Imaging you have a json file containing list of shapes. The shapes can have different types, like squares and rectangles:

{"shapes": [
        "type": "Square",
        "side": 10
        "type": "Rect",
        "width": 20,
        "height": 5

Now, you want to convert this json to a convinient Java (or Kotlin) class:

interface Shape
data class Square(val side: Int) : Shape
data class Rect(val width: Int, val height: Int) : Shape
data class Shapes(val shapes: List)

You could use moshi to parse the file into a list of Map, and then convert the entries to shape:

data class ShapesMap(val shapes: List Square((it["side"] as Number).toInt())
            "Rect" -> Rect((it["width"] as Number).toInt(), (it["height"] as Number).toInt())
            else -> throw IllegalArgumentException()

This is a lot of work. You also have a lot of casts and probably errors. You may also need to write extra code to write the JSON file from the object. When you want to add a new class you have to adapt the code.

The Solution

A far better solution is the class TypedJsonAdapter. With this class you cann add an @JsonSubClasses annotation to your Shape interface and the adapter will take care of the work.

@JsonSubClasses([Square::class, Rect::class])
interface Shape
data class Square(val side: Int) : Shape
data class Rect(val width: Int, val height: Int) : Shape
data class Shapes(val shapes: List)

You also have to add the factory for the adapter to moshi:


That's it. Now you can start parsing:

val shapesAdapter = moshi.adapter(
val shapes = shapesAdapter.fromJson(shapesJson)
println(shapes) //Prints: Shapes(shapes=[Square(side=10), Rect(width=20, height=5)])

Sealed Classes

TypedJsonAdapter works with sealed classes out of the box.

sealed class SealedShape {
    data class Rect(val width: Int, val height: Int) : SealedShape()
    data class Square(val side: Int) : SealedShape()
data class SealedShapes(val shapes: List)

val sealedAdapter = moshi.adapter(
val sealedShapes = sealedAdapter.fromJson(shapesJson)


There are several parameter you can use to confirue TypedJsonAdapter:

Field Name

You can configure the field name from type to anything you want by adding the fieldName parameter to the annotation:

@JsonSubClasses([Square::class, Rect::class], fieldName = "class")
interface Shape

moshi.adapter("""{"class": "Square", "side": 10},""")

If you want to change the field name for the whole project you can configure the default value in TypedJsonAdapter.Factory.

val factory = TypedJsonAdapter.Factory().apply { fieldName = "class" }
val moshi = Moshi.Builder().add(factory).addLast(KotlinJsonAdapterFactory()).build()

Class Names

Sometimes the names of the Java/Kotlin classes do not match the type values in your JSON file. You have two options to change the type names of you classes.

First you can add an @JsonNamedClass annotation directly to the Java/Kotlin class:

data class Rectangle(val width: Int, val height: Int) : Shape

The other option is to add a JsonNamedSubClass annotations to your JsonSubClasses annotation:

@JsonSubClasses(named = [
    JsonNamedSubClass(Square::class, "square"),
    JsonNamedSubClass(Rectangle::class, "rectangle"),
    JsonNamedSubClass(Rectangle::class, "rect"),
interface Shape

This way you can add multiple type names for one class. Now you can create Recangles by using rectangle or rect.

Qualified Names

When you enable the qualifiedNames flag then every JavaClass can be created using the qualified name:

@JsonSubClasses(qualifiedNames = true)
interface Shape

val shapesAdapter = moshi.adapter(
shapesAdapter.fromJson("""{"type": "", "side": 10}""")

This can easily cause casting exceptions or security problems. Be carefull when using this feature.

The Class

 * Copyright 2021 Max Nagl
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * See the License for the specific language governing permissions and
 * limitations under the License.


import com.squareup.moshi.*
import java.lang.reflect.Modifier
import java.lang.reflect.Type
import kotlin.reflect.KClass

class TypedJsonAdapter(private val moshi: Moshi, var fieldName: String) : JsonAdapter<Any>() {
    var typeClasses: HashMap<String, Class<*>> = HashMap()
    var qualifiedNames: Boolean = false
    var default: Class<*>? = null

    override fun fromJson(reader: JsonReader): Any? {
        reader.peekJson().use { peek ->
            while (peek.hasNext()) {
                if (peek.nextName() == fieldName) return getAdapterForType(peek.nextString()).fromJson(reader)
        default?.let { return moshi.adapter(it).fromJson(reader) }
        throw JsonDataException("Missing type definition.")

    private fun getAdapterForType(type: String): JsonAdapter<*> {
        typeClasses[type]?.let { return moshi.adapter(it) }
        if (qualifiedNames) try {
            return moshi.adapter(Class.forName(type))
        } catch (e: Exception) {
            throw throw JsonDataException("Class not found: $type", e)
        throw JsonDataException("Unknown type $type")

    override fun toJson(writer: JsonWriter, value: Any?) {
        if (value == null) {
        } else {
            val clazz = value.javaClass
            val adapter = moshi.adapter(clazz) ?: throw JsonDataException("Unknown class $clazz")
            val type = typeClasses.entries.firstOrNull { it.value == clazz }?.key
            if (type == null && default != clazz) throw JsonDataException("Unknown class $clazz")
            val flatten = writer.beginFlatten()
            adapter.toJson(writer, value)

    fun addClass(clazz: Class<*>, name: String? = null) {
        if (clazz.isInterface || Modifier.isAbstract(clazz.modifiers)) return
        if (name == null) {
            typeClasses[clazz.getAnnotation( ?: clazz.simpleName] = clazz
        } else typeClasses[name] = clazz

    private fun collect(clazz: Class<*>): TypedJsonAdapter {
        val annotations = clazz.annotations.filterIsInstance(
        if (annotations.any { it.inherit }) {
            clazz.superclass?.let { collect((it)) }
            clazz.interfaces.forEach { collect(it) }
        if (annotations.isEmpty()) {
            clazz.kotlin.sealedSubclasses.forEach { addClass( }

        } else collect(annotations)
        return this

    private fun collect(annotations: Collection<Annotation>): TypedJsonAdapter {
        annotations.forEach {
            if (it is JsonSubClasses) {
                if (it.default != Unit::class) default =
                if (it.qualifiedNames) qualifiedNames = true
                if (it.fieldName.isNotBlank()) fieldName = it.fieldName
                it.classes.forEach { clazz ->
                    if (it.extend) collect(
            if (it is JsonNamedSubClass) {
                if (it.extend) collect(
        return this

    private fun isEmpty() = typeClasses.isEmpty() && !qualifiedNames

    private fun copy() = TypedJsonAdapter(moshi, fieldName).also { copy ->
        copy.typeClasses = HashMap(typeClasses)
        copy.qualifiedNames = qualifiedNames
        copy.default = default

    class Factory : JsonAdapter.Factory {
        private val adapterCache = HashMap<Class<*>, TypedJsonAdapter>()
        var fieldName = "type"

        fun getPrototype(type: Type, moshi: Moshi): TypedJsonAdapter? {
            if (type !is Class<*>) return null
            return adapterCache.getOrPut(type) { TypedJsonAdapter(moshi, fieldName).collect(type) }

        override fun create(type: Type, annotations: Set<Annotation>, moshi: Moshi): JsonAdapter<*>? {
            var typeClasses = getPrototype(type, moshi) ?: return null
            if (typeClasses.isEmpty() && annotations.none { it is JsonSubClasses }) return null
            if (annotations.isNotEmpty()) typeClasses = typeClasses.copy().collect(annotations)
            return typeClasses

@Target(AnnotationTarget.CLASS, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.PROPERTY)
annotation class JsonSubClasses(
        val classes: Array<KClass<*>> = [],
        val named: Array<JsonNamedSubClass> = [],
        val default: KClass<*> = Unit::class,
        val qualifiedNames: Boolean = false,
        val fieldName: String = "",
        val inherit: Boolean = false,
        val extend: Boolean = true)

annotation class JsonNamedSubClass(val clazz: KClass<*>, val name: String, val extend: Boolean = true)

annotation class JsonNamedClass(val name: String)