En guide til JPA med forår

1. Oversigt

Denne vejledning viser, hvordan du opretter Spring med JPA, ved at bruge dvale som en persistensudbyder.

For en trinvis introduktion til opsætning af Spring-kontekst ved hjælp af Java-baseret konfiguration og den grundlæggende Maven pom til projektet, se denne artikel.

Vi starter med at oprette JPA i et Spring Boot-projekt, så ser vi på den fulde konfiguration, vi har brug for, hvis vi har et standard Spring-projekt.

Her er en video om opsætning af Hibernate 4 med Spring 4 (jeg anbefaler at se den i fuld 1080p):

2. JPA i Spring Boot

Spring Boot-projektet er beregnet til at gøre oprettelsen af ​​Spring-applikationer meget hurtigere og lettere. Dette gøres ved hjælp af startere og automatisk konfiguration til forskellige Spring-funktioner, JPA blandt dem.

2.1. Maven afhængigheder

For at aktivere JPA i en Spring Boot-applikation har vi brug for spring-boot-starter og spring-boot-starter-data-jpa afhængigheder:

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

Det spring-boot-starter indeholder den nødvendige auto-konfiguration til Spring JPA. Også den spring-boot-starter-jpa projekt refererer til alle de nødvendige afhængigheder som f.eks dvale-kerne.

2.2. Konfiguration

Spring Boot konfigurerer Dvale som standard JPA-udbyder, så det er ikke længere nødvendigt at definere entityManagerFactory bønne, medmindre vi vil tilpasse den.

Spring Boot kan også automatisk konfigurere datakilde bønne afhængigt af den database, vi bruger. I tilfælde af en in-memory database af typen H2, HSQLDB, og Apache Derby, Boot konfigurerer automatisk Datakilde hvis den tilsvarende databaseafhængighed er til stede på klassestien.

For eksempel hvis vi vil bruge en hukommelse H2 database i et Spring Boot JPA-program, behøver vi kun tilføje h2 afhængighed af pom.xml fil:

 com.h2database h2 1.4.200 

På denne måde behøver vi ikke definere datakilde bønne, men vi kan gøre det, hvis vi vil tilpasse det.

Hvis vi vil bruge JPA med MySQL database, så har vi brug for mysql-connector-java afhængighed samt at definere Datakilde konfiguration.

Vi kan gøre dette i en @Konfiguration klasse eller ved hjælp af standard Spring Boot egenskaber.

Java-konfigurationen ser ud som i et standard Spring-projekt:

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

For at konfigurere datakilden ved hjælp af en egenskabsfil skal vi indstille egenskaber forud for 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 = sand

Spring Boot konfigurerer automatisk en datakilde baseret på disse egenskaber.

Også i Spring Boot 1 var standardforbindelsespuljen Tomcat, men med Spring Boot 2 er det blevet ændret til HikariCP.

Du kan finde flere eksempler på konfiguration af JPA i Spring Boot i GitHub-projektet.

Som vi kan se, er den grundlæggende JPA-konfiguration ret enkel, hvis vi bruger Spring Boot.

Imidlertid, hvis vi har et standard Spring-projekt, så har vi brug for mere eksplicit konfiguration ved hjælp af enten Java eller XML. Det er det, vi vil fokusere på i de næste sektioner.

3. JPA-fjederkonfigurationen med Java - i et ikke-boot-projekt

For at bruge JPA i et forårsprojekt, vi er nødt til at oprette EntityManager.

Dette er hoveddelen af ​​konfigurationen, og vi kan gøre det via en Spring-fabriksbønne. Dette kan enten være det enklere LocalEntityManagerFactoryBean eller jo mere fleksibel LocalContainerEntityManagerFactoryBean.

Lad os se, hvordan vi kan bruge sidstnævnte mulighed:

@Configuration @EnableTransactionManagement public class PersistenceJPAConfig {@Bean public LocalContainerEntityManagerFactoryBean entityManagerFactory () {LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean (); em.setDataSource (dataSource ()); em.setPackagesToScan (ny streng [] {"com.baeldung.persistence.model"}); JpaVendorAdapter vendorAdapter = ny dvaleJpaVendorAdapter (); em.setJpaVendorAdapter (vendorAdapter); em.setJpaProperties (additionalProperties ()); returner dem; } // ...}

Vi skal også udtrykkeligt definere Datakilde bønne vi har brugt ovenfor:

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

Den sidste del af konfigurationen er de ekstra dvaleegenskaber og TransactionManager og undtagelse Oversættelse bønner:

@Bean offentlig PlatformTransactionManager transactionManager () {JpaTransactionManager transactionManager = ny JpaTransactionManager (); transactionManager.setEntityManagerFactory (entityManagerFactory (). getObject ()); returtransaktionManager; } @Bean public PersistenceExceptionTranslationPostProcessor exceptionTranslation () {returner ny PersistenceExceptionTranslationPostProcessor (); } Egenskaber additionalProperties () {Properties egenskaber = nye egenskaber (); egenskaber.setProperty ("hibernate.hbm2ddl.auto", "create-drop"); egenskaber.setProperty ("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect"); returegenskaber; }

4. JPA-fjederkonfiguration med XML

Lad os derefter se den samme forårskonfiguration med XML:

        Opret-slip org.hibernate.dialect.MySQL5Dialect 

Der er en relativt lille forskel mellem XML og den nye Java-baserede konfiguration. Navnlig i XML kan en henvisning til en anden bønne pege på enten bønnen eller en bønnefabrik for den bønne.

Da Java imidlertid er forskellige i Java, tillader compileren det ikke i Java, og så EntityManagerFactory hentes først fra sin bønnefabrik og sendes derefter til transaktionschefen:

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

5. Går fuld XML-mindre

Normalt definerer JPA en persistens enhed gennem META-INF / persistence.xml fil. Startende med forår 3.1, den persistence.xml er ikke længere nødvendigt. Det LocalContainerEntityManagerFactoryBean understøtter nu en PackagesToScan ejendom, hvor pakkerne skal scannes efter @Enhed klasser kan specificeres.

Denne fil var det sidste stykke XML, vi skal fjerne. Vi kan nu konfigurere JPA fuldt ud uden XML.

Vi specificerer normalt JPA-egenskaber i persistence.xml fil. Alternativt kan vi tilføje egenskaberne direkte til enhedens manager fabriksbønne:

factoryBean.setJpaProperties (this.additionalProperties ());

Som en sidebemærkning, hvis dvaletilstand ville være udholdenhedsudbyderen, ville dette også være måden at specificere dvaletilstandsspecifikke egenskaber.

6. Maven-konfigurationen

Ud over Spring Core og persistensafhængigheder - vist detaljeret i Spring with Maven-tutorial - er vi også nødt til at definere JPA og Dvaletilstand i projektet samt et MySQL-stik:

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

Bemærk, at MySQL-afhængighed er inkluderet her som et eksempel. Vi har brug for en driver til at konfigurere datakilden, men enhver dvale-understøttet database gør det.

7. Konklusion

Denne vejledning illustrerede, hvordan man konfigurerer JPA med dvale om foråret i både en Spring Boot og en standard Spring-applikation.

Som altid er koden præsenteret i denne artikel tilgængelig på GitHub.