streamalism.org

1. Overzicht

Deze tutorial laat zien hoe je Spring opzet met JPA, met behulp van Hibernate als persistentieleverancier.

Zie dit artikel voor een stapsgewijze introductie over het instellen van de Spring-context met behulp van op Java gebaseerde configuratie en de basis Maven pom voor het project.

We beginnen met het opzetten van JPA in een Spring Boot-project, daarna kijken we naar de volledige configuratie die we nodig hebben als we een standaard Spring-project hebben.

Hier is een video over het instellen van Hibernate 4 met Spring 4 (ik raad aan om het in volledige 1080p te bekijken):

2. JPA in Spring Boot

Het Spring Boot-project is bedoeld om het maken van Spring-applicaties veel sneller en gemakkelijker te maken. Dit wordt gedaan met behulp van starters en autoconfiguratie voor verschillende Spring-functionaliteiten, waaronder JPA.

2.1. Afhankelijkheden van Maven

Om JPA in een Spring Boot-applicatie in te schakelen, hebben we het spring-boot-starter en spring-boot-starter-data-jpa afhankelijkheden:

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

De spring-boot-starter bevat de noodzakelijke autoconfiguratie voor Spring JPA. Ook de spring-boot-starter-jpa project verwijst naar alle noodzakelijke afhankelijkheden zoals slaapstand-core.

2.2. Configuratie

Spring Boot configureert Slaapstand als de standaard JPA-provider, dus het is niet langer nodig om de entiteitManagerFactory bean tenzij we het willen aanpassen.

Spring Boot kan ook het databron bean, afhankelijk van de database die we gebruiken. In het geval van een in-memory database van het type H2, HSQLDB, en Apache Derby, Boot configureert automatisch het Databron als de overeenkomstige databaseafhankelijkheid aanwezig is op het klassenpad.

Als we bijvoorbeeld een in-memory H2 database in een Spring Boot JPA-applicatie, hoeven we alleen de h2 afhankelijkheid van de pom.xml het dossier:

 com.h2database h2 1.4.200 

Op deze manier hoeven we de databron bean, maar we kunnen dit doen als we het willen aanpassen.

Als we JPA willen gebruiken met MySQL database, dan hebben we de mysql-connector-java afhankelijkheid, evenals om de Databron configuratie.

We kunnen dit doen in een @Configuratie class, of door standaard Spring Boot-eigenschappen te gebruiken.

De Java-configuratie ziet er hetzelfde uit als in een standaard Spring-project:

@Bean openbare DataSource dataSource () {DriverManagerDataSource dataSource = nieuwe DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUsername ("mysqluser"); dataSource.setPassword ("mysqlpass"); dataSource.setUrl ("jdbc: mysql: // localhost: 3306 / myDb? createDatabaseIfNotExist = true"); retourneer dataSource; }

Om de gegevensbron te configureren met behulp van een eigenschappenbestand, moeten we eigenschappen instellen met het voorvoegsel 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 configureert automatisch een gegevensbron op basis van deze eigenschappen.

Ook in Spring Boot 1 was de standaard verbindingspool Kater, maar met Spring Boot 2 is het veranderd in HikariCP.

U kunt meer voorbeelden vinden van het configureren van JPA in Spring Boot in het GitHub-project.

Zoals we kunnen zien, is de basis JPA-configuratie vrij eenvoudig als we Spring Boot gebruiken.

Echter, als we een standaard Spring-project hebben, hebben we een meer expliciete configuratie nodig, met behulp van Java of XML. Dat is waar we ons in de volgende secties op zullen concentreren.

3. De JPA Spring-configuratie met Java - in een niet-opstartproject

Om JPA te gebruiken in een Spring-project, we moeten het EntityManager.

Dit is het belangrijkste onderdeel van de configuratie en we kunnen het doen via een Spring-fabrieksboon. Dit kan een van beide eenvoudiger zijn LocalEntityManagerFactoryBean of hoe flexibeler LocalContainerEntityManagerFactoryBean.

Laten we eens kijken hoe we de laatste optie kunnen gebruiken:

@Configuration @EnableTransactionManagement openbare klasse PersistenceJPAConfig {@Bean openbaar LocalContainerEntityManagerFactoryBean entityManagerFactory () {LocalContainerEntityManagerFactoryBean em = nieuwe LocalContainerEntityManagerFactoryBean (); em.setDataSource (dataSource ()); em.setPackagesToScan (nieuwe String [] {"com.baeldung.persistence.model"}); JpaVendorAdapter vendorAdapter = nieuwe HibernateJpaVendorAdapter (); em.setJpaVendorAdapter (vendorAdapter); em.setJpaProperties (additionalProperties ()); terug em; } // ...}

We moeten ook de Databron Boon we hebben hierboven gebruikt:

@Bean openbare DataSource dataSource () {DriverManagerDataSource dataSource = nieuwe DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUrl ("jdbc: mysql: // localhost: 3306 / spring_jpa"); dataSource.setUsername ("tutorialuser"); dataSource.setPassword ("tutorialmy5ql"); retourneer dataSource; }

Het laatste deel van de configuratie zijn de aanvullende Hibernate-eigenschappen en de TransactionManager en exceptionTranslation bonen:

@Bean openbaar PlatformTransactionManager transactionManager () {JpaTransactionManager transactionManager = nieuwe JpaTransactionManager (); transactionManager.setEntityManagerFactory (entityManagerFactory (). getObject ()); return transactionManager; } @Bean openbare PersistenceExceptionTranslationPostProcessor exceptionTranslation () {retourneer nieuwe PersistenceExceptionTranslationPostProcessor (); } Eigenschappen additioneleProperties () {Eigenschappen eigenschappen = nieuwe Eigenschappen (); properties.setProperty ("hibernate.hbm2ddl.auto", "create-drop"); properties.setProperty ("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect"); eigenschappen teruggeven; }

4. De JPA Spring-configuratie met XML

Laten we vervolgens dezelfde Spring-configuratie met XML bekijken:

        create-drop org.hibernate.dialect.MySQL5Dialect 

Er is een relatief klein verschil tussen de XML en de nieuwe op Java gebaseerde configuratie. In XML kan een verwijzing naar een andere boon namelijk verwijzen naar de boon of een bonenfabriek voor die boon.

In Java echter, aangezien de typen verschillend zijn, staat de compiler dit niet toe, en dus de EntityManagerFactory wordt eerst opgehaald uit de bonenfabriek en vervolgens doorgegeven aan de transactiemanager:

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

5. Volledig XML-loos gaan

Gewoonlijk definieert JPA een persistentie-eenheid via de META-INF / persistence.xml het dossier. Beginnend met Spring 3.1, de persistence.xml is niet langer nodig. De LocalContainerEntityManagerFactoryBean ondersteunt nu een packagesToScan eigenschap waar de pakketten naar moeten worden gescand @Entiteit klassen kunnen worden gespecificeerd.

Dit bestand was het laatste stukje XML dat we moesten verwijderen. We kunnen JPA nu volledig opzetten zonder XML.

Meestal specificeren we JPA-eigenschappen in het persistence.xml het dossier. Als alternatief kunnen we de eigenschappen rechtstreeks toevoegen aan de fabrieksboon van de entiteitsbeheerder:

factoryBean.setJpaProperties (this.additionalProperties ());

Als een kanttekening: als Hibernate de persistentieprovider zou zijn, dan zou dit ook de manier zijn om Hibernate-specifieke eigenschappen op te geven.

6. De Maven-configuratie

Naast de Spring Core- en persistentie-afhankelijkheden - in detail weergegeven in de Spring met Maven-tutorial - moeten we ook JPA en Hibernate in het project definiëren, evenals een MySQL-connector:

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

Merk op dat de MySQL-afhankelijkheid hier als voorbeeld is opgenomen. We hebben een stuurprogramma nodig om de gegevensbron te configureren, maar elke door Hibernate ondersteunde database zal het doen.

7. Conclusie

Deze tutorial illustreert hoe je moet configureren JPA met winterslaap in het voorjaar in zowel een Spring Boot als een standaard Spring-applicatie.

Zoals altijd is de code die in dit artikel wordt gepresenteerd, beschikbaar op GitHub.