ktor with kotlinx serialization: how to use JSON.nonstrict

Question

I'm trying to initialize Ktor http client and setup json serialization. I need to allow non-strict deserialization which JSON.nonstrict object allows. Just can't get how to apply this setting to serializer.

 val client = HttpClient {
                install(JsonFeature) {
                    serializer = KotlinxSerializer()                    
                }
        }

score 10 · Answer 1 · edited Jan 23 '20 at 09:43

10

Figured out - we can pass in constructor:

serializer = KotlinxSerializer(Json.nonstrict)

edited Jan 23 '20 at 09:43

xsveda

13,503
2
14
16

answered Nov 29 '18 at 21:51

Rodion Altshuler

1,583
14
29

4

This is deprecated now. – Jacques.S Jun 28 '20 at 13:46
form what I see they seem to change the API every 2 days – FRR Sep 17 '20 at 02:45

Jacques.S · Answer 2 · 2020-09-19T11:43:09.050

You can specify json configurations using the Json builder, which you pass into the KotlinxSerializer.

val client = HttpClient {
    install(JsonFeature) {
        serializer = KotlinxSerializer(Json {
            isLenient = true
            ignoreUnknownKeys = true
        })                    
    }
}

The exact fields for the Json builder is experimental and subject to change, so check out the source code here.

score 4 · Answer 3 · answered Aug 20 '20 at 10:07

After Kotlin 1.4.0 released:

val response = Json {
            ignoreUnknownKeys = true
        }
            .decodeFromString(ResponseObject.serializer(), jsonString)

And you httpClient:

            HttpClient {
                install(JsonFeature) {
                    serializer = KotlinxSerializer()
                }
                install(Logging) {
                    logger = Logger.DEFAULT
                    level = LogLevel.ALL
                }
            }

score 4 · Answer 4 · answered Nov 01 '20 at 20:58

This change very often, but with Kotlin 1.4.10 and Ktor 1.4.1 you need to pass a kotlinx Json (be careful because there is also a io.ktor.client.features.json.Json, I used an import alias to distinguish them because I needed both import kotlinx.serialization.json.Json as KotlinJson)

val client = HttpClient {
    install(JsonFeature) {
        serializer = KotlinxSerializer(KotlinJson { ignoreUnknownKeys = true })
    }
    ...

score 3 · Answer 5 · answered Oct 12 '19 at 14:43

For those who use retrofit, you might want to consider using JsonConfiguration(strictMode = false) on the retrofit builder.

E.g:

// your retrofit builder
Retrofit.Builder()
        .baseUrl(url)
        .client(okHttpClient)
        .client(httpClient)
        .addConverterFactory(
          Json(JsonConfiguration(strictMode = false))
              .asConverterFactory(MediaType.get("application/json")
        )
)

Source: issue on the kotlinx github

score 2 · Answer 6 · answered Feb 21 '20 at 15:00

Working from Rodion Altshuler's answer above, this is what worked for me in my KMP project:

install(JsonFeature) {
    serializer = KotlinxSerializer(kotlinx.serialization.json.Json(JsonConfiguration.Stable.copy(strictMode = false))).apply {
      useDefaultTransformers = true
    }
}

score 2 · Answer 7 · answered Sep 26 '20 at 06:50

With the "1.0.0RC" version, the use with retrofit is as follows.

Retrofit.Builder()
        .client(okHttpClient)
        .baseUrl(Env.BASE_URL)
        .addConverterFactory(Json{
            isLenient = true
            ignoreUnknownKeys = true
        }.asConverterFactory(MediaType.get("application/json")))
        .addCallAdapterFactory(CoroutineCallAdapterFactory())
        .build()

score 1 · Answer 8 · answered Mar 22 '21 at 17:56

This is how you can configure the JsonConfig for the Spring reactive Webclient:



val json = Json { ignoreUnknownKeys = true isLenient = true }

val strategies = ExchangeStrategies
    .builder()
    .codecs { clientDefaultCodecsConfigurer ->
        run {
            clientDefaultCodecsConfigurer.defaultCodecs()
                .kotlinSerializationJsonDecoder(KotlinSerializationJsonDecoder(json))
            clientDefaultCodecsConfigurer.defaultCodecs()
                .kotlinSerializationJsonEncoder(KotlinSerializationJsonEncoder(json))

        }
    }.build()

return WebClient
    .builder()
    .exchangeStrategies(strategies)
    .baseUrl(baseUrl!!)
    .build()

score 1 · Answer 9 · answered Apr 13 '21 at 22:37

It seems that for 1.4.32 I have it as follows:

install(JsonFeature) {
                    serializer = KotlinxSerializer(json = kotlinx.serialization.json.Json {
                        isLenient = true
                        ignoreUnknownKeys = true
                    })
                }

ktor with kotlinx serialization: how to use JSON.nonstrict

9 Answers9