{"id":142767,"date":"2021-05-07T09:42:05","date_gmt":"2021-05-07T08:42:05","guid":{"rendered":"https:\/\/blog.jetbrains.com\/kotlin\/2021\/05\/kotlinx-serialization-1-2-released\/"},"modified":"2021-05-21T12:29:41","modified_gmt":"2021-05-21T11:29:41","slug":"kotlinx-serialization-1-2-released","status":"publish","type":"kotlin","link":"https:\/\/blog.jetbrains.com\/de\/kotlin\/2021\/05\/kotlinx-serialization-1-2-released\/","title":{"rendered":"kotlinx.serialization 1.2 ver\u00f6ffentlicht: schnelle JSON-Verarbeitung, Unterst\u00fctzung von Werteklassen, \u00fcberarbeitete Dokumentation und mehr"},"content":{"rendered":"\n<p><code>kotlinx.serialization<\/code> 1.2 ist da! Die neueste Version unserer Multiplattform-Serialisierungsbibliothek enth\u00e4lt eine Reihe von Verbesserungen. Hier sind einige Highlights:<\/p>\n<ul>\n<li><a href=\"https:\/\/blog.jetbrains.com\/kotlin\/2021\/05\/kotlinx-serialization-1-2-released\/#fast-json\">Die JSON-Serialisierung erfolgt schneller als je zuvor.<\/a> Beim Parsen von JSON in typsichere Kotlin-Objekte und bei der Konvertierung von Kotlin-Objekten in Textform ist Version 1.2 teilweise doppelt so schnell wie fr\u00fchere Versionen.<\/li>\n<li><a href=\"https:\/\/blog.jetbrains.com\/kotlin\/2021\/05\/kotlinx-serialization-1-2-released\/#15-additions\">Mit Kotlin 1.5 eingef\u00fchrte Typsystem-Erg\u00e4nzungen werden jetzt unterst\u00fctzt.<\/a> Werteklassen und vorzeichenlose Zahlen k\u00f6nnen wie jede andere Kotlin-Klasse in JSON und zur\u00fcck konvertiert werden.<\/li>\n<li>Dank der <a href=\"https:\/\/blog.jetbrains.com\/kotlin\/2021\/05\/kotlinx-serialization-1-2-released\/#api-docs\">neuen API-Dokumentation<\/a> sind alle Funktionen von <code>kotlinx.serialization<\/code> leicht zu finden und zu erkunden.<\/li>\n<\/ul>\n<p>Neu in Version 1.2 ist auch die Unterst\u00fctzung f\u00fcr <a href=\"https:\/\/blog.jetbrains.com\/kotlin\/2021\/05\/kotlinx-serialization-1-2-released\/#alt-names\">alternative JSON-Feldnamen<\/a> sowie ein experimenteller Ansatz zur <a href=\"https:\/\/blog.jetbrains.com\/kotlin\/2021\/05\/kotlinx-serialization-1-2-released\/#protobuf-schemas\">automatischen Generierung von Protobuf-Schemas aus Kotlin-Klassen<\/a> \u2013 eine Funktion, zu der wir gerne Feedback von Ihnen h\u00e4tten!<\/p>\n<p><span id=\"more-137135\"><\/span><\/p>\n<p>Im Folgenden wollen wir einzeln auf die \u00c4nderungen und Erg\u00e4nzungen in dieser neuen Version eingehen. Wenn wir Sie bereits \u00fcberzeugt haben, k\u00f6nnen Sie nat\u00fcrlich \u00fcber den nachstehenden Link auch direkt zur Upgrade-Anleitung gehen!<\/p>\n<p align=\"center\"><a class=\"jb-download-button\" title=\"Installieren\" href=\"https:\/\/blog.jetbrains.com\/kotlin\/2021\/05\/kotlinx-serialization-1-2-released\/#start-using\">Mit kotlinx.serialization 1.2 loslegen<\/a><\/p>\n<p><iframe title=\"YouTube-Videoplayer\" src=\"https:\/\/www.youtube.com\/embed\/698I_AH8h6s\" height=\"445\" frameborder=\"0\" allowfullscreen=\"allowfullscreen\"><\/iframe><br \/>\n<a href=\"https:\/\/www.youtube.com\/channel\/UCP7uiEZIqci43m22KDl0sNw?sub_confirmation=1\" target=\"_blank\" rel=\"noopener\">Abonnieren Sie Kotlin auf YouTube!<\/a><\/p>\n<p><a name=\"fast-json\"><\/a><\/p>\n<h2>JSON-Codierung und -Decodierung schneller denn je<\/h2>\n<p>Das Konvertieren von Kotlin-Klassen in JSON-Zeichenfolgen und umgekehrt geh\u00f6rt zu den meistverwendeten Funktionen von <code>kotlinx.serialization<\/code>, und wir arbeiten st\u00e4ndig daran, die Performance in diesem Bereich zu verbessern.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2021\/04\/Kotlinx.serialization-1.2_2-03.png\" alt=\"JSON-Parsing mit kotlinx.serialization: bis zu 55 Prozent schneller\"><\/p>\n<p>In Version 1.2 wurde die interne Struktur von <code>kotlinx.serialization<\/code> komplett \u00fcberarbeitet. Ein Ergebnis ist die deutlich verbesserte Performance in diesem Kernbereich. Wir haben unseren JSON-Decoder (zur Umwandlung von Text in Kotlin-Objekte) neu geschrieben und unseren JSON-Encoder (zur Umwandlung von Kotlin-Objekten in Text) umfassend optimiert.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2021\/04\/Kotlinx.serialization-1.2_2-02-1.png\" alt=\"JSON-Encodierung mit kotlinx.serialization: bis zu 339 Prozent schneller\"><\/p>\n<p>Durch ein einfaches Upgrade auf die neueste Version unserer Bibliothek k\u00f6nnen Sie eine bis zu <em>zweifache Beschleunigung<\/em> von typischen Kodierungs- und Dekodierungsaufgaben erzielen. (Wie Sie sehen, wurden in einigen unserer internen Benchmarks, die von diesen neuen Optimierungen besonders stark profitieren, diese Werte sogar noch <em>\u00fcbertroffen<\/em>!)<\/p>\n<p>Mit diesen \u00c4nderungen erreicht <code>kotlinx.serialization<\/code> bereits im Lieferzustand das Leistungsniveau anderer JSON-Bibliotheken (und \u00fcbertrifft diese in bestimmten Bereichen sogar). Selbst die einfachsten Codeschnipsel profitieren von dieser \u00dcberarbeitung:<\/p>\n<pre class=\"kotlin-code\" data-highlight-only=\"true\" theme=\"idea\" indent=\"4\" style=\"visibility: hidden; padding: 36px 0;\">\n@Serializable\ndata class User(val name: String, val yearOfBirth: Int)\n\nfun main() {\n\/\/ Faster encoding...\nval data = User(&quot;Louis&quot;, 1901)\nval string = Json.encodeToString(data)\nprintln(string) \/\/ {&quot;name&quot;:&quot;Louis&quot;,&quot;yearOfBirth&quot;:1901}\n\n\/\/ ...and faster decoding!\nval obj = Json.decodeFromString(string)\nprintln(obj) \/\/ User(name=Louis, yearOfBirth=1901)\n}\n<\/pre>\n<p>Der beste Weg, um ein Gef\u00fchl f\u00fcr diese Verbesserungen zu bekommen, d\u00fcrfte das Benchmarking Ihrer eigenen Anwendung mit der neuesten Version unserer Bibliothek sein. Einen groben Anhaltspunkt f\u00fcr die Leistung bieten unsere internen Benchmarks f\u00fcr <a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/pull\/1354\" target=\"_blank\" rel=\"noopener\">Codierung<\/a> und <a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/pull\/1343\" target=\"_blank\" rel=\"noopener\">Dekodierung<\/a>, die die neueste Version von <code>kotlinx.serialization<\/code> mit der Vorg\u00e4ngerversion vergleichen.<\/p>\n<p><a name=\"15-additions\"><\/a><\/p>\n<h2>Stabile JSON-Serialisierung\/Deserialisierung f\u00fcr Werteklassen und vorzeichenlose Zahlentypen<\/h2>\n<p>Kotlin 1.5.0 f\u00fchrt zwei aufregende Neuerungen ein: <a href=\"https:\/\/kotlinlang.org\/docs\/inline-classes.html\" target=\"_blank\" rel=\"noopener\">Werteklassen<\/a> und <a href=\"https:\/\/kotlinlang.org\/docs\/basic-types.html#unsigned-integers\" target=\"_blank\" rel=\"noopener\">vorzeichenlose Ganzzahltypen<\/a>. <code>kotlinx.serialization<\/code> 1.2 bietet jetzt f\u00fcr beide erstklassige Unterst\u00fctzung bei der JSON-Encodierung und -Decodierung. Schauen wir uns das einmal n\u00e4her an.<\/p>\n<h3>Unterst\u00fctzung f\u00fcr Werteklassen<\/h3>\n<p><a href=\"https:\/\/kotlinlang.org\/docs\/inline-classes.html\" target=\"_blank\" rel=\"noopener\">Werteklassen<\/a> (fr\u00fcher <em>Inline-Klassen<\/em> genannt) bieten eine M\u00f6glichkeit, einen anderen Kotlin-Typ (z. B. eine Zahl) ohne zus\u00e4tzlichen Laufzeitaufwand typsicher zu verpacken. Dadurch k\u00f6nnen Sie Ihren Programmcode ohne Leistungseinbu\u00dfen ausdrucksvoller und sicherer gestalten.<\/p>\n<p>Die integrierte JSON-Serialisierung von <code>kotlinx.serialization<\/code> unterst\u00fctzt jetzt Werteklassen. Wie bei anderen Kotlin-Klassen m\u00fcssen wir dazu die <code>Werteklasse<\/code> nur mit der Annotation <code>@Serializable<\/code> versehen.<\/p>\n<pre class=\"kotlin-code\" data-highlight-only=\"true\" theme=\"idea\" indent=\"4\" style=\"visibility: hidden; padding: 36px 0;\">\n@Serializable\nvalue class Color(val rgb: Int)\n<\/pre>\n<p>Werteklassen werden direkt als der zugrunde liegende Typ gespeichert (und serialisiert). Wir k\u00f6nnen dies erkennen, indem wir eine <code>Werteklasse<\/code> als Feld zu einer serialisierbaren <code>Datenklasse<\/code> hinzuf\u00fcgen und die entsprechende Ausgabe untersuchen:<\/p>\n<pre class=\"kotlin-code\" data-highlight-only=\"true\" theme=\"idea\" indent=\"4\" style=\"visibility: hidden; padding: 36px 0;\">\n@Serializable\nvalue class Color(val rgb: Int)\n<\/pre>\n\nValue classes are stored (and serialized) directly as their underlying type. We can see this by adding a field with a value class type to a serializable data class, and inspecting its output:\n\n<pre class=\"kotlin-code\" data-highlight-only=\"true\" theme=\"idea\" indent=\"4\" style=\"visibility: hidden; padding: 36px 0;\">\n@Serializable\ndata class NamedColor(val color: Color, val name: String)\n\nfun main() {\nprintln(Json.encodeToString(NamedColor(Color(0), &quot;black&quot;)))\n}\n\n\/\/ {&quot;color&quot;: 0, &quot;name&quot;: &quot;black&quot;}\n<\/pre>\n<p>Im obigen Beispiel behandelt <code>NamedColor<\/code> die <code>Werteklasse<\/code> <code>Color<\/code> als den <em>zugrunde liegenden primitiven Typ <\/em>(<code>Int<\/code>). Dies bedeutet, dass Sie in Ihrem Kotlin-Code auf maximale Typsicherheit setzen k\u00f6nnen und dennoch von einer kompakten Serialisierung dieser Typen profitieren, ohne unn\u00f6tiges Boxing oder Verschachteln.<\/p>\n<p>Wir arbeiten noch an der Optimierung des Designs f\u00fcr handgeschriebene, benutzerdefinierte Serialisierer f\u00fcr Werteklassen, und daher verbleiben sie vorerst im experimentellen Stadium. Weitere Informationen zu diesem Thema finden Sie in der <a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/blob\/master\/docs\/inline-classes.md#using-inline-classes-in-your-custom-serializers\" target=\"_blank\" rel=\"noopener\">Dokumentation auf GitHub<\/a>.<\/p>\n<h3>Unterst\u00fctzung f\u00fcr vorzeichenlose Ganzzahlen<\/h3>\n<p><a href=\"https:\/\/kotlinlang.org\/docs\/basic-types.html#unsigned-integers\" target=\"_blank\" rel=\"noopener\">Vorzeichenlose Ganzzahlen<\/a> sind eine Erg\u00e4nzung f\u00fcr die Kotlin-Standardbibliothek, die jetzt auch f\u00fcr <em>nicht negative Zahlen<\/em> Typen und Operationen bereitstellt. Ab Kotlin 1.5.0 stehen die folgenden vorzeichenlosen Zahlentypen zur Verf\u00fcgung:<\/p>\n<ul>\n<li><code>UByte<\/code> mit Werten von 0 bis 255<\/li>\n<li><code>UShort<\/code> mit Werten von 0 bis 65535<\/li>\n<li><code>UInt<\/code> mit Werten von 0 bis 2^32 \u2013 1<\/li>\n<li><code>ULong<\/code> mit Werten von 0 bis 2^64 \u2013 1<\/li>\n<\/ul>\n<p>Der JSON-Encoder und -Decoder in <code>kotlinx.serialization<\/code> bietet jetzt integrierte Unterst\u00fctzung f\u00fcr diese Typen. Wie die anderen Zahlentypen werden auch vorzeichenlose Ganzzahlen in ihrer einfachen Zahlendarstellung serialisiert (dieselbe Darstellung, die Sie beim Aufruf von <code>.toString<\/code> sehen) \u2013 ohne K\u00fcrzung, Wrapping oder Konvertierung in einen vorzeichenbehafteten Typ.<\/p>\n<pre class=\"kotlin-code\" data-highlight-only=\"true\" theme=\"idea\" indent=\"4\" style=\"visibility: hidden; padding: 36px 0;\">\n@Serializable\nclass Counter(val counted: UByte, val description: String)\n\n@Serializable\nclass BigCounter(val counted: ULong)\n\nval counted = 239.toUByte()\nprintln(Json.encodeToString(Counter(counted, &quot;tries&quot;)))\n\/\/ {&quot;counted&quot;:239,&quot;description&quot;:&quot;tries&quot;}\n\nprintln(Json.encodeToString(BigCounter(ULong.MAX_VALUE)))\n\/\/ {&quot;counted&quot;:18446744073709551615}\n<\/pre>\n<p>Bitte beachten Sie, dass die Unterst\u00fctzung f\u00fcr Werteklassen und vorzeichenlose Ganzzahlen derzeit nur f\u00fcr JSON verf\u00fcgbar ist. In einer k\u00fcnftigen Version werden auch direkte Integrationen f\u00fcr CBOR und Protobuf bereitgestellt \u2013 wir werden Sie informieren!<\/p>\n<p>Um \u00fcber k\u00fcnftige Versionen von <code>kotlinx.serialization<\/code> und die Programmiersprache Kotlin auf dem Laufenden zu bleiben, <em>abonnieren Sie unseren Newsletter f\u00fcr Kotlin-Produktupdates<\/em> \u00fcber das Formular neben diesem Blogartikel.<\/p>\n<p>Weitere Informationen zur Verwendung von Werteklassen und vorzeichenlosen Typen mit <code>kotlinx.serialization<\/code> finden Sie in der <a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/blob\/master\/docs\/inline-classes.md\" target=\"_blank\" rel=\"noopener\">Dokumentation auf GitHub<\/a>.<\/p>\n<p><a name=\"alt-names\"><\/a><\/p>\n<h2>Unterst\u00fctzung f\u00fcr alternative JSON-Feldnamen<\/h2>\n<p>Manchmal m\u00fcssen wir JSON-Felder einlesen, die trotz unterschiedlicher Namen denselben Zweck haben \u2013 zum Beispiel aus Gr\u00fcnden der Abw\u00e4rtskompatibilit\u00e4t. Mit der neuen Annotation <code>@JsonNames<\/code> k\u00f6nnen Sie JSON-Feldern jetzt alternative Namen zuweisen, die bei der Dekodierung verwendet werden.<\/p>\n<p>Schauen wir uns das an einem Beispiel an. Nehmen wir an, dass uns ein Server je nach Version eine der beiden folgenden Antworten gibt:<\/p>\n<pre class=\"kotlin-code\" data-highlight-only=\"true\" theme=\"idea\" indent=\"4\" style=\"visibility: hidden; padding: 36px 0;\">\n{&quot;name&quot;:&quot;kotlinx.serialization&quot;}\n\/<em> ...or: <\/em>\/\n{&quot;title&quot;:&quot;kotlinx.serialization&quot;}\n<\/pre>\n<p>Sowohl <code>name<\/code> als auch <code>title<\/code> haben dieselbe Bedeutung, und wir m\u00f6chten beide in demselben Feld unserer Kotlin-Klasse speichern. Mit der neuen <code>@JsonNames<\/code>-Annotation k\u00f6nnen wir <code>title<\/code> als alternativen Schl\u00fcssel f\u00fcr <code>name<\/code> angeben:<\/p>\n<pre class=\"kotlin-code\" data-highlight-only=\"true\" theme=\"idea\" indent=\"4\" style=\"visibility: hidden; padding: 36px 0;\">\n@Serializable\ndata class Project(@JsonNames(&quot;title&quot;) val name: String)\n<\/pre>\n<p>Beachten Sie den Unterschied zur Annotation <code>@SerialName<\/code>, die es Ihnen erm\u00f6glicht, <em>Felder umzubenennen<\/em> \u2013 sowohl f\u00fcr die Encodierung als auch f\u00fcr die Decodierung \u2013, jedoch nicht die M\u00f6glichkeit bietet, <em>Alternativen anzugeben<\/em>.<\/p>\n<p>Wir hoffen, dass Ihnen dieses Feature in verschiedenen Szenarien das Leben erleichtern wird: bei der Arbeit mit Services, die unterschiedlich benannte Felder mit denselben Werten zur\u00fcckgeben, bei der pannenfreien Durchf\u00fchrung von Schemamigrationen und bei der Bereitstellung von reibungslosen Upgrades f\u00fcr Ihre Anwendungen!<\/p>\n<p><a name=\"api-docs\"><\/a><\/p>\n<h2>Neue API-Dokumentation<\/h2>\n<p>Um Ihnen das Einarbeiten in <code>kotlinx.serialization<\/code> so komfortabel und kurzweilig wie m\u00f6glich zu machen, stellen wir Ihnen eine Reihe von Referenzmaterialien zur Verf\u00fcgung. Dazu geh\u00f6rt der <a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/blob\/master\/docs\/serialization-guide.md\" target=\"_blank\" rel=\"noopener\">Kotlin-Serialisierungsleitfaden auf GitHub<\/a>. Dieser bietet einen \u00dcberblick \u00fcber die Funktionalit\u00e4t sowie jeweils eigenst\u00e4ndige, intuitive Beispiele f\u00fcr die einzelnen Funktionen.<\/p>\n<p>Auch die <a href=\"https:\/\/kotlin.github.io\/kotlinx.serialization\/\" target=\"_blank\" rel=\"noopener\">Dokumentation der kotlinx.serialization-API<\/a> haben wir komplett \u00fcberarbeitet. Basierend auf einer neuen Version der Kotlin-Dokumentationsengine <a href=\"https:\/\/github.com\/Kotlin\/dokka\" target=\"_blank\" rel=\"noopener\">Dokka<\/a> verf\u00fcgt die neue API-Dokumentation \u00fcber ein neues, ansprechendes und modernes Design sowie Symbole, die die Navigation vereinfachen.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2021\/04\/image1.png\" alt=\"Beispiel zur neuen API-Dokumentation; zu sehen ist die Dokumentation von JsonElement\"><\/p>\n<p align=\"center\"><a class=\"jb-download-button\" title=\"Installieren\" href=\"https:\/\/kotlin.github.io\/kotlinx.serialization\/\" target=\"_blank\" rel=\"noopener\">Entdecken Sie die neue Dokumentation der kotlinx.serialization-API!<\/a><\/p>\n<p><a name=\"protobuf-schemas\"><\/a><\/p>\n<h2>Protobuf: experimentelle Schemagenerierung aus Kotlin-Klassen<\/h2>\n<p><a href=\"https:\/\/developers.google.com\/protocol-buffers\" target=\"_blank\" rel=\"noopener\">Protocol Buffers<\/a> (Protobuf) ist ein von Google konzipiertes <em>bin\u00e4res Serialisierungsformat<\/em> f\u00fcr strukturierte Daten. Als Bin\u00e4rformat ist es platzsparender als JSON oder XML und bietet dennoch eine <em>sprachunabh\u00e4ngige Struktur<\/em>, die sich f\u00fcr die Kommunikation \u00fcber Anwendungsgrenzen hinweg eignet.<\/p>\n<p><code>kotlinx.serialization<\/code> bietet Ihnen jetzt eine <a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/blob\/master\/docs\/formats.md#protobuf-experimental\" target=\"_blank\" rel=\"noopener\">plattform\u00fcbergreifende Protobuf-Serialisierung<\/a> (mit <a href=\"https:\/\/developers.google.com\/protocol-buffers\/docs\/proto\" target=\"_blank\" rel=\"noopener\">proto2-Semantik<\/a>) in einem <em>experimentellen<\/em> Stadium. Wie bei den anderen Formaten versehen Sie Ihre Klasse mit der Annotation <code>@Serializable<\/code> und verwenden die integrierten Methoden <code>encode<\/code> und <code>decode<\/code>:<\/p>\n<pre class=\"kotlin-code\" data-highlight-only=\"true\" theme=\"idea\" indent=\"4\" style=\"visibility: hidden; padding: 36px 0;\">\n@Serializable\ndata class Project(val name: String, val language: String)\n\nfun main() {\nval data = Project(&quot;kotlinx.serialization&quot;, &quot;Kotlin&quot;)\nval bytes = ProtoBuf.encodeToByteArray(data)\nprintln(bytes.toAsciiHexString())\nval obj = ProtoBuf.decodeFromByteArray(bytes)\nprintln(obj)\n}\n<\/pre>\n<p>Mit Ihren Kotlin-Klassen als <em>source of truth<\/em> (inklusive eventueller <a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/blob\/master\/docs\/formats.md#protobuf-experimental\" target=\"_blank\" rel=\"noopener\">Anpassungen<\/a>, die Sie vielleicht ben\u00f6tigen), kann <code>kotlinx.serialization<\/code> das bin\u00e4re Schema der Daten ableiten. Dadurch kann Protobuf f\u00fcr die kompakte und komfortable Kommunikation <em>zwischen mehreren Kotlin-Anwendungen<\/em> verwendet werden.<\/p>\n<p><code>kotlinx.serialization<\/code> 1.2 enth\u00e4lt jetzt auch einen experimentellen <em>Schemagenerator f\u00fcr Protocol Buffers<\/em>. Dieser generiert aus Ihren Kotlin-Datenklassen <code>.proto<\/code>-Dateien, die Sie verwenden k\u00f6nnen, um Ihre Kommunikationsschemas in anderen Sprachen \u2013 einschlie\u00dflich Python, C++ und TypeScript \u2013 darzustellen.<\/p>\n<p>Anweisungen zur Verwendung des neuen Schemagenerators finden Sie im entsprechenden Bereich der <a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/blob\/master\/docs\/formats.md#protobuf-experimental\" target=\"_blank\" rel=\"noopener\">Dokumentation<\/a>.<\/p>\n<p>Sobald die <code>.proto<\/code>-Datei generiert wurde, k\u00f6nnen Sie sie in Ihrem Repository speichern und zum Generieren von Darstellungen Ihrer Kotlin-Klassen in anderen Sprachen verwenden. Wir hoffen, dass Ihnen dies die M\u00f6glichkeit bietet, die Protobuf-Integration von <code>kotlinx.serialization<\/code> in <em>mehrsprachigen Anwendungen<\/em> einzusetzen, ohne auf die komfortable Verwaltung Ihrer Schemas direkt im Kotlin-Quellcode verzichten zu m\u00fcssen.<\/p>\n<p>Da dies die <em>erste Iteration<\/em> des Protobuf-Schemagenerators ist, hoffen wir stark auf Ihr Feedback. Bitte probieren Sie ihn aus und berichten Sie uns von Ihren Anwendungsf\u00e4llen, von der Verwaltung Ihrer Modelle und <code>.proto<\/code>-Dateien, von gefundenen Problemen und von den Funktionen, die Sie eventuell vermissen. Bitte verwenden Sie dazu unseren <a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/issues\" target=\"_blank\" rel=\"noopener\">Issue-Tracker auf GitHub<\/a>.<\/p>\n<p>Bei der Arbeit mit dem Schemagenerator sollten Sie einige Beschr\u00e4nkungen im Hinterkopf behalten. Als Faustregel gilt Folgendes: Wenn eine Kotlin-Klasse mit der protobuf-Implementierung von <code>kotlinx.serialization<\/code> serialisiert werden kann, wird sie auch vom Schemagenerator unterst\u00fctzt. Dies bedeutet gleichzeitig, dass f\u00fcr den Schemagenerator <a href=\"https:\/\/kotlin.github.io\/kotlinx.serialization\/kotlinx-serialization-protobuf\/kotlinx-serialization-protobuf\/kotlinx.serialization.protobuf\/-proto-buf\/index.html\" target=\"_blank\" rel=\"noopener\">die gleichen Einschr\u00e4nkungen<\/a> gelten. Hier sind einige Punkte, auf die Sie achten sollten:<\/p>\n<ul>\n<li>Die <em>Kotlin-Klassen und -Eigenschaftsnamen<\/em> m\u00fcssen der <a href=\"https:\/\/developers.google.com\/protocol-buffers\/docs\/reference\/proto2-spec\" target=\"_blank\" rel=\"noopener\">protobuf-Spezifikation<\/a> gen\u00fcgen und d\u00fcrfen keine unzul\u00e4ssigen Zeichen enthalten.<\/li>\n<li>Die <em>Nullability<\/em> in Kotlin wird im Schema nicht dargestellt (da proto2 keine Semantik daf\u00fcr besitzt). Die von Protocol Buffers bereitgestellten <em>optionalen Felder<\/em> werden dann verwendet, wenn Ihre Kotlin-Eigenschaften <em>Standardwerte<\/em> definieren.<\/li>\n<li>Kotlin-<em>Standardwerte<\/em> sind nicht im Schema enthalten. (Dies bedeutet, dass Sie selbst f\u00fcr die Einheitlichkeit der Standardwerte in den verschiedenen Sprachimplementierungen sorgen m\u00fcssen.)<\/li>\n<\/ul>\n<p><a name=\"start-using\"><\/a><\/p>\n<h2>Legen Sie mit kotlinx.serialization 1.2 los!<\/h2>\n<p>Damit ist unser \u00dcberblick auch schon abgeschlossen. Sind Sie bereit f\u00fcr <em>eine schnellere JSON-Codierung und -Decodierung, Nutzung der Typsystem-Erg\u00e4nzungen von Kotlin 1.5, die Generierung von Protobuf-Schemas und vieles mehr<\/em>? Dann ist es Zeit f\u00fcr ein Upgrade!<\/p>\n<p>Wenn Sie <code>kotlinx.serialization<\/code> bereits verwenden, ist das Upgrade auf Version 1.2 sehr schnell erledigt. Und wenn Sie <code>kotlinx.serialization<\/code> noch nicht ausprobiert haben, ist dies die perfekte Gelegenheit dazu! Aktualisieren Sie als Erstes den <code>plugins<\/code>-Abschnitt in Ihrer <code>build.gradle.kts<\/code>-Datei:<\/p>\n<pre class=\"kotlin-code\" data-highlight-only=\"true\" theme=\"idea\" indent=\"4\" style=\"visibility: hidden; padding: 36px 0;\">\nplugins {\nkotlin(&quot;jvm&quot;) version &quot;1.5.0&quot; \/\/ or kotlin(&quot;multiplatform&quot;) or any other kotlin plugin\nkotlin(&quot;plugin.serialization&quot;) version &quot;1.5.0&quot;\n}\n<\/pre>\n<p>Nehmen Sie dann die Laufzeitbibliothek in den <code>dependencies<\/code>-Abschnitt auf, mit den Formaten, die Sie in Ihrer Anwendung verwenden m\u00f6chten:<\/p>\n<pre class=\"kotlin-code\" data-highlight-only=\"true\" theme=\"idea\" indent=\"4\" style=\"visibility: hidden; padding: 36px 0;\">\ndependencies {\nimplementation(&quot;org.jetbrains.kotlinx:kotlinx-serialization-json:1.2.1&quot;)\nimplementation(&quot;org.jetbrains.kotlinx:kotlinx-serialization-protobuf:1.2.0&quot;)\n\/\/ . . .\n}\n<\/pre>\n<h2>Interessantes zum Lesen und Ansehen<\/h2>\n<ul>\n<li><a href=\"https:\/\/youtu.be\/698I_AH8h6s\" target=\"_blank\" rel=\"noopener\">Video zu kotlinx.serialization 1.2<\/a><\/li>\n<li><a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/\" target=\"_blank\" rel=\"noopener\">Die Bibliothek auf GitHub<\/a><\/li>\n<li><a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/blob\/master\/docs\/serialization-guide.md\" target=\"_blank\" rel=\"noopener\">Leitfaden zu kotlinx.serialization<\/a><\/li>\n<li><a href=\"https:\/\/kotlin.github.io\/kotlinx.serialization\/\" target=\"_blank\" rel=\"noopener\">API-Dokumentation<\/a><\/li>\n<li><a href=\"https:\/\/blog.jetbrains.com\/kotlin\/2021\/05\/kotlin-1-5-0-released\/\">Blogartikel zur Ver\u00f6ffentlichung von Kotlin 1.5.0<\/a><\/li>\n<\/ul>\n<h3>Hilfe bei Problemen<\/h3>\n<ul>\n<li>Bitte melden Sie Probleme in unserem <a href=\"https:\/\/github.com\/Kotlin\/kotlinx.serialization\/issues\" target=\"_blank\" rel=\"noopener\">Issue-Tracker auf GitHub<\/a>.<\/li>\n<li>Unterst\u00fctzung finden Sie im #serialization-Kanal des Kotlin-Slacks (<a href=\"https:\/\/surveys.jetbrains.com\/s3\/kotlin-slack-sign-up\" target=\"_blank\" rel=\"noopener\">eine Einladung erhalten Sie hier<\/a>).<\/li>\n<\/ul>\n<p><a href=\"https:\/\/www.youtube.com\/channel\/UCP7uiEZIqci43m22KDl0sNw?sub_confirmation=1\" target=\"_blank\" rel=\"noopener\">Abonnieren Sie Kotlin auf YouTube!<\/a> Viel Spa\u00df beim (De)Serialisieren!<\/p>\n","protected":false},"author":1038,"featured_media":137328,"comment_status":"closed","ping_status":"closed","template":"","categories":[909],"tags":[671],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/kotlin\/142767"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/kotlin"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/types\/kotlin"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/users\/1038"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/comments?post=142767"}],"version-history":[{"count":10,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/kotlin\/142767\/revisions"}],"predecessor-version":[{"id":144119,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/kotlin\/142767\/revisions\/144119"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/media\/137328"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/media?parent=142767"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/categories?post=142767"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/tags?post=142767"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/cross-post-tag?post=142767"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}