Clean Architecture is a term introduced by Robert C. Martin (Uncle Bob) as a software design approach that focuses primarily on two points: the separation of concerns and domain independence.

For this, it distinguishes two parts:

• The Core: The main part, which gives meaning and origin to the system, the business logic, the use cases.

• The Details: Everything external, the technology, the tools (frameworks, UI, database, external systems) allow the system to function but are not part of the business logic.

# Fundamental Principles

• Framework Independence: The system should not depend on the existence of any particular software library. It allows using frameworks as tools.

• Testable: Business logic can be tested without the UI, the database, or the web server.

• UI and DB Independence: Both the user interface and the database engine can change without affecting the Core.

# Structure

1. 1

   Entities (Enterprise Business Rules): Contain the most general and high-level business rules.

2. 2

   Use Cases (Application Business Rules): Application-specific business logic. They orchestrate the data flow.

3. 3

   Interface Adapters: Convert data between the format convenient for use cases and external mechanisms.

4. 4

   Frameworks and Drivers: External layer with databases, web frameworks, etc.

# Typical Scenario

The Controller takes user input, packages it, and passes it through an InputBoundary interface to the UseCaseInteractor. The latter uses the Entities and DataAccess to process the request and returns OutputData to the Presenter, who prepares the data for the View.

# Example: E-commerce

package ecommerce.domain;

public class Order {
    private Product product;
    private int quantity;

    public Order(Product product, int quantity) {
        this.product = product;
        this.quantity = quantity;
    }
}

package ecommerce.usecases;

public class AddProductToCartInteractor {
    private OrderRepository repository;
    private OrderOutputBoundary presenter;

    public void add(Order order) {
        // Logic to add product to the cart
        repository.saveOrder(order);
        presenter.presentOrderConfirmation(order);
    }
}

package ecommerce.presenter;

public class OrderPresenter implements OrderOutputBoundary {
    @Override
    public void presentOrderConfirmation(Order order) {
        System.out.println("Order confirmed: " + order.getProduct().getName());
    }
}