Ein Leitfaden für JPA mit Frühling

1. Übersicht

Dieses Tutorial zeigt, wie Sie Spring mit JPA einrichten und Hibernate als Persistenzanbieter verwenden.

Eine schrittweise Einführung zum Einrichten des Spring-Kontexts mithilfe der Java-basierten Konfiguration und des grundlegenden Maven-POM für das Projekt finden Sie in diesem Artikel.

Wir beginnen mit der Einrichtung von JPA in einem Spring Boot-Projekt und untersuchen dann die vollständige Konfiguration, die wir benötigen, wenn wir ein Standard-Spring-Projekt haben.

Hier ist ein Video zum Einrichten von Hibernate 4 mit Spring 4 (ich empfehle, es in 1080p in voller Länge anzusehen):

2. JPA im Spring Boot

Das Spring Boot-Projekt soll das Erstellen von Spring-Anwendungen viel schneller und einfacher machen. Dies erfolgt unter Verwendung von Startern und automatischer Konfiguration für verschiedene Federfunktionen, darunter JPA.

2.1. Maven-Abhängigkeiten

Um JPA in einer Spring Boot-Anwendung zu aktivieren, benötigen wir die Abhängigkeiten Spring-Boot-Starter und Spring-Boot-Starter-Daten-JPA :

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

Der Spring-Boot-Starter enthält die notwendige Autokonfiguration für Spring JPA. Das Spring-Boot-Starter-JPA- Projekt verweist außerdem auf alle erforderlichen Abhängigkeiten, z. B. den Ruhezustand .

2.2. Aufbau

Spring Boot konfiguriert Hibernate als Standard-JPA-Anbieter , sodass die entityManagerFactory- Bean nicht mehr definiert werden muss , es sei denn, wir möchten sie anpassen.

Spring Boot kann die dataSource- Bean abhängig von der verwendeten Datenbank auch automatisch konfigurieren . Bei einer speicherinternen Datenbank vom Typ H2 , HSQLDB und Apache Derby konfiguriert Boot die DataSource automatisch, wenn die entsprechende Datenbankabhängigkeit im Klassenpfad vorhanden ist.

Wenn wir beispielsweise eine speicherinterne H2- Datenbank in einer Spring Boot JPA-Anwendung verwenden möchten , müssen wir nur die h2- Abhängigkeit zur Datei pom.xml hinzufügen :

 com.h2database h2 1.4.200 

Auf diese Weise müssen wir die dataSource- Bean nicht definieren , können dies jedoch tun, wenn wir sie anpassen möchten.

Wenn wir JPA mit der MySQL- Datenbank verwenden möchten, benötigen wir die Abhängigkeit mysql-connector-java sowie die Definition der DataSource- Konfiguration.

Wir können dies in einer @ Configuration- Klasse oder mithilfe der Standard-Spring Boot-Eigenschaften tun .

Die Java-Konfiguration sieht genauso aus wie in einem Standard-Spring-Projekt:

@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; }

Um die Datenquelle mithilfe einer Eigenschaftendatei zu konfigurieren, müssen Eigenschaften festgelegt werden, denen spring.datasource vorangestellt ist :

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 konfiguriert automatisch eine Datenquelle basierend auf diesen Eigenschaften.

Auch in Spring Boot 1 war der Standardverbindungspool Tomcat , aber mit Spring Boot 2 wurde er in HikariCP geändert .

Weitere Beispiele zum Konfigurieren von JPA in Spring Boot finden Sie im GitHub-Projekt.

Wie wir sehen können, ist die grundlegende JPA-Konfiguration ziemlich einfach, wenn wir Spring Boot verwenden.

Doch wenn wir ein Standard - Frühling Projekt haben, dann brauchen wir mehr explizite Konfiguration, entweder Java oder XML. Darauf konzentrieren wir uns in den nächsten Abschnitten.

3. Die JPA Spring-Konfiguration mit Java - in einem Nicht-Boot-Projekt

Um JPA in einem Spring-Projekt verwenden zu können, müssen Sie den EntityManager einrichten .

Dies ist der Hauptteil der Konfiguration und wir können dies über eine Spring Factory Bean tun. Dies kann entweder die einfachere LocalEntityManagerFactoryBean oder die flexiblere LocalContainerEntityManagerFactoryBean sein .

Mal sehen, wie wir die letztere Option verwenden können:

@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; } // ... }

Wir müssen auch die oben verwendete DataSource- Bean explizit definieren :

@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; }

Der letzte Teil der Konfiguration sind die zusätzlichen Eigenschaften für den Ruhezustand sowie die Beans TransactionManager und 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. Die JPA Spring-Konfiguration mit XML

Als nächstes sehen wir uns dieselbe Spring-Konfiguration mit XML an:

        create-drop org.hibernate.dialect.MySQL5Dialect              

Es gibt einen relativ kleinen Unterschied zwischen der XML- und der neuen Java-basierten Konfiguration. In XML kann ein Verweis auf eine andere Bean entweder auf die Bean oder auf eine Bean-Factory für diese Bean verweisen.

In Java lässt der Compiler dies jedoch nicht zu, da die Typen unterschiedlich sind. Daher wird die EntityManagerFactory zuerst aus ihrer Bean-Factory abgerufen und dann an den Transaktionsmanager übergeben:

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

5. Vollständiges XML-frei

Normalerweise definiert JPA eine Persistenzeinheit über die Datei META-INF / persistence.xml . Ab Spring 3.1 ist die Datei persistence.xml nicht mehr erforderlich . Die LocalContainerEntityManagerFactoryBean unterstützt jetzt eine packagesToScan- Eigenschaft, in der die Pakete angegeben werden können, nach denen nach @Entity- Klassen gesucht werden soll.

Diese Datei war das letzte XML-Stück, das wir entfernen müssen. Wir können JPA jetzt vollständig ohne XML einrichten.

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

In diesem Tutorial wurde veranschaulicht, wie JPA mit Hibernate in Spring sowohl in einem Spring Boot als auch in einer Standard-Spring-Anwendung konfiguriert wird .

Wie immer ist der in diesem Artikel vorgestellte Code auf GitHub verfügbar.