Configuration et dépendances (`spring-boot-starter-data-jdbc`)

Mettre en place Spring Data JDBC : Les prérequis

Pour utiliser Spring Data JDBC, l'alternative plus simple et plus directe à Spring Data JPA pour l'accès aux bases de données relationnelles, la configuration initiale est relativement simple, notamment grâce à l'auto-configuration de Spring Boot. Les étapes principales consistent à inclure les bonnes dépendances dans votre projet et à configurer la connexion à votre base de données.

Contrairement à JPA qui nécessite un fournisseur de persistance comme Hibernate, Spring Data JDBC s'appuie directement sur les abstractions JDBC de Spring Framework (comme JdbcTemplate) et ne requiert donc pas de dépendance ORM supplémentaire.

Ajouter les dépendances Maven/Gradle

La première étape consiste à ajouter le starter Spring Data JDBC à votre fichier de build. Ce starter apporte les bibliothèques Spring Data JDBC de base et les dépendances nécessaires de Spring Framework.

1. Le Starter Spring Data JDBC :

    org.springframework.boot
    spring-boot-starter-data-jdbc

// build.gradle (Gradle)
implementation 'org.springframework.boot:spring-boot-starter-data-jdbc'

2. Le Driver JDBC de votre base de données :

Point important : Contrairement à spring-boot-starter-data-jpa qui inclut souvent une dépendance transitoire vers un fournisseur JPA (comme Hibernate), spring-boot-starter-data-jdbc n'inclut PAS le driver JDBC spécifique à votre base de données. Vous devez l'ajouter explicitement.

Voici quelques exemples courants :

Pour PostgreSQL :

    org.postgresql
    postgresql
    runtime 

// build.gradle (Gradle)
runtimeOnly 'org.postgresql:postgresql'

Pour MySQL :

    com.mysql
    mysql-connector-j
    runtime

// build.gradle (Gradle)
runtimeOnly 'com.mysql:mysql-connector-j'

Pour H2 (base de données en mémoire, utile pour les tests ou le développement) :

    com.h2database
    h2
    runtime

// build.gradle (Gradle)
runtimeOnly 'com.h2database:h2'

Assurez-vous d'ajouter le driver correspondant à la base de données que vous utilisez.

Configurer la `DataSource`

Une fois les dépendances ajoutées, vous devez indiquer à Spring Boot comment se connecter à votre base de données. Cela se fait en configurant les propriétés de la DataSource dans votre fichier application.properties ou application.yml.

Spring Boot auto-configure un bean DataSource (en utilisant HikariCP comme pool de connexions par défaut si disponible) si les propriétés nécessaires sont fournies et si un driver JDBC est détecté sur le classpath.

Exemple avec `application.properties` :

# DataSource Configuration
spring.datasource.url=jdbc:postgresql://localhost:5432/ma_base_de_donnees
spring.datasource.username=mon_utilisateur
spring.datasource.password=mon_mot_de_passe
# Optionnel : Spécifier explicitement le nom de la classe driver (souvent non nécessaire si le driver est standard)
# spring.datasource.driver-class-name=org.postgresql.Driver

# Configuration du pool de connexions (HikariCP par défaut)
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000
spring.datasource.hikari.maximum-pool-size=10

Exemple avec `application.yml` :

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/ma_base_de_donnees
    username: mon_utilisateur
    password: mon_mot_de_passe
    # driver-class-name: org.postgresql.Driver
    hikari:
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
      maximum-pool-size: 10

Remplacez l'URL, le nom d'utilisateur et le mot de passe par les informations de connexion de votre propre base de données. Spring Boot est assez intelligent pour déduire souvent le driver-class-name à partir de l'URL JDBC.

Qu'est-ce qui est auto-configuré d'autre ?

Avec le starter spring-boot-starter-data-jdbc et la configuration de la DataSource, Spring Boot met en place les éléments suivants pour vous :

• Un bean DataSource (généralement un pool de connexions HikariCP).
• Un bean JdbcTemplate et un NamedParameterJdbcTemplate, configurés avec la DataSource. Bien que Spring Data JDBC les utilise en interne, vous pouvez également les injecter et les utiliser directement si nécessaire pour des opérations JDBC plus bas niveau.
• Les composants centraux de Spring Data JDBC : JdbcConverter (pour le mapping objet-relationnel simple), RelationalManagedTypes (pour découvrir les entités), DataAccessStrategy (pour abstraire les opérations CRUD), SqlGeneratorSource (pour générer le SQL de base).
• Un PlatformTransactionManager (DataSourceTransactionManager) pour la gestion des transactions JDBC.
• L'activation de la détection des interfaces Repository Spring Data JDBC dans les packages scannés.

Cette auto-configuration vous permet de commencer à définir vos entités (annotées avec @Table, @Id) et vos interfaces Repository étendant CrudRepository (ou une autre interface Spring Data JDBC) presque immédiatement après avoir configuré les dépendances et la source de données.

En résumé, la mise en place de Spring Data JDBC consiste principalement à ajouter deux types de dépendances (le starter JDBC et le driver de base de données) et à fournir les informations de connexion à la base de données via les propriétés de l'application. Spring Boot et Spring Data s'occupent du reste de la configuration de base.