Introduktion til Spring Data JPA

1. Oversigt

Denne artikel vil fokusere på introduktion af Spring Data JPA i et Spring-projekt og fuldstændig konfiguration af persistenslaget. 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.

2. Forårsdata genererede DAO - Ingen flere DAO-implementeringer

Som vi diskuterede i en tidligere artikel, består DAO-laget normalt af en masse kedelpladekode, der kan og bør forenkles. Fordelene ved en sådan forenkling er mange: et fald i antallet af artefakter, som vi har brug for at definere og vedligeholde, konsistensen af ​​dataadgangsmønstre og konsistensen af ​​konfigurationen.

Spring Data tager denne forenkling et skridt fremad og gør det muligt at fjerne DAO-implementeringerne fuldstændigt. Grænsefladen til DAO er nu den eneste artefakt, som vi skal definere eksplicit.

For at begynde at udnytte Spring Data-programmeringsmodellen med JPA, skal en DAO-grænseflade udvide den specifikke JPA Datalager grænseflade - JpaRepository. Dette gør det muligt for Spring Data at finde denne grænseflade og automatisk oprette en implementering for den.

Ved at udvide grænsefladen får vi de mest relevante CRUD-metoder til standard dataadgang tilgængelig i en standard DAO.

3. Brugerdefineret adgangsmetode og forespørgsler

Som diskuteret, ved at implementere en af Datalager grænseflader, vil DAO allerede have nogle grundlæggende CRUD-metoder (og forespørgsler) defineret og implementeret.

For at definere mere specifikke adgangsmetoder understøtter Spring JPA en hel del muligheder:

  • ganske enkelt definere en ny metode i grænsefladen
  • give den faktiske JPQL-forespørgsel ved hjælp af @Forespørgsel kommentar
  • brug de mere avancerede Specifikation og Querydsl support i Spring Data
  • Definere brugerdefinerede forespørgsler via JPA Navngivne Forespørgsler

Den tredje mulighed - Specifikationer og Querydsl-understøttelse - svarer til JPA-kriterier, men bruger en mere fleksibel og praktisk API. Dette gør hele operationen meget mere læsbar og genanvendelig. Fordelene ved denne API vil blive mere udtalt, når vi beskæftiger os med et stort antal faste forespørgsler, da vi potentielt kan udtrykke disse mere kortfattet gennem et mindre antal genanvendelige blokke.

Denne sidste mulighed har den ulempe, at den enten involverer XML eller belaster domæneklassen med forespørgslerne.

3.1. Automatiske brugerdefinerede forespørgsler

Når Spring Data opretter et nyt Datalager implementering analyserer den alle de metoder, der er defineret af grænsefladerne, og prøver at genererer automatisk forespørgsler fra metodens navne. Selvom dette har nogle begrænsninger, er det en meget kraftfuld og elegant måde at definere nye brugerdefinerede adgangsmetoder på med meget lidt indsats.

Lad os se på et eksempel: hvis enheden har en navn felt (og Java Bean-standarden getName og sætnavn metoder), vi definerer findByName metode i DAO-grænsefladen; dette genererer automatisk den korrekte forespørgsel:

offentlig grænseflade IFooDAO udvider JpaRepository {Foo findByName (strengnavn); }

Dette er et relativt simpelt eksempel. Mekanismen til oprettelse af forespørgsler understøtter et meget større sæt nøgleord.

Hvis parseren ikke kan matche ejendommen med domæneobjektfeltet, ser vi følgende undtagelse:

java.lang.IllegalArgumentException: Ingen egenskabsnavn fundet til type klasse com.baeldung.spring.data.persistence.model.Foo

3.2. Manuel brugerdefinerede forespørgsler

Lad os nu se på en brugerdefineret forespørgsel, som vi definerer via @Forespørgsel kommentar:

@Query ("VÆLG f FRA Foo F WHERE LOWER (f.name) = LOWER (: name)") Foo retrieveByName (@Param ("name") String name);

For endnu mere detaljeret kontrol over oprettelse af forespørgsler, f.eks. Ved hjælp af navngivne parametre eller ændring af eksisterende forespørgsler, er referencen et godt sted at starte.

4. Transaktionskonfiguration

Den faktiske implementering af den forårsledede DAO er faktisk skjult, da vi ikke arbejder direkte med den. Dette er dog en enkel nok implementering - det SimpleJpaRepository - som definerer transaktionssemantik ved hjælp af annoteringer.

Mere eksplicit bruger dette en skrivebeskyttet @Transaktionel kommentar på klasseniveau, som derefter tilsidesættes for de ikke-skrivebeskyttede metoder. Resten af ​​transaktionssemantikken er standard, men disse kan let tilsidesættes manuelt pr. Metode.

4.1. Undtagelsesoversættelse er levende og godt

Spørgsmålet er nu - da Spring Data JPA ikke afhænger af de gamle ORM-skabeloner (JpaTemplate, Dvaletilstand) og de er blevet fjernet siden forår 5 - vil vi stadig få vores JPA-undtagelser oversat til forårets DataAccessException hierarki?

Selvfølgelig er vi - undtagelse oversættelse er stadig aktiveret af brugen af @Repository kommentar om DAO. Denne kommentar gør det muligt for en postbearbejdning af Spring Bean at rådgive alle @Repository bønner med alle PersistenceExceptionTranslator forekomster, der findes i containeren, og giver undtagelsesoversættelse ligesom før.

Lad os kontrollere undtagelsesoversættelse med en integrationstest:

@Test (forventet = DataIntegrityViolationException.class) offentlig ugyldighed givenFooHasNoName_whenInvalidEntityIsCreated_thenDataException () {service.create (ny Foo ()); }

Husk det undtagelse oversættelse sker gennem fuldmagter. For at Spring skal kunne oprette fuldmagter omkring DAO-klasser, skal disse ikke erklæres endelig.

5. Spring Data JPA Repository Configuration

For at aktivere Spring JPA repository support kan vi bruge @EnableJpaRepositories kommentar og angiv pakken, der indeholder DAO-grænsefladerne:

@EnableJpaRepositories (basePackages = "com.baeldung.spring.data.persistence.repository") offentlig klasse PersistenceConfig {...}

Vi kan gøre det samme med en XML-konfiguration:

6. Java- eller XML-konfiguration

Vi har allerede diskuteret i detaljer, hvordan man konfigurerer JPA om foråret i en tidligere artikel. Spring Data drager også fordel af Spring's support til JPA @PersistenceContext kommentar. Det bruger dette til at binde kablet EntityManager ind i forårets fabriksbønne, der er ansvarlig for at skabe de faktiske DAO-implementeringer - JpaRepositoryFactoryBean.

Ud over den allerede diskuterede konfiguration skal vi også medtage Spring Data XML Config - hvis vi bruger XML:

@Configuration @EnableTransactionManagement @ImportResource ("classpath *: * springDataConfig.xml") offentlig klasse PersistenceJPAConfig {...}

7. Maven afhængighed

Ud over Maven-konfigurationen til JPA, som i en tidligere artikel, tilføjer vi spring-data-jpa afhængighed:

 org.springframework.data spring-data-jpa 2.2.7.RELEASE 

8. Brug af Spring Boot

Vi kan også bruge Spring Boot Starter Data JPA-afhængighed, der automatisk konfigurerer Datakilde for os.

Vi skal også sørge for, at den database, vi vil bruge, er til stede i klassestien. I vores eksempel har vi tilføjet H2-hukommelsesdatabasen:

 org.springframework.boot spring-boot-starter-data-jpa 2.2.6.RELEASE com.h2database h2 1.4.200 

Som et resultat, bare ved at gøre disse afhængigheder, er vores applikation kørende, og vi kan bruge den til andre databasefunktioner.

Den eksplicitte konfiguration for en standard Spring-applikation er nu inkluderet som en del af Spring Boot-automatisk konfiguration.

Vi kan selvfølgelig ændre den automatiske konfiguration ved at tilføje vores tilpassede eksplicitte konfiguration.

Spring Boot giver en nem måde at gøre dette ved hjælp af egenskaber i application.properties fil:

spring.datasource.url = jdbc: h2: mem: db; DB_CLOSE_DELAY = -1 spring.datasource.username = sa spring.datasource.password = sa

I dette eksempel har vi ændret forbindelses-URL og legitimationsoplysninger.

9. Konklusion

Denne artikel dækkede konfigurationen og implementeringen af ​​persistenslaget med Spring 5, JPA 2 og Spring Data JPA (en del af Spring Data-paraplyprojektet) ved hjælp af både XML- og Java-baseret konfiguration.

Vi diskuterede måder at definere mere på avancerede brugerdefinerede forespørgsler, såvel som transaktionel semantikog en konfiguration med det nye jpa navneområde. Det endelige resultat er en ny og elegant tilgang til dataadgang med Spring med næsten intet faktisk implementeringsarbejde.

Implementeringen af ​​denne Spring Data JPA Tutorial kan findes i GitHub-projektet.