How is the dependency inversion principle applied in Clean Architecture to separate responsibilities between layers?

In Clean Architecture, the Dependency Inversion Principle is applied to separate responsibilities between layers as follows:

• High-level modules (e.g., business logic) do not depend on low-level modules (e.g., data access implementation or UI), but both depend on abstractions (interfaces).

• Abstractions are defined in higher-level layers (e.g., in the domain layer), and their implementations are in lower layers (e.g., in infrastructure).

• This allows business logic to be independent of implementation details, facilitating testing, maintenance, and extension.

Example: an interface for the repository is defined in the domain layer:

interface UserRepository {
    fun getUser(id: String): User
}

This interface is implemented in the data layer:

class UserRepositoryImpl : UserRepository {
    override fun getUser(id: String): User {
        // implementation for database access
    }
}

Business logic depends only on the UserRepository interface, and the specific implementation is injected via constructor or DI container. Thus, layers are connected through abstractions, not directly.