TP1 - Configuration Datasource et Pool de Connexions

Objectifs du TP

Dans ce TP, vous allez:

1. ✅ Configurer une datasource H2 pour le développement
2. ✅ Configurer une datasource PostgreSQL pour la production
3. ✅ Optimiser les paramètres HikariCP
4. ✅ Monitorer le pool de connexions avec Actuator
5. ✅ Simuler une saturation du pool

Durée estimée: 1 heure

---

Prérequis

• Module 1 à 6 complétés
• IntelliJ IDEA ou VS Code
• PostgreSQL installé (ou Docker)
• Maven

---

Partie 1: Création du Projet

1.1 Créer le Projet avec Spring Initializr

Créez un nouveau projet avec:

• Artifact: datasource-demo
• Dependencies:
  • Spring Web
  • Spring Data JPA
  • H2 Database
  • PostgreSQL Driver
  • Spring Boot Actuator
  • Lombok

1.2 Structure du Projet

datasource-demo/
├── src/main/java/com/example/datasourcedemo/
│   ├── DatasourceDemoApplication.java
│   ├── model/
│   │   └── Product.java
│   ├── repository/
│   │   └── ProductRepository.java
│   ├── service/
│   │   └── ProductService.java
│   └── controller/
│       └── ProductController.java
└── src/main/resources/
    ├── application.properties
    ├── application-dev.properties
    └── application-prod.properties

---

Partie 2: Entité et Repository

2.1 Créer l'Entité Product

// src/main/java/com/example/datasourcedemo/model/Product.java
package com.example.datasourcedemo.model;

import jakarta.persistence.*;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;

import java.math.BigDecimal;
import java.time.LocalDateTime;

@Entity
@Table(name = "products")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    private String description;

    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal price;

    @Column(nullable = false)
    private Integer stock;

    @Column(name = "created_at")
    private LocalDateTime createdAt = LocalDateTime.now();
}

2.2 Créer le Repository

// src/main/java/com/example/datasourcedemo/repository/ProductRepository.java
package com.example.datasourcedemo.repository;

import com.example.datasourcedemo.model.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByStockLessThan(Integer threshold);
}

2.3 Créer le Service

// src/main/java/com/example/datasourcedemo/service/ProductService.java
package com.example.datasourcedemo.service;

import com.example.datasourcedemo.model.Product;
import com.example.datasourcedemo.repository.ProductRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@RequiredArgsConstructor
@Slf4j
public class ProductService {

    private final ProductRepository productRepository;

    public List<Product> getAllProducts() {
        log.info("Récupération de tous les produits");
        return productRepository.findAll();
    }

    public Product createProduct(Product product) {
        log.info("Création du produit: {}", product.getName());
        return productRepository.save(product);
    }

    public Product getProduct(Long id) {
        return productRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("Produit non trouvé: " + id));
    }

    // Méthode pour simuler une requête lente
    public List<Product> getAllProductsSlow() throws InterruptedException {
        log.info("Début requête lente...");
        Thread.sleep(5000);  // 5 secondes
        log.info("Fin requête lente");
        return productRepository.findAll();
    }
}

2.4 Créer le Controller

// src/main/java/com/example/datasourcedemo/controller/ProductController.java
package com.example.datasourcedemo.controller;

import com.example.datasourcedemo.model.Product;
import com.example.datasourcedemo.service.ProductService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/products")
@RequiredArgsConstructor
public class ProductController {

    private final ProductService productService;

    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    @GetMapping("/{id}")
    public Product getProduct(@PathVariable Long id) {
        return productService.getProduct(id);
    }

    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return productService.createProduct(product);
    }

    // Endpoint pour tester les connexions
    @GetMapping("/slow")
    public List<Product> getProductsSlow() throws InterruptedException {
        return productService.getAllProductsSlow();
    }
}

---

Partie 3: Configuration Développement (H2)

3.1 Configuration de Base

# application.properties (configuration commune)

# Profil actif par défaut
spring.profiles.active=dev

# Actuator
management.endpoints.web.exposure.include=health,metrics,info
management.endpoint.health.show-details=always

# Logging
logging.level.com.zaxxer.hikari=DEBUG
logging.level.org.hibernate.SQL=DEBUG

3.2 Configuration H2 (Développement)

# application-dev.properties

# ===== DATASOURCE H2 =====
spring.datasource.url=jdbc:h2:mem:devdb;DB_CLOSE_DELAY=-1
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

# Console H2
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

# ===== JPA =====
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

# ===== HIKARI (Pool de connexions) =====
spring.datasource.hikari.pool-name=DevPool
spring.datasource.hikari.minimum-idle=2
spring.datasource.hikari.maximum-pool-size=5
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=300000
spring.datasource.hikari.max-lifetime=600000

# Détection des fuites (30 secondes)
spring.datasource.hikari.leak-detection-threshold=30000

3.3 Tester

# Démarrer l'application
mvn spring-boot:run

# Ou avec le profil explicite
mvn spring-boot:run -Dspring-boot.run.profiles=dev

Vérifications:

1. Ouvrir http://localhost:8080/h2-console
2. JDBC URL: jdbc:h2:mem:devdb
3. Connexion avec sa / (vide)

---

Partie 4: Configuration Production (PostgreSQL)

4.1 Démarrer PostgreSQL avec Docker

# Créer et démarrer PostgreSQL
docker run --name postgres-demo \
  -e POSTGRES_USER=demo \
  -e POSTGRES_PASSWORD=demo123 \
  -e POSTGRES_DB=productdb \
  -p 5432:5432 \
  -d postgres:15

4.2 Configuration PostgreSQL

# application-prod.properties

# ===== DATASOURCE POSTGRESQL =====
spring.datasource.url=jdbc:postgresql://localhost:5432/productdb
spring.datasource.driver-class-name=org.postgresql.Driver
spring.datasource.username=demo
spring.datasource.password=demo123

# Console H2 désactivée
spring.h2.console.enabled=false

# ===== JPA =====
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.show-sql=false
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

# ===== HIKARI (Pool optimisé pour production) =====
spring.datasource.hikari.pool-name=ProdPool
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000

# Validation des connexions
spring.datasource.hikari.connection-test-query=SELECT 1

# Détection des fuites (60 secondes)
spring.datasource.hikari.leak-detection-threshold=60000

4.3 Démarrer en Mode Production

# Avec le profil prod
mvn spring-boot:run -Dspring-boot.run.profiles=prod

---

Partie 5: Monitoring avec Actuator

5.1 Endpoints HikariCP

Démarrez l'application et testez ces URLs:

# Santé globale
curl http://localhost:8080/actuator/health

# Métriques HikariCP
curl http://localhost:8080/actuator/metrics/hikaricp.connections

# Connexions actives
curl http://localhost:8080/actuator/metrics/hikaricp.connections.active

# Connexions inactives
curl http://localhost:8080/actuator/metrics/hikaricp.connections.idle

# Connexions en attente
curl http://localhost:8080/actuator/metrics/hikaricp.connections.pending

# Temps d'acquisition de connexion
curl http://localhost:8080/actuator/metrics/hikaricp.connections.acquire

5.2 Créer un Endpoint de Diagnostic

// src/main/java/com/example/datasourcedemo/controller/PoolInfoController.java
package com.example.datasourcedemo.controller;

import com.zaxxer.hikari.HikariDataSource;
import com.zaxxer.hikari.HikariPoolMXBean;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api/pool")
@RequiredArgsConstructor
public class PoolInfoController {

    private final DataSource dataSource;

    @GetMapping("/info")
    public Map<String, Object> getPoolInfo() {
        HikariDataSource hikariDS = (HikariDataSource) dataSource;
        HikariPoolMXBean poolMXBean = hikariDS.getHikariPoolMXBean();

        Map<String, Object> info = new HashMap<>();
        info.put("poolName", hikariDS.getPoolName());
        info.put("maximumPoolSize", hikariDS.getMaximumPoolSize());
        info.put("minimumIdle", hikariDS.getMinimumIdle());
        info.put("activeConnections", poolMXBean.getActiveConnections());
        info.put("idleConnections", poolMXBean.getIdleConnections());
        info.put("totalConnections", poolMXBean.getTotalConnections());
        info.put("threadsAwaitingConnection", poolMXBean.getThreadsAwaitingConnection());

        return info;
    }
}

Test:

curl http://localhost:8080/api/pool/info

Résultat attendu:

{
  "poolName": "DevPool",
  "maximumPoolSize": 5,
  "minimumIdle": 2,
  "activeConnections": 0,
  "idleConnections": 2,
  "totalConnections": 2,
  "threadsAwaitingConnection": 0
}

---

Partie 6: Simuler une Saturation du Pool

6.1 Configuration pour le Test

Modifiez temporairement application-dev.properties:

# Pool très petit pour tester
spring.datasource.hikari.maximum-pool-size=2
spring.datasource.hikari.connection-timeout=5000  # 5 secondes

6.2 Script de Test

Créez un script pour envoyer plusieurs requêtes simultanées:

# test-pool.sh (Linux/Mac)
#!/bin/bash

echo "Envoi de 5 requêtes simultanées..."

for i in {1..5}; do
    curl -s http://localhost:8080/api/products/slow &
done

wait
echo "Terminé!"

Ou avec PowerShell (Windows):

# test-pool.ps1
Write-Host "Envoi de 5 requêtes simultanées..."

$jobs = @()
for ($i = 1; $i -le 5; $i++) {
    $jobs += Start-Job -ScriptBlock {
        Invoke-RestMethod -Uri "http://localhost:8080/api/products/slow"
    }
}

$jobs | Wait-Job | Receive-Job
Write-Host "Terminé!"

6.3 Observer les Logs

HikariPool-1 - Pool stats (total=2, active=2, idle=0, waiting=3)
HikariPool-1 - Connection is not available, request timed out after 5001ms.

6.4 Corriger

# Augmenter le pool
spring.datasource.hikari.maximum-pool-size=10

# Ou augmenter le timeout
spring.datasource.hikari.connection-timeout=60000

---

Partie 7: Données de Test

7.1 Créer data.sql

-- src/main/resources/data.sql
INSERT INTO products (name, description, price, stock, created_at) VALUES
('Laptop Pro', 'Ordinateur portable haute performance', 1299.99, 50, CURRENT_TIMESTAMP),
('Souris Sans Fil', 'Souris ergonomique Bluetooth', 49.99, 200, CURRENT_TIMESTAMP),
('Clavier Mécanique', 'Clavier gaming RGB', 129.99, 75, CURRENT_TIMESTAMP),
('Écran 27 pouces', 'Moniteur 4K IPS', 399.99, 30, CURRENT_TIMESTAMP),
('Webcam HD', 'Caméra 1080p avec micro', 79.99, 100, CURRENT_TIMESTAMP);

7.2 Activer l'Initialisation

# application-dev.properties
spring.jpa.defer-datasource-initialization=true
spring.sql.init.mode=always

---

Vérification Finale

Checklist

• L'application démarre avec le profil dev (H2)
• La console H2 est accessible
• Les endpoints /api/products fonctionnent
• Les métriques Actuator sont disponibles
• /api/pool/info retourne les stats du pool
• Le test de saturation montre les timeouts
• L'application démarre avec le profil prod (PostgreSQL)

Tests à Effectuer

# 1. Créer un produit
curl -X POST http://localhost:8080/api/products \
  -H "Content-Type: application/json" \
  -d '{"name":"Test","price":99.99,"stock":10}'

# 2. Lister les produits
curl http://localhost:8080/api/products

# 3. Vérifier le pool
curl http://localhost:8080/api/pool/info

# 4. Vérifier la santé
curl http://localhost:8080/actuator/health

---

Résumé

Dans ce TP, vous avez appris à:

Compétence	Description
Configuration multi-profil	dev (H2) vs prod (PostgreSQL)
HikariCP	Paramètres du pool de connexions
Actuator	Monitoring des métriques
Diagnostic	Endpoint personnalisé pour le pool
Tests de charge	Simuler une saturation

---

🎯 Prochaine Étape

Maintenant que vous maîtrisez la configuration des datasources, apprenez à gérer les transactions dans le prochain TP.

➡️ TP7.2: Transactions et Rollback

---

⬅️ Retour au Module 7