Kostenlos testen
Beliebt Neu Genres Autoren
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Suche läuft...
SoBrief
Clean Architecture

Clean Architecture

Entwickeln Sie Software, deren Änderungen dauerhaft erschwinglich bleiben – ohne für Komplexität zu bezahlen, die Sie vielleicht nie benötigen.
von Robert C. Martin 2017 432 Seiten
4.21
7.000+ Bewertungen
Anhören
Immersiv
V2.3
Amazon Kindle Audible
3 Tage Vollzugriff testen
Schalten Sie Audioinhalte & mehr frei!
Weiter

Wichtigste Erkenntnisse

Miss die Architektur daran, ob sich die nächste gewöhnliche Änderung weiterhin bezahlbar umsetzen lässt

Entwurf ist eine wirtschaftliche Entscheidung. Martin betrachtet Entwurf und Architektur als ein Kontinuum von Entscheidungen – von der übergreifenden Struktur bis zu kleinen Implementierungsdetails. Ihr Zweck ist es, den menschlichen Aufwand für Entwicklung und Wartung eines Systems über dessen gesamte Lebensdauer hinweg gering zu halten. In einem Unternehmensbeispiel stiegen die Zahl der Entwicklungsmitarbeiter und die Lohnkosten stark an, während die Menge des erzeugten Codes nahezu stagnierte. Bei der achten Veröffentlichung kostete jede Codezeile in der Produktion etwa 40-mal so viel wie bei der ersten. Das anwachsende Durcheinander hatte dazu geführt, dass die Arbeit an Funktionen vor allem darin bestand, sich durch den alten Code zu kämpfen.

Saubere Arbeit kann schneller sein. Bei einem kleinen, sechstägigen Experiment zur Umwandlung von Zahlen in römische Ziffern dauerten Tage mit testgetriebener Entwicklung etwa 10 Prozent weniger lang als Tage ohne diese Vorgehensweise. Das ist ein Beispiel, keine definitive Studie, stellt aber die Vorstellung infrage, Aufräumen sei ein Luxus, den man auf später verschieben könne.

Analyse

Die wirtschaftliche Perspektive macht Architektur auch für Menschen verständlich, die keinen Code schreiben: Steigende Änderungskosten sind ein Geschäftsrisiko, keine Entwicklerpräferenz. Sie verdeutlicht außerdem, warum ein System korrekt funktionieren und dennoch in schlechtem Zustand sein kann. Die Belege müssen allerdings mit Augenmaß betrachtet werden. Codezeilen sind ein grobes Maß für den gelieferten Nutzen, und ein sechstägiges Experiment kann keinen universellen Produktivitätsvorteil einer einzelnen Vorgehensweise belegen. Der aussagekräftigere Maßstab ist, ob Teams wahrscheinliche Änderungen mit vorhersehbarem Aufwand umsetzen können, ohne dabei immer wieder unabhängige Funktionen zu destabilisieren.

Bewahre die Änderbarkeit ebenso sorgfältig wie die heute funktionierenden Funktionen

Software hat zwei Werte. Ihr Verhalten erzeugt oder spart heute einen Nutzen; ihre Struktur bestimmt, wie leicht sich dieses Verhalten ändern lässt. Der zweite Wert wird leicht vernachlässigt, weil Funktionsanforderungen dringend eintreffen, während sich architektonische Schäden unbemerkt anhäufen. Martin greift auf die mit Eisenhower verbundene Unterscheidung zwischen Wichtigkeit und Dringlichkeit zurück: Dringende Arbeit ist nicht automatisch wichtige Arbeit. Entwickler müssen Entscheidungsträgern helfen, die künftigen Kosten sichtbar zu machen, wenn Architektur zur Nebensache wird.

Der Umfang ist nicht der ganze Aufwand. Eine kleine Anforderung kann teuer sein, wenn sie nicht zur Struktur des Systems passt. Erfordert ein neuer Bericht Änderungen in voneinander unabhängigen Modulen, erschwert die Architektur die Änderung stärker, als es die Anforderung selbst rechtfertigt. Änderbarkeit zu bewahren bedeutet nicht, jede erdenkliche Option einzubauen. Es bedeutet, häufige, absehbare Änderungen vor systemweiten Operationen zu bewahren.

Analyse

Diese Unterscheidung ähnelt dem Unterschied zwischen betrieblicher Leistungsfähigkeit und organisatorischer Widerstandsfähigkeit: Ein System kann das heutige Ziel erreichen und zugleich die Fähigkeit verlieren, morgen darauf zu reagieren. Die Dringlichkeitsfalle ist in Produktorganisationen besonders mächtig, weil sichtbare Produkteinführungen belohnt werden, während vermiedene Wartungskosten unsichtbar bleiben. Flexibilität ist jedoch nicht kostenlos. Jede Grenze und jede Abstraktion beansprucht Aufmerksamkeit; Architektur sollte daher plausible Änderungspfade schützen, keine hypothetischen. In der Praxis geht es weniger darum, sich für Funktionen oder Architektur zu entscheiden, als darum, die Kosten aufzuschieben­der Strukturarbeit sichtbar zu machen.

Begrenze Kontrollfluss, Indirektion und Veränderlichkeit, damit Programme leichter zu testen sind

Programmierung macht durch Beschränkungen Fortschritte. Martin beschreibt strukturierte Programmierung als Disziplinierung uneingeschränkter Sprünge, objektorientierte Programmierung als sicherere Kontrolle indirekter Aufrufe und funktionale Programmierung als Disziplinierung veränderlicher Zustände. Jede dieser Ansätze erschwert bestimmte Arten von Code und macht den Code im Gegenzug leichter nachvollziehbar. Dijkstras Arbeit zur strukturierten Programmierung zeigte, wie Sequenz, Auswahl und Wiederholung Programme in kleinere Einheiten zerlegen, die sich untersuchen und testen lassen.

Zustand hat Nebenläufigkeitskosten. Unveränderlichkeit bedeutet, dass Werte nicht beiläufig überschrieben werden; dadurch sinkt das Risiko von Wettlaufsituationen und widersprüchlichen Aktualisierungen, auch wenn sich nicht jedes Nebenläufigkeitsproblem beseitigen lässt. Ereignisbasierte Speicherung (Event Sourcing) ist ein Beispiel dafür: Transaktionen wie Einzahlungen und Abhebungen werden gespeichert, und der Kontostand wird daraus abgeleitet, statt ihn wiederholt zu ersetzen. Momentaufnahmen können begrenzen, wie viel Historie neu berechnet werden muss.

Analyse

Die verbindende Idee ist nicht, dass Programmierer einem gerade angesagten Paradigma folgen sollten, sondern dass Beschränkungen das Denken in unabhängigen Teilen erleichtern können. Das knüpft an die Sicherheitstechnik an, in der es oft wichtiger ist, gefährliche Handlungen einzuschränken, als von Menschen ständige Wachsamkeit zu verlangen. Die Aussage zur Nebenläufigkeit braucht eine Einschränkung: Unveränderliche Daten verringern gemeinsam genutzten veränderlichen Zustand, doch Systeme haben weiterhin mit Reihenfolgen, Ressourcenkonkurrenz und verteilter Konsistenz zu tun. Ereignisverläufe bringen außerdem Aufwand für Speicherung, Wiedergabe und Interpretation mit sich. Die nützliche Entwurfsfrage lautet, wo Veränderlichkeit nötig ist und wie eng sie sich begrenzen lässt.

Richte Quellcodeabhängigkeiten auf die Geschäftspolitik aus, nicht auf die Technologie

Die Geschäftspolitik gehört nach innen. Clean Architecture ist Martins Anordnung von Software, bei der die Geschäftsregeln unabhängig von externen Mechanismen bleiben. Entitäten bilden wichtige Geschäftsregeln ab, die anwendungsübergreifend gelten können. Anwendungsfälle koordinieren diese Regeln, um die Aufgaben einer bestimmten Anwendung zu erfüllen. Äußere Adapter übersetzen zwischen diesen inneren Richtlinien und Details wie Webanfragen oder Datenbankdatensätzen.

Abhängigkeiten weisen nach innen. Die Abhängigkeitsregel besagt, dass Quellcode in einer inneren Richtlinienschicht äußere Implementierungsdetails weder benennen noch von ihnen abhängen darf. Der Ablauf zur Laufzeit kann sich dennoch nach außen bewegen: Ein innerer Anwendungsfall ruft eine Schnittstelle auf, deren Eigentümer er ist, und ein äußerer Presenter oder Datenbankadapter implementiert diese Schnittstelle. So können die Geschäftsregeln einen Wechsel der Datenbank oder der Bildschirmgestaltung überstehen, ohne frameworkspezifische Typen oder Datenformate übernehmen zu müssen.

Analyse

Die Unterscheidung zwischen Ablauf zur Laufzeit und Abhängigkeit im Quellcode ist subtil, aber wirkungsvoll. Sie trennt die Frage, wer eine Handlung auslöst, von der Frage, wer den Vertrag festlegen darf – ein Unterschied, der auch aus Protokolldesign und institutioneller Steuerung bekannt ist. Die innere Schicht besitzt die Schnittstelle, weil sie die Anforderung hat; der Adapter stellt einen austauschbaren Mechanismus bereit. Diese Anordnung verlangt nicht, dass jedes Projekt aus konzentrischen Diagrammen besteht. Sie ist vielmehr ein Test der Zuständigkeit: Wenn ein Wechsel der Datenbankbibliothek Änderungen an den Geschäftsregeln erzwingt, erfüllt die Grenze ihren Zweck nicht.

Ziehe Grenzen zwischen Gründen für Änderungen, nicht zwischen willkürlichen technischen Kategorien

Gruppiere nach Zuständigkeit. Das Single-Responsibility-Prinzip besagt, dass ein Modul einem Akteur dienen sollte, also einer Gruppe, die eine bestimmte Art von Änderung anfordert. In Martins Beispiel zur Lohnabrechnung vereint eine Employee-Klasse die Gehaltsberechnung, die Erfassung der Arbeitsstunden und die Datenbankspeicherung. Eine gemeinsam genutzte Routine für Arbeitsstunden kann dann dazu führen, dass eine Änderung für die Lohnabrechnung versehentlich HR-Berichte beschädigt. Eine Gliederung des Codes nach den Personen und Zwecken, die Änderungen daran vornehmen, verringert solche Kollisionen.

Gestalte für sichere Variationen. Das Open-Closed-Prinzip bevorzugt eine Erweiterung des Verhaltens, statt geschützten Code wiederholt zu ändern. Das Liskov-Substitutionsprinzip verlangt, dass austauschbare Implementierungen die Zusagen einhalten, auf die ihre Nutzer vertrauen. Das Interface-Segregation-Prinzip vermeidet, dass Clients von Operationen abhängen müssen, die sie nicht nutzen. Das Dependency-Inversion-Prinzip stellt stabile Abstraktionen zwischen die zentrale Richtlinie und wechselhafte Details. Zusammen helfen diese Ideen, Änderungen einzudämmen, statt Klassen bloß zu schmücken.

Analyse

Diese Prinzipien sind am wirksamsten, wenn man sie als Fragen zur Zuständigkeit für Änderungen versteht und nicht als Checkliste für Klassenstrukturen. Das Beispiel zur Lohnabrechnung legt ebenso sehr ein soziales wie ein technisches Problem offen: Ein Team kann Code verändern, auf den ein anderes Team vertraut, ohne es zu merken. Schnittstellen können diese Zuständigkeit deutlich machen. Doch für jeden Akteur ein eigenes Modul zu erstellen, kann unnötige Abstimmung und Indirektion verursachen. Gute Grenzen bilden wiederkehrende Unterschiede bei Änderungen ab; um zu erkennen, wann zwei Zuständigkeiten tatsächlich auseinanderlaufen, braucht es weiterhin Code-Reviews und Fachwissen.

Löse Komponentenzyklen auf, bevor sie Veröffentlichungen zum teamweiten Notfall machen

Komponenten prägen die Zusammenarbeit. Eine Komponente ist eine bereitstellbare Einheit, etwa ein Java-Archiv oder eine gemeinsam genutzte Bibliothek. Drei Komponentenkohäsionsprinzipien helfen bei der Entscheidung, was zusammengehört: Gruppiere Code, der gemeinsam veröffentlicht wird; gruppiere Code, der sich aus denselben Gründen ändert; und vermeide es, Klassen zu bündeln, die Nutzer nicht gemeinsam benötigen. Diese Ziele stehen miteinander in Konflikt. Die passende Komponentengröße kann sich daher ändern, wenn ein Projekt von der internen Entwicklung zur Wiederverwendung übergeht.

Halte Abhängigkeiten kreisfrei. Das Prinzip der azyklischen Abhängigkeiten besagt, dass Komponentenabhängigkeiten einen gerichteten Graphen ohne Schleifen bilden. Ein Zyklus kann dazu führen, dass mehrere Teams von derselben synchronisierten Veröffentlichung abhängen, wodurch isolierte Tests und schrittweise Integration erschwert werden. Stabilität bietet einen weiteren Maßstab: Komponenten mit vielen Abhängigkeiten von anderen lassen sich nur kostspielig ändern; wechselhafte Komponenten sollten deshalb keine Voraussetzungen für stabile Richtlinien sein. Abstrakte Schnittstellen können Abhängigkeiten stattdessen auf stabile Komponenten ausrichten.

Analyse

Ein Abhängigkeitsgraph ist auch eine Karte der Abstimmungskosten. Zyklen schaffen das softwareseitige Gegenstück zu eng gekoppelten Abteilungen, die ihre Abläufe nicht ändern können, ohne sich miteinander abzustimmen. Ein azyklischer Graph garantiert keine gute Architektur, erleichtert aber Überlegungen zu Build-Reihenfolge, Testumfang und Auswirkungen einer Veröffentlichung. Stabilitätskennzahlen können überraschende Abhängigkeitsmuster aufzeigen, aber nicht entscheiden, ob eine Komponente sinnvoll oder angemessen dimensioniert ist. Solche Messwerte sind Diagnoseinstrumente, keine objektiven Qualitätsnoten.

Beginne mit einem Monolithen; verteile erst, wenn reale Einschränkungen den Aufwand rechtfertigen

Bereitstellung ist nicht Architektur. Ein Monolith kann sorgfältig getrennte Komponenten enthalten, während eine Ansammlung von Diensten weiterhin eng gekoppelt sein kann. Funktionsaufrufe innerhalb eines Prozesses sind günstig und können häufig erfolgen. Aufrufe über Prozess- oder Netzwerkgrenzen verursachen zusätzliche Latenz, Datenkonvertierung und betriebliche Fehlerquellen. Grenzen auf diesen Ebenen sollten daher einem realen Entwicklungs-, Bereitstellungs- oder Betriebsbedarf dienen.

Dienste garantieren keine Unabhängigkeit. In Martins Beispiel einer Taxibuchungsplattform wirkt sich eine Funktion zur Kätzchenlieferung auf die Auswahl geeigneter Angebote, die Zuweisung von Fahrern, Lieferantenregeln und die Prüfung von Kundenallergien aus. Die Aufteilung dieser Verhaltensweisen auf Dienste verhinderte nicht, dass die Funktion all ihre Grenzen überschritt. Ein Komponentendesign mit Erweiterungspunkten könnte das neue Angebot isolieren. Empfohlen wird, zunächst die Trennung im Code zu bewahren und ausgewählte Grenzen erst dann in bereitstellbare Einheiten oder Dienste zu überführen, wenn die Fakten dafür sprechen.

Analyse

Das ist eine hilfreiche Korrektur der Gleichsetzung von Netzwerkverteilung und Modularität. Verteilte Systeme tauschen lokale Einfachheit gegen Latenz, Teilausfälle, Bereitstellungsabstimmung und Anforderungen an die Beobachtbarkeit ein. Das Kätzchenbeispiel zeigt, dass gemeinsam genutzte Daten und übergreifende Richtlinien Dienste ebenso eng koppeln können, wie Funktionen Klassen miteinander verbinden. Umgekehrt kann ein Monolith zum Engpass werden, wenn Teams oder betriebliche Anforderungen tatsächlich unabhängige Bereitstellungen verlangen. Die architektonische Frage lautet nicht, welche Topologie modern ist, sondern welche Grenze die gesamten Abstimmungs- und Fehlerkosten in der konkreten Umgebung senkt.

Halte Datenbanken, Webschnittstellen und Frameworks außerhalb der Geschäftsregeln

Verschiebe austauschbare Entscheidungen. Martin behandelt Datenbanken, Webbereitstellung und Frameworks als Details, denn die Geschäftsvorgaben sollten ihre konkreten Implementierungen nicht kennen müssen. In FitNesse ermöglichte eine einfache Schnittstelle für die Seitenspeicherung dem Team, zuerst Funktionen mit einer In-Memory-Implementierung und anschließend mit einfachen Dateien zu entwickeln. Ein Kunde ergänzte später innerhalb von ungefähr einem Tag eine MySQL-Implementierung. Letztlich benötigte das Team diese Option nicht.

Nutze Werkzeuge, ohne den Kern aus der Hand zu geben. Frameworks können die Arbeit beschleunigen, doch ihre Autoren entwerfen sie für die eigenen Probleme, und eine enge Bindung kann einen späteren Austausch kostspielig machen. Frameworkspezifischer Code sollte in einem äußeren Adapter oder einer Einrichtungskomponente verbleiben. Das Datenmodell selbst kann für das Geschäft zentral sein; die Datenbanksoftware und ihre Abfragesprache müssen es nicht sein. Externe Kunden- oder Organisationsanforderungen können eine bestimmte Technologie dennoch erforderlich machen.

Analyse

Die FitNesse-Geschichte veranschaulicht den Wert umkehrbarer Entscheidungen: Eine kleine Nahtstelle bewahrte die Möglichkeit, später zu wählen, ohne dass das Team das perfekte Speichersystem vorhersagen musste. Das ähnelt dem Denken in Realoptionen in der Wirtschaft, bei dem geringe Anfangskosten wertvolle Wahlmöglichkeiten unter Unsicherheit offenhalten können. Aufschieben ist jedoch nicht automatisch klug. Eine Technologieentscheidung kann Leistung, Personal, Compliance oder Beschaffung beeinflussen; solche Einschränkungen können wesentlich und nicht bloß modisch sein. Ziel ist nicht, so zu tun, als gäbe es keine Einschränkungen, sondern zu verhindern, dass sie die Richtlinien unnötig durchdringen.

Verankere Tests und Hardwareschnittstellen in der Architektur, statt sie außen herumzubauen

Teste an der Richtliniengrenze. Das Humble-Object-Muster verlagert schwer testbares Verhalten in eine minimale Komponente und belässt die Logik in einer testbaren Komponente. Ein Presenter kann Datumsangaben und Beträge in ein View-Modell formatieren, während die Bildschirmansicht sie lediglich darstellt. Eine spezielle Test-API kann Tests den Zugriff auf Geschäftsregeln ermöglichen, ohne dass sie durch eine instabile grafische Oberfläche navigieren oder jede Produktionsklasse eins zu eins nachbilden müssen. Das verringert die Anfälligkeit von Tests und den Widerstand gegen harmlose Umgestaltungen.

Trenne Software von Hardware. Eingebettete Systeme benötigen eine Hardwareabstraktionsschicht, eine Schnittstelle, die nützliche Dienste bereitstellt und zugleich die gerätespezifische Implementierung verbirgt. Eine Betriebssystemabstraktion kann dieselbe Rolle für Abhängigkeiten vom Betriebssystem übernehmen. Ohne solche Nahtstellen kann ein Hardwarewechsel weitreichende Änderungen erzwingen, und der Code ist möglicherweise nur auf dem Zielgerät testbar.

Analyse

Testbarkeit ist hier eine strukturelle Eigenschaft und kein nachträglicher Gedanke des Testteams. Eine stabile API ermöglicht Tests den Zugriff auf Verhalten und schirmt sie zugleich vor nebensächlichen Änderungen am Bildschirmaufbau und an der Klassenstruktur ab. Bei eingebetteter Software schafft dieselbe Logik einen Weg, schon vor der Verfügbarkeit der Hardware zu testen oder weiterzutesten, nachdem ein Gerät veraltet ist. Leistungsfähige Testzugänge erfordern Sorgfalt: Werden Sicherheitsvorkehrungen umgangen oder teure Ressourcen ersetzt, können Risiken entstehen, falls nur für Tests gedachte Fähigkeiten in die Produktion gelangen. Die Isolation muss neben sauberem Quellcode auch Bereitstellung und Zugriffskontrolle umfassen.

Lass die Architektur das Produkt erkennen und setze ihre Grenzen anschließend im Code durch

Mach die Fachdomäne sichtbar. Ein Repository sollte seinen Zweck erkennen lassen – ob es Videoverkäufe, Gesundheitsversorgung oder Buchhaltung unterstützt –, statt nur sein Webframework anzukündigen. Im Beispiel eines Videoverkaufs gibt es verschiedene Akteure: Privatkunden, Geschäftskunden, Autoren und Administratoren. Die Gruppierung ihrer Anwendungsfälle trägt dazu bei, dass die Anforderungen eines Akteurs nicht wahllos das gesamte System durchdringen.

Die Implementierung kann den Entwurf zunichtemachen. Simon Browns Kapitel vergleicht die Gliederung von Code nach technischer Schicht, Funktion, Fachdomänengrenze oder Komponente. In Java schwächt es die Kapselung auf Paketebene, wenn jede Klasse öffentlich ist; der Compiler kann Aufrufer dann nicht davon abhalten, die vorgesehenen Schnittstellen zu umgehen. Ein komponentenorientiertes Paket kann einen Zugangspunkt nach außen freigeben und seine interne Implementierung verbergen. Grenzen sollten gestärkt werden, wenn ihr Nutzen den Pflegeaufwand übersteigt, nicht vorsorglich überall.

Analyse

Architektur vermittelt sowohl Maschinen als auch Menschen etwas. Eine an der Fachdomäne ausgerichtete Struktur kann die Einarbeitung verkürzen, weil Neueinsteiger erkennen können, was das System tut, bevor sie seine Framework-Entscheidungen kennenlernen. Vom Compiler durchgesetzte Zugriffsbeschränkungen machen diese Struktur zu mehr als einem Diagramm oder einem Versprechen im Code-Review. Dennoch ist die Gliederung nach Funktionen oder Komponenten nicht grundsätzlich überlegen; Sichtbarkeitsregeln der Sprache, Teamgröße und Bereitstellungsanforderungen beeinflussen die passende Anordnung. Das entscheidende Kriterium ist, ob die gewählte Struktur vorgesehene Abhängigkeiten erleichtert und versehentliche erschwert.

Analyse

Der wichtigste Schritt des Buches ist, Architektur nicht länger als Bild aus Kästchen, sondern als Strategie zur Steuerung der Änderungskosten zu begreifen. Dadurch hängen die Empfehlungen zusammen: Dependency Inversion schützt die Richtlinien, Komponentengraphen organisieren die Zusammenarbeit, testbare Grenzen begrenzen das Risiko von Regressionen, und aufgeschobene Technologieentscheidungen bewahren Wahlmöglichkeiten. Am überzeugendsten ist das Argument dort, wo es Softwarestruktur mit menschlichem Aufwand verknüpft. Ein verworrener Abhängigkeitsgraph ist nicht bloß ästhetisch mangelhaft; er führt zu langsamer Integration, umfangreicheren Tests und dazu, dass mehr Menschen nötig sind, um gewöhnliche Änderungen umzusetzen.

Das Rahmenwerk des Buches lässt sich bewusst auf verschiedene Sprachen und Epochen übertragen. Wiederkehrende Grundelemente sind Sequenz, Auswahl, Wiederholung, Daten und Indirektion, während sich Hardware und Werkzeuge verändern. Diese historische Perspektive stellt sich sinnvollerweise gegen die Annahme, ein neues Framework oder ein neuer Bereitstellungsstil beseitige alte Entwurfsprobleme. Die Behauptung, architektonische Regeln blieben im Wesentlichen unverändert, sollte jedoch als Aussage über dauerhafte Prinzipien verstanden werden, nicht über eine unveränderte Umsetzung. Moderne verteilte Plattformen, Cloudbetrieb und regulatorische Anforderungen verändern das Kostenprofil von Grenzen, selbst wenn Richtlinien von Details unabhängig bleiben sollten.

Das Buch bietet außerdem eine wertvolle Spannung statt eines Rezepts. Wiederverwendung, lokale Änderungen und das Vermeiden unnötiger Abhängigkeiten ziehen den Komponententwurf in unterschiedliche Richtungen. Ebenso kann eine vorweggenommene Grenze kostspielige Eingriffe verhindern, während spekulative Abstraktion ein kleines Produkt belasten kann. Die architektonische Aufgabe ist daher empirisch: beobachten, wo Änderungen kollidieren, Tests brüchig werden und Bereitstellung oder Betrieb reale Einschränkungen mit sich bringen, und dann in die Grenze investieren, deren erwartete Einsparungen ihren Pflegeaufwand rechtfertigen.

Manche Belege sind anschaulich, aber nicht schlüssig. Im Produktivitätsbeispiel dienen Codezeilen als Maß, und das Experiment zur testgetriebenen Entwicklung ist klein. Keines von beiden belegt einen universellen, zahlenmäßig bestimmbaren Ertrag sauberer Gestaltung. Sie machen vielmehr einen plausiblen Wirkungsmechanismus sichtbar: Eine unübersichtliche Struktur verbraucht Aufwand, der sonst nützliches Verhalten hervorbringen könnte. Die bleibende Lehre lautet nicht, Abstraktion zu maximieren. Vielmehr sollten die wichtigen Richtlinien eines Systems verständlich und testbar sein und möglichst wenig von den Details abhängen, die sich am ehesten ändern.

Zusammenfassung in 30 Sekunden
Die Architektur bestimmt, wie viel Aufwand gewöhnliche Änderungen über die Lebensdauer eines Systems erfordern. Halten Sie Geschäftsregeln unabhängig von Datenbanken, Schnittstellen und Frameworks und richten Sie die Codeabhängigkeiten auf diese Regeln aus. Trennen Sie Module nach Verantwortlichkeiten, verhindern Sie zirkuläre Abhängigkeiten und ziehen Sie Grenzen dort, wo Änderungen kollidieren oder Tests fragil werden. Beginnen Sie mit einem gut getrennten Monolithen; wechseln Sie erst dann zu verteilten Diensten, wenn betriebliche oder entwicklungstechnische Einschränkungen deren Kosten rechtfertigen. Bei einem Unternehmen wuchs die Codeausgabe trotz einer steigenden Zahl von Mitarbeitern kaum; spätere Releases kosteten pro Codezeile etwa 40-mal so viel.
Enthält Spoiler

Zuletzt aktualisiert:

Problem melden

Rezensionsübersicht

4.21 von 5
Durchschnitt von 7.000+ Bewertungen von Goodreads und Amazon.

Clean Architecture: A Craftsman's Guide to Software Structure and Design wird unterschiedlich beurteilt. Viele loben den Schwerpunkt auf den SOLID-Prinzipien und der Entkopplung, während andere das Buch repetitiv und arm an praktischen Beispielen finden. Einige Leser schätzen den historischen Kontext und die Anekdoten, andere meinen, sie lenkten vom Kerninhalt ab. Insgesamt gilt das Buch als hilfreich für das Verständnis grundlegender Architekturkonzepte, doch gehen die Meinungen auseinander, wie nützlich es für Anfängerinnen und Anfänger im Vergleich zu erfahrenen Entwicklern ist. Mehrere Rezensenten merken an, der Inhalt hätte knapper vermittelt werden können.

Ihre Bewertung:
4.6
633 Bewertungen
Möchten Sie das vollständige Buch lesen?

Glossar

Clean Architecture

Geschäftsregeln von technischen Details abschirmen

Ein Architekturansatz, bei dem wichtige Geschäftsregeln im Inneren liegen und technische Mechanismen wie Datenbanken, Webframeworks und Geräte außen. Die Abhängigkeiten im Quellcode weisen auf die inneren Geschäftsregeln. Das System kann weiterhin externe Werkzeuge verwenden, doch die zentralen Regeln sollten nicht von deren Namen, Formaten oder Implementierungsentscheidungen abhängen.

Abhängigkeitsregel

Abhängigkeiten weisen auf die Geschäftsregeln

Die Regel, dass Abhängigkeiten im Quellcode einer geschichteten Architektur nach innen weisen müssen – von den Details hin zu den übergeordneten Geschäftsregeln. Innerer Code darf weder auf Namen noch auf Datenformate verweisen, die in äußeren Schichten deklariert sind. Schnittstellen, die dem inneren Code gehören, ermöglichen Aufrufe zur Laufzeit an Implementierungen in äußeren Schichten, ohne die Abhängigkeit im Quellcode umzukehren.

Entität

Zentrale Geschäftsregeln und -daten

Ein Softwareobjekt oder -modul, das wichtige Geschäftsdaten und die darauf wirkenden Regeln zusammenführt. Eine Entität bildet ein Geschäftskonzept ab, das über die Schnittstelle oder Datenbank einer bestimmten Anwendung hinaus bedeutsam bleibt. Sie sollte nicht von diesen technischen Mechanismen abhängen.

Anwendungsfall

Anwendungsspezifischer Geschäftsablauf

Eine Beschreibung und Implementierung dessen, wie ein automatisiertes System eingesetzt wird, um ein Ziel zu erreichen. Ein Anwendungsfall legt relevante Eingaben, Ausgaben und Verarbeitungsschritte fest und koordiniert die Entitäten, die allgemeinere Geschäftsregeln enthalten. Er sollte nicht davon abhängen, ob Nutzer über eine Webseite, eine Konsole oder eine andere Schnittstelle interagieren.

SOLID-Prinzipien

Leitlinien für änderungsfreundliches Design

Fünf miteinander verbundene Entwurfsprinzipien zu Verantwortung, Erweiterbarkeit, Ersetzbarkeit, Schnittstellengröße und Abhängigkeitsrichtung. Sie geben Orientierung dafür, wie Funktionen und Daten gruppiert werden und wie Module voneinander abhängen. Ihr gemeinsames Ziel ist es, Software leichter änderbar, verständlicher und wiederverwendbar zu machen, ohne nicht zusammengehörige Verantwortlichkeiten zu koppeln.

Komponentenkohäsionsprinzipien

Regeln für die Gruppierung auslieferbarer Codeeinheiten

Die Prinzipien der Wiederverwendungs-/Release-Äquivalenz, der gemeinsamen Änderungsgründe und der gemeinsamen Wiederverwendung geben Orientierung dafür, welche Klassen zu einer Komponente gehören. Sie wägen einen koordinierten Release, die Gruppierung von gemeinsam geändertem Code und das Vermeiden von Abhängigkeiten zu ungenutzten Klassen gegeneinander ab. Da diese Ziele miteinander in Konflikt geraten können, sollte die Komponentenstruktur den aktuellen Entwicklungs- und Wiederverwendungsanforderungen eines Projekts entsprechen.

Ereignisbasierte Speicherung (Event Sourcing)

Ereignisse speichern, aktuellen Zustand ableiten

Eine Datenstrategie, bei der die Abfolge von Transaktionen oder Ereignissen gespeichert wird, statt den aktuellen Zustand wiederholt zu überschreiben. Der Zustand wird rekonstruiert, indem diese Ereignisse angewendet werden; manchmal geschieht dies ausgehend von einem gespeicherten Schnappschuss, um den erneuten Durchlauf zu verkürzen. Dadurch können veränderliche Aktualisierungen reduziert werden, allerdings müssen der aufgezeichnete Verlauf gespeichert und verarbeitet werden.

Humble-Object-Muster

Schwer testbares Verhalten abtrennen

Ein Entwurfsmuster, das Verhalten auf eine minimale Komponente für schwer testbare Mechanismen und eine separate Komponente mit testbarer Logik aufteilt. Eine Ansicht kann beispielsweise vorbereitete Werte anzeigen, während ein Presenter sie formatiert. Durch diese Trennung entsteht häufig eine nützliche Architekturgrenze.

Test-API

Stabiler Zugang für automatisierte Tests

Eine Schnittstelle, über die Tests das Geschäftsverhalten prüfen können, ohne sich auf die Benutzeroberfläche zu stützen oder jede Produktivklasse nachzubilden. Sie kann kontrollierte Möglichkeiten bieten, den Systemzustand festzulegen, kostspielige Ressourcen zu umgehen oder auf Vorgänge zuzugreifen, die gewöhnlichen Nutzern nicht zur Verfügung stehen. Sensible Testfunktionen sollten aus den Zugriffswegen der Produktionsumgebung herausgehalten werden.

Hardwareabstraktionsschicht (HAL)

Hardware hinter Diensten verbergen

Eine Softwareschnittstelle, die die von einer Anwendung benötigten Dienste bereitstellt und dabei die Einzelheiten bestimmter Hardware verbirgt. Statt Geräteregister oder Pinbelegungen offenzulegen, kann sie in Produktbegriffen formulierte Operationen anbieten. So können sich die Implementierungen mit der Hardware ändern, während die übergeordnete Software davon abgeschirmt bleibt.

Hauptdiagonale (Main Sequence)

Stabilität und Abstraktion ausbalancieren

Eine Linie in einem Komponentendiagramm, die Stabilität und Abstraktheit zueinander in Beziehung setzt. Komponenten nahe dem einen Ende sind stabil und abstrakt; nahe dem anderen sind sie instabil und konkret. Komponenten, die weit von der Linie entfernt liegen, können entweder starr sein, obwohl sie konkret sind, oder abstrakt, ohne sinnvolle abhängige Komponenten zu haben. Der Messwert ist ein diagnostischer Anhaltspunkt, kein Qualitätsbeweis.

FAQ

Worum geht es in Clean Architecture?

  • Softwarestruktur im Fokus: Clean Architecture von Robert C. Martin betont, wie wichtig eine wirksame Softwarearchitektur ist, damit Systeme leicht entwickelt, gewartet und bereitgestellt werden können.
  • Zeitlose Prinzipien: Das Buch erläutert Prinzipien wie SOLID, die für verschiedene Programmierparadigmen gelten und Entwicklern Orientierung beim Schreiben sauberen, wartbaren Codes geben.
  • Trennung der Zuständigkeiten: Das Buch befürwortet, Geschäftsregeln von technischen Details zu trennen, um Flexibilität und Anpassungsfähigkeit im Softwaredesign zu verbessern.

Warum sollte ich Clean Architecture lesen?

  • Softwaredesign-Fähigkeiten verbessern: Das Buch vertieft das Verständnis von Softwarearchitektur und bietet praktische Ratschläge für reale Projekte.
  • Zeitloses Wissen: Die Prinzipien sind nicht an bestimmte Technologien gebunden und bleiben dadurch während der gesamten beruflichen Laufbahn relevant.
  • Beispiele aus der Praxis: Martin gibt Einblicke in seine umfangreiche Erfahrung und bietet anschauliche Beispiele und Fallstudien, die komplexe Konzepte verständlicher machen.

Was sind die wichtigsten Erkenntnisse aus Clean Architecture?

  • Architektur ist eine Struktur: Die Softwarearchitektur wird durch die Aufteilung in Komponenten und deren Kommunikation bestimmt und erleichtert so Entwicklung und Wartung.
  • Geschäftsregeln entkoppeln: Geschäftsregeln von technischen Details zu trennen, erleichtert Änderungen und Anpassungen.
  • Optionen offenhalten: Eine gute Architektur schiebt technische Entscheidungen auf und ermöglicht so Flexibilität, wenn sich Anforderungen ändern.

Welche SOLID-Prinzipien werden in Clean Architecture erwähnt?

  • Single-Responsibility-Prinzip (SRP): Eine Klasse sollte nur einen Grund haben, sich zu ändern. Das reduziert die Komplexität und erleichtert die Wartung.
  • Open-Closed-Prinzip (OCP): Softwareeinheiten sollten für Erweiterungen offen, für Änderungen jedoch geschlossen sein, um das Fehlerrisiko zu senken.
  • Liskovsches Substitutionsprinzip (LSP): Untertypen müssen anstelle ihrer Basistypen verwendet werden können, ohne die Korrektheit des Programms zu beeinträchtigen.

Was bedeutet das Dependency-Inversion-Prinzip (DIP) in Clean Architecture?

  • Übergeordnete Module: Das DIP besagt, dass übergeordnete Module nicht von untergeordneten Modulen abhängen sollten; beide sollten von Abstraktionen abhängen.
  • Abstraktionen statt Details: Abhängigkeiten von Abstraktionen statt konkreten Implementierungen machen Systeme leichter änderbar und erweiterbar.
  • Einsatz von Schnittstellen: Das Prinzip fördert den Einsatz von Schnittstellen zur Definition von Verträgen zwischen Komponenten und erleichtert so Tests und Wartung.

Wie definiert Clean Architecture eine gute Softwarearchitektur?

  • Unterstützung von Anwendungsfällen: Eine gute Architektur muss die vorgesehenen Anwendungsfälle unterstützen und sie innerhalb der Struktur klar und sichtbar machen.
  • Menschlichen Aufwand minimieren: Sorgfältiges Design sollte den für Entwicklung, Bereitstellung und Wartung nötigen Aufwand minimieren.
  • Optionen offenhalten: Eine gut entworfene Architektur lässt Optionen für künftige Änderungen offen, was für langfristigen Erfolg entscheidend ist.

Welche Bedeutung haben Grenzen in Clean Architecture?

  • Trennung der Zuständigkeiten: Grenzen trennen Systemkomponenten und stellen sicher, dass Änderungen in einem Bereich andere nicht nachteilig beeinflussen.
  • Abhängigkeiten kontrollieren: Die Verwaltung von Abhängigkeiten über Grenzen hinweg verhindert Störungen und trägt zu einem stabilen System bei.
  • Unabhängige Entwicklung ermöglichen: Grenzen erlauben es Teams, unabhängig voneinander zu arbeiten, was die Produktivität steigert und Konflikte verringert.

Was bedeutet das Konzept der „Screaming Architecture“ in Clean Architecture?

  • Die Architektur macht die Absicht sichtbar: „Screaming Architecture“ bedeutet, dass die Architektur eines Systems seinen Zweck und seine Funktionalität klar vermitteln sollte.
  • Von Anwendungsfällen bestimmt: Eine gute Architektur wird von Anwendungsfällen bestimmt und bewahrt während der gesamten Entwicklung Klarheit und Zweckorientierung.
  • Abhängigkeit von Frameworks vermeiden: Die Architektur sollte sich an den geschäftlichen Anforderungen ausrichten und nicht von Frameworks oder Werkzeugen bestimmt werden.

Wie behandelt Clean Architecture das Thema Testen?

  • Testbare Architekturen: Das Buch betont Architekturen, die Unit-Tests von Geschäftsregeln ermöglichen, ohne dass externe Systeme laufen müssen.
  • Humble-Object-Muster: Es trennt schwer testbaren Code von testbarem Code, damit sich die Tests auf die Logik konzentrieren können, ohne durch die Komplexität von Benutzeroberflächen oder Frameworks beeinträchtigt zu werden.
  • Test-API: Es schlägt vor, eine Test-API einzurichten, mit der Sicherheitsbeschränkungen umgangen werden können, um verschiedene Szenarien besser testen zu können.

Wie unterscheidet Clean Architecture zwischen dem Web und der Architektur eines Systems?

  • Das Web als Auslieferungsmechanismus: Das Web wird als Auslieferungsmechanismus betrachtet, nicht als bestimmendes Merkmal der Systemarchitektur.
  • Auslieferung von der Logik entkoppeln: Wird das Web als Detail behandelt, lassen sich Systeme entwerfen, die unabhängig von der Auslieferungsmethode sind.
  • Fokus auf Geschäftslogik: Geschäftslogik und Anwendungsfälle haben Vorrang vor den Einzelheiten der Webauslieferung, sodass die Kernfunktionalität erhalten bleibt.

Welche Risiken birgt der Einsatz von Frameworks laut Clean Architecture?

  • Enge Kopplung: Frameworks können zu enger Kopplung führen und den Wechsel der Technologie erschweren.
  • Zusätzlicher Aufwand und Komplexität: Eine starke Abhängigkeit von Frameworks kann unnötige Komplexität verursachen und die Leistung beeinträchtigen.
  • Kontrollverlust: Eine übermäßige Abhängigkeit von Frameworks kann zu einem starren System führen, in dem Änderungen und Anpassungen schwierig sind.

Was sind die besten Zitate aus Clean Architecture und was bedeuten sie?

  • „Ihre Architektur sollte den Lesern etwas über das System sagen, nicht über die Frameworks, die Sie in Ihrem System verwendet haben.“: Das unterstreicht, dass die Architektur die Geschäftsdomäne und Anwendungsfälle widerspiegeln sollte, nicht die verwendeten Technologien.
  • „Frameworks sind Werkzeuge, keine Lebensweise.“: Eine Erinnerung daran, dass Entwickler die Kontrolle über die Architektur behalten und sich nicht zu stark auf Frameworks verlassen sollten.
  • „Eine gute Architektur macht es unnötig, sich bis weit in das Projekt hinein für Rails, Spring, Hibernate, Tomcat oder MySQL zu entscheiden.“: Das hebt hervor, dass Technologieentscheidungen aufgeschoben werden sollten, bis die Architektur feststeht, um Flexibilität zu bewahren.

Über den Autor

Robert Cecil Martin, bekannt als Uncle Bob, ist ein bekannter Softwareentwickler und Verfechter agiler Entwicklungsmethoden. Als Präsident von Object Mentor Inc. leitet er ein Team von Beratern, das auf objektorientiertes Design, Entwurfsmuster, UML und agile Methoden spezialisiert ist. Martin verfügt über umfassende Erfahrung in der Softwarebranche und war von 1996 bis 1999 Chefredakteur des C++ Report. Als gefragter Redner auf internationalen Konferenzen und Fachmessen gibt er sein Wissen über bewährte Vorgehensweisen in der Softwareentwicklung weiter. Sein Einfluss reicht über die Beratung hinaus: Er hat mehrere einflussreiche Bücher über Softwarehandwerk und saubere Programmierpraktiken verfasst.

PDF herunterladen

Lade das kostenlose PDF herunter, um die Zusammenfassung von Clean Architecture für später zu speichern. Du kannst es ausdrucken oder offline lesen, wann immer du möchtest.
Download PDF

EPUB herunterladen

Lade das kostenlose EPUB herunter, um die Zusammenfassung von Clean Architecture auf deinem E-Reader oder in einer Lese-App zu lesen. Das digitale Buchformat .epub eignet sich ideal zum Lesen auf Smartphones, Tablets und E-Readern.
Download EPUB
Möchten Sie das vollständige Buch lesen?
Folgen
Anhören
Start
Swipe
Biblio
App
3 Tage Vollzugriff testen
Anhören, speichern und mehr
Funktionen vergleichen Kostenlos Pro
📖 Zusammenfassungen lesen
Unbegrenzt Zusammenfassungen lesen. Kostenlose Nutzer erhalten 3 pro Monat
🎧 Zusammenfassungen anhören
Unbegrenzt Zusammenfassungen in 40 Sprachen anhören
—
❤️ Unbegrenzte Lesezeichen
Kostenlose Nutzer sind auf 4 begrenzt
—
📜 Unbegrenzter Verlauf
Kostenlose Nutzer sind auf 4 begrenzt
—
📥 Unbegrenzte Downloads
Kostenlose Nutzer sind auf 1 begrenzt
—
Risikofreier Zeitplan
Heute: Sofortzugang erhalten
Vollständige Zusammenfassungen von über 26.000 Büchern anhören. Das sind über 12.000 Stunden Audio!
Tag 2: Erinnerung an Testphase
Wir senden Ihnen eine Benachrichtigung, dass Ihre Testphase bald endet.
Tag 3: Ihr Abonnement beginnt
Die Abbuchung erfolgt am 24. Nov.,
vorher jederzeit kündbar.
Consume 2.8× More Books
2.8× weitere Bücher Hören Lesen
Unsere Nutzer lieben uns
1M+ Leser
Trustpilot Rating
TrustPilot
4.6 Hervorragend
Diese Seite ist ein absoluter Gamechanger. Ich habe noch nie so schnell Buchzusammenfassungen gelesen. Sehr, sehr empfehlenswert.
— Dave G
Das Geld und die Zeit absolut wert und wirklich gut gemacht. Eine solche Qualität von Zusammenfassungen habe ich auf anderen Websites noch nie gesehen. Sehr hilfreich!
— Em
Sehr empfehlenswert!! Fantastischer Service. Perfekt für alle, die mehr als einen Teaser möchten, aber nicht alle Details eines vollständigen Hörbuchs brauchen.
— Greg M
62 % sparen
Jährlich
$119.88 $44.99/Jahr/J.
$3.75/Mon.
Monatlich
$9.99/Mon.
3-tägige kostenlose Testphase starten
3 Tage kostenlos, dann $44.99/Jahr. Jederzeit kündbar.
Unlock a world of fiction & nonfiction books
26.000+ Bücher zum Preis von 2 Büchern
Lesen Sie jedes Buch in 10 Minuten
Entdecken Sie neue Bücher wie bei Tinder
Fordern Sie jedes Buch an, das noch nicht zusammengefasst ist
Lesen Sie mehr Bücher als jeder, den Sie kennen
Die Nr. 1 App für Buchliebhaber
Lifelike & immersive summaries
30-Tage-Geld-zurück-Garantie
Zusammenfassungen als EPUB oder PDF herunterladen
Jederzeit mit wenigen Klicks kündbar

Warum nur eine Zusammenfassung?

Scanner
Barcode zum Scannen finden

⭐
⭐
⭐
Wir haben ein besonderes Geschenk für Sie
Öffnen
38% Rabatt
RABATT FÜR DICH
⭐
⭐
⭐
$79.99
$49.99/Jahr
Nur $4.16 pro Monat
Weiter
Mit 2 Taps starten, ganz einfach kündigen
Einstellungen
Allgemein
Widget
Wird geladen...