Un guide de JPA avec Spring

1. Vue d'ensemble

Ce tutoriel 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 à l'aide de la configuration Java et du pom Maven de base du projet, consultez cet article.

Nous commencerons par configurer JPA dans un projet Spring Boot, puis nous examinerons la configuration complète dont nous avons besoin si nous avons un projet Spring standard.

Voici une vidéo sur la configuration d'Hibernate 4 avec Spring 4 (je recommande de la regarder en 1080p):

2. JPA dans Spring Boot

Le projet Spring Boot vise à rendre la création d'applications Spring beaucoup plus rapide et plus facile. Cela se fait avec l'utilisation de démarreurs et la configuration automatique pour diverses fonctionnalités de Spring, JPA parmi elles.

2.1. Dépendances de Maven

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

 org.springframework.boot spring-boot-starter 2.2.6.RELEASE   org.springframework.boot spring-boot-starter-data-jpa 2.2.6.RELEASE 

Le spring-boot-starter contient la configuration automatique nécessaire pour Spring JPA. De plus, le projet spring-boot-starter-jpa fait référence à toutes les dépendances nécessaires telles que hibernate-core .

2.2. Configuration

Spring Boot configure Hibernate comme fournisseur JPA par défaut , il n'est donc plus nécessaire de définir le bean entityManagerFactory à moins que nous ne souhaitions le personnaliser.

Spring Boot peut également configurer automatiquement 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 base de données correspondante est présente sur le chemin de classe.

Par exemple, si nous voulons utiliser une base de données H2 en mémoire dans une application Spring Boot JPA, il suffit d'ajouter la dépendance h2 au fichier pom.xml :

 com.h2database h2 1.4.200 

De cette façon, 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 , nous avons besoin de la dépendance mysql-connector-java , ainsi que pour définir la configuration DataSource .

Nous pouvons le faire dans une classe @Configuration ou en utilisant les propriétés standard de Spring Boot.

La configuration Java a la même apparence que dans 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 à l'aide d'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.

Toujours dans Spring Boot 1, le pool de connexions par défaut était Tomcat , mais avec Spring Boot 2, il a été changé en 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, utilisant Java ou XML. C'est ce sur quoi nous allons nous concentrer dans les prochaines sections.

3. La configuration JPA Spring avec Java - dans un projet sans démarrage

Pour utiliser JPA dans un projet Spring, nous devons configurer EntityManager.

C'est la partie principale de la configuration et nous pouvons le faire via un bean usine Spring. Il peut s'agir du LocalEntityManagerFactoryBean plus simple ou 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 comprend les propriétés Hibernate supplémentaires et les beans TransactionManager et exceptionTranslation :

@Bean public PlatformTransactionManager transactionManager() { JpaTransactionManager transactionManager = new JpaTransactionManager(); transactionManager.setEntityManagerFactory(entityManagerFactory().getObject()); 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; }

4. La configuration JPA Spring avec XML

Ensuite, voyons la même configuration Spring avec XML:

        create-drop org.hibernate.dialect.MySQL5Dialect              

Il y a une différence relativement petite entre le XML et la nouvelle configuration basée sur Java. À savoir, en XML, une référence à un autre bean peut pointer vers le bean ou une usine de bean pour ce bean.

En Java, cependant, comme les types sont différents, le compilateur ne le permet pas, et donc EntityManagerFactory est d'abord récupéré de sa fabrique de haricots puis transmis au gestionnaire de transactions:

transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());

5. Passer au format XML complet

En général, JPA définit une unité de persistance via le fichier META-INF / persistence.xml . À partir de Spring 3.1, le fichier persistence.xml n'est plus nécessaire . Le LocalContainerEntityManagerFactoryBean prend désormais en charge une packagesToScan propriété où les paquets à analyser pour @Entity les classes peuvent être spécifiées.

Ce fichier était le dernier élément XML que nous devions supprimer. Nous pouvons maintenant configurer JPA entièrement sans XML.

We would usually specify JPA properties in the persistence.xml file. Alternatively, we can add the properties directly to the entity manager factory bean:

factoryBean.setJpaProperties(this.additionalProperties());

As a side note, if Hibernate would be the persistence provider, then this would be the way to specify Hibernate specific properties as well.

6. The Maven Configuration

In addition to the Spring Core and persistence dependencies – show in detail in the Spring with Maven tutorial – we also need to define JPA and Hibernate in the project, as well as a MySQL connector:

 org.hibernate hibernate-core 5.2.17.Final runtime   mysql mysql-connector-java 8.0.19 runtime 

Note that the MySQL dependency is included here as an example. We need a driver to configure the datasource, but any Hibernate-supported database will do.

7. Conclusion

Ce didacticiel a illustré comment configurer JPA avec Hibernate au printemps dans une application Spring Boot et une application Spring standard.

Comme toujours, le code présenté dans cet article est disponible à l'adresse over sur GitHub.