Sto ricevendo una stringa di oggetto JSON abbastanza profonda da un servizio che devo analizzare in un oggetto JSON e quindi mapparlo alle classi.

Come posso trasformare una stringa JSON in oggetto in Kotlin?

Dopo la mappatura alle rispettive classi, stavo usando StdDeserializer di Jackson. Il problema sorge nel momento in cui l'oggetto aveva proprietà che dovevano essere deserializzate in classi. Non sono riuscito a ottenere il mappatore di oggetti, almeno non sapevo come, all'interno di un altro deserializzatore.

Grazie in anticipo per qualsiasi aiuto. Preferibilmente, in modo nativo, sto cercando di ridurre il numero di dipendenze di cui ho bisogno, quindi se la risposta è solo per la manipolazione e l'analisi JSON sarebbe sufficiente.

Puoi usare questa libreria https://github.com/cbeust/klaxon

Klaxon è una libreria leggera per analizzare JSON in Kotlin.

Non c'è dubbio che il futuro dell'analisi in Kotlin sarà con kotlinx.serialization. Fa parte delle librerie Kotlin. È ancora al momento della scrittura in fase di incubazione.

https://github.com/Kotlin/kotlinx.serialization

import kotlinx.serialization.*
import kotlinx.serialization.json.JSON

@Serializable
data class MyModel(val a: Int, @Optional val b: String = "42")

fun main(args: Array<String>) {

    // serializing objects
    val jsonData = JSON.stringify(MyModel.serializer(), MyModel(42))
    println(jsonData) // {"a": 42, "b": "42"}

    // serializing lists
    val jsonList = JSON.stringify(MyModel.serializer().list, listOf(MyModel(42)))
    println(jsonList) // [{"a": 42, "b": "42"}]

    // parsing data back
    val obj = JSON.parse(MyModel.serializer(), """{"a":42}""")
    println(obj) // MyModel(a=42, b="42")
}

Senza libreria esterna (su Android)

Per analizzarlo:

val jsonString = """
    {
       "type":"Foo",
       "data":[
          {
             "id":1,
             "title":"Hello"
          },
          {
             "id":2,
             "title":"World"
          }
       ]
    }        
"""

Usa queste classi:

import org.json.JSONObject

class Response(json: String) : JSONObject(json) {
    val type: String? = this.optString("type")
    val data = this.optJSONArray("data")
            ?.let { 0.until(it.length()).map { i -> it.optJSONObject(i) } } // returns an array of JSONObject
            ?.map { Foo(it.toString()) } // transforms each JSONObject of the array into Foo
}

class Foo(json: String) : JSONObject(json) {
    val id = this.optInt("id")
    val title: String? = this.optString("title")
}

Uso:

val foos = Response(jsonString)

Puoi usare Gson.

Esempio

Passo 1

Aggiungi compile

compile 'com.google.code.gson:gson:2.8.2'

Passo 2

Converti json in Kotlin Bean(usa JsonToKotlinClass )

Come questo

Json dati

{
"timestamp": "2018-02-13 15:45:45",
"code": "OK",
"message": "user info",
"path": "/user/info",
"data": {
    "userId": 8,
    "avatar": "/uploads/image/20180115/1516009286213053126.jpeg",
    "nickname": "",
    "gender": 0,
    "birthday": 1525968000000,
    "age": 0,
    "province": "",
    "city": "",
    "district": "",
    "workStatus": "Student",
    "userType": 0
},
"errorDetail": null
}

Kotlin Bean

class MineUserEntity {

    data class MineUserInfo(
        val timestamp: String,
        val code: String,
        val message: String,
        val path: String,
        val data: Data,
        val errorDetail: Any
    )

    data class Data(
        val userId: Int,
        val avatar: String,
        val nickname: String,
        val gender: Int,
        val birthday: Long,
        val age: Int,
        val province: String,
        val city: String,
        val district: String,
        val workStatus: String,
        val userType: Int
    )
}

Passaggio 3

Uso Gson

var gson = Gson()
var mMineUserEntity = gson?.fromJson(response, MineUserEntity.MineUserInfo::class.java)

Non sono sicuro che questo sia ciò di cui hai bisogno, ma è così che l'ho fatto.

Utilizzando import org.json.JSONObject:

    val jsonObj = JSONObject(json.substring(json.indexOf("{"), json.lastIndexOf("}") + 1))
    val foodJson = jsonObj.getJSONArray("Foods")
    for (i in 0..foodJson!!.length() - 1) {
        val categories = FoodCategoryObject()
        val name = foodJson.getJSONObject(i).getString("FoodName")
        categories.name = name
    }

Ecco un esempio del json:

{"Foods": [{"FoodName": "Apples", "Weight": "110"}]}

Personalmente uso il modulo Jackson per Kotlin che puoi trovare qui: jackson-module-kotlin .

implementation "com.fasterxml.jackson.module:jackson-module-kotlin:$version"

Ad esempio, ecco il codice per analizzare il JSON dello skilltree Path of Exile che è piuttosto pesante (84k righe quando formattato):

Codice Kotlin:

package util

import com.fasterxml.jackson.databind.DeserializationFeature
import com.fasterxml.jackson.module.kotlin.*
import java.io.File

data class SkillTreeData( val characterData: Map<String, CharacterData>, val groups: Map<String, Group>, val root: Root,
                          val nodes: List<Node>, val extraImages: Map<String, ExtraImage>, val min_x: Double,
                          val min_y: Double, val max_x: Double, val max_y: Double,
                          val assets: Map<String, Map<String, String>>, val constants: Constants, val imageRoot: String,
                          val skillSprites: SkillSprites, val imageZoomLevels: List<Int> )


data class CharacterData( val base_str: Int, val base_dex: Int, val base_int: Int )

data class Group( val x: Double, val y: Double, val oo: Map<String, Boolean>?, val n: List<Int> )

data class Root( val g: Int, val o: Int, val oidx: Int, val sa: Int, val da: Int, val ia: Int, val out: List<Int> )

data class Node( val id: Int, val icon: String, val ks: Boolean, val not: Boolean, val dn: String, val m: Boolean,
                 val isJewelSocket: Boolean, val isMultipleChoice: Boolean, val isMultipleChoiceOption: Boolean,
                 val passivePointsGranted: Int, val flavourText: List<String>?, val ascendancyName: String?,
                 val isAscendancyStart: Boolean?, val reminderText: List<String>?, val spc: List<Int>, val sd: List<String>,
                 val g: Int, val o: Int, val oidx: Int, val sa: Int, val da: Int, val ia: Int, val out: List<Int> )

data class ExtraImage( val x: Double, val y: Double, val image: String )

data class Constants( val classes: Map<String, Int>, val characterAttributes: Map<String, Int>,
                      val PSSCentreInnerRadius: Int )

data class SubSpriteCoords( val x: Int, val y: Int, val w: Int, val h: Int )

data class Sprite( val filename: String, val coords: Map<String, SubSpriteCoords> )

data class SkillSprites( val normalActive: List<Sprite>, val notableActive: List<Sprite>,
                         val keystoneActive: List<Sprite>, val normalInactive: List<Sprite>,
                         val notableInactive: List<Sprite>, val keystoneInactive: List<Sprite>,
                         val mastery: List<Sprite> )

private fun convert( jsonFile: File ) {
    val mapper = jacksonObjectMapper()
    mapper.configure( DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT, true )

    val skillTreeData = mapper.readValue<SkillTreeData>( jsonFile )
    println("Conversion finished !")
}

fun main( args : Array<String> ) {
    val jsonFile: File = File( """rawSkilltree.json""" )
    convert( jsonFile )

JSON (non formattato): http://filebin.ca/3B3reNQf3KXJ/rawSkilltree.json

Data la tua descrizione, credo che corrisponda alle tue esigenze.

Per convertire JSON in Kotlin usa http://www.json2kotlin.com/

Inoltre puoi usare il plugin Android Studio. File> Impostazioni, selezionare Pluginsnella struttura a sinistra, premere "Sfoglia repository ...", cercare " JsonToKotlinClass ", selezionarlo e fare clic sul pulsante verde "Installa".

Dopo il riavvio di AS puoi usarlo. Puoi creare una classe con File > New > JSON To Kotlin Class (JsonToKotlinClass). Un altro modo è premere Alt + K.

Quindi vedrai una finestra di dialogo per incollare JSON.

Nel 2018 ho dovuto aggiungere package com.my.package_name all'inizio di una lezione.

Prima di tutto.

Puoi utilizzare il plug-in del convertitore di classi di dati da JSON a Kotlin in Android Studio per il mapping JSON alle classi POJO (classe di dati kotlin). Questo plugin annoterà la tua classe di dati Kotlin in base a JSON.

Quindi puoi utilizzare il convertitore GSON per convertire JSON in Kotlin.

Segui questo tutorial completo: Kotlin Android JSON Parsing Tutorial

Se vuoi analizzare manualmente json.

val **sampleJson** = """
  [
  {
   "userId": 1,
   "id": 1,
   "title": "sunt aut facere repellat provident occaecati excepturi optio 
    reprehenderit",
    "body": "quia et suscipit\nsuscipit recusandae consequuntur expedita"
   }]
   """

Codice da analizzare sopra JSON Array e relativo oggetto all'indice 0.

var jsonArray = JSONArray(sampleJson)
for (jsonIndex in 0..(jsonArray.length() - 1)) {
Log.d("JSON", jsonArray.getJSONObject(jsonIndex).getString("title"))
}

http://www.jsonschema2pojo.org/ Ciao, puoi usare questo sito web per convertire json in pojo.
controllo + Alt + shift + k

Dopodiché puoi convertire manualmente quella classe del modello in una classe del modello kotlin. con l'aiuto della scorciatoia sopra.

Un po 'tardi, ma qualunque cosa.

Se preferisci analizzare JSON a JavaScript come i costrutti che fanno uso della semantica di Kotlin, ti consiglio JSONKraken , di cui sono l'autore.

Suggerimenti e opinioni in merito sono molto apprezzati!

Scarica la fonte di deme da qui ( analisi Json in Android Kotlin )

Aggiungi questa dipendenza:

compile 'com.squareup.okhttp3:okhttp:3.8.1'

Chiama la funzione API:

 fun run(url: String) {
    dialog.show()
    val request = Request.Builder()
            .url(url)
            .build()

    client.newCall(request).enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            dialog.dismiss()

        }

        override fun onResponse(call: Call, response: Response) {
            var str_response = response.body()!!.string()
            val json_contact:JSONObject = JSONObject(str_response)

            var jsonarray_contacts:JSONArray= json_contact.getJSONArray("contacts")

            var i:Int = 0
            var size:Int = jsonarray_contacts.length()

            al_details= ArrayList();

            for (i in 0.. size-1) {
                var json_objectdetail:JSONObject=jsonarray_contacts.getJSONObject(i)


                var model:Model= Model();
                model.id=json_objectdetail.getString("id")
                model.name=json_objectdetail.getString("name")
                model.email=json_objectdetail.getString("email")
                model.address=json_objectdetail.getString("address")
                model.gender=json_objectdetail.getString("gender")

                al_details.add(model)


            }

            runOnUiThread {
                //stuff that updates ui
                val obj_adapter : CustomAdapter
                obj_adapter = CustomAdapter(applicationContext,al_details)
                lv_details.adapter=obj_adapter
            }

            dialog.dismiss()

        }

    })