Clean Architecture

Warum Clean Architecture wichtig ist

Im Bereich der Softwareentwicklung steht die Clean Architecture für ein Konzept, das sich stark auf die Strukturierung und Organisation der Codebasis konzentriert. Sie bietet mehrere Vorteile:

• Wartbarkeit: Dank klarer Trennung der Schichten ist der Code leichter zu aktualisieren und anzupassen.
• Unabhängigkeit von Frameworks: Die Architektur macht es möglich, Technologien einfacher einzutauschen oder zu aktualisieren.
• Leichtere Testbarkeit: Durch die modulare Struktur wird das Testen einzelner Komponenten erleichtert.
• Skalierbarkeit: Die Systeme lassen sich besser erweitern, ohne das gesamte Projekt umzuschreiben.

 interface UserRepository {    User findUserById(String userId);} class UserInteractor {    private final UserRepository userRepository;    UserInteractor(UserRepository userRepository) {        this.userRepository = userRepository;    }    User getUser(String userId) {        return userRepository.findUserById(userId);    }}

Clean Architecture einfach erklärt

Die Clean Architecture bietet eine strukturierte Herangehensweise an die Softwareentwicklung, die darauf abzielt, Code stark organisiert und wartbar zu halten. Diese Architektur verbessert die Flexibilität und Langlebigkeit von Projekten.

Schichtenmodell der Clean Architecture

Ein zentrales Konzept in der Clean Architecture ist das Schichtenmodell. Die Struktur ist typischerweise in vier Schichten gegliedert:

• Enterprise Business Rules: Diese Schicht enthält die Kerngeschäftslogik der Anwendung.
• Application Business Rules: Diese fokussiert sich auf Anwendungen, die Geschäftslogik der Enterprise-Schicht nutzen.
• Interface Adapters: Verknüpft die Geschäftslogik mit Datenbanken, Benutzeroberflächen und anderen Schnittstellen.
• Frameworks and Drivers: Diese Schicht enthält spezifische Implementierungsdetails, wie Datenbank- oder UI-Frameworks.

interface AccountRepository {    Account getAccountById(String accountId);    void save(Account account);}class AccountService {    private final AccountRepository accountRepository;    AccountService(AccountRepository repository) {        this.accountRepository = repository;    }    void transferFunds(String fromAccountId, String toAccountId, double amount) {        Account from = accountRepository.getAccountById(fromAccountId);        Account to = accountRepository.getAccountById(toAccountId);        from.withdraw(amount);        to.deposit(amount);        accountRepository.save(from);        accountRepository.save(to);    }}

Clean Architecture Robert C Martin

Clean Architecture wurde von Robert C. Martin, einem einflussreichen Softwareentwickler, konzipiert. Diese Architektur zielt darauf ab, Software so zu strukturieren, dass sie leicht wartbar und skalierbar ist. Mit einer sauberen Trennung der verschiedenen logischen Schichten wird verhindert, dass Änderungen in einem Bereich unvorhergesehene Folgen in einem anderen haben.

Robert C. Martins Vision zur Clean Architecture

Robert C. Martin, auch bekannt als Uncle Bob, hat die Clean Architecture entwickelt, um die Qualität der Softwareentwicklung zu verbessern. Die Hauptziele dieser Architektur sind:

• Unabhängigkeit von Frameworks: Keine spezifische Technologie sollte die Applikation diktieren.
• Testbarkeit: Isolation der Geschäftslogik erleichtert umfassende Tests.
• Unveränderliche Entitäten: Geschäftsregeln bleiben konsistent, unabhängig von äußeren Einflüssen.

public interface PaymentProcessor {    void processPayment(String orderId, double amount);}class OrderService {    private final PaymentProcessor paymentProcessor;    OrderService(PaymentProcessor paymentProcessor) {        this.paymentProcessor = paymentProcessor;    }    void placeOrder(String orderId, double amount) {        paymentProcessor.processPayment(orderId, amount);    }}

Clean Architecture C#

Die Clean Architecture bietet ein bewährtes Framework für die Organisation von Anwendungen in C#, das Skalierbarkeit und Wartbarkeit fördert. Sie entkoppelt verschiedene Komponenten und stellt sicher, dass Änderungen leicht implementiert werden können.

Clean Architecture Technik

In der Clean Architecture wird die Anwendung in mehrere Schichten unterteilt, jede mit einer klar definierten Rolle:

• Entities: Diese Schicht enthält die Geschäftslogik der Anwendung.
• Use Cases: Koordiniert die Interaktion zwischen Entities und der Benutzeroberfläche.
• Interface Adapters: Wandelt Daten zwischen den inneren Schichten und externen Schnittstellen um.
• Frameworks und Tools: Enthält spezifische Implementierungen für Datenbanken, Web-Frameworks und andere externe Tools.

public interface IArticleRepository {    Article GetArticleById(int articleId);    void SaveArticle(Article article);}class ArticleService {    private readonly IArticleRepository repository;    public ArticleService(IArticleRepository repo) {        this.repository = repo;    }    public void PublishArticle(int articleId) {        var article = repository.GetArticleById(articleId);        article.Publish();        repository.SaveArticle(article);    }}

Uncle Bob Clean Architecture

Uncle Bob, alias Robert C. Martin, hat die Prinzipien der Clean Architecture entwickelt, um die Qualität von Softwaresystemen zu verbessern. Dabei zielt er darauf ab, dass die Geschäftslogik nicht durch technische Details beeinflusst wird.

Die Architektur verfolgt folgende Prinzipien:

• SRP - Single Responsibility Principle: Jede Klasse sollte nur eine Aufgabe haben.
• OCP - Open/Closed Principle: Softwaremodule sollten für Erweiterungen offen, für Modifikationen jedoch geschlossen sein.
• LSP - Liskov Substitution Principle: Objekte einer Basisklasse sollten durch Objekte einer abgeleiteten Klasse ersetzt werden können.
• ISP - Interface Segregation Principle: Keine Klasse sollte gezwungen werden, Schnittstellen zu implementieren, die sie nicht benötigt.
• DIP - Dependency Inversion Principle: Abstraktionen sollten nicht auf Details angewiesen sein, vielmehr sollte der umgekehrte Fall zutreffen.