Un guide de JPA avec le printemps
1. Vue d'ensemble
Ce tutorielshows how to set up Spring with JPA, utilisant Hibernate comme fournisseur de persistance.
Pour une introduction étape par étape sur la configuration du contexte Spring à l'aide de la configuration basée sur Java et du pom Maven de base pour le projet, consultezthis 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.
Lectures complémentaires:
Définir les entités JPA
Apprenez à définir des entités et à les personnaliser à l'aide de l'API Java Persistence.
Botte de printemps avec Hibernate
Une introduction rapide et pratique à l'intégration de Spring Boot et Hibernate / JPA.
NEW: Voici une vidéo sur la configuration d'Hibernate 4 avec Spring 4 (je recommande de la regarder en 1080p):
[.iframe-fluid] ##
2. JPA dans Spring Boot
Le projet Spring Boot vise à rendre la création d'applications Spring beaucoup plus rapide et plus simple. Ceci est fait avec l'utilisation de démarreurs et d'auto-configuration pour diverses fonctionnalités de Spring, dont JPA.
2.1. Dépendances Maven
Pour activer JPA dans une application Spring Boot, nous avons besoin des dépendancesspring-boot-starter etspring-boot-starter-data-jpa:
org.springframework.boot
spring-boot-starter
2.1.4.RELEASE
org.springframework.boot
spring-boot-starter-data-jpa
2.1.4.RELEASE
Lespring-boot-starter contient la configuration automatique nécessaire pour Spring JPA. De plus, le projetspring-boot-starter-jpa fait référence à toutes les dépendances nécessaires telles quehibernate-entitymanager.
2.2. Configuration
Spring Boot configures Hibernate as the default JPA provider, il n'est donc plus nécessaire de définir le beanentityManagerFactory sauf si nous voulons le personnaliser.
Spring Boot can also auto-configure the dataSource bean, depending on the database we’re using. Dans le cas d'une base de données en mémoire de typeH2,HSQLDB etApache Derby, Boot configure automatiquement lesDataSource 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éesH2 en mémoire dans une application Spring Boot JPA, il suffit d'ajouter la dépendanceh2 au fichierpom.xml:
com.h2database
h2
1.4.197
De cette façon, nous n'avons pas besoin de définir le beandataSource, mais nous pouvons le faire si nous voulons le personnaliser.
Si nous voulons utiliser JPA avec la base de donnéesMySQL, nous avons besoin de la dépendancemysql-connector-java, ainsi que de définir la configuration deDataSource.
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 parspring.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=trueSpring 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 étaitTomcat, mais avec Spring Boot 2, il a été changé enHikariCP.
Vous pouvez trouver plus d'exemples de configuration de JPA dans Spring Boot dans lesGitHub project.
Comme nous pouvons le voir, la configuration de base JPA est assez simple si nous utilisons Spring Boot.
Cependant,if we have a standard Spring project, then we need more explicit configuration, using either Java or XML. C'est ce sur quoi nous allons nous concentrer dans les sections suivantes.
3. La configuration JPA Spring avec Java - dans un projet sans démarrage
Pour utiliser JPA dans un projet Spring,we need to set up the EntityManager.
C'est la partie principale de la configuration et nous pouvons le faire via un haricot d'usine Spring. Cela peut être le plus simpleLocalEntityManagerFactoryBean outhe more flexible LocalContainerEntityManagerFactoryBean.
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.example.persistence.model" });
JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
em.setJpaVendorAdapter(vendorAdapter);
em.setJpaProperties(additionalProperties());
return em;
}
// ...
}We also need to explicitly define the DataSource bean 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 sont les propriétés Hibernate supplémentaires et les beansTransactionManager etexceptionTranslation:
@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;
}4. La configuration JPA Spring avec XML
Ensuite, voyons la même configuration Spring avec XML:
create-drop
org.hibernate.dialect.MySQL5Dialect
Il existe une différence relativement faible entre le XML et la nouvelle configuration basée sur Java. Notamment, en XML, une référence à un autre bean peut pointer soit vers le bean, soit vers une fabrique de beans pour ce bean.
En Java, cependant, comme les types sont différents, le compilateur ne le permet pas, et donc leEntityManagerFactory est d'abord récupéré de sa fabrique de haricots puis transmis au gestionnaire de transactions:
txManager.setEntityManagerFactory(this.entityManagerFactoryBean().getObject());
5. Passer au full XML sans
Habituellement, JPA définit une unité de persistance via le fichierMETA-INF/persistence.xml. Starting with Spring 3.1, the persistence.xml is no longer necessary. LeLocalContainerEntityManagerFactoryBean prend désormais en charge une propriété‘packagesToScan' où les packages à rechercher pour les classes@Entity peuvent être spécifiés.
Ce fichier était le dernier élément XML à supprimer. We can now set up JPA fully with no XML.
Nous spécifions généralement les propriétés JPA dans le fichierpersistence.xml. Alternativement, nous pouvons ajouter les propriétés directement au bean de fabrique de l'entité manager:
factoryBean.setJpaProperties(this.additionalProperties());
En passant, si Hibernate était le fournisseur de persistance, ce serait le moyen de spécifier des propriétés spécifiques à Hibernate.
6. La configuration Maven
En plus des dépendances Spring Core et de la persistance - présentées en détail dans lesSpring with Maven tutorial - nous devons également définir JPA et Hibernate dans le projet, ainsi qu'un connecteur MySQL:
org.hibernate
hibernate-entitymanager
5.4.2.Final
runtime
mysql
mysql-connector-java
6.0.6
runtime
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 quelHibernate supported database fera l'affaire.
7. Conclusion
Ce tutoriel a illustré comment configurerJPA with Hibernate in Spring à la fois dans une application Spring Boot et une application Spring standard.
Comme toujours, le code présenté dans cet article est disponibleover on Github.