Die Verarbeitung von JSON-Daten ist in der heutigen Softwareentwicklung von entscheidender Bedeutung, da viele Anwendungen auf den Austausch von strukturierten Daten angewiesen sind. Die Jackson-Bibliothek, eine weit verbreitete Java-Bibliothek f\u00fcr die Verarbeitung von JSON, bietet leistungsstarke Mechanismen f\u00fcr die Serialisierung und Deserialisierung von Java-Objekten. In diesem Artikel werden wir uns auf bidirektionale Beziehungen zwischen Java-Klassen konzentrieren und wie Jackson diese Beziehungen effektiv handhabt.<\/p>\n\n\n\n
Jackson ist eine Java-Bibliothek, die es erm\u00f6glicht, JSON-Daten in Java-Objekte zu konvertieren und umgekehrt. Sie bietet eine einfache und flexible API, um Daten zwischen Java-Objekten und JSON zu \u00fcbertragen. Jackson verwendet Annotationen, um die Serialisierung und Deserialisierung von Java-Objekten zu steuern.<\/p>\n\n\n
\/\/ Beispielklasse mit Jackson-Annotationen<\/span>\npublic<\/span> class<\/span> Person<\/span> <\/span>{\n @JsonProperty(\"name\"<\/span>)\n private<\/span> String fullName;\n\n @JsonProperty(\"age\"<\/span>)\n private<\/span> int age;\n\n \/\/ Konstruktoren, Getter und Setter<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\nIm obigen Beispiel wird die @JsonProperty<\/code>-Annotation verwendet, um die Zuordnung zwischen den Feldern der Java-Klasse und den Schl\u00fcsseln im JSON-Objekt festzulegen.<\/p>\n\n\n\nBidirektionale Beziehungen verstehen<\/h2>\n\n\n\n
Bidirektionale Beziehungen treten auf, wenn zwei Klassen in einer Weise miteinander verbunden sind, dass eine Instanz einer Klasse eine Beziehung zu einer oder mehreren Instanzen der anderen Klasse hat, und umgekehrt. Dies kann in der Praxis h\u00e4ufig vorkommen, beispielsweise wenn wir eine Person<\/code>-Klasse und eine Address<\/code>-Klasse haben, wobei eine Person eine Adresse hat und eine Adresse einer oder mehreren Personen zugeordnet sein kann.<\/p>\n\n\n\/\/ Beispiel f\u00fcr bidirektionale Beziehung<\/span>\npublic<\/span> class<\/span> Person<\/span> <\/span>{\n @JsonProperty(\"name\"<\/span>)\n private<\/span> String fullName;\n\n @JsonProperty(\"age\"<\/span>)\n private<\/span> int age;\n\n @JsonProperty(\"address\"<\/span>)\n private<\/span> Address address;\n\n \/\/ Konstruktoren, Getter und Setter<\/span>\n}\n\npublic<\/span> class<\/span> Address<\/span> <\/span>{\n @JsonProperty(\"street\"<\/span>)\n private<\/span> String street;\n\n @JsonProperty(\"city\"<\/span>)\n private<\/span> String city;\n\n @JsonProperty(\"residents\"<\/span>)\n private<\/span> List<\/span><Person> residents;\n\n \/\/ Konstruktoren, Getter und Setter<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\nIn diesem Beispiel hat die Person<\/code>-Klasse eine Referenz auf eine Address<\/code>-Instanz, und die Address<\/code>-Klasse hat eine Liste von Person<\/code>-Instanzen als Bewohner. Dies ist eine bidirektionale Beziehung zwischen den Klassen.<\/p>\n\n\n\nHerausforderungen bei der Serialisierung von bidirektionalen Beziehungen<\/h2>\n\n\n\n
Bei der Serialisierung von Objekten mit bidirektionalen Beziehungen k\u00f6nnen Schwierigkeiten auftreten. Wenn beide Klassen einfach so serialisiert werden, besteht das Risiko von Endlosschleifen oder redundanten Daten. Betrachten wir das obige Beispiel und wie Jackson damit umgeht.<\/p>\n\n\n
\/\/ Beispiel f\u00fcr bidirektionale Beziehung<\/span>\npublic<\/span> class<\/span> Person<\/span> <\/span>{\n @JsonProperty(\"name\"<\/span>)\n private<\/span> String fullName;\n\n @JsonProperty(\"age\"<\/span>)\n private<\/span> int age;\n\n @JsonProperty(\"address\"<\/span>)\n private<\/span> Address address;\n\n \/\/ Konstruktoren, Getter und Setter<\/span>\n}\n\npublic<\/span> class<\/span> Address<\/span> <\/span>{\n @JsonProperty(\"street\"<\/span>)\n private<\/span> String street;\n\n @JsonProperty(\"city\"<\/span>)\n private<\/span> String city;\n\n @JsonProperty(\"residents\"<\/span>)\n private<\/span> List<\/span><Person> residents;\n\n \/\/ Konstruktoren, Getter und Setter<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\nWenn wir versuchen, eine Person<\/code>-Instanz zu serialisieren, wird Jackson standardm\u00e4\u00dfig auch die zugeh\u00f6rige Address<\/code>-Instanz serialisieren, und umgekehrt. Dies kann zu einem unerw\u00fcnschten Effekt f\u00fchren, da die Person<\/code>-Instanz in der Address<\/code>-Instanz enthalten ist, und diese wiederum auf die urspr\u00fcngliche Person<\/code>-Instanz verweist, was zu einer Endlosschleife f\u00fchren kann.<\/p>\n\n\n\nUm dieses Problem zu l\u00f6sen, bietet Jackson verschiedene Ans\u00e4tze und Annotationen.<\/p>\n\n\n\n
@JsonManagedReference und @JsonBackReference<\/h2>\n\n\n\n
Eine M\u00f6glichkeit, bidirektionale Beziehungen zu handhaben, besteht darin, die Annotationen @JsonManagedReference<\/code> und @JsonBackReference<\/code> zu verwenden. Diese Annotationen weisen Jackson an, wie die Beziehung zwischen den Klassen verwaltet werden soll.<\/p>\n\n\n\/\/ Beispiel mit @JsonManagedReference und @JsonBackReference<\/span>\npublic<\/span> class<\/span> Person<\/span> <\/span>{\n @JsonProperty(\"name\"<\/span>)\n private<\/span> String fullName;\n\n @JsonProperty(\"age\"<\/span>)\n private<\/span> int age;\n\n @JsonManagedReference\n @JsonProperty(\"address\"<\/span>)\n private<\/span> Address address;\n\n \/\/ Konstruktoren, Getter und Setter<\/span>\n}\n\npublic<\/span> class<\/span> Address<\/span> <\/span>{\n @JsonProperty(\"street\"<\/span>)\n private<\/span> String street;\n\n @JsonProperty(\"city\"<\/span>)\n private<\/span> String city;\n\n @JsonBackReference\n @JsonProperty(\"residents\"<\/span>)\n private<\/span> List<\/span><Person> residents;\n\n \/\/ Konstruktoren, Getter und Setter<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\nIn diesem Beispiel wird @JsonManagedReference<\/code> auf das Feld in der „managenden“ Klasse (Person<\/code>) angewendet, und @JsonBackReference<\/code> wird auf das Feld in der „r\u00fcckverweisenden“ Klasse (Address<\/code>) angewendet. Dies teilt Jackson mit, dass die „managende“ Seite der Beziehung w\u00e4hrend der Serialisierung ber\u00fccksichtigt werden sollte, w\u00e4hrend die „r\u00fcckverweisende“ Seite ignoriert wird. Dies verhindert die Endlosschleife und redundante Daten.<\/p>\n\n\n\n@JsonIdentityInfo<\/h2>\n\n\n\n
Eine andere M\u00f6glichkeit, bidirektionale Beziehungen zu handhaben, ist die Verwendung der @JsonIdentityInfo<\/code>-Annotation. Diese Annotation erm\u00f6glicht es Jackson, Objekte mit einer eindeutigen ID zu versehen und sicherzustellen, dass dieselbe Instanz w\u00e4hrend der Serialisierung nur einmal erscheint.<\/p>\n\n\n\/\/ Beispiel mit @JsonIdentityInfo<\/span>\n@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = \"id\"<\/span>)\npublic class<\/span> Person<\/span> <\/span>{\n @JsonProperty(\"id\"<\/span>)\n private Long id;\n\n @JsonProperty(\"name\"<\/span>)\n private String<\/span> fullName;\n\n @JsonProperty(\"age\"<\/span>)\n private int age;\n\n @JsonProperty(\"address\"<\/span>)\n private Address address;\n\n \/\/ Konstruktoren, Getter und Setter<\/span>\n}\n\n@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = \"id\"<\/span>)\npublic class<\/span> Address<\/span> <\/span>{\n @JsonProperty(\"id\"<\/span>)\n private Long id;\n\n @JsonProperty(\"street\"<\/span>)\n private String<\/span> street;\n\n @JsonProperty(\"city\"<\/span>)\n private String<\/span> city;\n\n @JsonProperty(\"residents\"<\/span>)\n private List<Person> residents;\n\n \/\/ Konstruktoren, Getter und Setter<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\nIn diesem Beispiel wird @JsonIdentityInfo<\/code> auf beide Klassen angewendet und mit einem PropertyGenerator<\/code> konfiguriert. Dies stellt sicher, dass Objekte mit derselben ID w\u00e4hrend der Serialisierung nur einmal erscheinen, unabh\u00e4ngig von ihrer tats\u00e4chlichen Verwendung in der Datenstruktur.<\/p>\n\n\n\nFazit<\/h2>\n\n\n\n
Die Handhabung bidirektionaler Beziehungen in der Serialisierung und Deserialisierung von JSON mit Jackson erfordert sorgf\u00e4ltige Aufmerksamkeit, um Endlosschleifen und redundante Daten zu vermeiden. Die vorgestellten Ans\u00e4tze mit Annotationen wie @JsonManagedReference<\/code>, @JsonBackReference<\/code> und @JsonIdentityInfo<\/code> bieten effektive L\u00f6sungen f\u00fcr dieses Problem. Entwickler sollten die geeignete Methode basierend auf den Anforderungen ihrer Anwendung ausw\u00e4hlen und sicherstellen, dass die JSON-Daten konsistent und korrekt verarbeitet werden.<\/p>\n","protected":false},"excerpt":{"rendered":"Die Verarbeitung von JSON-Daten ist in der heutigen Softwareentwicklung von entscheidender Bedeutung, da viele Anwendungen auf den Austausch von strukturierten Daten angewiesen sind. Die Jackson-Bibliothek, eine weit verbreitete Java-Bibliothek f\u00fcr die Verarbeitung von JSON, bietet leistungsstarke Mechanismen f\u00fcr die Serialisierung und Deserialisierung von Java-Objekten. In diesem Artikel werden wir uns auf bidirektionale Beziehungen zwischen Java-Klassen […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-171","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/171","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=171"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/171\/revisions"}],"predecessor-version":[{"id":172,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/171\/revisions\/172"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=171"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=171"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=171"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}