ALOM

🔖 Persistance de données

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 !

🔎 La source de données

Une application :

fournit un service
manipule des données

Problématique :

comment enregistrer des données ?
comment accéder aux données enregistrées ?

Design Best Practices

👮 S.O.L.I.D

Design Pattern

💉 Injection de dépendance

Design Pattern

DAO - Data Access Object / Repository

🔎 La source de données

des fichiers
une API
une base de données SQL
une base de données NoSQL

Bases de données SQL

Modèle relationnel (SQL)

Stockage de l'information en tables
Relations entre les tables (clés étrangères)
Requêtage dans un langage dédié : SQL

Bases de données SQL

Comment lier le modèle BDD relationnel et le modèle objet Java?

id	name	sprite
25	pikachu	pikachu.png
120	staryu	staryu.png
121	starmie	starmie.png

id	name
1	ash
2	misty

trainer_id	pokemon_type	level
1	25	18
2	120	18
2	121	21

à la dure : JDBC

Fonctionnement de JDBC

JDBC avec : JDBCTemplate

#### Configuration spring-boot
                            ```xml
                            <dependency>
                                <groupId>org.springframework.boot</groupId>
                                <artifactId>spring-boot-starter-jdbc</artifactId>
                            </dependency>
                            ```
                            \+ un driver JDBC

```xml
                            <dependency>
                                <groupId>org.postgresql</groupId>
                                <artifactId>postgresql</artifactId>
                                <scope>runtime</scope>
                            </dependency>
                            ```

![](images/spring-boot-starter-jdbc.png)

---

https://xkcd.com/327/

![](images/exploits_of_a_mom_2x.png)

---

```xml [4]
                            <dependency>
                                <groupId>org.postgresql</groupId>
                                <artifactId>postgresql</artifactId>
                                <scope>runtime</scope>
                            </dependency>
                            ```

Les drivers JDBC peuvent être positionnés en *scope* Maven `runtime`.

* Ils ne sont pas nécessaire à la compilation du code
                            * Leur *jar* doit être présent à l'exécution

---

#### 🔎 JDBC AutoConfiguration
                            ![](images/spring-boot-jdbc-autoconfiguration.png)

---

### javax.sql.DataSource

Interface permettant de récupérer des connections à une base de données.

![](images/datasource.png)

---

##### DataSourceProperties
                            Permet de configurer la source de données
                            ```properties
                            spring.datasource.url
                            spring.datasource.username
                            spring.datasource.password
                            ```

##### DataSourceAutoConfiguration
                            Configure un *bean* de type `javax.sql.DataSource`.

Si `spring.datasource.url` est renseignée, elle sera utilisée.
                            Sinon, si une base de données embarquée (*h2*, *derby*, ou *hsqldb*) est disponible, elle sera utilisée.

Utilise une implémentation avec un pool de connexions si disponible (HikariCP par défaut).

---

##### Cas d'usages
                            Utilisation de la base de données embarquée H2:
                            ```xml
                            <dependency>
                                <groupId>com.h2database</groupId>
                                <artifactId>h2</artifactId>
                                <scope>runtime</scope>
                            </dependency>
                            ```
                            Pas de properties particulières.

---

##### Cas d'usages
                            Utilisation d'une base de données postgresql:
                            ```xml
                            <dependency>
                                <groupId>org.postgresql</groupId>
                                <artifactId>postgresql</artifactId>
                                <scope>runtime</scope>
                            </dependency>
                            ```

Properties avec l'url:

```properties
                            spring.datasource.url=jdbc:postgresql://<database_host>:<port>/<database_name>
                            spring.datasource.username=<user>
                            spring.datasource.password=<password>
                            ```

##### JdbcTemplateConfiguration
                            Si un *bean* de type `javax.sql.DataSource` existe, crée un bean de type `org.springframework.jdbc.core.JdbcTemplate`.
                            ```java [1,6|2,3,6|5,6,10|10-25]
@AutoConfiguration(after = DataSourceAutoConfiguration.class)
@ConditionalOnClass({ DataSource.class, JdbcTemplate.class })
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(JdbcProperties.class)
@Import({ JdbcTemplateConfiguration.class})
public class JdbcTemplateAutoConfiguration {}

@Configuration
@ConditionalOnMissingBean(JdbcTemplate.class)
class JdbcTemplateConfiguration {

@Bean
	@Primary
	JdbcTemplate jdbcTemplate(DataSource dataSource, JdbcProperties properties) {
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		JdbcProperties.Template template = properties.getTemplate();
		jdbcTemplate.setFetchSize(template.getFetchSize());
		jdbcTemplate.setMaxRows(template.getMaxRows());
		if (template.getQueryTimeout() != null) {
			jdbcTemplate.setQueryTimeout((int) template.getQueryTimeout().getSeconds());
		}
		return jdbcTemplate;
	}

}
                            ```

JPA - Java Persistence API

Surcouche à JDBC - Fournit un moyen de mapper les tables aux objets et une abstraction de l'exécution de requêtes via les annotations

Fonctionnement de JPA

JPA avec

Repository Spring/JPA (mode DAO):

spring-data JPA

Génération automatique des méthodes au runtime à partir d'interfaces!

### Connection Pooling

⚠️ Ouvrir une connexion à une BDD est coûteux

* Ouverture d'une socket
                        * Authentification

💡 Ouvrir les connexions au démarrage de l'application et maintenir les connexion ouvertes

---

### Connection Pooling

![](./images/connection-pool.png)

---

### Connection Pooling

Avec `Spring Boot`, utilisation de `HikariCP` :

![](images/spring-boot-starter-jdbc.png)

Possibilité d'utiliser d'autres pools ( [doc](https://docs.spring.io/spring-boot/docs/current/reference/html/data.html#data.sql.datasource.connection-pool) )

---

### Connection Pooling

Configuration du pool de connexions :

Properties `spring.datasource.hikari.*`

```properties
                        # nombre de connection conservées au minimum
                        spring.datasource.hikari.minimum-idle=1

# nombre de connections max
                        spring.datasource.hikari.maximum-pool-size=10
                        ```

### Transactions

⚠️ Effectuer plusieurs opérations en même temps

#### Transactions ACID

Garantir la fiabilité d'une transaction en BDD

* Atomicité : Tout ou rien
                        * Cohérence : L'état base de données est valide à tout instant (contraintes)
                        * Isolation : Les transactions peuvent être exécutées simultanément
                        * Durabilité : Une transaction validée survit à une défaillance du système

---

### Transactions en Java

```java
                        public interface java.sql.Connection {
                            Statement createStatement() throws SQLException;
                            void setAutoCommit(boolean autoCommit) throws SQLException;
                            void commit() throws SQLException;
                            void rollback() throws SQLException;
                        }
                        ```

```java
                        public interface jakarta.transaction.UserTransaction {
                            void commit() throws IllegalStateException, SystemException;
                            void rollback() throws IllegalStateException, SystemException;
                        }
                        ```

---

### Transactions

Avec `Spring Boot`, utilisation de l'`AOP` et de l'annotation `@Transactional` (`Spring` ou `jakarta`)

```java
                        org.springframework.transaction.annotation.@Transactional

jakarta.transaction.@Transactional
                        ```

Par défaut, tous les appels aux repositories sont dans une transaction :

```java
                        package org.springframework.data.jpa.repository.support;

@Repository
                        @Transactional
                        public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> {
                          ...
                        }
                        ```

---

### Transactions

À réfléchir quand on développe :

* Est-ce que je dois gérer plusieurs modifications dans une même transaction ?

⚠️ L'annotation `@Transactional` se pose au niveau de la couche `service`

⚠️ Au niveau de la couche `controller`, risque d'ouvrir des transactions trop tôt (erreurs HTTP), et de consommer des ressources pour rien (connection de pool + commit / rollback)

⚠️ Au niveau de la couche `repository`, risque de perdre l'atomicité sur plusieurs opérations

### [spring-data mongodb](https://docs.spring.io/spring-data/mongodb/reference/)

Configuration Maven
                        ```xml
                        
                        <dependency>
                            <groupId>org.springframework.boot</groupId>
                            <artifactId>spring-boot-starter-data-mongodb</artifactId>
                        </dependency>
                        ```

---

### spring-data mongodb

* Instanciation d'un `MongoTemplate`
                        * Configuration du `MongoClient`
                        * Support des transactions avec `@Transactional`
                        * [Repository interfaces](https://docs.spring.io/spring-data/mongodb/reference/mongodb/repositories/repositories.html) avec `@EnableMongoRepositories`

---

### spring-data mongodb configuration

[Properties](https://docs.spring.io/spring-boot/reference/data/nosql.html#data.nosql.mongodb.connecting)

```properties
                        spring.data.mongodb.uri=mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test

# ou

spring.data.mongodb.host=mongoserver1.example.com
                        spring.data.mongodb.port=27017
                        spring.data.mongodb.additional-hosts[0]=mongoserver2.example.com:23456
                        spring.data.mongodb.database=test
                        spring.data.mongodb.username=user
                        spring.data.mongodb.password=secret
                        ```

TP

Spring repositories !

ALOM

🔖 Persistance de données

UBER

Un micro-service c'est :

🔎 un micro-service Java

🔎 La source de données

Design Best Practices

👮 S.O.L.I.D

Design Pattern

💉 Injection de dépendance

Design Pattern

DAO - Data Access Object / Repository

🔎 La source de données

Bases de données SQL

Bases de données SQL

à la dure : JDBC

Fonctionnement de JDBC

JDBC avec : JDBCTemplate

JPA - Java Persistence API

Fonctionnement de JPA

JPA avec

spring-data JPA

TP

Fin du cours