Software-Architekturmuster: Die wichtigsten Muster im Überblick

Von Schichten über Hexagonal bis Microservices: wofür jedes Muster taugt und wann es mehr kostet, als es bringt
Aktualisiert:
Abstract
- #Software-Architektur
- #Architekturmuster
- #Softwareentwicklung
- #Entwickler
- #Microservices
- #Hexagonale Architektur
- #Event-driven Architecture
- #CQRS
Welches Architekturmuster passt zu welchem Problem – und woran Sie das vor dem ersten Code erkennen
Angenommen, ein Webshop wächst seit fünf Jahren. Am Anfang reichten ein Framework, eine Datenbank und ein Entwickler. Heute arbeiten drei Teams am Code, die Lagerverwaltung soll angebunden werden, und jede Änderung an der Preislogik bricht irgendwo die Rechnungserstellung. Das Team steht vor der Frage, ob es Microservices braucht, eine saubere Schichtung oder etwas ganz anderes.
Genau für solche Situationen gibt es Architekturmuster. Sie sind benannte, erprobte Antworten auf wiederkehrende Strukturfragen: Wie teilt man ein System auf, wer darf wen aufrufen, wo liegen die Daten? Ein Muster nimmt Ihnen die Entscheidung nicht ab. Es gibt Ihnen aber einen gemeinsamen Wortschatz und eine Liste bekannter Folgen, bevor Sie die ersten Wochen in eine Richtung investieren.
Architekturmuster, Entwurfsmuster, Architekturstil: eine Begriffsklärung
Die Begriffe werden oft durcheinandergeworfen. Eine einfache Unterscheidung hilft:
- Entwurfsmuster (Design Patterns) wie Factory, Strategy oder Observer lösen Probleme im Kleinen, also im Zusammenspiel weniger Klassen oder Funktionen.
- Architekturmuster legen die Grobstruktur einer Anwendung fest: welche Bausteine es gibt, wie sie kommunizieren und welche Abhängigkeiten erlaubt sind.
- Verteilungs- oder Landschaftsmuster beschreiben, wie mehrere Anwendungen oder Dienste zusammen ein Gesamtsystem bilden, etwa ein Monolith gegenüber vielen Microservices.
Die Grenzen sind fließend. Wichtig ist nur: Die Muster liegen auf verschiedenen Ebenen und lassen sich kombinieren. Ein einzelner Dienst kann intern hexagonal aufgebaut sein, mit anderen Diensten über Ereignisse sprechen und im Browser eine komponentenbasierte Oberfläche haben.
Was ein Muster wert ist, zeigt sich an den sogenannten Qualitätsmerkmalen, also an nichtfunktionalen Anforderungen wie Änderbarkeit, Testbarkeit, Skalierbarkeit oder Betriebsaufwand. Jedes Muster verbessert einige davon und verschlechtert andere. Wer das Muster nennt, ohne die Abwägung zu nennen, hat noch keine Architekturentscheidung getroffen.
Muster für die innere Struktur einer Anwendung
Schichtenarchitektur: der vertraute Ausgangspunkt
Die Schichtenarchitektur (Layered Architecture) teilt eine Anwendung horizontal auf, typischerweise in Präsentation, Anwendungslogik, Fachlogik und Datenzugriff. Jede Schicht darf nur die darunterliegende aufrufen. Fast jedes Web-Framework legt diese Aufteilung nahe, und fast jede Entwicklerin kennt sie.
Die Stärke ist die Vertrautheit: Neue Teammitglieder finden sich schnell zurecht. Die Schwäche zeigt sich, wenn das System wächst. Eine neue Funktion wie „Rabatt für Stammkunden“ berührt dann jede Schicht, und die Fachlogik verteilt sich über Controller, Services und Datenbankabfragen. Hinzu kommt viel Code, der Daten nur von einer Schicht in die nächste reicht. Für kleine bis mittlere Anwendungen mit überschaubarer Fachlogik bleibt das Schichtenmodell trotzdem eine vernünftige Wahl.
Hexagonale Architektur und ihre Verwandten
Die hexagonale Architektur, auch „Ports and Adapters“ genannt, dreht die Abhängigkeitsrichtung um. Im Zentrum steht die Fachlogik, die weder die Datenbank noch das Web-Framework kennt. Sie definiert stattdessen Schnittstellen, die Ports, etwa „Bestellungen speichern“ oder „Zahlung anstoßen“. Außen implementieren Adapter diese Ports, zum Beispiel für PostgreSQL, eine REST-Schnittstelle oder einen Zahlungsanbieter.
Im Webshop-Beispiel bedeutet das: Die Preisberechnung lässt sich ohne Datenbank und ohne HTTP-Server testen, und der Wechsel des Zahlungsdienstleisters betrifft nur einen Adapter. Onion Architecture und Clean Architecture verfolgen dieselbe Grundidee mit etwas anderer Einteilung der Ringe. Für die Praxis ist der gemeinsame Kern entscheidend: Abhängigkeiten zeigen nach innen, zur Fachlogik.
Der Preis ist zusätzliche Indirektion. Für eine Anwendung, die im Wesentlichen Formulare in Tabellen schreibt, sind Ports und Adapter oft Zeremonie ohne Nutzen. Sobald aber echte Geschäftsregeln entstehen und mehrere Schnittstellen nach außen hinzukommen, zahlt sich die Trennung aus. Viele Teams kombinieren das Muster mit Domain-Driven Design, also mit einer Modellierung entlang der Fachsprache; einen Einstieg dazu bietet der Beitrag zu strategischem Design mit Domain-Driven Design.
Modularer Monolith: Grenzen ziehen, ohne zu verteilen
Ein modularer Monolith wird als eine Einheit gebaut und ausgeliefert, ist innen aber in fachliche Module mit klaren Schnittstellen gegliedert, etwa Katalog, Warenkorb, Bestellung und Rechnung. Module greifen nicht auf die Tabellen oder internen Klassen anderer Module zu, sondern nur auf deren veröffentlichte Schnittstelle.
Das Muster ist attraktiv, weil es viele Vorteile von Microservices bietet, ohne deren Betriebsaufwand: klare Zuständigkeiten, unabhängige Weiterentwicklung im Code, aber nur ein Deployment, eine Transaktion und ein Stacktrace beim Debuggen. Die Grenzen müssen allerdings technisch abgesichert werden, etwa durch Architekturtests oder Build-Regeln, sonst weichen sie im Alltag auf. Wie man solche Module als Blackbox mit stabilen Schnittstellen schneidet, beschreibt der Beitrag über modulare Software-Architektur nach dem Blackbox-Prinzip.
Microkernel: ein stabiler Kern mit Erweiterungen
Beim Microkernel- oder Plugin-Muster stellt ein kleiner Kern die Grundfunktionen und definiert Erweiterungspunkte. Plugins liefern zusätzliche Funktionen über diese Verträge. Entwicklungsumgebungen, Browser mit ihren Erweiterungen oder Content-Management-Systeme folgen diesem Prinzip.
Das Muster passt, wenn ein Produkt bei verschiedenen Kunden unterschiedlich ausgebaut wird oder Dritte Erweiterungen schreiben sollen. Schwierig ist der Entwurf der Erweiterungspunkte: Ist die Plugin-Schnittstelle zu eng, stoßen Erweiterungen an Grenzen; ist sie zu weit, lässt sich der Kern kaum noch ändern, ohne Plugins zu brechen.
Muster für Kommunikation und Daten
Event-driven Architecture: lose Kopplung über Ereignisse
In einer ereignisgesteuerten Architektur (Event-driven Architecture) melden Bausteine, dass etwas passiert ist, etwa „Bestellung aufgegeben“. Andere Bausteine reagieren darauf, ohne dass der Absender sie kennt. Ein Message Broker wie RabbitMQ, eine Event-Streaming-Plattform wie Apache Kafka oder ein Cloud-Dienst übernimmt die Zustellung.
Im Webshop kann so die Lagerverwaltung reservieren, der Versand ein Etikett anlegen und das Marketing eine E-Mail planen, ohne dass der Bestellprozess davon weiß. Neue Reaktionen lassen sich ergänzen, ohne den Absender anzufassen. Die Kehrseite: Der Ablauf eines Geschäftsvorgangs steht nicht mehr an einer Stelle im Code, sondern verteilt sich über viele Empfänger. Fehlersuche, Monitoring und die Frage, was bei doppelt zugestellten Nachrichten passiert, brauchen eigene Antworten. Wann sich ereignisbasierte Backends gegenüber klassischen Aufrufen lohnen, ordnet der Beitrag zu REST und Event-Streams ein.
CQRS: Lesen und Schreiben trennen
Command Query Responsibility Segregation (CQRS) trennt das Modell für Änderungen (Commands) vom Modell für Abfragen (Queries). Das Schreibmodell prüft Geschäftsregeln, das Lesemodell liefert Daten genau so, wie Bildschirme oder Berichte sie brauchen, gegebenenfalls aus einer eigenen, dafür optimierten Datenhaltung.
Das lohnt sich, wenn Lese- und Schreiblast stark auseinanderfallen oder wenn die Anzeige ganz andere Strukturen braucht als die Fachlogik. Werden die Lesedaten asynchron nachgeführt, sieht ein Nutzer seine Änderung unter Umständen erst mit kurzer Verzögerung (Eventual Consistency). Für eine einfache Verwaltungsanwendung ist CQRS meist zu viel.
Event Sourcing: die Geschichte statt des Endstands speichern
Event Sourcing speichert nicht den aktuellen Zustand eines Objekts, sondern die Folge aller Ereignisse, die zu ihm geführt haben. Ein Kontostand ergibt sich dann aus allen Buchungen. Das liefert eine lückenlose Historie, erleichtert Auswertungen im Nachhinein und erlaubt, Zustände zu jedem Zeitpunkt zu rekonstruieren.
Dafür werden Änderungen an Ereignisformaten aufwendig, denn alte Ereignisse bleiben gespeichert und müssen weiterhin lesbar sein. Hinzu kommen Themen wie Snapshots für lange Ereignisketten und das Löschen personenbezogener Daten, das sich mit unveränderlichen Ereignissen schlecht verträgt. Event Sourcing ist ein Spezialwerkzeug für Domänen, in denen die Historie selbst fachlich wichtig ist, etwa Buchhaltung, Verträge oder Logistik. CQRS und Event Sourcing werden häufig gemeinsam genannt, sind aber unabhängig voneinander einsetzbar.
Muster für die Verteilung: vom Monolithen bis Serverless
Monolith
Der klassische Monolith wird als eine Einheit gebaut und betrieben. Er ist einfach zu entwickeln, zu testen und auszuliefern. Sein schlechter Ruf rührt meist nicht von der Auslieferungsform, sondern von fehlender innerer Struktur. Ein gut geschnittener Monolith ist für viele Unternehmen die wirtschaftlichste Architektur.
Service-orientierte Architektur und Microservices
Die service-orientierte Architektur (SOA) der 2000er-Jahre setzte auf fachliche Dienste mit standardisierten Verträgen, oft verbunden über einen zentralen Enterprise Service Bus. Microservices übernahmen die Idee fachlicher Dienste, verzichteten aber auf die zentrale Integrationsplattform: Jeder Dienst hat eigene Daten, wird unabhängig ausgeliefert und gehört einem Team.
Microservices lösen vor allem ein organisatorisches Problem: Viele Teams sollen unabhängig voneinander liefern. Sie bringen dafür verteilte Fehlerbilder, Netzwerklatenz, aufwendiges Monitoring und die Frage, wie Daten über Dienstgrenzen konsistent bleiben. Für ein einzelnes Team von fünf Personen überwiegen in aller Regel die Kosten. Wie eine schrittweise Zerlegung gelingt, wenn sie wirklich nötig ist, zeigt der Beitrag zur Migration vom Monolithen zu Microservices.
Serverless
Bei Serverless betreibt ein Cloud-Anbieter die Laufzeitumgebung. Function as a Service führt einzelne Funktionen auf Anfrage aus, Backend as a Service liefert fertige Bausteine wie Authentifizierung oder Datenbanken. Abgerechnet wird nach Nutzung. Das passt gut für unregelmäßige Last, Ereignisverarbeitung und schnelle Experimente. Dagegen stehen Anbieterbindung, Grenzen bei Laufzeit und Speicher sowie Kaltstarts, also Verzögerungen, wenn eine Funktion erst gestartet werden muss.
Peer-to-Peer
Bei Peer-to-Peer kommunizieren gleichberechtigte Knoten direkt miteinander, ohne zentralen Server. Das Muster findet sich in Dateiverteilung, Blockchain-Netzen oder lokalen Synchronisationslösungen. Für typische Geschäftsanwendungen spielt es eine Nebenrolle.
Und die Benutzeroberfläche?
Lange galten MVC (Model-View-Controller), MVP (Model-View-Presenter) und MVVM (Model-View-ViewModel) als die drei UI-Muster schlechthin. MVC prägt bis heute serverseitige Frameworks wie Ruby on Rails, ASP.NET Core MVC oder Laravel. MVVM ist in Desktop- und Mobile-Umgebungen mit Data Binding verbreitet, etwa in WPF, .NET MAUI oder bei Android mit ViewModels.
Im Browser haben sich dagegen komponentenbasierte Ansätze durchgesetzt, wie sie React, Angular, Vue oder Svelte verfolgen: Die Oberfläche besteht aus verschachtelten Komponenten, die ihren Zustand selbst verwalten oder aus einem zentralen Store beziehen. Die alten Muster sind dabei nicht verschwunden, sondern leben in Form von Trennungsregeln weiter, etwa zwischen darstellenden Komponenten und Logik in eigenen Hooks oder Services. Wer große Frontends mit mehreren Teams baut, steht vor ähnlichen Schnittfragen wie im Backend; Strukturen, State Management und Komponentenarchitekturen behandelt unsere Seite zur Frontend-Architektur.
Wie Sie das passende Muster auswählen
Es gibt kein bestes Architekturmuster, nur eines, das zu Ihren Anforderungen und Ihrer Organisation passt. Vier Fragen helfen bei der Auswahl:
- Wie komplex ist die Fachlogik? Wenig Regeln, viel Datenpflege: Schichten genügen. Viele Regeln, die sich häufig ändern: hexagonale Struktur oder ein modularer Monolith mit klaren Fachmodulen.
- Wie viele Teams arbeiten am System? Ein Team kommt fast immer mit einer Einheit aus. Erst wenn mehrere Teams sich beim Ausliefern gegenseitig blockieren, rechtfertigt das den Aufwand verteilter Dienste.
- Welche Qualitätsmerkmale zählen wirklich? Hohe, schwankende Last spricht für Skalierung einzelner Teile oder Serverless. Revisionssicherheit spricht für Event Sourcing. Kurze Lieferzeiten sprechen für wenig bewegliche Teile.
- Was kann Ihr Betrieb leisten? Microservices und ereignisgesteuerte Systeme verlangen Erfahrung mit Monitoring, Tracing, Automatisierung und Fehlertoleranz. Fehlt sie, wird das Muster zum Risiko.
Halten Sie die Entscheidung samt Begründung schriftlich fest, etwa in einem Architecture Decision Record (ADR), einem kurzen Dokument pro Entscheidung mit Kontext, Optionen und Folgen. So lässt sich später nachvollziehen, unter welchen Annahmen ein Muster gewählt wurde, und eine Korrektur fällt leichter, wenn sich diese Annahmen ändern.
Was das für Ihr Team bedeutet
Die wichtigste Verschiebung der letzten Jahre ist eine Ernüchterung: Einzelne Organisationen, die früh auf feingranulare verteilte Dienste gesetzt hatten, sind teilweise zu größeren Einheiten zurückgekehrt; viel beachtet war 2023 ein Überwachungsdienst von Amazon Prime Video. Der modulare Monolith mit sauber geschnittenen Fachmodulen und einer nach innen gerichteten Abhängigkeitsstruktur ist für die meisten mittelständischen Projekte der vernünftige Startpunkt. Verteilt wird erst, wenn ein konkreter Grund dafür vorliegt, etwa unabhängige Teams oder stark unterschiedliche Lastprofile.
Überschätzt werden Muster, die vor allem gut klingen: CQRS und Event Sourcing für Anwendungen ohne entsprechende Anforderungen, Microservices für ein einziges Team. Unterschätzt wird dagegen, wie viel eine konsequent durchgesetzte Modulgrenze im Alltag bringt. Auch KI-Assistenten beim Programmieren ändern daran wenig: Sie erzeugen Code schneller, aber in einer unklaren Struktur entsteht dadurch nur schneller mehr unklarer Code. Klare Grenzen helfen Menschen und Werkzeugen gleichermaßen.
Wenn Ihr Team Architekturmuster nicht nur kennen, sondern an einem eigenen System abwägen möchte, eignen sich praxisnahe Seminare und Workshops, in denen die Entscheidung an echten Anforderungen durchgespielt wird.
Häufige Fragen zu Architekturmustern
Kann man mehrere Architekturmuster kombinieren?
Ja, das ist der Normalfall. Typisch ist etwa ein modularer Monolith, dessen Module intern hexagonal aufgebaut sind, mit einer komponentenbasierten Weboberfläche und einzelnen ereignisgesteuerten Abläufen für die Anbindung externer Systeme. Wichtig ist, dass jede Kombination begründet ist und nicht aus Gewohnheit entsteht.
Ist Clean Architecture dasselbe wie hexagonale Architektur?
Nicht ganz, aber sehr ähnlich. Beide stellen die Fachlogik ins Zentrum und lassen Abhängigkeiten nach innen zeigen. Clean Architecture gliedert die Ringe feiner und gibt mehr Namen vor, etwa Entities und Use Cases. Im Alltag sind die Unterschiede kleiner als die Gemeinsamkeiten.
Wann lohnt sich der Wechsel von einem Monolithen zu Microservices?
Wenn mehrere Teams sich beim Ausliefern regelmäßig gegenseitig blockieren, einzelne Teile deutlich anders skalieren müssen oder unterschiedliche Technologien brauchen. Vorher sollte der Monolith intern modularisiert sein, denn ohne klare Fachgrenzen entstehen nur verteilte Abhängigkeiten.
Welche Rolle spielt die Wahl der Programmiersprache?
Eine kleinere, als oft angenommen. Die genannten Muster lassen sich in Java, C#, TypeScript, Python, Go oder Rust gleichermaßen umsetzen. Sprachen und Frameworks legen bestimmte Strukturen allerdings nahe; ein Framework, das eine Schichtung vorgibt, macht eine hexagonale Struktur etwas mühsamer, aber nicht unmöglich.
Kategorien