Comment utiliser TypeToken + génériques avec Gson dans Kotlin

Je ne suis pas en mesure d'obtenir une Liste de type générique d'une classe personnalisée (Tours):

val turnsType = TypeToken<List<Turns>>() {}.type
val turns = Gson().fromJson(pref.turns, turnsType)

il dit:

cannot access '<init>' it is 'public /*package*/' in 'TypeToken'

InformationsquelleAutor Juancho | 2015-10-28

171

Créer cette inline plaisir:
```
inline fun <reified T> Gson.fromJson(json: String) = this.fromJson<T>(json, object: TypeToken<T>() {}.type)
```
et puis vous pouvez l'appeler de cette façon:
```
val turns = Gson().fromJson<Turns>(pref.turns)
//or
val turns: Turns = Gson().fromJson(pref.turns)
```
NOTE: Cette approche n'était pas possible avant dans le vieux kotlin versions plugin mais maintenant vous êtes en mesure de l'utiliser.

Variantes Précédentes:

VARIANTE 1:
```
val turnsType = object : TypeToken<List<Turns>>() {}.type
val turns = Gson().fromJson<List<Turns>>(pref.turns, turnsType)
```
Vous devez mettre object : et le type spécifique de fromJson<List<Turns>>

VARIANTE 2:

Comme @cypressious dire elle peut être également réalisée de cette façon:
```
inline fun <reified T> genericType() = object: TypeToken<T>() {}.type
```
utiliser comme:
```
val turnsType = genericType<List<Turns>>()
```
- Vous pouvez également créer une méthode d'assistance que le fait pour vous: inline fun <reified T> genericType() = object: TypeToken<T>() {}.type
- ou même s'étend Gson d'avoir une nouvelle surcharge de fromJson qui fait cela. Kotlin est conçu pour s'étendre, afin de prolonger Gson pour le rendre plus agréable et cacher TypeTokens.
- J'ai fait les modifications suggérées qui rend la réponse plus complète et officielle depuis cette réponse est susceptible d'être vu par plusieurs personnes qui utilisent Gson. J'ai ajouté des explications dans la réponse, et des liens vers Kotlin références pour les rubriques utilisées pour résoudre le problème ... si les gens n'ont pas de lire toutes les autres réponses ou des commentaires qui ont été de ce. Si vous acceptez de le modifier, je peux enlever ma réponse ci-dessous.
- Edit rejeté, voir ma réponse ci-dessous pour une version complète qui combine toutes les réponses et commentaires dans l'une réponse cohérente. Vous avez accepté votre propre réponse, mais il n'est pas complet.
- retrait de kotlin avertissement: inline fun <réifiée T> genericType() : Type? = objet: TypeToken<T>() {}.type
InformationsquelleAutor Juancho
25

Cela résout le problème:
```
val turnsType = object : TypeToken<List<Turns>>() {}.type
val turns = Gson().fromJson<List<Turns>>(pref.turns, turnsType)
```
La première ligne crée un l'objet de l'expression qui descend de TypeToken et obtient ensuite le Java Type de que. Puis le Gson().fromJson méthode ou les besoins du type spécifié pour le résultat de la fonction (qui doit correspondre à la TypeToken créé). Deux versions de cette œuvre, comme ci-dessus ou:
```
val turns: List<Turns> = Gson().fromJson(pref.turns, turnsType)
```
Pour le rendre plus facile pour créer le TypeToken vous pouvez créer une fonction d'assistance, qui est nécessaire pour être inline afin qu'il puisse utiliser réifiée paramètres de type:
```
inline fun <reified T> genericType() = object: TypeToken<T>() {}.type
```
Qui peut ensuite être utilisé dans l'une de ces façons:
```
val turnsType = genericType<List<Turns>>()
//or
val turnsType: List<Turns> = genericType()
```
Et l'ensemble du processus peut être enveloppé dans une fonction d'extension pour le Gson exemple:
```
inline fun <reified T> Gson.fromJson(json: String) = this.fromJson<T>(json, object: TypeToken<T>() {}.type)
```
De sorte que vous pouvez les appeler Gson et ne pas vous soucier de TypeToken à tous:
```
val turns = Gson().fromJson<Turns>(pref.turns)
//or
val turns: Turns = Gson().fromJson(pref.turns)
```
Ici Kotlin est l'aide de l'inférence de type, d'un côté de la cession ou de l'autre, et réifié génériques pour une fonction en ligne pour passer à travers le type complet (sans effacement), et en utilisant que pour construire un TypeToken et aussi faire l'appel à Gson
- Salut @Jayson, je ne pouvais pas faire cela fonctionne de cette inline plaisir dans Android Studio. Semble être OK, mais il n'est pas reconnu quand je le fais Gson().fromJson<kotlin.List<Turns>>(pref.turns)
- pouvez-vous me tél quoi "pas reconnu" signifie? Une erreur de compilateur? Vous avez la méthode d'extension importés et disponible à partir de ci-dessus?
- - Je copier et coller votre code dans Android Studio et importés du plaisir dans mon kotlin classe. J'ai essayé de faire ce que vous avez dit, mais pour une raison quelconque, le compilateur me dit que ce plaisir n'existe pas. Je suis déjà en utilisant d'autres l'extension des fonctions mais je ne sais pas ce que votre suggestion ne fonctionne pas. La version de COMME et Kotlin utilisez-vous? juste d'essayer de nouveau.
- Ce n'est pas lié à Android studio directement, Kotlin est la même à l'intérieur ou à l'extérieur de l'. Êtes-vous de la création de l'instance de Gson() ou tout simplement Gson comme-si elle est statique? Vous avez besoin de la première, une instance.
InformationsquelleAutor Jayson Minard
16

Une autre option (pas sûr, c'est plus élégant que les autres) pourrait être un appel comme ceci:
```
turns = Gson().fromJson(allPurchasesString, Array<Turns>::class.java).toMutableList()
```
De sorte que vous êtes en utilisant le java de la classe Array un liner à la place de "pure Kotlin".
- Depuis TypeToken ne fonctionnent pas sur tous les téléphones qui sont fiables, c'est la meilleure solution pour moi. Facile, doublure pur kotlin.
InformationsquelleAutor Tobias Reich

val obj: MutableList<SaleItemResponse> = Gson().fromJson(messageAfterDecrypt,
    object : TypeToken<List<SaleItemResponse>>() {}.type)

C'est ma façon à l'analyse des données de tableau dans kotlin.

Cela devrait être la bonne réponse

InformationsquelleAutor Toàn Mỹ

4

Cela fonctionne aussi bien, et est plus simple
```
    inline fun <reified T> Gson.fromJson(json: String) : T = 
         this.fromJson<T>(json, T::class.java)
```
- Le type de retour doit être nullable. Sinon, le code Java dans Gson bibliothèque peut retourner null, mais Kotlin suppose que le type est non nullable. Comme un résultat, vous obtenez des NPE dans Kotlin.
InformationsquelleAutor Christopher Perry

J'ai utilisé quelque chose comme cela pour convertir T à string & String retour à T à l'aide de Gson. Pas exactement ce que vous cherchez, mais juste au cas où.

Déclarant extension

inline fun <reified T : Any> T.json(): String = Gson().toJson(this, T::class.java)
inline fun <reified T : Any> String.fromJson(): T = Gson().fromJson(this,T::class.java)

Utilisation

//Passing an object to new Fragment
companion object {    
        private const val ARG_SHOP = "arg-shop"

        @JvmStatic
        fun newInstance(shop: Shop) =
                ShopInfoFragment().apply {
                    arguments = Bundle().apply {
                        putString(ARG_SHOP, shop.json())
                    }
                }
    }

//Parsing the passed argument
private lateinit var shop: Shop

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        arguments?.let {
            shop = it.getString(ARG_SHOP).fromJson() ?: return
        }
    }

InformationsquelleAutor harsh_v

Vous devez vous connecter pour publier un commentaire.