Heeft u ervaring met projecten die zijn uitgevoerd met een schone architectuur?

Ja, er is.

Bij het ontwikkelen met een schone architectuur heb ik de volgende lagen gebruikt:

• Domeinlaag: Bevat de bedrijfslogica en entiteiten. Het is onafhankelijk van andere lagen. Use Cases (Interactors) en repository-interfaces worden gedefinieerd.
• Datalaag: Implementeert de interfaces van de repositories uit de datalaag. Bevat werk met gegevens (netwerken, databases, SharedPreferences). Vaak worden repositories gebruikt om gegevens van externe bronnen om te zetten in domeinentiteiten.
• Presentatielaag: Bevat View (Fragment, Activity) en Presenter/ViewModel. Verantwoordelijk voor het weergeven van gegevens en interactie met de gebruiker. Communiceert met de Use Cases uit de domeinlaag.

Afhankelijkheden tussen lagen:

• De presentatielaag hangt af van de domeinlaag.
• De datalaag hangt af van de domeinlaag.

Patronen en principes toegepast in schone architectuur:

• SOLID: Vooral het principe van afhankelijkheidsomkering (Dependency Inversion Principle).
• Dependency Injection: Voor het vereenvoudigen van testen en afhankelijkheidsbeheer (bijvoorbeeld met Dagger, Koin).
• Repository Pattern: Abstractie over gegevensbronnen.
• Use Cases (Interactors): Vertegenwoordigen specifieke operaties in de bedrijfslogica.

Voorbeeld van de projectstructuur:

├── app
│   ├── build.gradle
│   └── src
│       └── main
│           ├── java
│           │   └── com
│           │       └── voorbeeld
│           │           └── mijnapp
│           │               ├── data // Implementaties van repositories, gegevensbronnen
│           │               │   ├── datasource
│           │               │   └── repository
│           │               ├── domain // Bedrijfslogica, Use Cases, entiteiten, repository-interfaces
│           │               │   ├── entity
│           │               │   ├── repository
│           │               │   └── usecase
│           │               └── presentatie // View-laag, ViewModel/Presenter
│           │                   ├── ui
│           │                   └── viewmodel
│           └── res

Interactie tussen lagen:

1. View roept de methode van ViewModel aan.
2. ViewModel roept de bijbehorende Use Case (bedrijfslogica) aan.
3. Use Case benadert de interfaces van de repositories uit de domeinlaag.
4. Implementaties van repositories (in de datalaag) halen gegevens uit bronnen (netwerk, database).
5. Repositories transformeren gegevens naar domeinentiteiten en geven ze terug aan de Use Case.
6. Use Case verwerkt de gegevens en geeft het resultaat terug aan de ViewModel.
7. ViewModel werkt de gegevens bij die worden weergegeven op de View.

Het gebruik van een schone architectuur maakt het mogelijk:

• Verbeteren van testbaarheid: Elke laag kan geïsoleerd worden getest.
• Verhogen van onderhoudbaarheid: Wijzigingen in één laag hebben minimale invloed op anderen.
• Verhogen van flexibiliteit: Het is gemakkelijker om implementaties van gegevensbronnen of UI-weergaven te vervangen.
• Verminderen van koppeling: Bedrijfslogica scheiden van implementatiedetails.