Comprendere i livelli architetturali

Welcome back! In Clean Architecture, your application is structured into distinct, concentric layers. Think of an onion, with layers protecting the core.

This structure helps manage complexity, making your software easier to understand, test, and maintain over time. It keeps your core business logic safe from external changes.

Clean Architecture defines four primary layers, moving from the innermost (most stable) to the outermost (most volatile):

• Entities: Your core business rules.
• Use Cases: Application-specific rules.
• Interface Adapters: Translators between layers.
• Frameworks & Drivers: External details like databases and UIs.

Each layer has a specific role in keeping your system clean and organized.

At the very center of Clean Architecture are your Entities. These are your core business objects and rules, independent of any specific application or framework.

Entities encapsulate the most general and high-level rules. They are the least likely to change when external factors like the database or UI change. They define what your business is about.

Surrounding the Entities are Use Cases (sometimes called Interactors). This layer contains application-specific business rules.

Use Cases orchestrate the flow of data to and from Entities to achieve a specific application feature. For example, 'Create New User' or 'Process Order'. They define how your application uses the business entities.

The Interface Adapters layer acts as a bridge. It converts data from the format most convenient for the Use Cases and Entities into the format most convenient for external agents (like the UI or database), and vice-versa.

This layer includes things like Presenters (for UI), Controllers (for web requests), and Gateways (for interacting with databases or external APIs). They translate between the inner and outer worlds.

The outermost layer consists of Frameworks and Drivers. This is where all the 'details' live: web frameworks (like Spring or Django), databases (SQL, NoSQL), UI frameworks, external devices, and tools.

These components are volatile and can change without affecting the core business logic. Your application shouldn't depend on them; they should depend on your application.

A crucial concept in Clean Architecture is the Dependency Rule. This rule states that dependencies can only point inwards.

• Inner circles know nothing about outer circles.
• Outer circles can depend on inner circles.

This means your core business logic (Entities, Use Cases) remains independent of frameworks, databases, and UI, making it highly testable and robust.

Organizing your code into these layers brings significant benefits:

• Independence: Core business rules are isolated from external concerns.
• Testability: Business logic can be tested without needing a UI, database, or web server.
• Flexibility: You can swap out databases or UI frameworks without rewriting core logic.
• Maintainability: Changes in one layer are less likely to break others.

Imagine a user request:

1. Frameworks/Drivers (UI) sends input.
2. Interface Adapters (Controller) receives it, converts to a Use Case input format.
3. Use Cases process the request using Entities.
4. Interface Adapters (Presenter) convert the Use Case output for the UI.
5. Frameworks/Drivers (UI) displays the result.

Notice how the request flows inwards, then the response flows outwards, always respecting the Dependency Rule.

You've explored the foundational layers of Clean Architecture:

• Entities: Core business rules.
• Use Cases: Application-specific rules.
• Interface Adapters: Data translation.
• Frameworks & Drivers: External details.

This structure, guided by the Dependency Rule, ensures a highly independent, testable, and flexible system. Next, we'll dive deeper into the Dependency Rule itself!