Ein Leitfaden für JPA mit Frühling
1. Überblick
In diesem Tutorialshows how to set up Spring with JPAwird Hibernate als Persistenzanbieter verwendet.
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 unterthis article.
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.
Weitere Lektüre:
JPA-Entitäten definieren
Erfahren Sie, wie Sie Entitäten definieren und mithilfe der Java-Persistenz-API anpassen.
Spring Boot mit Ruhezustand
Eine schnelle und praktische Einführung in die Integration von Spring Boot und Hibernate / JPA.
NEW: Hier ist ein Video zum Einrichten von Hibernate 4 mit Spring 4 (ich empfehle, es in 1080p in voller Länge anzusehen):
[.iframe-fluid] ##
2. JPA im Frühjahr Boot
Das Spring Boot-Projekt soll das Erstellen von Spring-Anwendungen erheblich beschleunigen und vereinfachen. Dies geschieht mithilfe von Startern und automatischer Konfiguration für verschiedene Spring-Funktionen, darunter JPA.
2.1. Maven-Abhängigkeiten
Um JPA in einer Spring Boot-Anwendung zu aktivieren, benötigen wir die Abhängigkeitenspring-boot-starter undspring-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
spring-boot-starter enthält die erforderliche automatische Konfiguration für Spring JPA. Das Projektspring-boot-starter-jpaverweist außerdem auf alle erforderlichen Abhängigkeiten, z. B.hibernate-entitymanager.
2.2. Aufbau
Spring Boot configures Hibernate as the default JPA provider, daher ist es nicht mehr erforderlich, die Bean (entityManagerFactory) zu definieren, es sei denn, wir möchten sie anpassen.
Spring Boot can also auto-configure the dataSource bean, depending on the database we’re using. Bei einer speicherinternen Datenbank vom TypH2,HSQLDB undApache Derby konfiguriert Boot dieDataSource automatisch, wenn die entsprechende Datenbankabhängigkeit im Klassenpfad vorhanden ist.
Wenn wir beispielsweise eine speicherinterneH2-Datenbank in einer Spring Boot-JPA-Anwendung verwenden möchten, müssen wir nur dieh2-abhängigkeit zurpom.xml-Datei hinzufügen:
com.h2database
h2
1.4.197
Auf diese Weise müssen wir diedataSource-Bohne nicht definieren, können dies jedoch tun, wenn wir sie anpassen möchten.
Wenn wir JPA mit der Datenbank vonMySQLverwenden möchten, benötigen wir die Abhängigkeit vonmysql-connector-javaowie die Konfiguration vonDataSource.
Wir können dies in einer@Configuration-Klasse oder mithilfe von 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 mit dem Präfixspring.datasource festgelegt werden:
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 konfiguriert automatisch eine Datenquelle basierend auf diesen Eigenschaften.
Auch in Spring Boot 1 war der StandardverbindungspoolTomcat, aber in Spring Boot 2 wurde er inHikariCP geändert.
Weitere Beispiele zum Konfigurieren von JPA in Spring Boot finden Sie inGitHub project.
Wie wir sehen können, ist die grundlegende JPA-Konfiguration ziemlich einfach, wenn wir Spring Boot verwenden.
if we have a standard Spring project, then we need more explicit configuration, using either Java or XML. Darauf konzentrieren wir uns in den nächsten Abschnitten.
3. Die JPA Spring-Konfiguration mit Java - in einem Nicht-Boot-Projekt
So verwenden Sie JPA in einem Spring-Projekt:we need to set up the EntityManager.
Dies ist der Hauptteil der Konfiguration und wir können dies über eine Spring Factory Bean tun. Dies kann entweder das einfachereLocalEntityManagerFactoryBean oderthe more flexible 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.example.persistence.model" });
JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
em.setJpaVendorAdapter(vendorAdapter);
em.setJpaProperties(additionalProperties());
return em;
}
// ...
}We also need to explicitly define the DataSource bean, die wir oben verwendet haben:
@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 und die BohnenTransactionManager undexceptionTranslation:
@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. 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 eine Bean-Factory für diese Bean verweisen.
In Java lässt der Compiler dies jedoch nicht zu, da die Typen unterschiedlich sind. Daher wirdEntityManagerFactory zuerst aus seiner Bean-Factory abgerufen und dann an den Transaktionsmanager übergeben:
txManager.setEntityManagerFactory(this.entityManagerFactoryBean().getObject());
5. Vollständiges XML-frei
Normalerweise definiert JPA eine Persistenzeinheit über die DateiMETA-INF/persistence.xml. Starting with Spring 3.1, the persistence.xml is no longer necessary. DasLocalContainerEntityManagerFactoryBean unterstützt jetzt eine‘packagesToScan'-Eigenschaft, in der die Pakete angegeben werden können, die nach@Entity-Klassen durchsucht werden sollen.
Diese Datei war das letzte Stück XML, das wir entfernen müssen. We can now set up JPA fully with no XML.
Normalerweise geben wir JPA-Eigenschaften in der Dateipersistence.xmlan. Alternativ können wir die Eigenschaften direkt zur Entity-Manager-Factory-Bean hinzufügen:
factoryBean.setJpaProperties(this.additionalProperties());
Wenn Hibernate der Persistenzanbieter ist, können Sie auf diese Weise Hibernate-spezifische Eigenschaften angeben.
6. Die Maven-Konfiguration
Zusätzlich zu den Spring Core- und Persistenzabhängigkeiten - detailliert inSpring with Maven tutorial dargestellt - müssen wir im Projekt auch JPA und Hibernate sowie einen MySQL-Connector definieren:
org.hibernate
hibernate-entitymanager
5.4.2.Final
runtime
mysql
mysql-connector-java
6.0.6
runtime
Beachten Sie, dass die MySQL-Abhängigkeit als Beispiel enthalten ist. Wir benötigen einen Treiber, um die Datenquelle zu konfigurieren, aber alleHibernate supported database reichen aus.
7. Fazit
In diesem Tutorial wurde veranschaulicht, wieJPA with Hibernate in Spring sowohl in einem Spring Boot als auch in einer Standard-Spring-Anwendung konfiguriert werden.
Wie immer ist der in diesem Artikel vorgestellte Codeover on Github verfügbar.