{"id":33131,"date":"2023-01-18T21:29:04","date_gmt":"2023-01-18T20:29:04","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=33131"},"modified":"2026-04-05T22:21:52","modified_gmt":"2026-04-05T20:21:52","slug":"hexagonale-architektur","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/software-craftsmanship\/hexagonale-architektur\/","title":{"rendered":"Hexagonale Architektur \u2013 Was ist das? Was sind ihre Vorteile?"},"content":{"rendered":"\n<p>In diesem Artikel erf\u00e4hrst du:<\/p>\n\n\n\n<ul class=\"wp-block-list hc-checked-list\">\n<li>Was ist hexagonale Architektur (bzw. \u201ePorts &amp; Adapters\u201c, wie diese Architektur offiziell hei\u00dft)?<\/li>\n\n\n\n<li>Was sind die Vorteile der hexagonalen Architektur gegen\u00fcber der klassischen Schichtenarchitektur?<\/li>\n\n\n\n<li>Was unterscheidet die hexagonale Architektur von \u201eClean Architecture\u201c und \u201eOnion Architecture\u201c?<\/li>\n\n\n\n<li>Wie stehen hexagonale Architektur, Microservices und Domain Driven Design im Zusammenhang?<\/li>\n<\/ul>\n\n\n\n<p><a href=\"\/de\/software-craftsmanship\/hexagonale-architektur-java\/\">Wie man eine hexagonale Software-Architektur mit Java <em>implementiert<\/em><\/a> \u2013 einmal ohne Application Framework, einmal <a href=\"\/de\/software-craftsmanship\/hexagonale-architektur-quarkus\/\">mit Quarkus<\/a> und einmal mit Spring Boot \u2013 und wie man sicherstellt, dass die Architekturgrenzen nicht verletzt werden, zeige ich dir in vier weiteren Teilen dieser Artikelserie.<\/p>\n\n\n\n<figure class=\"wp-block-embed is-type-video is-provider-youtube wp-block-embed-youtube wp-embed-aspect-16-9 wp-has-aspect-ratio\"><div class=\"wp-block-embed__wrapper\">\n<iframe title=\"Hexagonale Architektur: Robuste Software dank Schnittstellen statt Schichten\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/7GRG1mDVj8s?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>\n<\/div><\/figure>\n\n\n\n<p>Bevor ich auf die Details der hexagonalen Architektur eingehe, erkl\u00e4re ich kurz den Zweck einer Softwarearchitektur und warum das am weitesten verbreitete Architekturmuster, die Schichtenarchitektur, nicht f\u00fcr gr\u00f6\u00dfere Projekte geeignet ist.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"was-ist-das-ziel-einer-softwarearchitektur\">Was ist das Ziel einer Softwarearchitektur?<\/h2>\n\n\n\n<p>Unter Architektur verstehen wir die Aufteilung eines Systems in Komponenten, die Anordnung und Eigenschaften dieser Komponenten und die Art und Weise, wie diese Komponenten miteinander kommunizieren.<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-half_600\"><img decoding=\"async\" width=\"600\" height=\"302\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/software-architecture-600x302.png\" alt=\"Eine &quot;historisch gewachsene&quot; Softwarearchitektur\" class=\"wp-image-34969\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/software-architecture-600x302.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/software-architecture-224x113.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/software-architecture-336x169.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/software-architecture-504x254.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/software-architecture-672x338.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/software-architecture-400x201.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/software-architecture-800x403.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/software-architecture-944x475.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/software-architecture.png 1200w\" sizes=\"(max-width: 600px) 100vw, 600px\" \/><figcaption class=\"wp-element-caption\">Eine \u201ehistorisch gewachsene\u201c Softwarearchitektur<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Laut <a href=\"https:\/\/www.happycoders.eu\/de\/buecher\/clean-architecture-gute-softwarearchitekturen\/\">Robert C. Martins Buch \u201eClean Architecture\u201c<\/a> erlaubt eine <em>gute<\/em> Architektur, Software w\u00e4hrend ihrer Lebensdauer mit m\u00f6glichst geringem, gleichbleibendem Aufwand (und entsprechend planbaren Kosten f\u00fcr den Auftraggeber) zu \u00e4ndern.<\/p>\n\n\n\n<p>\u00c4nderungen k\u00f6nnten sein:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Umsetzung von Kundenw\u00fcnschen;<\/li>\n\n\n\n<li>Anpassungen an ge\u00e4nderte gesetzliche Vorgaben;<\/li>\n\n\n\n<li>Einsatz modernerer Technologien (z. B. Austausch einer SOAP-API durch eine REST-API);<\/li>\n\n\n\n<li>Upgrade von Infrastruktur-Komponenten (z. B. Upgrade des Datenbank-Servers oder der ORM-Library auf eine neue Version);<\/li>\n\n\n\n<li>Austausch von Drittsystemen (z. B. des externen Billing- oder Newsletter-Versandsystems);<\/li>\n\n\n\n<li>und sogar ein Austausch des Application Servers (z. B. Quarkus statt Glassfish).<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"wie-entwickelt-man-eine-gute-software-architektur\">Wie entwickelt man eine gute Software-Architektur?<\/h3>\n\n\n\n<p>Um eine Software \u201esoft\u201c zu halten, sollte die Anwendung in gut isolierte, unabh\u00e4ngig voneinander entwickelbare und testbare Komponenten aufgeteilt werden (ein automatisiertes Deployment geh\u00f6rt auch dazu, ist aber nicht Thema dieses Artikels).<\/p>\n\n\n\n<p>In den meisten Gesch\u00e4ftsanwendungen wird versucht, dieses Ziel durch die klassische Schichtenarchitektur zu erreichen:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-half_400\"><img decoding=\"async\" width=\"400\" height=\"417\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/three-layer-architecture.v2-400x417.png\" alt=\"Klassische Drei-Schichten-Architektur\" class=\"wp-image-34829\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/three-layer-architecture.v2-400x417.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/three-layer-architecture.v2-224x234.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/three-layer-architecture.v2-336x350.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/three-layer-architecture.v2-504x525.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/three-layer-architecture.v2-672x701.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/three-layer-architecture.v2-600x626.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/three-layer-architecture.v2.png 800w\" sizes=\"(max-width: 400px) 100vw, 400px\" \/><figcaption class=\"wp-element-caption\">Klassische Drei-Schichten-Architektur<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Die Praxis hat allerdings gezeigt, dass die Schichtenarchitektur f\u00fcr gro\u00dfe Projekte nicht gut geeignet ist. Warum das so ist, erf\u00e4hrst du im n\u00e4chsten Abschnitt.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"nachteile-der-schichtenarchitektur\">Nachteile der Schichtenarchitektur<\/h3>\n\n\n\n<p>Die Schichtenarchitektur f\u00fchrt zu einer unn\u00f6tigen Kopplung mit negativen Folgen:<\/p>\n\n\n\n<p>Die Gesch\u00e4ftslogik hat eine direkte Abh\u00e4ngigkeit zur Datenbank, die Pr\u00e4sentationsschicht hat eine transitive Abh\u00e4ngigkeit. So sind beispielsweise alle Entities, Repositories und ORM-Libraries (wie z. B. <a href=\"https:\/\/hibernate.org\/\" target=\"_blank\" rel=\"noopener\">Hibernate<\/a> oder <a href=\"https:\/\/eclipse.dev\/eclipselink\/\" target=\"_blank\" rel=\"noopener\">EclipseLink<\/a> in der Java-Welt) auch in der Pr\u00e4sentationsschicht verf\u00fcgbar. Dies verf\u00fchrt Entwickler \u2013 vor allem wenn sie unter Zeitdruck stehen \u2013 dazu, die Grenzen zwischen den Schichten aufweichen zu lassen.<\/p>\n\n\n\n<p>Nicht selten kommt es zu Fehlern, weil z. B. in der Pr\u00e4sentationsschicht versucht wird, \u00fcber eine nicht initialisierte One-To-Many-Collection einer JPA-Entity zu iterieren. Und so m\u00fcssen wir uns im Business Layer \u2013 der eigentlich <em>fachlichen<\/em> Schicht \u2013 Gedanken \u00fcber <em>technische<\/em> Belange wie Transaktionen, Lazy und Eager Loading machen.<\/p>\n\n\n\n<p>Die Kopplung macht es zudem unn\u00f6tig schwer, die Datenbank oder die Datenzugriffsschicht zu aktualisieren (z. B. auf eine neue Datenbank-Version oder eine neue Version des O\/R-Mappers). Ich habe zahlreiche Gesch\u00e4ftsanwendungen gesehen, die mit veralteten (d. h. fehlerhaften und\/oder unsicheren) Hibernate- oder EclipseLink-Versionen arbeiten, weil ein Update Anpassungen in allen Schichten der Anwendung erfordern w\u00fcrde und durch das Management herunterpriorisiert wurde.<\/p>\n\n\n\n<p>Das betrifft \u00fcbrigens nicht nur die Datenbank, sondern jegliche Art von Infrastruktur, auf die die Anwendung zugreift. So sind mir auch schon Zugriffe auf die <a href=\"https:\/\/developers.facebook.com\/docs\/graph-api\/\" target=\"_blank\" rel=\"noopener\">Facebook Graph API<\/a> aus der Pr\u00e4sentationsschicht begegnet.<\/p>\n\n\n\n<p>Die Aufweichung der Schichtengrenzen macht dar\u00fcberhinaus das isolierte Testen einzelner Komponenten \u2013 z. B. der Gesch\u00e4ftslogik ohne User Interface und Datenbank \u2013 unm\u00f6glich.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"was-ist-hexagonale-architektur\">Was ist Hexagonale Architektur?<\/h2>\n\n\n\n<p>Die hexagonale Software-Architektur wurde 2005 von Alistair Cockburn in <a rel=\"noopener\" href=\"https:\/\/alistair.cockburn.us\/hexagonal-architecture\" target=\"_blank\">einem Blogartikel<\/a> vorgestellt. Cockburn nennt folgende Ziele:<\/p>\n\n\n\n<ul class=\"wp-block-list hc-checked-list\">\n<li>Die Anwendung soll gleicherma\u00dfen von Benutzern, anderen Anwendungen oder automatisierten Tests gesteuert werden k\u00f6nnen. F\u00fcr die Gesch\u00e4ftslogik macht es keinen Unterschied, ob sie von einem User Interface, einer REST-API oder einem Test-Framework aufgerufen wird.<\/li>\n\n\n\n<li>Die Gesch\u00e4ftslogik soll isoliert von der Datenbank, von sonstiger Infrastruktur und von Drittsystemen entwickelt und getestet werden k\u00f6nnen. Aus Sicht der Gesch\u00e4ftslogik macht es keinen Unterschied, ob Daten in einer relationalen Datenbank, einem NoSQL-System, in XML-Dateien oder in einem propriet\u00e4ren Bin\u00e4rformat gespeichert werden.<\/li>\n\n\n\n<li>Die Modernisierung von Infrastruktur (z. B. Aktualisierung des Datenbankservers, Anpassung an ge\u00e4nderte externe Schnittstellen, Aktualisierung unsicherer Libraries) soll ohne Anpassungen an der Gesch\u00e4ftslogik m\u00f6glich sein.<\/li>\n<\/ul>\n\n\n\n<p>Wie die hexagonale Architektur diese Ziele erreicht, erf\u00e4hrst du im n\u00e4chsten Abschnitt.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"ports-und-adapter\">Ports und Adapter<\/h3>\n\n\n\n<p>Erreicht wird die Isolierung von Gesch\u00e4ftslogik (in der hexagonalen Architektur mit \u201eApplication\u201c bezeichnet) zur Au\u00dfenwelt \u00fcber sogenannte \u201ePorts\u201c und \u201eAdapter\u201c, wie in der folgenden Grafik dargestellt:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-half_600\"><img decoding=\"async\" width=\"600\" height=\"431\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture.v2-600x431.png\" alt=\"Hexagonale Architektur mit Kern (&quot;Application&quot;), Ports, Adaptern und externen Komponenten\" class=\"wp-image-34956\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture.v2-600x431.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture.v2-224x161.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture.v2-336x241.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture.v2-504x362.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture.v2-672x483.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture.v2-400x287.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture.v2-800x575.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture.v2-944x678.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture.v2.png 1200w\" sizes=\"(max-width: 600px) 100vw, 600px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur mit Gesch\u00e4ftslogik im Kern (\u201eApplication\u201c), Ports, Adaptern und externen Komponenten<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Die Gesch\u00e4ftslogik (\u201eApplication\u201c) befindet sich im Kern der Architektur und definiert Schnittstellen (\u201ePorts\u201c), um mit der Au\u00dfenwelt zu kommunizieren \u2013 und zwar sowohl um <em>gesteuert zu werden<\/em> (durch eine API, durch ein User Interface, durch andere Anwendungen) als auch um <em>zu steuern<\/em> (die Datenbank, externe Schnitstellen, sonstige Infrastruktur).<\/p>\n\n\n\n<p>Die Gesch\u00e4ftslogik kennt ausschlie\u00dflich diese Ports; all ihre Use Cases sind ausschlie\u00dflich gegen die Spezifikationen der Ports implementiert. F\u00fcr die Gesch\u00e4ftslogik ist es irrelevant, welche technischen Details sich m\u00f6glicherweise hinter diesen Ports befinden.<\/p>\n\n\n\n<p>Die folgende Abbildung zeigt eine beispielhafte Anwendung, die<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li>durch einen User \u00fcber ein User Interface gesteuert wird,<\/li>\n\n\n\n<li>durch einen User \u00fcber eine REST-API gesteuert wird,<\/li>\n\n\n\n<li>durch eine externe Anwendung \u00fcber dieselbe REST-API gesteuert wird,<\/li>\n\n\n\n<li>eine Datenbank ansteuert und<\/li>\n\n\n\n<li>eine externe Anwendung ansteuert.<\/li>\n<\/ol>\n\n\n\n<p>(Die Nummerierung steht nicht f\u00fcr eine Reihenfolge, sondern referenziert die Pfeile in der Abbildung.)<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"474\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4-800x474.png\" alt=\"Hexagonale Architektur mit Kontrollfluss\" class=\"wp-image-34981\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4-800x474.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4-224x133.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4-336x199.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4-504x299.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4-672x398.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4-400x237.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4-600x356.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4-944x559.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4-1200x711.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-with-control-flow.v4.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur mit Kontrollfluss<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Die Anbindung der externen Komponenten wird durch \u201eAdapter\u201c realisiert.<\/p>\n\n\n\n<p>So k\u00f6nnte z. B. das User Interface ein Registrierungsformular bereitstellen. Wenn der User alle Daten ausgef\u00fcllt hat und auf \u201eRegistrieren\u201c klickt, generiert der UI-Adapter daraus ein \u201eRegistriere User\u201c-Kommando und schickt dieses an die Gesch\u00e4ftslogik. Das gleiche Kommando k\u00f6nnte aber auch durch den REST-Adapter f\u00fcr einen entsprechenden HTTP-POST-Request generiert werden:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-half_600\"><img decoding=\"async\" width=\"600\" height=\"348\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driving-ports-and-adapters-600x348.png\" alt=\"Hexagonale Architektur: Port mit User-Interface- und REST-Adapter\" class=\"wp-image-34900\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driving-ports-and-adapters-600x348.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driving-ports-and-adapters-224x130.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driving-ports-and-adapters-336x195.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driving-ports-and-adapters-504x292.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driving-ports-and-adapters-672x390.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driving-ports-and-adapters-400x232.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driving-ports-and-adapters-800x464.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driving-ports-and-adapters-944x548.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driving-ports-and-adapters.png 1200w\" sizes=\"(max-width: 600px) 100vw, 600px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Port mit User-Interface- und REST-Adapter<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Auf der \u201eanderen Seite\u201c der Anwendung k\u00f6nnte der Datenbank-Adapter das Kommando \u201eSpeichere Benutzer\u201c in eine \u201e<code>INSERT INTO User VALUES (...)<\/code>\u201c-SQL-Query \u00fcbersetzen:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-half_600\"><img decoding=\"async\" width=\"600\" height=\"348\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driven-port-and-adapter-600x348.png\" alt=\"Hexagonale Architektur: Port mit Datenbank-Adapter\" class=\"wp-image-34898\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driven-port-and-adapter-600x348.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driven-port-and-adapter-224x130.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driven-port-and-adapter-336x195.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driven-port-and-adapter-504x292.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driven-port-and-adapter-672x390.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driven-port-and-adapter-400x232.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driven-port-and-adapter-800x464.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driven-port-and-adapter-944x548.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-driven-port-and-adapter.png 1200w\" sizes=\"(max-width: 600px) 100vw, 600px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Port mit Datenbank-Adapter<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Wie genau der Adapter das bewerkstelligt \u2013 ob er dazu einen O\/R-Mapper einsetzt und welchen und in welcher Version \u2013 spielt aus Sicht des Anwendungskerns keine Rolle.<\/p>\n\n\n\n<p>An einen Port k\u00f6nnen <em>mehrere<\/em> Adapter angeschlossen werden. So kann \u2013 wie im Beispiel oben \u2013 an den Port f\u00fcr die Steuerung der Anwendung ein User-Interface-Adapter und ein REST-Adapter angeschlossen sein. Und an einen Port zum Versand von Notifications k\u00f6nnte ein E-Mail-Adapter, ein SMS-Adapter und ein WhatsApp-Adapter angeschlossen sein.<\/p>\n\n\n\n<p>Der Begriff \u201ePort\u201c ist \u00fcbrigens eine Anspielung auf elektrische Anschl\u00fcsse (englisch: \u201eports\u201c), an die jedes Ger\u00e4t angeschlossen werden kann, das den mechanischen und elektrischen Protokollen des Anschlusses entspricht.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"primaere-und-sekundaere-ports-und-adapter\">Prim\u00e4re und sekund\u00e4re Ports und Adapter<\/h3>\n\n\n\n<p>Am Beispiel oben haben wir bereits gesehen, dass es zwei Arten von Ports und Adaptern gibt. Solche, die die Anwendung <em>steuern<\/em> und solche, die von der Anwendung <em>gesteuert werden<\/em>.<\/p>\n\n\n\n<p>Die erste Gruppe nennen wir \u201eprim\u00e4re\u201c oder \u201etreibende\u201c (englisch: \u201eprimary\u201c, \u201edriving\u201c) Ports und Adapter; diese werden in der Regel auf der linken Seite des Hexagons dargestellt.<\/p>\n\n\n\n<p>Die zweite Gruppe bezeichnen wir als \u201esekund\u00e4re\u201c oder \u201egetriebene\u201c (englisch: \u201esecondary\u201c, \u201edriven\u201c) Ports und Adapter; sie werden normalerweise rechts dargestellt.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"dependency-rule\">Dependency Rule <\/h3>\n\n\n\n<p>In der Theorie h\u00f6rt sich das soweit ganz gut an. Doch wie erreichen wir programmatisch, dass keine technischen Details (wie JPA-Entities) und Libraries (wie O\/R-Mapper) zur Anwendung durchsickern?<\/p>\n\n\n\n<p>Die Antwort findet sich in der sogenannten \u201eDependency Rule\u201c (deutsch: Abh\u00e4ngigkeitsregel). Diese besagt, dass alle Quellcode-Abh\u00e4ngkeiten ausschlie\u00dflich von au\u00dfen nach innen, also in Richtung des Application Hexagons zeigen d\u00fcrfen:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"458\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2-800x458.png\" alt=\"Hexagonale Architektur: Dependency Rule\" class=\"wp-image-34959\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2-800x458.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2-224x128.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2-336x192.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2-504x289.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2-672x385.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2-400x229.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2-600x344.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2-944x540.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2-1200x687.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-rule.v2.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Dependency Rule<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Die Umsetzung in Klassen und ihre Beziehungen zueinander gestaltet sich f\u00fcr <em>prim\u00e4re<\/em> Ports und Adapter (also die linke Seite der Grafik) recht simpel.<\/p>\n\n\n\n<p>Um beim Beispiel der Benutzerregistrierung zu bleiben, k\u00f6nnten wir die gew\u00fcnschte Architektur etwa mit folgenden Klassen realisieren:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"342\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2-800x342.png\" alt=\"Hexagonale Architektur: Klassendiagramm von prim\u00e4rem Port und Adapter\" class=\"wp-image-34921\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2-800x342.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2-224x96.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2-336x144.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2-504x215.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2-672x287.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2-400x171.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2-600x257.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2-944x404.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2-1200x513.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driving-side.v2.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Klassendiagramm von prim\u00e4rem Port und Adapter<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Der <code>RegistrationController<\/code> ist der Adapter. Der prim\u00e4re Port wird durch das Interface <code>RegistrationUseCase<\/code> definiert. Die durch den Port beschriebene Funktionalit\u00e4t wird durch den <code>RegistrationService<\/code> implementiert. (Diese Namenskonvention habe ich dem gro\u00dfartigen Buch <a href=\"https:\/\/www.happycoders.eu\/de\/buecher\/get-your-hands-dirty-on-clean-architecture\/\">\u201eGet Your Hands Dirty on Clean Architecture\u201c von Tom Hombergs<\/a> entnommen.)<\/p>\n\n\n\n<p>Die Quellcode-Abh\u00e4ngigkeit f\u00fchrt von <code>RegistrationController<\/code> zu <code>RegistrationUseCase<\/code>, also, wie gefordert, in Richtung Kern.<\/p>\n\n\n\n<p>Doch wie implementieren wir die <em>sekund\u00e4ren<\/em> Ports und Adapter, also die rechte Seite der Grafik, auf der die Quellcode-Abh\u00e4ngigkeit <em>entgegengesetzt<\/em> zur Aufrufrichtung sein muss? Wie kann der Kern der Anwendung beispielsweise auf die Datenbank zugreifen, wenn sich die Datenbank au\u00dferhalb des Kerns befindet und die Quellcode-Abh\u00e4ngkeit <em>zum<\/em> Kern gerichtet sein soll?<\/p>\n\n\n\n<p>Hier kommt das <a rel=\"noopener\" href=\"https:\/\/de.wikipedia.org\/wiki\/Dependency-Inversion-Prinzip\" target=\"_blank\">Dependency Inversion Principle<\/a>, also eine Umkehrung der Abh\u00e4ngigkeit, ins Spiel.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"dependency-inversion\">Dependency Inversion<\/h3>\n\n\n\n<p>Der Port wird auch hier durch ein Interface definiert. Allerdings sind die Beziehungen zwischen den Klassen ausgetauscht: Der <code>PersistanceAdapter<\/code> benutzt den <code>PersistencePort<\/code> nicht, sondern <em>implementiert<\/em> ihn. Und der <code>RegistrationService<\/code> implementiert den <code>PersistencePort<\/code> nicht, sondern <em>benutzt<\/em> ihn:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"347\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2-800x347.png\" alt=\"Hexagonale Architektur: Klassendiagramm von sekund\u00e4rem Port und Adapter\" class=\"wp-image-34922\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2-800x347.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2-224x97.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2-336x146.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2-504x219.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2-672x291.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2-400x174.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2-600x260.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2-944x409.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2-1200x521.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-class-diagram-driven-side.v2.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Klassendiagramm von sekund\u00e4rem Port und Adapter<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Mittels Dependency Inversion Principle k\u00f6nnen wir also die Richtung einer Code-Abh\u00e4ngigkeit w\u00e4hlen \u2013 f\u00fcr sekund\u00e4re Ports und Adapter also entgegengesetzt zur Aufrufrichtung.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"mapping\">Mapping<\/h3>\n\n\n\n<p>Die Isolierung der technischen Details vom Anwendungskern f\u00fchrt zu einem Dilemma, das sich z. B. beim Einsatz eines O\/R-Mappers bemerkbar macht. Entity-Klassen werden in der Regel mit Annotationen versehen, die den Mapper instruieren, auf welche Datenbanktabelle und Spalten die Entity und ihre Properties gemappt werden sollen, wie der Prim\u00e4rschl\u00fcssel zu generieren ist und wie Collections auf Relationen abzubilden sind.<\/p>\n\n\n\n<p>Da der Anwendungskern die technischen Details des Persistenz-Adapters nicht kennen soll, kann solch eine Entity im Anwendungskern nicht mit diesen technischen Annotationen versehen werden:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"362\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library-800x362.png\" alt=\"Dependency Rule: Abh\u00e4ngigkeiten vom Kern zum Adapter sind nicht erlaubt\" class=\"wp-image-35039\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library-800x362.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library-224x101.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library-336x152.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library-504x228.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library-672x304.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library-400x181.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library-600x271.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library-944x427.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library-1200x543.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-no-dependency-from-application-to-adapter-library.png 1566w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Dependency Rule: Abh\u00e4ngigkeiten vom Kern zum Adapter sind nicht erlaubt<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Andererseits kann die Entity nicht im Adapter implementiert werden, da dann der Anwendungskern keinen Zugriff mehr auf sie haben w\u00fcrde:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"433\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model-800x433.png\" alt=\"Dependency Rule: Abh\u00e4ngigkeiten vom Kern zum Adapter sind nicht erlaubt\" class=\"wp-image-35045\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model-800x433.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model-224x121.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model-336x182.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model-504x273.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model-672x364.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model-400x217.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model-600x325.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model-944x511.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model-1200x650.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-dependency-from-application-to-adapter-model.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Dependency Rule: Abh\u00e4ngigkeiten vom Kern zum Adapter sind nicht erlaubt<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Wie l\u00f6st man dieses Dilemma auf?<\/p>\n\n\n\n<p>In den n\u00e4chsten Abschnitten stelle ich dir verschiedene Strategien daf\u00fcr vor.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Duplikation mit Zwei-Wege-Mapping<\/h4>\n\n\n\n<p>Wir legen eine zus\u00e4tzliche Modellklasse im Adapter an, die keinerlei Gesch\u00e4ftslogik enth\u00e4lt, daf\u00fcr aber die technischen Annotationen. Der Adapter muss dann die Modellklasse des Kerns auf die eigene Modellklasse mappen und umgekehrt.<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"433\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping-800x433.png\" alt=\"Hexagonale Architektur: Duplikation mit Zwei-Wege-Mapping\" class=\"wp-image-35046\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping-800x433.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping-224x121.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping-336x182.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping-504x273.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping-672x364.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping-400x217.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping-600x325.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping-944x511.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping-1200x650.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-two-way-mapping.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Duplikation mit Zwei-Wege-Mapping<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Nach meiner Erfahrung ist diese Variante die am besten geeignete.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Duplikation mit Ein-Weg-Mapping<\/h4>\n\n\n\n<p>Wir definieren im Kern ein Interface, welches sowohl von der Modellklasse im Kern als auch von der Modellklasse im Adapter implementiert wird. So muss nur das vom Kern kommende Modell in das Adapter-Modell \u00fcbersetzt werden. Eine \u00dcbersetzung Richtung Kern ist nicht n\u00f6tig: Der Adapter kann dem Kern seine eigene Modellklasse schicken, da diese das im Kern definierte Interface implementiert.<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"541\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping-800x541.png\" alt=\"Hexagonale Architektur: Duplikation mit Ein-Weg-Mapping\" class=\"wp-image-35047\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping-800x541.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping-224x151.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping-336x227.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping-504x341.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping-672x454.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping-400x270.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping-600x406.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping-944x638.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping-1200x811.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-one-way-mapping.png 1592w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Duplikation mit Ein-Weg-Mapping<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Diese Variante erfordert, dass das Interface nur die Zugriffsmethoden f\u00fcr diejenigen Felder definiert, die persistiert werden sollen. Gesch\u00e4ftslogik-Methoden d\u00fcrfen im Interface nicht definiert werden. Mir gef\u00e4llt diese Strategie nicht, da sie weniger intuitiv ist und nach meiner Erfahrung mehr Aufwand darstellt und schlechter wartbar ist als das Zwei-Wege-Mapping.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Technische Instruktionen au\u00dferhalb des Programmcodes<\/h4>\n\n\n\n<p>Manche Libraries, wie z. B. Hibernate, erlauben es, die technischen Instruktionen in einer XML-Datei zu definieren anstatt mit Annotationen in der Modellklasse. So kann der Adapter die Modellklasse des Kerns verwenden ohne Code duplizieren zu m\u00fcssen.<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"434\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions-800x434.png\" alt=\"Hexagonale Architektur: Technische Instruktionen au\u00dferhalb des Programmcodes\" class=\"wp-image-35048\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions-800x434.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions-224x122.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions-336x182.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions-504x273.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions-672x365.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions-400x217.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions-600x326.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions-944x512.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions-1200x651.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-external-technical-instructions.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Technische Instruktionen au\u00dferhalb des Programmcodes<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Externe Instruktionen sind allerdings oft deutlich un\u00fcbersichtlicher als Annotationen im Code, so dass ich auch diese Strategie nicht gerne einsetze.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Aufweichung der Architekturgrenzen<\/h4>\n\n\n\n<p>Letztendlich kann man auch die bewusste Entscheidung treffen, die strengen Architekturgrenzen aufzuweichen, eine Abh\u00e4ngigkeit vom Kern zur ORM-Library zuzulassen und die Annotationen direkt an die Entity im Kern setzen.<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"353\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2-800x353.png\" alt=\"Hexagonale Architektur: Aufweichung der Architekturgrenzen\" class=\"wp-image-35057\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2-800x353.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2-224x99.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2-336x148.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2-504x222.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2-672x297.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2-400x177.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2-600x265.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2-944x417.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2-1200x530.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-softening-boundaries.v2.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Aufweichung der Architekturgrenzen<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Von dieser Option w\u00fcrde ich immer abraten. F\u00e4ngt man einmal damit an, dauert es gem\u00e4\u00df der <a rel=\"noopener\" href=\"https:\/\/de.wikipedia.org\/wiki\/Broken-Windows-Theorie\" target=\"_blank\">Broken-Windows-Theorie<\/a> nicht lange, bis die n\u00e4chste Architekturvorschrift aufgeweicht wird.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Mapping im REST-Adapter<\/h4>\n\n\n\n<p>Mapping ist nicht nur beim Datenbankadapter ein Thema, sondern z. B. auch bei einem REST-Adapter. Oft wollen wir nicht alle Attribute einer Entity \u00fcber die Schnittstelle sichtbar machen (z. B. Prim\u00e4rschl\u00fcssel oder Erstellungs- und \u00c4nderungsdatum) und f\u00fcr manche Attribute m\u00fcssen wir definieren, wie diese formatiert werden (z. B. Datums- und Zeitangaben).<\/p>\n\n\n\n<p>Auch das k\u00f6nnen wir mit technischen Annotationen steuern (z. B. <code>@JsonIgnore<\/code> oder <code>@JsonFormat<\/code> beim Einsatz von <a rel=\"noopener\" href=\"https:\/\/github.com\/FasterXML\/jackson\" target=\"_blank\">Jackson<\/a>). Aber auch diese wollen wir nicht im Anwendungskern haben. Daher ist es auch bei REST-Adaptern in der Regel sinnvoll, eine Entity auf eine Adapter-spezifische Modellklasse zu mappen, die nur die sichtbaren Felder sowie die Formatierungs-Instruktionen enth\u00e4lt.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"tests\">Tests<\/h3>\n\n\n\n<p>Ich habe zu Beginn des Artikels als eine der Anforderungen an eine gute Softwarearchitektur \u201eisoliert testbaren Komponenten\u201c genannt. Tats\u00e4chlich macht es uns die hexagonale Architektur sehr einfach (wie auch in den folgenden Teilen dieser Artikelserie in der Praxis zu sehen sein wird), die Gesch\u00e4ftslogik der Anwendung zu testen:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Tests k\u00f6nnen die Gesch\u00e4ftslogik \u00fcber die prim\u00e4ren Ports aufrufen.<\/li>\n\n\n\n<li>Die sekund\u00e4ren Ports k\u00f6nnen wir mit Test Doubles verbinden, z. B. in Form von Stubs, um Abfragen der Anwendung zu beantworten, oder Spies, um von der Anwendung gesendete Ereignisse aufzuzeichnen.<\/li>\n<\/ul>\n\n\n\n<p>Die folgende Grafik zeigt einen Unit Test, der ein Test Double f\u00fcr die Datenbank erzeugt und mit dem sekund\u00e4ren Datenbank-Port verbindet (\u201eArrange\u201c), einen Use-Case am prim\u00e4ren Port aufruft (\u201eAct\u201c) und die Antwort des Ports sowie die Interaktion mit dem Test Double verifiziert (\u201eAssert\u201c):<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"237\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2-800x237.png\" alt=\"Hexagonale Architektur: Unit Tests f\u00fcr die Gesch\u00e4ftslogik\" class=\"wp-image-34933\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2-800x237.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2-224x66.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2-336x100.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2-504x149.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2-672x199.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2-400x119.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2-600x178.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2-944x280.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2-1200x356.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-unit-test.v2.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Unit Tests f\u00fcr die Gesch\u00e4ftslogik<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Nicht nur die Gesch\u00e4ftslogik kann isoliert von den Adaptern getestet werden, sondern auch die Adapter isoliert von der Gesch\u00e4ftslogik (z. B. im Java-\u00d6kosystem prim\u00e4re REST-Adapter mit <a rel=\"noopener\" href=\"https:\/\/rest-assured.io\/\" target=\"_blank\">REST Assured<\/a>, sekund\u00e4re REST-Adapter mit <a href=\"https:\/\/wiremock.org\/\">WireMock<\/a> und Datenbank-Adapter mit <a rel=\"noopener\" href=\"https:\/\/testcontainers.com\/\" target=\"_blank\">TestContainers<\/a>).<\/p>\n\n\n\n<p>Die folgende Grafik zeigt einen Integrationstest, der ein Test Double f\u00fcr den prim\u00e4ren Port erzeugt (\u201eArrange\u201c), per REST Assured einen HTTP-POST-Request an den REST-Adapter sendet (\u201eAct\u201c) und schlie\u00dflich die HTTP-Antwort sowie die Interaktion mit dem Test Double verifiziert (\u201eAssert\u201c):<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"234\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter-800x234.png\" alt=\"Hexagonale Architektur: Integrationstest f\u00fcr REST-Adapter\" class=\"wp-image-34934\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter-800x234.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter-224x65.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter-336x98.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter-504x147.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter-672x196.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter-400x117.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter-600x175.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter-944x276.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter-1200x350.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-rest-adapter.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Integrationstest f\u00fcr REST-Adapter<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Die letzte Grafik zeigt einen Integrationstest f\u00fcr den Datenbank-Adapter, der per TestContainers eine Test-Datenbank hochf\u00e4hrt (\u201eArrange\u201c), eine Methode auf dem Datenbank-Adapter aufruft (\u201eAct\u201c) und schlie\u00dflich pr\u00fcft, ob der R\u00fcckgabewert der Methode und ggf. die \u00c4nderungen in der Test-Datenbank den Erwartungen entsprechen (\u201eAssert\u201c):<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"206\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter-800x206.png\" alt=\"Hexagonale Architektur: Integrationstest f\u00fcr Datenbank-Adapter\" class=\"wp-image-34935\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter-800x206.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter-224x58.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter-336x87.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter-504x130.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter-672x173.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter-400x103.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter-600x155.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter-944x243.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter-1200x309.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-integration-test-database-adapter.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur: Integrationstest f\u00fcr Datenbank-Adapter<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Neben diesen isolierten Tests d\u00fcrfen nat\u00fcrlich auch vollst\u00e4ndige Systemtests nicht fehlen (in geringerem Umfang gem\u00e4\u00df der Testpyramide).<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"warum-ein-hexagon\">Warum ein Hexagon?<\/h3>\n\n\n\n<p>Alistair Cockburn wird immer wieder gefragt, ob das Hexagon oder die Zahl \u201esechs\u201c eine bestimmte Bedeutung habe. Seine Anwort auf diese Frage ist: \u201eNein\u201c. Er wollte eine Form verwenden, die noch keiner verwendet hat. Vierecke werden \u00fcberall verwendet, und F\u00fcnfecke sind schwer zu zeichnen. Also wurde es ein Sechseck.<\/p>\n\n\n\n<p>Das Sechseck ist au\u00dferdem hervorragend geeignet, um links zwei prim\u00e4re Ports und rechts zwei sekund\u00e4re Ports einzuzeichnen. Cockburn sagt, ihm sei noch nie ein Projekt begegnet, f\u00fcr dessen schematische Darstellung mehr als vier Ports n\u00f6tig waren.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"vorteile-der-hexagonalen-architektur\">Vorteile der Hexagonalen Architektur<\/h2>\n\n\n\n<p>Nachdem wir die hexagonale Architektur von allen Seiten betrachtet haben, ist es an der Zeit sich die Ziele einer guten Softwarearchitektur in Erinnerung zu rufen und zu \u00fcberpr\u00fcfen, inwieweit die hexagonale Architektur diese Ziele erf\u00fcllt.<\/p>\n\n\n\n<p>Software soll leicht \u00e4nderbar sein und dies w\u00e4hrend ihrer gesamten Lebensdauer bleiben. Dazu sollte sie in voneinander isolierte, unabh\u00e4ngig entwickelbare und testbare Komponenten strukturiert sein.<\/p>\n\n\n\n<p>Gehen wir die Kriterien im einzelnen durch...<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">\u00c4nderbarkeit<\/h4>\n\n\n\n<ul class=\"wp-block-list hc-checked-list\">\n<li>Wir k\u00f6nnen die Gesch\u00e4ftslogik im Anwendungskern \u00e4ndern, ohne die Adapter oder die Infrastruktur \u00e4ndern zu m\u00fcssen (wobei in der Praxis eine \u00c4nderung der Gesch\u00e4ftslogik oft mit \u00c4nderungen am User Interface und der Datenspeicherung einhergeht).<\/li>\n\n\n\n<li>Wir k\u00f6nnen die Infrastruktur (z. B. die Datenbank oder den O\/R-Mapper) aktualisieren und austauschen, ohne auch nur eine Zeile Code in der Gesch\u00e4ftslogik \u00e4ndern zu m\u00fcssen. Wir m\u00fcssen ausschlie\u00dflich den entsprechenden Adapter anpassen.<\/li>\n\n\n\n<li>Indem wir mit der Entwicklung des Anwendungskerns beginnen, k\u00f6nnen wir Entscheidungen \u00fcber die Infrastruktur hinausz\u00f6gern und sehr sp\u00e4t im Entwicklungsprozess treffen. Die bei der Entwicklung des Kerns gesammelte Erfahrung erlaubt es uns, bessere Entscheidungen \u00fcber die einzusetzende Infrastruktur (Application Framework, Datenbanksystem, etc.) zu treffen.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Isolierung<\/h4>\n\n\n\n<ul class=\"wp-block-list hc-checked-list\">\n<li>In der Anwendungskern werden ausschlie\u00dflich <em>fachliche<\/em> Themen behandelt. <\/li>\n\n\n\n<li>Alle <em>technischen<\/em> Belange sind in den prim\u00e4ren und sekund\u00e4ren Adaptern implementiert.<\/li>\n\n\n\n<li>Anwendungskern und Adapter sind durch Ports isoliert \u2013 die Use Cases im Anwendungskern interagieren ausschlie\u00dflich mit diesen Ports, ohne die technischen Details dahinter zu kennen.<\/li>\n\n\n\n<li>Die Isolierung erlaubt es, alle Verantwortlichkeiten im Code klar zu lokalisieren, was das Risiko der Aufweichung der Architekturgrenzen erheblich verringert.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Entwicklung<\/h4>\n\n\n\n<ul class=\"wp-block-list hc-checked-list\">\n<li>Sobald die Ports der Anwendung definiert sind, kann die Arbeit an den Komponenten (Kern, User Interface, Datenbankanbindung, etc.) leicht auf mehrere Entwickler, Pairs oder Teams aufgeteilt werden.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Testbarkeit<\/h4>\n\n\n\n<ul class=\"wp-block-list hc-checked-list\">\n<li>Wie oben im Detail gezeigt, k\u00f6nnen alle Komponenten durch Einsatz von Test Doubles vollst\u00e4ndig isoliert getestet werden.<\/li>\n<\/ul>\n\n\n\n<p>Die hexagonale Architektur erf\u00fcllt damit alle Kriterien einer guten Softwarearchitektur. Das h\u00f6rt sich fast zu gut an, um wahr zu sein. Hat das hexagonale Architekturmodell denn keine Nachteile?<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"nachteile-der-hexagonalen-architektur\">Nachteile der Hexagonalen Architektur <\/h2>\n\n\n\n<p>Das Implementieren der Ports und Adapter und die Umsetzung der gew\u00e4hlten Mapping-Strategie stellt einen nicht zu vernachl\u00e4ssigen Mehraufwand dar. Dieser amortisiert sich f\u00fcr gro\u00dfe Enterprise-Applikationen schnell; f\u00fcr kleinere Anwendungen, z. B. einen einfachen CRUD-Microservice mit minimaler Gesch\u00e4ftslogik lohnt sich der Mehraufwand eher nicht.<\/p>\n\n\n\n<p>Im besten Fall habt ihr einen seniorigen Entwickler\/Architekten im Team, der bereits Erfahrung mit der hexagonalen Architektur hat und der beurteilen kann, ob sich der initiale Mehraufwand f\u00fcr euer Projekt lohnt.<\/p>\n\n\n\n<p>Ich empfehle dir, die Beispiel-Anwendung, an der ich in den weiteren Teile dieser Tutorial-Serie die Implementierung der hexagonalen Architektur demonstrieren werde, nachzuprogrammieren. So sammelst du erste Erfahrungen und wirst vielleicht selbst dieser erfahrene Entwickler, der die hexagonale Architektur f\u00fcr euer n\u00e4chstes Projekt ins Spiel bringt.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"hexagonale-architektur-und-ddd-domain-driven-design\">Hexagonale Architektur und DDD (Domain Driven Design)<\/h2>\n\n\n\n<p>In der Literatur findet man immer wieder Darstellungen der hexagonalen Architektur mit \u201eEntities\u201c und \u201eUse Cases\u201c oder \u201eServices\u201c innerhalb des Application Hexagons und\/oder mit einem \u201eDomain\u201c- oder \u201eDomain Model\u201c-Hexagon innerhalb des Application Hexagons \u2013 in etwa wie in der folgenden Abbildung:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-half_600\"><img decoding=\"async\" width=\"600\" height=\"484\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-ddd-domain-driven-design-600x484.png\" alt=\"Hexagonale Architektur und DDD (Domain Driven Design)\" class=\"wp-image-34951\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-ddd-domain-driven-design-600x484.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-ddd-domain-driven-design-224x181.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-ddd-domain-driven-design-336x271.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-ddd-domain-driven-design-504x407.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-ddd-domain-driven-design-672x542.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-ddd-domain-driven-design-400x323.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-ddd-domain-driven-design-800x645.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-ddd-domain-driven-design-944x761.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-ddd-domain-driven-design.png 1200w\" sizes=\"(max-width: 600px) 100vw, 600px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur und DDD (Domain Driven Design)<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Tats\u00e4chlich l\u00e4sst die hexagonale Architektur aber bewusst offen, was sich innerhalb des Application Hexagons befindet. Alistair Cockburn antwortete in einem sehr sehenswerten <a rel=\"noopener\" href=\"https:\/\/www.youtube.com\/watch?v=AOIWUPjal60\" target=\"_blank\">Interview<\/a> auf die Frage \u201eWhat do you see inside the Application?\u201c mit \u201eI don\u2019t care \u2013 not my business\u201c. Das hexagonale Entwurfsmuster stehe f\u00fcr <em>eine<\/em> Design-Entscheidung: \u201eWrap your app in an API and put tests around it\u201c.<\/p>\n\n\n\n<p>Nichtsdestotrotz erg\u00e4nzen sich Domain Driven Design (DDD) und hexagonale Architektur ausgesprochen gut, denn der DDD-Teilbereich des taktischen Designs eignet sich hervorragend, um die Gesch\u00e4ftsregeln innerhalb des Anwendungshexagons zu strukturieren.<\/p>\n\n\n\n<p>Ich werde daher in den folgenden Artikeln dieser Serie, in denen ich die Implementierung einer hexagonalen Architektur mit Java demonstrieren werde, ebenfalls dieses zus\u00e4tzliche Domain-Hexagon einsetzen.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"hexagonale-architekture-und-microservices\">Hexagonale Architekture und Microservices<\/h2>\n\n\n\n<p>Die hexagonale Architektur eignet sich auch f\u00fcr die Implementierung von Microservices, sofern diese zwei Kriterien erf\u00fcllen:<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li><strong>Sie m\u00fcssen Gech\u00e4ftslogik enthalten und nicht rein technischer Natur sein.<\/strong> Ein Microservice, der z. B. alle Events, die er auf einem Event-Bus abh\u00f6rt, in ein anderes System loggt, hat einen rein technischen Zweck. Hier gibt es keine Gesch\u00e4ftslogik, die von den technischen Details isoliert werden k\u00f6nnte.<\/li>\n\n\n\n<li><strong>Sie m\u00fcssen eine gewisse Gr\u00f6\u00dfe haben.<\/strong> F\u00fcr einen Microservice mit minimaler Gesch\u00e4ftslogik lohnt sich der Mehraufwand f\u00fcr Ports, Adapter und Mapping nicht. Eine feste Gr\u00f6\u00dfengrenze gibt es nicht, hier muss eine Entscheidung aus Erfahrung heraus getroffen werden. Wenn nach Domain Driven Design gearbeitet wird und ein Microservice ein Aggregate mit mehreren Entities und die zugeh\u00f6rigen Services umfasst, ist der Einsatz der hexaginalen Architektur in der Regel sinnvoll. <\/li>\n<\/ol>\n\n\n\n<p>Aus Sicht eines Microservices sind alle anderen Microservices Teile der Au\u00dfernwelt und werden \u2013 genau wie die restliche Infrastruktur \u2013 \u00fcber Ports und Adapter isoliert:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"359\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices-800x359.png\" alt=\"Hexagonale Architektur und Microservices\" class=\"wp-image-35071\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices-800x359.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices-224x101.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices-336x151.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices-504x226.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices-672x302.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices-400x180.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices-600x269.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices-944x424.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices-1200x539.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-and-microservices.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur und Microservices<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Meine Heransgehensweise f\u00fcr die Planung einer komplexen Gesch\u00e4ftsanwendung ist in der Regel eine Kombination aus Domain Driven Design, Microservices und hexagonaler Architektur:<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li>Einsatz von Strategic Design zur Planung von Core Domain, Sub Domains und Bounded Contexts.<\/li>\n\n\n\n<li>Aufteilung eines Bounded Contexts in einen oder mehrere Microservices. Ein Microservice kann ein oder mehrere Aggregates enthalten, aber auch den kompletten Bounded Context, sofern dieser nicht zu gro\u00df ist (und statt des gew\u00fcnschten Microservices wieder ein Monolith entsteht).<\/li>\n\n\n\n<li>Implementierung des Application Hexagons nach Tactical Design, also mit Entities, Value Objects, Aggregates, Services, etc.<\/li>\n<\/ol>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"hexagonale-architektur-vs-ports-adapters\">Hexagonale Architektur vs. \u201ePorts &amp; Adapters\u201c<\/h2>\n\n\n\n<p>Hexagonale Architektur und \u201ePorts and Adapters\u201c (manchmal auch \u201ePorts &amp; Adapters\u201c) bezeichnen dieselbe Architektur. Der <em>offizielle<\/em> Name, den Alistair Cockburn dem in diesem Artikel beschriebenen Architekturmuster gegeben hat, ist \u201ePorts and Adapters\u201c. <\/p>\n\n\n\n<p>Die gebr\u00e4uchlichere, bildliche Bezeichnung \u201eHexagonale Architektur\u201c ergab sich aus der grafischen Darstellung der Architektur mit Sechsecken. Alistair Cockburn hat im oben erw\u00e4hnten <a rel=\"noopener\" href=\"https:\/\/www.youtube.com\/watch?v=AOIWUPjal60\" target=\"_blank\">Interview<\/a> verraten, dass auch er den figurativen Namen vorzieht \u2013 dass der offizielle Name eines Musters aber einer sein muss, der dessen Eigenschaften beschreibt.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"hexagonale-architektur-vs-schichtenarchitektur\">Hexagonale Architektur vs. Schichtenarchitektur<\/h2>\n\n\n\n<p>Bereits zu Beginn des Artikels habe ich die weit verbreitete Schichtenarchitektur und deren Nachteile angesprochen (transitive Abh\u00e4ngigkeiten zur Datenbank, verschwimmende Schichtengrenzen, mangelhafte Isolierung der Komponenten, schlechte Testbarkeit, schlechte Aktualisierbarkeit und Austauschbarkeit von Infrastrukturkomponenten).<\/p>\n\n\n\n<p>Im folgenden siehst du die beiden Architekturmuster gegen\u00fcbergestellt. Im Gegensatz zur hexagonalen Architektur (hier in ihrer urspr\u00fcnglichen Darstellung von Alistair Cockburn ohne explizite Ports) steht bei der Schichtenarchitektur nicht die Gesch\u00e4ftslogik im Zentrum, sondern die Datenbank:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"317\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2-800x317.png\" alt=\"Hexagonale Architektur vs. Schichtenarchitektur\" class=\"wp-image-35080\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2-800x317.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2-224x89.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2-336x133.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2-504x199.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2-672x266.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2-400x158.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2-600x237.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2-944x373.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2-1200x475.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-simple.v2.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur vs. Schichtenarchitektur<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Wir wenden sozusagen ein \u201eDatabase-Driven Design\u201c an und starten unsere Planungen damit, wie wir unser Modell in Tabellen speichern, anstatt zu \u00fcberlegen, wie sich unser Modell <em>verhalten<\/em> soll.<\/p>\n\n\n\n<p>Viele von uns Entwicklern arbeiten schon so lange mit dem Schichtenmodell, dass es in Fleisch und Blut \u00fcbergegangen ist und wir es f\u00fcr das Normalste der Welt halten, eine Anwendung rund um eine Datenbank zu planen.<\/p>\n\n\n\n<p>Ist es nicht viel sinnvoller, zuerst die Fachlichkeit einer Anwendung zu planen und zu entwickeln? Und erst dann, wenn es n\u00f6tig ist, dar\u00fcber nachzudenken, wie Daten persistiert werden? Sollte es nicht so sein, dass \u00c4nderungen in der Gesch\u00e4ftslogik ggf. \u00c4nderungen an der Persistenz erfordern \u2013 und nicht umgekehrt? Ich finde, ja.<\/p>\n\n\n\n<p>Und selten bleibt eine Gesch\u00e4ftsanwendung so einfach wie oben dargestellt. Wird die Anwendung erst einmal komplexer, werden zus\u00e4tzliche Abh\u00e4ngigkeiten geschaffen. Die folgenden Abbildung zeigt die Architektur erweitert um eine REST-API und die Anbindung eines Drittanbieter-Services:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"317\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2-800x317.png\" alt=\"Hexagonale Architektur vs. Schichtenarchitektur: Erweiterung der Anwendung\" class=\"wp-image-35081\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2-800x317.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2-224x89.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2-336x133.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2-504x200.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2-672x266.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2-400x159.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2-600x238.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2-944x374.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2-1200x476.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-complex.v2.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur vs. Schichtenarchitektur: Erweiterung der Anwendung<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Bei der hexagonalen Architektur ist klar definiert, wo die zus\u00e4tzlichen Komponenten hingeh\u00f6ren. <\/p>\n\n\n\n<p>Bei der Schichtenarchitektur wird oft eine REST-API an die Gesch\u00e4ftslogik geh\u00e4ngt (dabei wird evtl. im Presentation Layer implementierte Gesch\u00e4ftslogik dupliziert, wenn nicht vorher refactored wird), und die Gesch\u00e4ftslogik wiederum erh\u00e4lt eine zus\u00e4tzliche Abh\u00e4ngigkeit auf den externen Service.<\/p>\n\n\n\n<p>Den \u201eThird-party client\u201c habe ich gestrichelt eingezeichnet, da dieser auch gerne weggelassen und direkt aus dem Business Layer (wenn nicht sogar aus dem Presentation Layer) auf die Schnittstelle der externen Anwendung zugegriffen wird.<\/p>\n\n\n\n<p>W\u00e4hrend bei der hexagonalen Architektur ein Port und zwei Adapter mit klaren Quellcode-Abh\u00e4ngigkeiten Richtung Kern hinzugekommen sind, w\u00e4chst das Abh\u00e4ngigkeitschaos zwischen den Schichten: Wir haben jetzt transitive Abh\u00e4ngigkeiten von der REST-API zur Datenzugriffsschicht, von der REST-API zur Third-Party-API, vom User-Interface zur Datenzugriffsschicht und vom User-Interface zur Third-Party-API:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"317\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies-800x317.png\" alt=\"Hexagonalen Architektur vs. Schichtenarchitektur: Quellcode-Abh\u00e4ngigkeiten\" class=\"wp-image-35084\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies-800x317.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies-224x89.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies-336x133.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies-504x200.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies-672x266.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies-400x159.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies-600x238.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies-944x374.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies-1200x476.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-layered-architecture-with-source-code-dependencies.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonalen Architektur vs. Schichtenarchitektur: Quellcode-Abh\u00e4ngigkeiten<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Diese Anh\u00e4ngigkeiten machen nicht nur den Code der unteren Schichten in REST-API, Presentation Layer und Business Layer verf\u00fcgbar, sondern auch alle dort verwendeten Libraries. Und so verschwimmen die Architekturgrenzen weiter.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"hexagonale-architektur-vs-clean-architecture\">Hexagonale Architektur vs. Clean Architecture<\/h2>\n\n\n\n<p>Clean Architecture wurde 2012 von Robert Martin (\u201eUncle Bob\u201c) auf seinem <a href=\"https:\/\/blog.cleancoder.com\/uncle-bob\/2012\/08\/13\/the-clean-architecture.html\" target=\"_blank\" rel=\"noopener\">Clean Coders Blog<\/a> vorgestellt und 2017 im <a href=\"https:\/\/www.happycoders.eu\/de\/buecher\/clean-architecture-gute-softwarearchitekturen\/\">Buch \u201eClean Architecture\u201c<\/a> ausf\u00fchrlich beschrieben.<\/p>\n\n\n\n<p>Wie in der hexagonalen Architektur steht auch in der Clean Architecture die Gesch\u00e4ftslogik (\u201eBusiness Rules\u201c) im Mittelpunkt. Um sie herum befinden sich die sogenannten Schnittstellenadapter (\u201eInterface Adapters\u201c), welche den Kern mit der Benutzeroberfl\u00e4che, der Datenbank und anderen externen Komponenten verbinden. Der Kern kennt nur die Schnittstellen der Adapter, wei\u00df aber nichts \u00fcber deren konkrete Implementierungen und die dahinter liegenden Komponenten.<\/p>\n\n\n\n<p>Auch bei der Clean Architecture zeigen alle Quellcode-Abh\u00e4ngigkeiten ausschlie\u00dflich in Richtung des Kerns. Dort, wo die Aufrufe von innen nach au\u00dfen, also in die entgegengesetzte Richtung zur Quellcode-Abh\u00e4ngigkeit, f\u00fchren, wird ebenfalls das Dependency Inversion Principle eingesetzt.<\/p>\n\n\n\n<p>Die folgenden Grafik zeigt hexagonale Architektur und Clean Architecture gegen\u00fcbergestellt:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"312\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4-800x312.png\" alt=\"Hexagonale Architektur vs. Clean Architecture\" class=\"wp-image-34943\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4-800x312.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4-224x87.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4-336x131.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4-504x197.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4-672x262.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4-400x156.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4-600x234.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4-944x368.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4-1200x468.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-1.v4.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur vs. Clean Architecture<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Wenn wir in der hexagonalen Architektur die Farben etwas anpassen und in der Clean Architecture die konkreten Adapter und externen Komponenten durch namenlose Platzhalter ersetzen, entstehen zwei sehr \u00e4hnliche Abbildungen:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"310\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4-800x310.png\" alt=\"Hexagonale Architektur vs. Clean Architecture (beide &quot;normalisiert&quot;)\" class=\"wp-image-34944\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4-800x310.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4-224x87.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4-336x130.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4-504x195.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4-672x260.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4-400x155.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4-600x233.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4-944x366.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4-1200x465.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-clean-architecture-2.v4.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur vs. Clean Architecture (beide \u201enormalisiert\u201c)<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Die Hexagone lassen sich nahezu eins zu eins auf die Ringe der Clean Architecture \u00fcbertragen:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Die um das \u00e4u\u00dfere Hexagon angeordneten \u201eExternal Agencies\u201c entsprechen dem \u00e4u\u00dferen Ring der Clean Architecture, \u201eFrameworks &amp; Drivers\u201c.<\/li>\n\n\n\n<li>Das \u00e4u\u00dfere Hexagon \u201eAdapters\u201c entspricht dem Ring \u201eInterface Adapters\u201c.<\/li>\n\n\n\n<li>Das Application Hexagon entspricht in der Clean Architecture den \u201eBusiness Rules\u201c, also den Gesch\u00e4ftsregeln. Diese werden allerdings weiter unterteilt in \u201eUnternehmensbezogene Gesch\u00e4ftsregeln\u201c (Entities) und \u201eGesch\u00e4ftsregeln der Anwendung\u201c (Use Cases, die die Entities orchestrieren und den Datenfluss von und zu ihnen steuern). Die hexagonale Architektur hingegen l\u00e4sst die Architektur innerhalb des Application Hexagons bewusst offen.<\/li>\n<\/ul>\n\n\n\n<p>Die Ports werden in der Clean Architecture nicht explizit genannt, sind aber in den zugeh\u00f6rigen UML-Diagrammen und Quellcode-Beispielen in Form von Interfaces ebenfalls vorhanden:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-half_400\"><img decoding=\"async\" width=\"400\" height=\"395\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/clean-architecture-dependency-inversion-principle-400x395.png\" alt=\"Interfaces: Implizite &quot;Ports&quot; in der Clean Architecture\" class=\"wp-image-34786\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/clean-architecture-dependency-inversion-principle-400x395.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/clean-architecture-dependency-inversion-principle-224x221.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/clean-architecture-dependency-inversion-principle-336x332.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/clean-architecture-dependency-inversion-principle-504x498.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/clean-architecture-dependency-inversion-principle-672x664.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/clean-architecture-dependency-inversion-principle-600x593.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/clean-architecture-dependency-inversion-principle.png 800w\" sizes=\"(max-width: 400px) 100vw, 400px\" \/><figcaption class=\"wp-element-caption\">Interfaces: Implizite \u201ePorts\u201c in der Clean Architecture<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Zusammengefasst sind also beide Architekturen nahezu identisch: Die Software ist in Schichten aufgeteilt und alle Quellcode-Abh\u00e4ngigkeiten zeigen von den \u00e4u\u00dferen zu den inneren Schichten. Der Kern der Anwendung kennt keine Einzelheiten der \u00e4u\u00dferen Schichten und wird nur gegen deren Schnittstellen implementiert. So entsteht ein System, dessen technische Details austauschbar sind und das ohne diese vollst\u00e4ndig testbar ist.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"hexagonale-architektur-vs-onion-architecture\">Hexagonale Architektur vs. Onion Architecture<\/h2>\n\n\n\n<p>Auch bei der von Jeffrey Palermo 2008 <a rel=\"noopener\" href=\"https:\/\/jeffreypalermo.com\/2008\/07\/the-onion-architecture-part-1\/\" target=\"_blank\">auf seinem Blog<\/a> vorgestellten \u201eOnion Architecture\u201c steht die Gesch\u00e4ftslogik im Kern, im sogenannten \u201eApplication Core\u201c. Dieser definiert Schnittstellen zum User Interface und zur Infrastruktur (Datenbank, Filesystem, externe Systeme, usw.), kennt aber deren konkreten Implementierungen nicht. Somit wird auch hier der Kern von der Infrastruktur isoliert.<\/p>\n\n\n\n<p>Genau wie bei der hexagonalen Architektur und bei der Clean Architecture zeigen auch bei der Onion Architecture alle Quellcode-Abh\u00e4ngigkeiten Richtung Kern. Dort, wo die Aufrufrichtung vom Kern zur Infrastruktur, also entgegengesetzt zur Quellcode-Abh\u00e4ngigkeit, geht, wird dies ebenfalls durch Dependency Inversion erreicht.<\/p>\n\n\n\n<p>In der folgenden Grafik siehst du die hexagonale Architektur und die Onion Architektur gegen\u00fcbergestellt:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"267\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3-800x267.png\" alt=\"Hexagonale Architektur vs. Onion Architecture\" class=\"wp-image-34948\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3-800x267.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3-224x75.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3-336x112.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3-504x168.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3-672x224.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3-400x134.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3-600x200.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3-944x315.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3-1200x401.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-1.v3.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur vs. Onion Architecture<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Wenn wir erneut die Farben etwas anpassen und in der Onion Architecture User Interface, Tests und Infrastruktur durch Platzhalter ersetzen und die optionalen Ringe des Applikationskernes ausblenden, entstehen wieder zwei sehr \u00e4hnliche Abbildungen:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full_800\"><img decoding=\"async\" width=\"800\" height=\"267\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3-800x267.png\" alt=\"Hexagonale Architektur vs. Onion Architecture (beide &quot;normalisiert&quot;)\" class=\"wp-image-34949\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3-800x267.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3-224x75.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3-336x112.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3-504x168.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3-672x224.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3-400x134.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3-600x200.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3-944x315.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3-1200x401.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/01\/hexagonal-architecture-vs-onion-architecture-2.v3.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><figcaption class=\"wp-element-caption\">Hexagonale Architektur vs. Onion Architecture (beide \u201enormalisiert\u201c)<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Die Hexagone lassen sich nahezu eins zu eins auf die Ringe der Onion Architektur abbilden:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Die um das \u00e4u\u00dfere Hexagon angeordneten \u201eExternal Agencies\u201c werden in der Onion Architektur durch die Infrastrukturkomponenten rechts unten dargestellt.<\/li>\n\n\n\n<li>Das \u00e4u\u00dfere Hexagon \u201eAdapters\u201c entspricht dem Ring, der \u201eUser Interface\u201c, \u201eTests\u201c und \u201eInfrastructure\u201c enth\u00e4lt.<\/li>\n\n\n\n<li>Das Application Hexagon entspricht in der Onion Architecture dem \u201eApplication Core\u201c. Dieser wird weiter unterteilt in \u201eApplication Services\u201c, \u201eDomain Services\u201c und \u201eDomain Model\u201c, wobei nur das \u201eDomain Model\u201c fester Bestandteil der Onion Architecture ist. Die weiteren Ringe des Anwendungskerns sind explizit als variabel gekennzeichnet. Das \u201eDomain Model\u201c definiert die \u201eEnterprise Business Rules\u201c und entspricht damit dem \u201eEntities\u201c-Ring \u2013 also dem innersten Ring \u2013 der Clean Architecture.<\/li>\n<\/ul>\n\n\n\n<p>Im Endeffekt ist also auch die Onion Architecture nahezu identisch mit der hexagonalen Architektur \u2013 sie unterscheidet sich letztendlich nur durch das explizite \u201eDom\u00e4nenmodell\u201c im Zentrum des Anwendungskerns.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"zusammenfassung-und-ausblick\">Zusammenfassung und Ausblick<\/h2>\n\n\n\n<p>Hexagonale Architektur bzw. \u201ePorts and Adapters\u201c (alternativ Clean Architecture oder Onion-Architektur) sind ein Architekturmuster, das die Probleme der herk\u00f6mmlichen Schichtenarchitektur (das Durchsickern von technischen Details in andere Schichten, schlechte Testbarkeit) eliminiert und es erm\u00f6glicht Entscheidungen \u00fcber technische Details (z. B. die verwendete Datenbank) hinauszuschieben und zu \u00e4ndern, ohne den Kern der Anwendung anpassen zu m\u00fcssen.<\/p>\n\n\n\n<p>Fachlicher Code befindet sich im Anwendungskern, bleibt dort unabh\u00e4ngig von technischem Code der Infrastruktur und kann isoliert entwickelt und getestet werden.<\/p>\n\n\n\n<p>Alle Quellcode-Anh\u00e4ngigkeiten zeigen ausschlie\u00dflich Richtung Kern. Dort wo die Aufrufe in die entgegengesetzte Richtung gehen, also vom Kern zur Infrastruktur (z. B. zur Datenbank), wird dies durch das Dependency Inversion Prinzip erm\u00f6glicht.<\/p>\n\n\n\n<p>Das hexagonale Entwurfsmuster erfordert einen gewissen Mehraufwand und eigent sich daher insbesondere f\u00fcr komplexe Gesch\u00e4ftsanwendungen mit einer erwarteten Lebenszeit von mehreren Jahren bis Jahrzehnten.<\/p>\n\n\n\n<p>Dieser Artikel ist der erste einer mehrteiligen Serie. In den folgenden Teilen werde ich dir zeigen:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><a href=\"\/de\/software-craftsmanship\/hexagonale-architektur-java\/\">Wie implementiert man eine hexagonale Architektur mit Java<\/a> \u2013 ganz ohne Application-Framework wie Spring oder Quarkus?<\/li>\n\n\n\n<li><a href=\"\/de\/software-craftsmanship\/hexagonale-architektur-java\/#ueberwachung-der-architekturgrenzen\">Wie kann man die Einhaltung der Architekturvorgaben sicherstellen?<\/a><\/li>\n\n\n\n<li><a href=\"\/de\/software-craftsmanship\/ports-and-adapters-java-tutorial-db\/\">Wie verbindet man einen Persistenz-Port, der bereits mit einem In-Memory-Adapter verbunden ist, mit einem zus\u00e4tzlichen Datenbank-Adapter?<\/a><\/li>\n\n\n\n<li><a href=\"\/de\/software-craftsmanship\/hexagonale-architektur-quarkus\/\">Wie implementiert man eine hexagonale Architektur mit Quarkus?<\/a><\/li>\n\n\n\n<li><a href=\"\/de\/software-craftsmanship\/hexagonale-architektur-spring-boot\/\">Wie implementiert man eine hexagonale Architektur mit Spring Boot?<\/a><\/li>\n<\/ul>\n<aside><p>Wenn dir der Artikel weitergeholfen hat, w\u00fcrde ich mich sehr \u00fcber eine positive Bewertung auf meinem <a href=\"https:\/\/www.provenexpert.com\/de-de\/sven-woltmann-happycoders-eu\/7smk\/\" target=\"_blank\" rel=\"noopener\">ProvenExpert-Profil<\/a> freuen. Dein Feedback hilft mir, meine Inhalte weiter zu verbessern und motiviert mich, neue informative Artikel zu schreiben.<\/p>\r\n                        <p>\ud83d\udc49 <a href=\"https:\/\/www.provenexpert.com\/de-de\/sven-woltmann-happycoders-eu\/7smk\/\" target=\"_blank\" rel=\"noopener\">Bewertung abgeben<\/a><\/p>\r\n                        <p>M\u00f6chtest du auf dem Laufenden bleiben und informiert werden, wenn neue Artikel auf HappyCoders.eu ver\u00f6ffentlicht werden? Dann <a href=\"#\" data-formkit-toggle=\"d8ee997126\">klicke hier<\/a>, um dich f\u00fcr den HappyCoders-Newsletter anzumelden.<\/p>\r\n                        <p>\ud83d\udc49 <a href=\"#\" data-formkit-toggle=\"d8ee997126\">Newsletter-Anmeldung<\/a><\/p><\/aside>","protected":false},"excerpt":{"rendered":"<p>Was ist hexagonale Architektur (Ports &#038; Adapters) \u2013 Vorteile gegen\u00fcber der Schichtenarchitektur \u2013 Hexagonale Architektur, Microservices und DDD<\/p>\n","protected":false},"author":1,"featured_media":33133,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_seopress_robots_primary_cat":"","_seopress_titles_title":"Hexagonale Architektur \u2013 Was ist das? + Ihre Vorteile","_seopress_titles_desc":"Was ist hexagonale Architektur (Ports & Adapters)? \u2013 Vorteile gegen\u00fcber der Schichtenarchitektur \u2013 Hexagonale Architektur, Microservices und DDD","_seopress_robots_index":"","_uag_custom_page_level_css":"","_wp_convertkit_post_meta":{"form":"-1","landing_page":"","tag":"0","restrict_content":"0"},"_metis_text_type":"standard","_metis_text_length":34820,"_post_count":0,"footnotes":""},"categories":[204],"tags":[209],"class_list":["post-33131","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-software-craftsmanship","tag-hexagonale-architektur"],"uagb_featured_image_src":{"full":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders.jpg",1770,986,false],"thumbnail":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders.jpg",150,84,false],"medium":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders.jpg",300,167,false],"medium_large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders.jpg",768,428,false],"large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders.jpg",1024,570,false],"feature_thumb_224":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-224x125.jpg",224,125,true],"feature_thumb_336":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-336x187.jpg",336,187,true],"feature_thumb_504":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-504x281.jpg",504,281,true],"feature_thumb_672":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-672x374.jpg",672,374,true],"half_400":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-400x223.jpg",400,223,true],"half_600":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-600x334.jpg",600,334,true],"full_800":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-800x446.jpg",800,446,true],"full_944":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-944x526.jpg",944,526,true],"full_1200":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-1200x668.jpg",1200,668,true],"wide_1180":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-1180x490.jpg",1180,490,true],"wide_1770":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders-1770x735.jpg",1770,735,true],"1536x1536":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders.jpg",1536,856,false],"2048x2048":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/11\/hexagonal-architecture-happycoders.jpg",1770,986,false]},"uagb_author_info":{"display_name":"Sven Woltmann","author_link":"https:\/\/www.happycoders.eu\/de\/author\/sven\/"},"uagb_comment_info":10,"uagb_excerpt":"Was ist hexagonale Architektur (Ports & Adapters) \u2013 Vorteile gegen\u00fcber der Schichtenarchitektur \u2013 Hexagonale Architektur, Microservices und DDD","public_identification_id":"06e74d7071ea443f8c51cc1507911b4a","private_identification_id":"b4a34f6e8e8a493f88a04c919a116a5f","_links":{"self":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/33131","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/comments?post=33131"}],"version-history":[{"count":12,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/33131\/revisions"}],"predecessor-version":[{"id":54443,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/33131\/revisions\/54443"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media\/33133"}],"wp:attachment":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media?parent=33131"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/categories?post=33131"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/tags?post=33131"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}