Persistance avec Spring

[Sous-titre du document]

Khalil
[Date]
1 UN GUIDE POUR JPA AVEC SPRING

1.1 APERÇU
Ce chapitre montre comment configurer Spring avec JPA en utilisant Hibernate comme
fournisseur de persistance.
Pour une introduction étape par étape sur la configuration du contexte Spring en utilisant la
configuration basée sur Java et le fichier pom Maven de base pour le projet, consultez cet
article. (https://www.baeldung.com/bootstraping-a-web-application-with-spring-and-java-
based-configuration)
Nous commencerons par configurer JPA dans un projet Spring Boot, puis nous examinerons
la configuration complète nécessaire pour un projet Spring standard.

1.2 JPA DANS SPRING BOOT

Le projet Spring Boot vise à rendre la création d'applications Spring beaucoup plus rapide et
plus facile. Cela est réalisé grâce à l'utilisation de starters et à l'autoconfiguration pour
diverses fonctionnalités de Spring, dont JPA.

1.2.1 Dépendances Maven

Pour activer JPA dans une application Spring Boot, nous avons besoin des dépendances
spring-boot-starter et spring-boot-starter-data-jpa :

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.1.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
<version>2.1.4.RELEASE</version>
</dependency>
Le spring-boot-starter contient la configuration automatique nécessaire pour Spring JPA. De
plus, le projet spring-boot-starter-jpa référence toutes les dépendances nécessaires telles que
hibernate-entitymanager.

1.2.2 Configuration
Spring Boot configure Hibernate comme le fournisseur JPA par défaut, il n'est donc plus
nécessaire de définir le bean entityManagerFactory à moins que nous voulions le
personnaliser.
Spring Boot peut également auto-configurer le bean dataSource, en fonction de la base de
données que nous utilisons. Dans le cas d'une base de données en mémoire de type H2,
HSQLDB et Apache Derby, Boot configure automatiquement le DataSource si la dépendance
de la base de données correspondante est présente dans le classpath.
Par exemple, si nous voulons utiliser une base de données H2 en mémoire dans une
application Spring Boot JPA, nous devons simplement ajouter la dépendance h2 au fichier
pom.xml :

<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.4.197</version>
</dependency>

De cette manière, nous n'avons pas besoin de définir le bean dataSource, mais nous pouvons
le faire si nous voulons le personnaliser.
Si nous voulons utiliser JPA avec la base de données MySQL, alors nous avons besoin de la
dépendance mysql-connector-java, ainsi que de définir la configuration du DataSource.
Nous pouvons le faire dans une classe @Configuration, ou en utilisant les propriétés standard
de Spring Boot.
La configuration Java ressemble à celle d'un projet Spring standard :

@Bean
public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName(“com.mysql.cj.jdbc.Driver”);
dataSource.setUsername(“mysqluser”);
dataSource.setPassword(“mysqlpass”);
dataSource.setUrl(“jdbc:mysql://localhost:3306/myDb?
createDatabaseIfNotExist=true”);

return dataSource;
}

Pour configurer la source de données en utilisant un fichier de propriétés, nous devons définir
des propriétés préfixées par spring.datasource :

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=mysqluser
spring.datasource.password=mysqlpass
spring.datasource.url=
jdbc:mysql://localhost:3306/myDb?createDatabaseIfNotExist=true

Spring Boot configurera automatiquement une source de données en fonction de ces

propriétés.
Aussi, dans Spring Boot 1, le pool de connexions par défaut était Tomcat, mais avec Spring
Boot 2, il a été changé pour HikariCP.
Vous pouvez trouver plus d'exemples de configuration de JPA dans Spring Boot dans le projet
GitHub.
Comme nous pouvons le voir, la configuration de base de JPA est assez simple si nous
utilisons Spring Boot.
Cependant, si nous avons un projet Spring standard, nous avons besoin d'une configuration
plus explicite, en utilisant soit Java soit XML. C'est sur cela que nous nous concentrerons
dans les sections suivantes.

1.2.3 Configuration JPA Spring avec Java

Pour utiliser JPA dans un projet Spring, nous devons configurer l'EntityManager.
C'est la partie principale de la configuration et nous pouvons le faire via un bean factory
Spring. Il peut s'agir soit du bean LocalEntityManagerFactoryBean plus simple, soit du
LocalContainerEntityManagerFactoryBean plus flexible.
Voyons comment nous pouvons utiliser cette dernière option :

@Configuration
@EnableTransactionManagement
public class PersistenceJPAConfig{
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory()
{
LocalContainerEntityManagerFactoryBean em
= new LocalContainerEntityManagerFactoryBean();
em.setDataSource(dataSource());
em.setPackagesToScan(new String[] { “com.baeldung.persistence.
model” });
JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
em.setJpaVendorAdapter(vendorAdapter);
em.setJpaProperties(additionalProperties());
return em;
}

// ...
}
Nous devons également définir explicitement le bean DataSource que nous avons utilisé ci-
dessus :

@Bean
public DataSource dataSource(){
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName(“com.mysql.cj.jdbc.Driver”);
dataSource.setUrl(“jdbc:mysql://localhost:3306/spring_jpa”);
 dataSource.setUsername( “tutorialuser” );
dataSource.setPassword( “tutorialmy5ql” );
return dataSource;
}
La dernière partie de la configuration concerne les propriétés Hibernate supplémentaires ainsi
que les beans TransactionManager et exceptionTranslation :

@Bean
public PlatformTransactionManager
transactionManager(EntityManagerFactory emf) {
JpaTransactionManager transactionManager = new
JpaTransactionManager();
transactionManager.setEntityManagerFactory(emf);
return transactionManager;
}
@Bean
public PersistenceExceptionTranslationPostProcessor
exceptionTranslation(){
return new PersistenceExceptionTranslationPostProcessor();
}
Properties additionalProperties() {
Properties properties = new Properties();
properties.setProperty(“hibernate.hbm2ddl.auto”, “create-drop”);
properties.setProperty(“hibernate.dialect”, “org.hibernate.dialect.
MySQL5Dialect”);

return properties;
}

1.2.4 Configuration JPA Spring avec XML

Ensuite, voyons la même configuration Spring avec XML :
<bean id=”myEmf”
class=”org.springframework.orm.jpa.
LocalContainerEntityManagerFactoryBean”>
<property name=”dataSource” ref=”dataSource” />
<property name=”packagesToScan” value=”com.baeldung.persistence.
model” />
<property name=”jpaVendorAdapter”>
<bean class=”org.springframework.orm.jpa.vendor.
HibernateJpaVendorAdapter” />
</property>
<property name=”jpaProperties”>
<props>
<prop key=”hibernate.hbm2ddl.auto”>create-drop</prop>
<prop key=”hibernate.dialect”>org.hibernate.dialect.MySQL5Dialect</prop>
</props>
</property>
</bean>
<bean id=”dataSource”
class=”org.springframework.jdbc.datasource.DriverManagerDataSource”>
 <property name=”driverClassName” value=”com.mysql.cj.jdbc.Driver” />
<property name=”url” value=”jdbc:mysql://localhost:3306/spring_jpa”
/>
<property name=”username” value=”tutorialuser” />
<property name=”password” value=”tutorialmy5ql” />
</bean>
<bean id=”transactionManager” class=”org.springframework.orm.jpa.
JpaTransactionManager”>
<property name=”entityManagerFactory” ref=”myEmf” />
</bean>
<tx:annotation-driven />
<bean id=”persistenceExceptionTranslationPostProcessor” class=
“org.springframework.dao.annotation.
PersistenceExceptionTranslationPostProcessor” />

<?xml version="1.0" encoding="UTF-8"?>

Il y a une différence relativement petite entre la configuration XML et la nouvelle

configuration basée sur Java. À savoir, en XML, une référence à un autre bean peut pointer
soit vers le bean lui-même, soit vers une fabrique de bean pour ce bean.
Cependant, en Java, étant donné que les types sont différents, le compilateur ne le permet pas,
et donc l'EntityManagerFactory est d'abord récupéré de sa fabrique de bean, puis passé au
gestionnaire de transactions :
txManager.setEntityManagerFactory(this.entityManagerFactoryBean().getObject());

1.2.5 Aller complètement sans XML

Généralement, JPA définit une unité de persistance à travers le fichier
META-INF/persistence.xml. À partir de Spring 3.1, le persistence.xml n'est plus nécessaire.
Le LocalContainerEntityManagerFactoryBean prend désormais en charge une propriété
'packagesToScan' où les packages à scanner pour les classes @Entity peuvent être spécifiés.
Ce fichier était le dernier morceau de XML que nous devions supprimer. Nous pouvons
maintenant configurer JPA entièrement sans XML.
Nous spécifierions généralement les propriétés JPA dans le fichier persistence.xml. En
alternative, nous pouvons ajouter les propriétés directement à la fabrique de l'EntityManager :
factoryBean.setJpaProperties(this.additionalProperties());

En note supplémentaire, si Hibernate était le fournisseur de persistance, c'est ainsi que l'on
spécifierait les propriétés spécifiques à Hibernate.

1.2.6 Configuration Maven

En plus des dépendances Spring Core et persistence, détaillées dans le tutoriel Spring avec
Maven, nous devons également définir JPA et Hibernate dans le projet, ainsi qu'un connecteur
MySQL :
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.4.2.Final</version>
 <scope>runtime</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>6.0.6</version>
<scope>runtime</scope>
</dependency>

Notez que la dépendance MySQL est incluse à titre d'exemple. Nous avons besoin d'un pilote
pour configurer la source de données, mais n'importe quelle base de données prise en charge
par Hibernate fera l'affaire.

1.2.7 Conclusion
Ce chapitre a illustré comment configurer JPA avec Hibernate dans Spring à la fois dans une
application Spring Boot et dans une application Spring standard.
Comme toujours, le code présenté dans ce chapitre est disponible sur Github.
2 INITIALISATION DE HIBERNATE 5 AVEC SPRING

2.1 APERÇU
Dans ce chapitre, nous discuterons de la manière d'initialiser Hibernate 5 avec Spring en
utilisant à la fois une configuration Java et XML.

2.2 INTÉGRATION AVEC SPRING

Initialiser une SessionFactory avec l'API native d'Hibernate est un peu compliqué et
nécessiterait plusieurs lignes de code (consultez la documentation officielle si vous en avez
vraiment besoin).
Heureusement, Spring prend en charge l'initialisation de la SessionFactory, de sorte que nous
n'avons besoin que de quelques lignes de code Java ou d'une configuration XML.
Avant de plonger, si vous travaillez avec des versions plus anciennes d'Hibernate, vous
pouvez consulter les articles sur Hibernate 3 ainsi que sur Hibernate 4 avec Spring.

2.3 DÉPENDANCES MAVEN

Commençons par ajouter les dépendances nécessaires à notre fichier pom.xml :
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.4.2.Final</version>
</dependency>
Le module spring-orm fournit l'intégration de Spring avec Hibernate :
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>5.1.6.RELEASE</version>
</dependency>
Pour simplifier, nous utiliserons H2 comme base de données :
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.4.197</version>
</dependency>
Enfin, nous allons utiliser le pooling de connexions JDBC de Tomcat, qui convient mieux à
des fins de production que le DriverManagerDataSource fourni par Spring :
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-dbcp</artifactId>
<version>9.0.1</version>
</dependency>
2.4 CONFIGURATION
Comme mentionné précédemment, Spring nous assiste dans l'initialisation de la
SessionFactory Hibernate.
Tout ce que nous avons à faire est de définir quelques beans ainsi que quelques paramètres.
Avec Spring, nous avons deux options pour ces configurations, une basée sur Java et une
basée sur XML.

2.4.1 Utilisation de la configuration Java

Pour utiliser Hibernate 5 avec Spring, peu de choses ont changé depuis Hibernate 4 : nous
devons utiliser LocalSessionFactoryBean du package org.springframework.orm.hibernate5 au
lieu de org.springframework.orm.hibernate4.
Comme avec Hibernate 4 auparavant, nous devons définir des beans pour
LocalSessionFactoryBean, DataSource et PlatformTransactionManager, ainsi que quelques
propriétés spécifiques à Hibernate.
Créons notre classe HibernateConfig pour configurer Hibernate 5 avec Spring :
@Configuration
@EnableTransactionManagement
public class HibernateConf {
@Bean
public LocalSessionFactoryBean sessionFactory() {
LocalSessionFactoryBean sessionFactory = new
LocalSessionFactoryBean();
sessionFactory.setDataSource(dataSource());
sessionFactory.setPackagesToScan(
{“com.baeldung.hibernate.bootstrap.model” });
sessionFactory.setHibernateProperties(hibernateProperties());
return sessionFactory;
}
@Bean
public DataSource dataSource() {
BasicDataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName(“org.h2.Driver”);
dataSource.setUrl(“jdbc:h2:mem:db;DB_CLOSE_DELAY=-1”);
dataSource.setUsername(“sa”);
dataSource.setPassword(“sa”);
return dataSource;
}
@Bean
public PlatformTransactionManager hibernateTransactionManager() {
HibernateTransactionManager transactionManager
= new HibernateTransactionManager();
transactionManager.setSessionFactory(sessionFactory().
getObject());
return transactionManager;
}
private final Properties hibernateProperties() {
Properties hibernateProperties = new Properties();
hibernateProperties.setProperty(
“hibernate.hbm2ddl.auto”, “create-drop”);
hibernateProperties.setProperty(
“hibernate.dialect”, “org.hibernate.dialect.H2Dialect”);
 return hibernateProperties;
}

2.4.2 Utilisation de la configuration XML

En tant qu'option secondaire, nous pouvons également configurer Hibernate 5 avec une
configuration basée sur XML :
<?xml version=”1.0” encoding=”UTF-8”?>
<beans xmlns=”...”>
<bean id=”sessionFactory”
class=”org.springframework.orm.hibernate5.
LocalSessionFactoryBean”>
<property name=”dataSource”
ref=”dataSource”/>
<property name=”packagesToScan”
value=”com.baeldung.hibernate.bootstrap.model”/>
<property name=”hibernateProperties”>
<props>
<prop key=”hibernate.hbm2ddl.auto”>
create-drop
</prop>
<prop key=”hibernate.dialect”>
org.hibernate.dialect.H2Dialect
</prop>
</props>
</property>
</bean>
<bean id=”dataSource”
class=”org.apache.tomcat.dbcp.dbcp2.BasicDataSource”>
<property name=”driverClassName” value=”org.h2.Driver”/>
<property name=”url” value=”jdbc:h2:mem:db;DB_CLOSE_DELAY=-1”/>
<property name=”username” value=”sa”/>
<property name=”password” value=”sa”/>
</bean>
<bean id=”txManager”
class=”org.springframework.orm.hibernate5.
HibernateTransactionManager”>
<property name=”sessionFactory” ref=”sessionFactory”/>
</bean>
</beans>
Comme nous pouvons le voir facilement, nous définissons exactement les mêmes beans et
paramètres que dans la configuration basée sur Java précédente.
Pour intégrer le XML dans le contexte Spring, nous pouvons utiliser un simple fichier de
configuration Java si l'application est configurée avec une configuration Java :
@Configuration
@EnableTransactionManagement
@ImportResource({“classpath:hibernate5Configuration.xml”})
public class HibernateXMLConf {
//
}
Alternativement, nous pouvons simplement fournir le fichier XML au contexte Spring, si la
configuration globale est purement XML.