코틀린에서 JSON을 해석하는 방법

코틀린에서 JSON을 해석하는 방법

서비스로부터 꽤 깊은 JSON 오브젝트 문자열을 수신하고 있습니다.이 문자열을 JSON 오브젝트에 해석하여 클래스에 매핑해야 합니다.

Kotlin에서 JSON 문자열을 객체로 변환하려면 어떻게 해야 합니까?

그 후 각 클래스로의 매핑을 잭슨사의 StdDeserializer를 사용하고 있었습니다.이 문제는 객체가 클래스로 역직렬화되어야 하는 속성을 가지고 있는 시점에서 발생합니다.다른 탈직렬기 안에서 오브젝트 맵퍼를 구할 수 없었습니다.

가급적 기본적으로 필요한 의존관계 수를 줄이려고 하기 때문에 JSON 조작과 파싱에만 대한 답변이면 충분합니다.

Kotlin에서의 해석의 미래는 kotlinx.serialization에 있습니다.Kotlin 라이브러리의 일부입니다.버전 kotlinx.serialization 1.0이 드디어 출시되었습니다.

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

이 라이브러리는 https://github.com/cbeust/klaxon 에서 사용할 수 있습니다.

Klaxon은 Kotlin에 있는 JSON을 해석하는 경량 라이브러리입니다.

외부 라이브러리 없음(Android)

해석하려면:

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

다음 클래스를 사용합니다.

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

사용방법:

val foos = Response(jsonString)

하시면 됩니다.Gson.

예

순서 1

컴파일 추가

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

순서 2

을 json으로 변환합니다.Kotlin Bean(JsonToKotlin Class 사용)

이것처럼.

Json(데이터)

{
"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
    )
}

순서 3

Gson

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

이게 네가 원하는 건지 모르겠지만 난 이렇게 했어.

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
    }

다음은 json의 샘플입니다.

{"식품": [{"식품명": "애플", 중량: "110" }}

저는 개인적으로 여기에 있는 잭슨 모듈을 Kotlin에 사용하고 있습니다.jackson-module-kotlin.

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

예를 들어 상당히 무거운(포맷된 경우 84k 행) Exply 스킬트리의 JSON을 해석하는 코드를 다음에 나타냅니다.

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 (비표준) : http://filebin.ca/3B3reNQf3KXJ/rawSkilltree.json

당신의 인상착의를 들어보면 당신의 요구와 일치한다고 생각합니다.

JSON을 Kotlin으로 변환하려면 http://www.json2kotlin.com/을 사용합니다.

Android Studio ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★」> 、 [ File ]> [ Settings ]를 합니다.Plugins왼쪽 트리에서 "저장소 찾아보기..."를 누르고 "JsonToKotlinClass"를 검색한 후 선택하고 녹색 버튼 "설치"를 클릭합니다.

AS 시 as as as as as as as as as 클래스는 '클래스'를 만들 수 .File > New > JSON To Kotlin Class (JsonToKotlinClass)또 다른 방법은 Alt + K를 누르는 것입니다.

그러면 JSON을 붙여넣는 대화상자가 나타납니다.

2018년에 저는 또package com.my.package_name수업을 시작할 때

GSON은 Kotlin 프로젝트에서 JSON을 해석하기 위한 Android 및 Web 플랫폼에 적합한 선택입니다.이 라이브러리는 구글에 의해 개발되었습니다.https://github.com/google/gson

1. 먼저 프로젝트에 GSON을 추가합니다.

dependencies {
   implementation 'com.google.code.gson:gson:2.8.6'
}

2. 이제 JSON을 Kotlin 데이터 클래스로 변환해야 합니다.

JSON을 복사하여 이(https://json2kt.com) 웹 사이트로 이동하여 JSON을 Input Json 상자에 붙여넣습니다.적절한 상자에 패키지(예: com.example.appName)와 클래스 이름(예: UserData)을 입력합니다.이 사이트에는 아래 데이터 클래스의 라이브 미리 보기가 표시되며 모든 클래스를 zip 파일로 한 번에 다운로드할 수 있습니다.

모든 클래스를 다운로드한 후 zip 파일을 추출하여 프로젝트에 저장합니다.

3. 다음과 같이 해석합니다.

val myJson = """
{
    "user_name": "john123",
    "email": "john@example.com",
    "name": "John Doe"
}
""".trimIndent()

val gson = Gson()
var mUser = gson.fromJson(myJson, UserData::class.java)
println(mUser.userName)

완료:)

일단은.

Android Studio에서 JSON-Kotlin 데이터 클래스 변환기 플러그인을 사용하여 POJO 클래스(kotlin 데이터 클래스)에 JSON 매핑할 수 있습니다.이 플러그인은 JSON에 따라 Kotlin 데이터 클래스에 주석을 추가합니다.

다음으로 GSON 컨버터를 사용하여 JSON을 Kotlin으로 변환할 수 있습니다.

이 전체 튜토리얼: Kotlin Android JSON 구문 분석 튜토리얼에 따르십시오.

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"
   }]
   """

JSON Array 위의 해석 코드와 인덱스 0의 해당 개체.

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

이것은 엘리사의 대답처럼 사용된다.한편, 프로젝트는 1.0보다 이전 버전이기 때문에 API가 변경되었습니다.주의해 주세요. JSON.parse로 이름이 변경되었습니다.Json.decodeFromString또한 Kotlin 1.4.0부터 그라들별로 Import가 다릅니다.

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.2.0"
}
apply plugin: 'kotlinx-serialization'

사용 예:

import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.decodeFromString
import kotlinx.serialization.encodeToString

@Serializable
data class Point(val x: Int, val y: Int)

val pt = Json.decodeFromString<Point>("""{"y": 1, "x": 2}""")
val str = Json.encodeToString(pt)  // type can be inferred!

val ilist = Json.decodeFromString<List<Int>>("[-1, -2]")
val ptlist = Json.decodeFromString<List<Point>>(
    """[{"x": 3, "y": 4}, {"x": 5, "y": 6}]"""
)

null 타입을 사용할 수 있습니다(T?)는 nullable 필드와 optional 필드 모두 다음과 같습니다.

@Serializable
data class Point2(val x: Int, val y: Int? = null)

val nlist = Json.decodeFromString<List<Point2>>(
    """[{"x": 7}, {"x": 8, "y": null}, {"x": 9, "y": 0}]"""
)

코틀린스data class주로 데이터를 보유하고 멤버를 가지고 있는 클래스입니다..toString()및 기타 방법(예: 선언 파기)이 자동으로 정의됩니다.

조금 늦었지만, 어쨌든.

Kotlin 구문을 이용한 JavaScript와 유사한 구성보다 JSON을 해석하는 것을 선호한다면, JSONKraken을 추천합니다.

그 문제에 대한 제안과 의견은 매우 높이 평가됩니다!

코틴 세리아제이션

지원되는 모든 플랫폼(Android, JVM, JavaScript, Native)을 지원하는 Jetbrains의 Kotlin 전용 라이브러리

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

모시

Moshi는 Android 및 Java by Square용 JSON 라이브러리입니다.

https://github.com/square/moshi

잭슨

https://github.com/FasterXML/jackson

지손

가장 인기 있지만 거의 사용되지 않음

https://github.com/google/gson

JSON에서 Java로

http://www.jsonschema2pojo.org/

JSON에서 Kotlin으로

IntelliJ 플러그인 - https://plugins.jetbrains.com/plugin/9960-json-to-kotlin-class-jsontokotlinclass-

http://www.jsonschema2pojo.org/ 안녕하세요. 이 웹 사이트를 사용하여 json을 pojo로 변환할 수 있습니다.
실행+Alt+shift+k

그런 다음 해당 모델 클래스를 kotlin 모델 클래스로 수동으로 변환할 수 있습니다.위의 숏컷을 사용하여.

Kotlin 개체에 대한 JSON 문자열 구문 분석

다른 사람들이 추천하는 것처럼, Gson 라이브러리가 가장 간단한 방법입니다!

파일이 자산 폴더에 있는 경우 다음과 같이 할 수 있습니다.

dependencies {
  implementation 'com.google.code.gson:gson:2.9.0'
}

자산에서 파일을 가져옵니다.

jsonString = context.assets.open(fileName).bufferedReader().use { it.readText() }

다음으로 Gson을 사용합니다.

val gson = Gson()
val listPersonType = object : TypeToken<List<Person>>() {}.type
var persons: List<Person> = gson.fromJson(jsonFileString, listPersonType)
persons.forEachIndexed { idx, person -> Log.i("data", "> Item $idx:\n$person") }

서 ★★★★★Person는 입니다.Model/Data class 이렇게.

data class Person(val name: String, val age: Int, val messages: List) {
}

커스텀 실장을 코틀린에서 사용하고 있습니다.

/**
 * Created by Anton Kogan on 10/9/2020
 */
object JsonParser {

    val TAG = "JsonParser"
    /**
 * parse json object
 * @param objJson
 * @param include - all  keys, that you want to display
 * @return  Map<String, String>
 * @throws JSONException
 */
    @Throws(JSONException::class)
    fun parseJson(objJson: Any?, map :HashMap<String, String>, include : Array<String>?): Map<String, String> {
        // If obj is a json array
        if (objJson is JSONArray) {
            for (i in 0 until objJson.length()) {
                parseJson(objJson[i], map, include)
            }
        } else if (objJson is JSONObject) {
            val it: Iterator<*> = objJson.keys()
            while (it.hasNext()) {
                val key = it.next().toString()
                // If you get an array
                when (val jobject = objJson[key]) {
                    is JSONArray -> {
                        Log.e(TAG, " JSONArray: $jobject")
                        parseJson(
                            jobject, map, include
                        )
                    }
                    is JSONObject -> {
                        Log.e(TAG, " JSONObject: $jobject")
                        parseJson(
                            jobject, map, include
                        )
                    }
                    else -> {
//
                        if(include == null || include.contains(key)) // here is check for include param
                        {
                            map[key] = jobject.toString()
                            Log.e(TAG, " adding to map: $key $jobject")
                        }
                    }
                }
            }
        }
        return map
    }

    /**
     * parse json object
     * @param objJson
     * @param include - all  keys, that you want to display
     * @return  Map<String, String>
     * @throws JSONException
     */
    @Throws(JSONException::class)
    fun parseJson(objJson: Any?, map :HashMap<String, String>): Map<String, String> {
        return parseJson(objJson, map, null)
    }
}

다음과 같이 사용할 수 있습니다.

    val include= arrayOf(
        "atHome",//JSONArray
        "cat",
        "dog",
        "persons",//JSONArray
        "man",
        "woman"
    )
    JsonParser.parseJson(jsonObject, map, include)
    val linearContent: LinearLayout = taskInfoFragmentBinding.infoContainer

다음은 유용한 링크입니다.

json 구문 분석:

플러그인: https://plugins.jetbrains.com/plugin/9960-json-to-kotlin-class-jsontokotlinclass-

json에서 POJO 작성:https://codebeautify.org/jsonviewer

개장: https://square.github.io/retrofit/

https://github.com/google/gson

여기서 품위의 출처를 다운로드합니다(안드로이드 코틀린에서의 Json 구문 분석).

다음 종속성 추가:

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

호출 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()

        }

    })

언급URL : https://stackoverflow.com/questions/41928803/how-to-parse-json-in-kotlin