streamalism.org

1. Oversikt

Denne opplæringen viser hvordan du setter opp våren med JPA, bruker dvalemodus som en utholdenhetsleverandør.

For en trinnvis introduksjon om å sette opp vårkonteksten ved hjelp av Java-basert konfigurasjon og den grunnleggende Maven pom for prosjektet, se denne artikkelen.

Vi starter med å sette opp JPA i et Spring Boot-prosjekt, så ser vi på den fullstendige konfigurasjonen vi trenger hvis vi har et standard Spring-prosjekt.

Her er en video om hvordan du setter opp Hibernate 4 med Spring 4 (jeg anbefaler å se den i full 1080p):

2. JPA i Spring Boot

Spring Boot-prosjektet er ment å gjøre det enklere å lage vårapplikasjoner. Dette gjøres med bruk av forretter og automatisk konfigurasjon for forskjellige vårfunksjoner, blant annet JPA.

2.1. Maven avhengigheter

For å aktivere JPA i en Spring Boot-applikasjon trenger vi spring-boot-starter og spring-boot-starter-data-jpa avhengigheter:

 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 inneholder den nødvendige autokonfigurasjonen for Spring JPA. Også, den spring-boot-starter-jpa prosjekt refererer til alle nødvendige avhengigheter som dvale-kjerne.

2.2. Konfigurasjon

Spring Boot konfigureres Dvalemodus som standard JPA-leverandør, så det er ikke lenger nødvendig å definere entityManagerFactory bønne med mindre vi vil tilpasse den.

Spring Boot kan også konfigurere datakilde avhengig av hvilken database vi bruker. I tilfelle en minnedatabase av typen H2, HSQLDB, og Apache Derby, Boot konfigurerer automatisk Datakilde hvis den tilsvarende databaseavhengigheten er tilstede på klassestien.

For eksempel hvis vi vil bruke et minne H2 i en Spring Boot JPA-applikasjon, trenger vi bare å legge til h2 avhengighet av pom.xml fil:

 com.h2database h2 1.4.200 

På denne måten trenger vi ikke å definere datakilde bønne, men vi kan gjøre det hvis vi vil tilpasse den.

Hvis vi vil bruke JPA med MySQL database, så trenger vi mysql-connector-java avhengighet, samt å definere Datakilde konfigurasjon.

Vi kan gjøre dette i en @Konfigurasjon klasse, eller ved å bruke standard Spring Boot-egenskaper.

Java-konfigurasjonen ser ut som den gjør i et standard vårprosjekt:

@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"); returner datakilde; }

For å konfigurere datakilden ved hjelp av en egenskapsfil, må vi sette egenskaper foran våren.datakilde:

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 konfigurerer automatisk en datakilde basert på disse egenskapene.

Også i Spring Boot 1 var standard tilkoblingsbasseng Tomcat, men med Spring Boot 2 er den endret til HikariCP.

Du kan finne flere eksempler på konfigurering av JPA i Spring Boot i GitHub-prosjektet.

Som vi kan se, er den grunnleggende JPA-konfigurasjonen ganske enkel hvis vi bruker Spring Boot.

Derimot, Hvis vi har et standard vårprosjekt, trenger vi mer eksplisitt konfigurasjon ved hjelp av enten Java eller XML. Det er det vi vil fokusere på i de neste avsnittene.

3. JPA-vårkonfigurasjonen med Java - i et ikke-oppstartsprosjekt

For å bruke JPA i et vårprosjekt, vi trenger å sette opp EntityManager.

Dette er hoveddelen av konfigurasjonen, og vi kan gjøre det via en vårfabrikkbønne. Dette kan enten være det enklere LocalEntityManagerFactoryBean eller jo mer fleksibel LocalContainerEntityManagerFactoryBean.

La oss se hvordan vi kan bruke det siste alternativet:

@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 dvalemodusJpaVendorAdapter (); em.setJpaVendorAdapter (vendorAdapter); em.setJpaProperties (additionalProperties ()); returnere dem; } // ...}

Vi må også definere eksplisitt Datakilde bønne vi har brukt ovenfor:

@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"); returner datakilde; }

Den siste delen av konfigurasjonen er de ekstra dvalemodusegenskapene og TransactionManager og unntak Oversettelse bønner:

@Bean offentlig PlatformTransactionManager transactionManager () {JpaTransactionManager transactionManager = ny JpaTransactionManager (); transactionManager.setEntityManagerFactory (entityManagerFactory (). getObject ()); returtransaksjonManager; } @Bean public PersistenceExceptionTranslationPostProcessor exceptionTranslation () {return new PersistenceExceptionTranslationPostProcessor (); } Egenskaper additionalProperties () {Properties egenskaper = nye egenskaper (); properties.setProperty ("dvalemodus.hbm2ddl.auto", "create-drop"); properties.setProperty ("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect"); returegenskaper; }

4. JPA-fjærkonfigurasjonen med XML

La oss se den samme vårkonfigurasjonen med XML:

        create-drop org.hibernate.dialect.MySQL5Dialect 

Det er en relativt liten forskjell mellom XML og den nye Java-baserte konfigurasjonen. I XML kan en referanse til en annen bønne peke på enten bønnen eller en bønnefabrikk for den bønnen.

I Java, men siden typene er forskjellige, tillater ikke kompilatoren det, og så EntityManagerFactory blir først hentet fra bønnefabrikken og deretter overført til transaksjonssjefen:

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

5. Å gå full XML-fri

Vanligvis definerer JPA en utholdenhetsenhet gjennom META-INF / persistence.xml fil. Fra og med våren 3.1, den persistence.xml er ikke lenger nødvendig. De LocalContainerEntityManagerFactoryBean støtter nå en PackagesToScan eiendom der pakkene du skal skanne etter @Enhet klasser kan spesifiseres.

Denne filen var den siste delen av XML vi trenger å fjerne. Vi kan nå sette opp JPA helt uten XML.

Vi spesifiserer vanligvis JPA-egenskaper i persistence.xml fil. Alternativt kan vi legge til egenskapene direkte til enhetslederens fabrikkbønne:

factoryBean.setJpaProperties (this.additionalProperties ());

Som en sidemerknad, hvis dvalemodus vil være utholdenhetsleverandøren, vil dette også være måten å spesifisere dvalemodus-spesifikke egenskaper.

6. Maven-konfigurasjonen

I tillegg til Spring Core og utholdenhetsavhengighet - vis detaljert i våren med Maven-veiledningen - må vi også definere JPA og Hibernate i prosjektet, samt en MySQL-kontakt:

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

Merk at MySQL-avhengigheten er inkludert her som et eksempel. Vi trenger en driver for å konfigurere datakilden, men enhver database som støttes av dvalemodus, vil gjøre det.

7. Konklusjon

Denne opplæringen illustrerte hvordan du konfigurerer JPA med dvalemodus om våren i både en vårstøvel og en standard vårapplikasjon.

Som alltid er koden presentert i denne artikkelen tilgjengelig på GitHub.