ALOM

UBER

Un micro-service c'est :

Un ensemble de fonctionnalités du même domaine métier
Un ou plusieurs canaux de communication
- HTTP - REST/JSON
Une source de données dédiée

🔎 un micro-service Java

On s'appuie sur les technologies connues: les servlets !

💉 Dependency injection

🚗 un morceau d'UBER

🏗️ La vision architecture

🤔 Le code du NotificationService

❓ Quel est le problème de ce code?

👮 S.O.L.I.D principles

S : Single Responsability

Une classe doit avoir une seule responsabilité

O : Open/Closed

Ouvert à l'extension, mais fermé à la modification

L : Liskov Substitution

Pouvoir utiliser un sous-type

I : Interface Segregation

Présenter plusieurs interfaces spécifiques

D : Dependency Inversion

Dépendre d'abstractions, et non d'implémentations

👮 Is it S.O.L.I.D ?

S	❌
O	❌
L	❌
I	❌
D	❌

🚑 Refactoring !

S	✅
O	✅
L	✅
I	✅
D	✅

ℹ️

Rendre notre code S.O.L.I.D :

Le rend testable
Le rend compatible avec de l'injection de dépendances

Le secret ?

C'est les interfaces, observez le sens des flêches !

💉 Injection de dépendance

Laisser la plateforme fournir les dépendances:

En fonction du contexte
En fonction des composants disponibles

Nécessite des efforts de conception objet!

💉 Injection de dépendances avec

💉 Injection de dépendances

3 moyens :

Par le construteur (recommandé)
Par les setters (bof, non-immutable)
Par les attributs de classe (déconseillé)

## Spring-Boot "Extension" à Spring Fournit la configuration automatique des frameworks les plus utilisés: * spring-web * spring-security * jpa * mongodb * ...

## Spring-Boot Les applications sont packagées dans des `jar` auto-portés. Le `jar` contient le code de l'application, plus les librairies (spring-core, spring-web, etc...). Les applications contiennent un `main` Java, qui démarre Spring-Boot. Adapté à un écosystème 🐳 containers

### Architecture d'une application en couches

```text
.
├── pom.xml
└── src
    └── main
        ├── java
        │   └── fr
        │       └── univ_lille
        │           └── alom
        │               ├── Application.java  // main
        │               ├── config
        │               ├── controllers
        │               │   ├── PokemonController.java
        │               │   └── TrainerController.java
        │               ├── model
        │               │   ├── + Pokemon.java
        │               │   └── + Trainer.java
        │               ├── repositories
        │               │   ├── + PokemonRepository.java
        │               │   └── + TrainerRepository.java
        │               └── services
        │                   ├── + PokemonService.java
        │                   └── + TrainerService.java
        └── resources
            └── application.properties
						```

⚠️ implique que tout le code soit `public`.
						Dépendances entre packages claires, mais dépendances spaghetti 🍝 entre les classes.

### Architecture d'une application en feature

```text
.
├── pom.xml
└── src
    └── main
        ├── java
        │   └── fr
        │       └── univ_lille
        │           └── alom
        │               ├── Application.java
        │               ├── config
        │               ├── pokemons
        │               │   ├── PokemonController.java
        │               │   ├── + Pokemon.java
        │               │   ├── PokemonRepository.java
        │               │   └── + PokemonService.java
        │               └── trainers
        │                   ├── TrainerController.java
        │                   ├── + Trainer.java
        │                   ├── TrainerRepository.java
        │                   └── + TrainerService.java
        └── resources
            └── application.properties
						```

👍 permet de controller la visibilité des classes (`package-private` 💙).
						💡 `@Repository` ne sont pas `public` pour forcer l'utilisation des `@Service`.

TP

Jouer avec spring-boot !

Fin du cours

Cours suivant :
Persistance des données avec JPA