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()                    
                }
        }

Jacques.S · Answer 1 · 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 12 · Answer 2 · edited Feb 01 '22 at 15:49

12

After Kotlin 1.4.0 released:

use this for converting string to Object:

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

And for your httpClient use:

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

edited Feb 01 '22 at 15:49

sud007

5,824
4
56
63

answered Aug 20 '20 at 10:07

Dr.jacky

3,341
6
53
91

Thanks it worked! So, I am already doing this in Network Layer in for HTTP client but the first one with `decodeFromString` was really helpful as I needed this for a String conversion to model. – sud007 Feb 01 '22 at 15:46

score 11 · Answer 3 · edited Jan 23 '20 at 09:43

11

Figured out - we can pass in constructor:

serializer = KotlinxSerializer(Json.nonstrict)

edited Jan 23 '20 at 09:43

xsveda

17,074
2
16
16

answered Nov 29 '18 at 21:51

Rodion Altshuler

1,713
1
15
31

4

This is deprecated now. – Jacques.S Jun 28 '20 at 13:46
1

form what I see they seem to change the API every 2 days – frankelot Sep 17 '20 at 02:45

score 6 · 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 5 · Answer 5 · answered Oct 12 '19 at 14:43

5

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

answered Oct 12 '19 at 14:43

mochadwi

1,190
9
32
87

2

Json { ignoreUnknownKeys = true }.asConverterFactory(contentType) – Duanniston Cardoso Cabral Dec 08 '21 at 22:52

score 4 · Answer 6 · 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 3 · Answer 7 · 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 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 2 · 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
                    })
                }

score 2 · Answer 10 · answered Jul 27 '22 at 09:00

For ktor 2.0+

        return HttpClient(CIO) {
            engine {
                maxConnectionsCount = 10
            }

            install(ContentNegotiation) {
                json(kotlinx.serialization.json.Json {
                    ignoreUnknownKeys = true
                })
            }

            install(HttpTimeout) {
                requestTimeoutMillis = 1000L
                connectTimeoutMillis = 1000L
                socketTimeoutMillis = 1000L
            }
        }

ktor with kotlinx serialization: how to use JSON.nonstrict

10 Answers10