Vårdataanmerkninger

Denne artikkelen er en del av en serie: • Spring Core Annotations

• Nettnotater om våren

• Kommentarer om vårstøvler

• Kommentarer om vårplanlegging

• Merknader om vårdata (nåværende artikkel) • Merknader om vårbønner

1. Introduksjon

Spring Data gir en abstraksjon over datalagringsteknologier. Derfor kan vår forretningslogikkode være mye mer uavhengig av den underliggende implementeringen av utholdenhet. Dessuten forenkler Spring håndteringen av implementeringsavhengige detaljer om datalagring.

I denne opplæringen ser vi de vanligste kommentarene til Spring Data, Spring Data JPA og Spring Data MongoDB-prosjekter.

2. Vanlige vårdatamerknader

2.1. @Transaksjonell

Når vi vil konfigurere transaksjonsadferden til en metode, vi kan gjøre det med:

@Transaksjonell ugyldig betaling () {}

Hvis vi bruker denne merknaden på klassenivå, så fungerer den på alle metodene i klassen. Vi kan imidlertid overstyre effekten ved å bruke den på en bestemt metode.

Den har mange konfigurasjonsalternativer, som du finner i denne artikkelen.

2.2. @NoRepositoryBean

Noen ganger ønsker vi å lage repositorgrensesnitt med det eneste målet å tilby vanlige metoder for barneoppbevaringsstedene.

Selvfølgelig vil vi ikke at våren skal lage en bønne av disse depotene, siden vi ikke vil injisere dem hvor som helst. @NoRepositoryBean gjør akkurat dette: når vi markerer et barnegrensesnitt for org.springframework.data.repository.Repository, Våren vil ikke lage en bønne av den.

For eksempel hvis vi vil ha en Valgfritt findById (ID-id) metode i alle våre arkiver, kan vi opprette et basislager:

@NoRepositoryBean-grensesnitt MyUtilityRepository utvider CrudRepository {Valgfritt findById (ID id); }

Denne kommentaren påvirker ikke barnegrensesnittene. derav vil Spring lage en bønne for følgende lagringsgrensesnitt:

@Repository-grensesnitt PersonRepository utvider MyUtilityRepository {}

Merk at eksemplet ovenfor ikke er nødvendig siden Spring Data versjon 2 som inkluderer denne metoden som erstatter den eldre T findOne (ID id).

2.3. @Param

Vi kan sende navngitte parametere til spørsmålene våre ved hjelp av @Param:

@Query ("FRA Person p WHERE p.name =: name") Person findByName (@Param ("name") Strengnavn);

Merk at vi refererer til parameteren med :Navn syntaks.

For flere eksempler, besøk denne artikkelen.

2.4. @Id

@Id markerer et felt i en modellklasse som primærnøkkel:

klasse Person {@Id Long id; // ...}

Siden det er implementeringsuavhengig, gjør det en modellklasse enkel å bruke med flere datalagermotorer.

2.5. @Flyktig

Vi kan bruke denne merknaden til å markere et felt i en modellklasse som forbigående. Derfor vil ikke datalagermotoren lese eller skrive dette feltets verdi:

klasse Person {// ... @Transient int age; // ...}

Som @Id, @Flyktig er også implementasjonsuavhengig, noe som gjør det praktisk å bruke med flere implementeringer av datalager.

2.6. @Laget av, @LastModifiedBy, @Opprettet dato, @LastModifiedDate

Med disse kommentarene kan vi revidere modellklassene våre: Spring fyller automatisk ut de merkede feltene med rektor som opprettet objektet, sist endret det, dato for opprettelse og siste endring:

offentlig klasse Person {// ... @CreatedBy User creator; @LastModifiedBy User modifier; @CreatedDate Dato opprettetAt; @LastModifiedDate Dato endretAt; // ...}

Merk at hvis vi vil at Spring skal fylle rektorene, må vi også bruke Spring Security.

For en mer grundig beskrivelse, besøk denne artikkelen.

3. Vårdata JPA-merknader

3.1. @Spørsmål

Med @Spørsmål, kan vi tilby en JPQL-implementering for en depotmetode:

@Query ("VELG TELL (*) FRA Person p") lang getPersonCount ();

Vi kan også bruke navngitte parametere:

@Query ("FRA Person p WHERE p.name =: name") Person findByName (@Param ("name") Strengnavn);

Dessuten kan vi bruke innfødte SQL-spørsmål, hvis vi stiller inn nativeQuery argument til ekte:

@Query (value = "SELECT AVG (s.age) FRA person p", nativeQuery = true) int getAverageAge ();

For mer informasjon, besøk denne artikkelen.

3.2. @Fremgangsmåte

Med Spring Data JPA kan vi enkelt ringe lagrede prosedyrer fra arkiver.

Først må vi erklære depotet for enhetsklassen ved hjelp av standard JPA-merknader:

@NamedStoredProcedureQueries ({@NamedStoredProcedureQuery (name = "count_by_name", procedureName = "person.count_by_name", parameters = {@StoredProcedureParameter (mode = ParameterMode.IN, name = "name", type = String.class), @StoredPeter = ParameterMode.OUT, name = "count", type = Long.class)})}) class Person {}

Etter dette kan vi referere til det i depotet med navnet vi erklærte i Navn argument:

@Procedure (name = "count_by_name") long getCountByName (@Param ("name") Strengnavn);

3.3. @Låse

Vi kan konfigurere låsemodus når vi utfører en spørringsmetode for depot:

@Lock (LockModeType.NONE) @Query ("VELG TELL (*) FRA Person p") lang getPersonCount ();

De tilgjengelige låsemodusene:

LESE
SKRIVE
OPTIMISTISK
OPTIMISTIC_FORCE_INCREMENT
PESSIMISTIC_READ
PESSIMISTIC_WRITE
PESSIMISTIC_FORCE_INCREMENT
INGEN

3.4. @Modifying

Vi kan endre data med en depotmetode hvis vi kommenterer dem med @Modifying:

@Modifying @Query ("UPDATE Person p SET p.name =: name WHERE p.id =: id") void changeName (@Param ("id") long id, @Param ("name") Strengnavn);

For mer informasjon, besøk denne artikkelen.

3.5. @EnableJpaRepositories

For å bruke JPA-arkiver må vi indikere det til våren. Vi kan gjøre dette med @EnableJpaRepositories.

Merk at vi må bruke denne merknaden med @Konfigurasjon:

@Configuration @EnableJpaRepositories klasse PersistenceJPAConfig {}

Våren vil se etter arkiver i underpakningene til dette @Konfigurasjon klasse.

Vi kan endre denne oppførselen med basePackages argument:

@Configuration @EnableJpaRepositories (basePackages = "com.baeldung.persistence.dao") klasse PersistenceJPAConfig {}

Vær også oppmerksom på at Spring Boot gjør dette automatisk hvis den finner Spring Data JPA på klassestien.

4. Vårdata Mongo-merknader

Spring Data gjør arbeidet med MongoDB mye enklere. I de neste avsnittene vil vi utforske de mest grunnleggende funksjonene i Spring Data MongoDB.

For mer informasjon, besøk vår artikkel om Spring Data MongoDB.

4.1. @Dokument

Denne merknaden markerer en klasse som et domeneobjekt som vi vil vedvare til databasen:

Bruker av @Document-klasse {}

Det lar oss også velge navnet på samlingen vi vil bruke:

@Document (collection = "user") klasse bruker {}

Merk at denne kommentaren er Mongo-ekvivalent med @Enhet i JPA.

4.2. @Felt

Med @Felt, kan vi konfigurere navnet på et felt vi vil bruke når MongoDB fortsetter dokumentet:

@Document class User {// ... @Field ("email") String emailAddress; // ...}

Merk at denne kommentaren tilsvarer Mongo @Kolonne i JPA.

4.3. @Spørsmål

Med @Spørsmål, kan vi gi et søk på en MongoDB-depotmetode:

@Query ("{'name':? 0}") Liste findUsersByName (strengnavn);

4.4. @EnableMongoRepositories

For å bruke MongoDB-arkiver må vi indikere det til våren. Vi kan gjøre dette med @EnableMongoRepositories.

Merk at vi må bruke denne merknaden med @Konfigurasjon:

@Configuration @EnableMongoRepositories klasse MongoConfig {}

Våren vil se etter arkiver i underpakningene til dette @Konfigurasjon klasse. Vi kan endre denne oppførselen med basePackages argument:

@Configuration @EnableMongoRepositories (basePackages = "com.baeldung.repository") klasse MongoConfig {}

Vær også oppmerksom på at Spring Boot gjør dette automatisk hvis den finner Spring Data MongoDB på klassestien.

5. Konklusjon

I denne artikkelen så vi hvilke som er de viktigste merknadene vi trenger for å håndtere data generelt ved hjelp av Spring. I tillegg så vi på de vanligste JPA- og MongoDB-merknadene.

Som vanlig er eksempler tilgjengelig på GitHub her for vanlige og JPA-merknader, og her for MongoDB-merknader.

Neste » Merknader om vårbønner « Forrige vårplanleggingskommentarer

streamalism.org