mattia-battiston/clean-architecture-example
Clean Architecture Example
This project is a reference implementation for structuring Java applications using clean architecture and domain-driven design principles. It provides a template for organizing code into concentric layers, ensuring that core business rules and domain entities remain entirely independent of external frameworks, databases, and delivery mechanisms.
The architecture relies on the dependency inversion principle to decouple business logic from infrastructure. By defining abstract interfaces for data access and external services, the system allows for the replacement of underlying technologies without requiring modifications to the core application logic. A dedicated configuration layer manages dependency injection, isolating framework-specific wiring from the domain code.
The codebase supports a comprehensive testing strategy that validates system behavior across multiple levels, including isolated unit logic, business-focused acceptance scenarios, and end-to-end journeys. This modular approach facilitates long-term maintenance by ensuring that business actions remain encapsulated as independent, testable units.
Features
- Clean Architecture Frameworks - Structures Java applications to keep core business rules independent of frameworks, databases, and external delivery mechanisms.
- Clean Architecture Implementations - Provides a reference implementation of clean architecture principles to decouple business logic from external frameworks and infrastructure.
- Dependency Inversion Patterns - Ensures high-level business logic depends on abstractions rather than concrete infrastructure implementations to maintain loose coupling.
- Domain-Driven Designs - Encapsulates complex business logic and data entities into isolated objects free from infrastructure dependencies.
- Layered Architectures - Organizes application code into concentric functional layers to isolate business logic from infrastructure and delivery concerns.
- Data Abstraction Layers - Defines abstract interfaces for data operations to allow swapping storage technologies without modifying core business logic.
- Data Access Abstractions - Defines interfaces for data operations to allow swapping storage backends without affecting core application code.
- Agnostic Models - Implements core business entities as plain objects independent of external persistence frameworks or runtime environments.
- Decoupled Logic Layers - Separates user interfaces and data access layers from core application logic to allow for flexible technology upgrades.
- Explicit Dependency-Injection Wiring - Implements explicit dependency injection wiring to decouple business logic from framework-specific infrastructure.
- Business Entities - Encapsulates core business data and rules within independent objects free from infrastructure or framework requirements.
- Logic Decoupling - Separates user interaction points and background tasks from core business logic to ensure accessibility through any communication channel.
- Testability Optimizations - Designs application components with clear interfaces to enable comprehensive testing without requiring external system environments.
- Use Case Driven Architectures - Implements discrete business actions as independent units that define their own data requirements to ensure isolation from delivery mechanisms.
- Business Logic Isolation - Executes discrete business actions as independent units that define their own data requirements through interfaces.
- End-to-End Testing - Validates system behavior through a tiered testing strategy covering unit logic, acceptance scenarios, and end-to-end journeys.
Star history
How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.
