SOLID-Prinzipien in moderner Webentwicklung: Was funktioniert noch?

Fünf Regeln aus der Objektorientierung im Praxistest: Was in TypeScript, React und Node.js trägt und was Teams getrost lockerer sehen dürfen
Aktualisiert:
Abstract
- #SOLID Prinzipien
- #Software Design
- #Webentwicklung
- #TypeScript
- #React
- #Clean Code
- #Architektur
- #Single Responsibility Principle
- #Open-Closed Principle
- #Liskov Substitution Principle
- #Interface Segregation Principle
- #Dependency Inversion Principle
- #Dependency Injection
- #Moderne Softwareentwicklung
- #Best Practices
- #Code Wartbarkeit
- #Entwurfsmuster
Klassen werden seltener, die Ideen dahinter bleiben: SOLID gilt heute für Komponenten, Module und Funktionen
Ein typisches Frontend-Projekt im Jahr 2026 enthält kaum noch Klassenhierarchien. Komponenten sind Funktionen, Zustand steckt in Hooks oder Signals, das Backend besteht aus ein paar Route-Handlern in Node.js. Wer in so einem Projekt im Code-Review „Das verletzt SOLID“ sagt, erntet schnell ein Stirnrunzeln: Die Prinzipien stammen schließlich aus der Welt von Java und C++, in der Vererbung das zentrale Werkzeug war.
Trotzdem tauchen dieselben Probleme auch in modernen Webanwendungen auf. Eine Komponente, die Daten lädt, Preise formatiert und nebenbei Analytics verschickt, ist schwer zu testen. Ein Service, der seine Datenbank selbst erzeugt, lässt sich nicht austauschen. Die Frage ist also nicht, ob SOLID veraltet ist, sondern welche der fünf Ideen in heutigem TypeScript-Code noch tragen und welche Teams lockerer sehen dürfen.
Woher SOLID kommt und warum die Frage berechtigt ist
Die fünf Prinzipien hat Robert C. Martin um das Jahr 2000 zusammengestellt, das Kürzel SOLID prägte wenig später Michael Feathers. Einzelne Bausteine sind älter: Das Open-Closed Principle geht auf Bertrand Meyer zurück (1988), das Liskov Substitution Principle auf Barbara Liskov (1987). Gemeint waren sie für objektorientierte Systeme mit langen Lebenszyklen und vielen Teams, in denen jede Änderung an einer Basisklasse kostspielig war.
Webentwicklung funktioniert heute anders. TypeScript arbeitet mit strukturellen Typen, also mit Typen, die allein über ihre Form verglichen werden, nicht über eine explizite Vererbungsbeziehung. React, Vue oder Svelte setzen auf Komposition statt auf Unterklassen. Deployments laufen mehrmals am Tag, und ein Refactoring über die ganze Codebasis ist mit einer guten IDE eine Sache von Minuten. Das verschiebt die Gewichte: Manche Prinzipien sind wichtiger geworden, andere haben ihre ursprüngliche Begründung teilweise verloren.
Wer die fünf Prinzipien zuerst Schritt für Schritt kennenlernen möchte, findet die Grundlagen im Beitrag SOLID-Prinzipien in der Praxis. Hier geht es um die Einordnung: Was davon bewährt sich in modernen Web-Projekten?
Single Responsibility: Gilt für Komponenten, Hooks und Module
Das Single Responsibility Principle (SRP) besagt, dass ein Baustein nur einen Grund haben sollte, sich zu ändern. Martin selbst hat später klargestellt, dass mit „Grund“ eher eine Person oder Rolle gemeint ist: die Fachabteilung, die Preise festlegt, das Design-Team, das die Darstellung bestimmt, die IT, die den Datenbankzugriff verantwortet. Wenn zwei dieser Gruppen denselben Code ändern wollen, kollidieren ihre Wünsche.
Dieses Prinzip hat am besten gealtert, weil es nicht an Klassen hängt. Es passt auf Funktionen, Module, React-Komponenten, Hooks und ganze Services. Angenommen, ein Webshop zeigt eine Bestellübersicht an:
// Vorher: Laden, Rechnen und Darstellen in einer Komponente
export function OrderPage({ orderId }: { orderId: string }) {
const [order, setOrder] = useState<Order | null>(null);
useEffect(() => {
fetch(`/api/orders/${orderId}`)
.then((res) => res.json())
.then(setOrder);
}, [orderId]);
if (!order) return <p>Lädt …</p>;
const total = order.items.reduce((sum, i) => sum + i.price * i.qty, 0);
return <p>Summe: {(total / 100).toFixed(2)} €</p>;
}
// Nachher: jede Verantwortung an ihrem Ort
export function orderTotal(order: Order): number {
return order.items.reduce((sum, i) => sum + i.price * i.qty, 0);
}
export const formatEuro = (cents: number) =>
new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(
cents / 100,
);
export function OrderSummary({ order }: { order: Order }) {
return <p>Summe: {formatEuro(orderTotal(order))}</p>;
}
export function OrderPage({ orderId }: { orderId: string }) {
const order = useOrder(orderId); // eigener Hook, kapselt das Laden
if (!order) return <p>Lädt …</p>;
return <OrderSummary order={order} />;
}
Die Preisberechnung lässt sich jetzt ohne Browser und ohne Netzwerk testen, die Darstellung ohne Server, und wenn das Laden später auf TanStack Query oder Server Components umgestellt wird, ändert sich nur der Hook.
Die Grenze liegt dort, wo die Aufteilung selbst zum Problem wird. Zehn Dateien mit je drei Zeilen sind nicht übersichtlicher als eine Datei mit dreißig Zeilen. Eine brauchbare Faustregel: Aufteilen, wenn sich Teile unabhängig voneinander ändern oder getestet werden sollen, nicht vorsorglich.
Auch auf Architekturebene gilt SRP. Ein API-Gateway ruft viele Dienste auf, hat aber eine einzige Aufgabe: einen einheitlichen Zugang zu bieten. Ein Microservice, der Rechnungen schreibt und nebenbei Newsletter verschickt, ist dagegen ein Kandidat für die Aufteilung.
Open/Closed: Für APIs und Bibliotheken wichtig, im eigenen Code oft überschätzt
„Software-Einheiten sollten offen für Erweiterung, aber geschlossen für Veränderung sein.“ Das Open-Closed Principle (OCP) klingt elegant und ist zugleich das am häufigsten missverstandene der fünf. In vielen Codebasen hat es zu Plugin-Mechanismen, Fabriken und Strategie-Klassen geführt, die nie mehr als eine Implementierung hatten.
Unsere Einschätzung: Innerhalb einer einzelnen Anwendung, deren Code das Team vollständig kontrolliert, ist Veränderung kein Risiko, das man vermeiden muss. Dort zählt, dass Code leicht änderbar ist. Typprüfung, automatisierte Tests und Refactoring-Werkzeuge machen Änderungen sicherer als jede vorab gebaute Erweiterungsschicht. Anforderungen ändern sich ohnehin anders, als man beim Entwurf vermutet.
Anders sieht es aus, wo andere von Ihrem Code abhängen, ohne dass Sie deren Code anpassen können.
Öffentliche Web-APIs
Wer eine API für Partner, Apps oder Kunden betreibt, kann Verträge nicht beliebig ändern. Neue Felder kommen hinzu, bestehende bleiben erhalten:
// Antwort, auf die sich bestehende Clients verlassen
interface UserResponse {
id: string;
name: string;
}
// Erweiterung ohne Bruch: neue Felder sind optional
interface UserResponseV2 extends UserResponse {
email?: string;
avatarUrl?: string;
}
Das funktioniert nur, wenn Clients unbekannte Felder ignorieren. Umbenennen oder Entfernen eines Felds ist dagegen ein Breaking Change und gehört in eine neue API-Version.
Bibliotheken und Design-Systeme
Ähnlich ist es bei Bibliotheken und internen Komponentenbibliotheken. Wer eine Tabellenkomponente für zehn Produktteams pflegt, sollte Erweiterungspunkte vorsehen, etwa Render-Props, children oder Callback-Optionen für eigene Zellformate. In React ist Komposition die natürliche Form von OCP: Die Komponente bleibt unverändert, das Verhalten kommt von außen.
Liskov: Weniger Vererbung, aber Verträge bleiben
Das Liskov Substitution Principle (LSP) verlangt, dass ein Untertyp überall dort einsetzbar ist, wo der Obertyp erwartet wird, ohne dass sich das Programm anders verhält als zugesagt. Im klassischen Lehrbuchbeispiel erbt ein Quadrat von einem Rechteck und bricht dabei die Erwartung, dass sich Breite und Höhe unabhängig setzen lassen.
Weil moderne Webprojekte Vererbung selten einsetzen, gilt LSP oft als das am wenigsten relevante Prinzip. Das stimmt nur halb. Die Vererbungsfrage hat sich durch „Composition over Inheritance“, also den Grundsatz, Verhalten eher zusammenzusetzen als zu erben, weitgehend erledigt. Der Kern von LSP betrifft aber jede Implementierung einer Schnittstelle, auch ohne extends:
interface KeyValueCache {
get(key: string): Promise<string | undefined>;
set(key: string, value: string, ttlSeconds: number): Promise<void>;
}
// Hält den Vertrag ein: speichert nichts, liefert nie einen Treffer
class NoopCache implements KeyValueCache {
async get() {
return undefined;
}
async set() {}
}
// Verletzt den Vertrag: Aufrufer rechnen nicht mit einer Ausnahme
class ReadOnlyCache implements KeyValueCache {
constructor(private data: Map<string, string>) {}
async get(key: string) {
return this.data.get(key);
}
async set(): Promise<void> {
throw new Error('Schreiben wird nicht unterstützt');
}
}
TypeScript akzeptiert beide Klassen, denn die Signaturen passen. Der Fehler zeigt sich erst zur Laufzeit, wenn ein Aufrufer den ReadOnlyCache bekommt. Genau davor schützt LSP: Eine Schnittstelle ist mehr als ihre Typen, sie ist ein Versprechen über Verhalten. Das gilt für Adapter zu Zahlungsanbietern, Speicher-Backends oder Mock-Objekte in Tests gleichermaßen.
Wo eine Implementierung eine Methode nicht sinnvoll erfüllen kann, ist meist die Schnittstelle zu breit. Damit ist man beim nächsten Prinzip.
Interface Segregation: Schmale Props und schmale Abhängigkeiten
„Clients sollten nicht von Schnittstellen abhängen, die sie nicht nutzen.“ Das Interface Segregation Principle (ISP) ist in TypeScript besonders leicht umzusetzen, weil strukturelle Typen keine explizite Implementierung verlangen. Eine Funktion kann genau die Form beschreiben, die sie braucht, und jedes Objekt mit dieser Form passt.
// Zu breit: wer nur lesen will, hängt trotzdem an Export und Backup
interface DocumentStore {
load(id: string): Promise<Doc>;
save(doc: Doc): Promise<void>;
remove(id: string): Promise<void>;
exportAll(): Promise<Blob>;
backup(): Promise<void>;
}
// Schmal: jede Funktion verlangt nur, was sie aufruft
type DocReader = Pick<DocumentStore, 'load'>;
type DocWriter = Pick<DocumentStore, 'save' | 'remove'>;
async function showPreview(store: DocReader, id: string) {
const doc = await store.load(id);
return doc.title;
}
Im Frontend zeigt sich dasselbe Muster bei Props. Eine Komponente UserBadge, die das komplette User-Objekt mit Adresse, Rollen und Einstellungen bekommt, obwohl sie nur Name und Avatar anzeigt, ist schwerer wiederzuverwenden und schwerer zu testen. Mit Pick<User, 'name' | 'avatarUrl'> als Prop-Typ wird die Abhängigkeit sichtbar, und die Komponente lässt sich auch mit Daten aus einer anderen Quelle füllen.
Auf Architekturebene ist ISP eine Spielart der losen Kopplung: Ein Dienst sollte von möglichst wenig Funktionalität anderer Dienste abhängen. Das betrifft auch versteckte Abhängigkeiten wie globale Variablen, Singletons oder Umgebungsvariablen, die tief im Code gelesen werden. Sie tauchen in keiner Signatur auf und überraschen erst, wenn ein Test in einer anderen Umgebung läuft.
Dependency Inversion: Das Prinzip mit der größten Wirkung
Das Dependency Inversion Principle (DIP) besagt, dass fachliche Logik nicht von technischen Details abhängen soll, sondern beide von Abstraktionen. Praktisch heißt das: Der Code, der eine Bestellung abschließt, kennt eine Schnittstelle „Zahlung ausführen“, aber nicht das SDK eines bestimmten Zahlungsanbieters.
Wichtig ist die Abgrenzung zu Dependency Injection. DIP ist das Prinzip, die Richtung der Abhängigkeiten. Dependency Injection ist eine Technik, um es umzusetzen: Abhängigkeiten werden von außen übergeben, statt im Code selbst erzeugt. Frameworks wie Angular oder NestJS bringen dafür einen eigenen Container mit, wie im Beitrag über Angular Services und Dependency Injection beschrieben. In vielen TypeScript-Projekten genügen aber einfache Parameter:
interface PaymentGateway {
charge(orderId: string, amountCents: number): Promise<{ ok: boolean }>;
}
interface Mailer {
send(to: string, subject: string, body: string): Promise<void>;
}
// Fachlogik kennt nur die Schnittstellen
export function createCheckout(deps: {
payments: PaymentGateway;
mailer: Mailer;
}) {
return async function checkout(order: Order) {
const result = await deps.payments.charge(order.id, orderTotal(order));
if (!result.ok) throw new Error('Zahlung abgelehnt');
await deps.mailer.send(
order.email,
'Bestellbestätigung',
`Nr. ${order.id}`,
);
};
}
// Verdrahtung an einer Stelle, etwa beim Start der Anwendung
// const checkout = createCheckout({ payments: stripeGateway, mailer: smtpMailer });
Der größte Nutzen zeigt sich beim Testen. Statt einen echten Zahlungsanbieter anzusprechen, übergibt der Test eine Attrappe:
import { describe, it, expect, vi } from 'vitest';
describe('checkout', () => {
it('verschickt nach erfolgreicher Zahlung eine Bestätigung', async () => {
const payments = { charge: vi.fn().mockResolvedValue({ ok: true }) };
const mailer = { send: vi.fn().mockResolvedValue(undefined) };
const checkout = createCheckout({ payments, mailer });
await checkout({ id: 'A-17', email: 'kunde@example.com', items: [] });
expect(mailer.send).toHaveBeenCalledWith(
'kunde@example.com',
'Bestellbestätigung',
'Nr. A-17',
);
});
});
DIP ist außerdem das Fundament der gängigen Architekturstile. Schichtenarchitektur, Hexagonal- oder Onion-Architektur und Clean Architecture ordnen Code so, dass die Fachlogik innen liegt und Datenbank, HTTP und Frameworks außen. Auch die derzeit oft diskutierte Vertical Slice Architecture, die Code nach Funktionen statt nach technischen Schichten schneidet, nutzt innerhalb jedes Slices dieselbe Idee.
Im Großen findet sich das Prinzip ebenfalls wieder: Anwendungen prüfen Anmeldungen nicht selbst, sondern verlassen sich auf einen Identitätsanbieter über ein Standardprotokoll wie OpenID Connect. Dienste kommunizieren über Warteschlangen oder Event-Broker und kennen nur das Nachrichtenformat, nicht den Empfänger.
Wo SOLID in modernen Projekten überzogen wird
Die Prinzipien selbst sind selten das Problem, wohl aber ihre mechanische Anwendung. Drei Muster begegnen in Code-Reviews immer wieder:
- Interfaces mit genau einer Implementierung, die nur existieren, „weil man das so macht“. In TypeScript lässt sich eine Schnittstelle jederzeit nachträglich aus einer konkreten Klasse ableiten, wenn eine zweite Implementierung tatsächlich ansteht.
- Abstraktionen auf Vorrat: Strategie-Muster, Fabriken und Plugin-Registries für Varianten, die es nie geben wird. Sie kosten Lesbarkeit, ohne etwas zu schützen.
- Zerstückelung im Namen von SRP: Komponenten und Funktionen, die so klein geschnitten sind, dass man für einen einfachen Ablauf durch ein Dutzend Dateien springen muss.
Ein guter Gegencheck ist die Frage, welche konkrete Änderung eine Abstraktion leichter macht. Gibt es darauf keine Antwort, ist der direkte Code meist die bessere Wahl. Daneben gibt es Grundsätze, die in Webprojekten oft schwerer wiegen als SOLID: klare Namen, unveränderliche Daten, reine Funktionen ohne Seiteneffekte und eine durchgängige Typisierung. Wie diese Regeln zusammenspielen, beschreibt der Beitrag zur langfristig wartbaren Frontend-Architektur.
Was das für Ihr Team bedeutet
Unterm Strich hat SOLID besser gealtert, als die Herkunft aus der Java-Welt vermuten lässt, allerdings mit verschobenen Gewichten:
| Prinzip | Bedeutung heute | Wo es sich zeigt |
|---|---|---|
| Single Responsibility | hoch | Komponenten, Hooks, Module, Services |
| Open/Closed | gezielt | öffentliche APIs, Bibliotheken, Design-Systeme |
| Liskov Substitution | als Vertragsdenken | Adapter, Implementierungen von Schnittstellen |
| Interface Segregation | hoch | Props, Funktionsparameter, Service-Grenzen |
| Dependency Inversion | sehr hoch | Testbarkeit, Architekturschichten |
Für die meisten Teams lohnt es sich, bei Single Responsibility und Dependency Inversion anzusetzen. Beide verbessern Testbarkeit und Verständlichkeit sofort und lassen sich ohne neue Werkzeuge umsetzen. Interface Segregation kommt in TypeScript fast nebenbei, sobald Funktionen nur noch die Daten verlangen, die sie tatsächlich nutzen. Open/Closed sollte bewusst an den Stellen eingesetzt werden, an denen andere von Ihrem Code abhängen, und Liskov als Erinnerung, dass jede Implementierung den Vertrag ihrer Schnittstelle einhalten muss.
Überschätzt wird SOLID dort, wo es als Checkliste im Review dient. Die Prinzipien sind Begründungshilfen: Sie erklären, warum ein bestimmter Code schwer zu ändern ist. Sie ersetzen nicht das Urteil, ob sich eine Abstraktion in diesem Projekt lohnt.
Wer Architekturentscheidungen dieser Art für ein konkretes Projekt treffen oder im Team verankern möchte, findet auf unseren Themenseiten zur Frontend-Architektur und zur Codequalität mit TypeScript Angebote für Beratung, Coaching und Seminare.
Häufige Fragen zu SOLID in der Webentwicklung
Sollte man SOLID in jedem Projekt anwenden?
Nicht dogmatisch. In Prototypen und kleinen Werkzeugen ist direkter, gut lesbarer Code meist sinnvoller als eine Schichtenarchitektur. Mit wachsender Codebasis und mehreren Entwickler:innen steigt der Nutzen. Ein guter Einstieg sind klare Zuständigkeiten pro Modul und Abhängigkeiten, die als Parameter übergeben werden.
Wie passt SOLID zu funktionaler Programmierung?
Die Kernideen lassen sich übertragen. Eine Funktion mit einer Aufgabe entspricht SRP, schmale Parametertypen entsprechen ISP, und Abhängigkeiten, die als Argumente hereinkommen, setzen DIP um. Funktionale Stile mit unveränderlichen Daten vermeiden viele Probleme, die LSP ursprünglich adressierte, weil es keine Vererbung und keinen geteilten veränderlichen Zustand gibt.
Braucht man für Dependency Inversion einen DI-Container?
Nein. Ein Container wie in Angular oder NestJS ist praktisch, wenn ein Framework ihn ohnehin mitbringt oder sehr viele Abhängigkeiten verdrahtet werden müssen. In den meisten React- und Node.js-Projekten reichen Funktionsparameter, Factory-Funktionen oder React Context für die wenigen Stellen, an denen Implementierungen getauscht werden.
Was ist wichtiger: SOLID oder Clean Code?
Das ist kein Gegensatz. SOLID ist ein Teil dessen, was unter Clean Code verstanden wird, und betrifft vor allem den Zuschnitt von Modulen und deren Abhängigkeiten. Aussagekräftige Namen, kurze Funktionen und verständliche Tests gehören ebenso dazu. Lesbarer Code im Kleinen ist die Voraussetzung, damit sich gute Struktur im Großen überhaupt auszahlt.
Kategorien