Forårsdataanmærkninger

Denne artikel er en del af en serie: • Spring Core Annotations

• Annoncer om foråret på nettet

• Kommentarer om forårstøvler

• Kommentarer om forårets planlægning

• Spring Data Annotations (nuværende artikel) • Spring Bean Annotations

1. Introduktion

Spring Data giver en abstraktion over datalagringsteknologier. Derfor kan vores forretningslogikode være meget mere uafhængig af den underliggende implementering af persistens. Spring forenkler også håndteringen af implementeringsafhængige detaljer i datalagring.

I denne vejledning ser vi de mest almindelige annoteringer af Spring Data, Spring Data JPA og Spring Data MongoDB-projekter.

2. Almindelige forårsdata-anmærkninger

2.1. @Transaktionel

Når vi vil konfigurere en metodes transaktionsadfærd, vi kan gøre det med:

@Transaktionel ugyldig betaling () {}

Hvis vi anvender denne kommentar på klasseniveau, fungerer den på alle metoder inde i klassen. Vi kan dog tilsidesætte dens virkninger ved at anvende den på en bestemt metode.

Det har mange konfigurationsmuligheder, som kan findes i denne artikel.

2.2. @NoRepositoryBean

Nogle gange vil vi oprette repository-grænseflader med det eneste mål at levere almindelige metoder til underordnede arkiver.

Naturligvis ønsker vi ikke, at foråret opretter en bønne af disse arkiver, da vi ikke injicerer dem overalt. @NoRepositoryBean gør nøjagtigt dette: når vi markerer et underordnet interface af org.springframework.data.repository.Repository, Foråret skaber ikke en bønne ud af det.

For eksempel, hvis vi vil have en Valgfri findById (ID-id) metode i alle vores arkiver, kan vi oprette et basislager:

@NoRepositoryBean interface MyUtilityRepository udvider CrudRepository {Valgfri findById (ID id); }

Denne kommentar påvirker ikke barnets grænseflader; derfor opretter Spring en bønne til følgende lagringsgrænseflade:

@Repository-grænseflade PersonRepository udvider MyUtilityRepository {}

Bemærk, at eksemplet ovenfor ikke er nødvendigt, da Spring Data version 2, som inkluderer denne metode, der erstatter den ældre T findOne (ID id).

2.3. @Param

Vi kan videregive navngivne parametre til vores forespørgsler ved hjælp af @Param:

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

Bemærk, at vi henviser til parameteren med :navn syntaks.

For yderligere eksempler, se denne artikel.

2.4. @Id

@Id markerer et felt i en modelklasse som den primære nøgle:

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

Da det er implementeringsuafhængigt, gør det en modelklasse nem at bruge med flere datalagermotorer.

2.5. @Transient

Vi kan bruge denne kommentar til at markere et felt i en modelklasse som forbigående. Derfor vil datalagermotoren ikke læse eller skrive dette felts værdi:

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

Synes godt om @Id, @Transient er også implementeringsuafhængig, hvilket gør det praktisk at bruge med flere datalagerimplementeringer.

2.6. @Lavet af, @LastModifiedBy, @CreatedDate, @LastModifiedDate

Med disse bemærkninger kan vi revidere vores modelklasser: Spring udfylder automatisk de kommenterede felter med den hovedstol, der oprettede objektet, sidst ændrede det, oprettelsesdatoen og sidste ændring:

offentlig klasseperson {// ... @CreatedBy User creator; @LastModifiedBy brugermodifikator; @CreatedDate Dato oprettetAt; @LastModifiedDate Dato ændretAt; // ...}

Bemærk, at hvis vi ønsker, at Spring skal udfylde hovedpersonerne, skal vi også bruge Spring Security.

For en mere detaljeret beskrivelse, se denne artikel.

3. Forårsdata JPA-bemærkninger

3.1. @Forespørgsel

Med @Forespørgsel, kan vi levere en JPQL-implementering til en arkivmetode:

@Query ("SELECT COUNT (*) FRA Person p") lang getPersonCount ();

Vi kan også bruge navngivne parametre:

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

Desuden kan vi bruge native SQL-forespørgsler, hvis vi indstiller nativeQuery argument til rigtigt:

@Query (værdi = "VÆLG AVG (s.alder) FRA person p", nativeQuery = sand) int getAverageAge ();

For mere information, se venligst denne artikel.

3.2. @Procedure

Med Spring Data JPA kan vi nemt ringe til lagrede procedurer fra arkiver.

Først skal vi erklære lageret på enhedsklassen ved hjælp af standard JPA-kommentarer:

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

Herefter kan vi henvise til det i arkivet med det navn, vi erklærede i navn argument:

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

3.3. @Låse

Vi kan konfigurere låsemodus, når vi udfører en arkivforespørgselsmetode:

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

De tilgængelige låsemetoder:

LÆS
SKRIVE
OPTIMISTISK
OPTIMISTIC_FORCE_INCREMENT
PESSIMISTIC_READ
PESSIMISTIC_WRITE
PESSIMISTIC_FORCE_INCREMENT
INGEN

3.4. @Modifying

Vi kan ændre data med en arkivmetode, 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") String name);

For mere information, se venligst denne artikel.

3.5. @EnableJpaRepositories

For at bruge JPA-arkiver skal vi angive det for foråret. Vi kan gøre dette med @EnableJpaRepositories.

Bemærk, at vi skal bruge denne kommentar med @Konfiguration:

@Configuration @EnableJpaRepositories klasse PersistenceJPAConfig {}

Foråret vil kigge efter opbevaringssteder i underpakkerne til dette @Konfiguration klasse.

Vi kan ændre denne adfærd med basePackages argument:

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

Bemærk også, at Spring Boot gør dette automatisk, hvis det finder Spring Data JPA på klassestien.

4. Spring Data Mongo Annotations

Spring Data gør det meget lettere at arbejde med MongoDB. I de næste sektioner udforsker vi de mest grundlæggende funktioner i Spring Data MongoDB.

For mere information, besøg vores artikel om Spring Data MongoDB.

4.1. @Dokument

Denne kommentar markerer en klasse som et domæneobjekt, som vi vil fortsætte i databasen:

Bruger af @Document-klasse {}

Det giver os også mulighed for at vælge navnet på den samling, vi vil bruge:

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

Bemærk, at denne kommentar svarer til Mongo @Enhed i JPA.

4.2. @Mark

Med @Mark, kan vi konfigurere navnet på et felt, vi vil bruge, når MongoDB fortsætter dokumentet:

@Document klasse bruger {// ... @Field ("e-mail") String emailAddress; // ...}

Bemærk, at denne kommentar svarer til Mongo @Kolonne i JPA.

4.3. @Forespørgsel

Med @Forespørgsel, kan vi give en søgeforespørgsel om en MongoDB-arkivmetode:

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

4.4. @EnableMongoRepositories

For at bruge MongoDB-arkiver skal vi angive det for foråret. Vi kan gøre dette med @EnableMongoRepositories.

Bemærk, at vi skal bruge denne kommentar med @Konfiguration:

@Configuration @EnableMongoRepositories klasse MongoConfig {}

Foråret vil kigge efter opbevaringssteder i underpakkerne til dette @Konfiguration klasse. Vi kan ændre denne adfærd med basePackages argument:

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

Bemærk også, at Spring Boot gør dette automatisk, hvis det finder Spring Data MongoDB på klassestien.

5. Konklusion

I denne artikel så vi, hvilke er de vigtigste bemærkninger, vi har brug for for at behandle data generelt ved hjælp af Spring. Derudover undersøgte vi de mest almindelige JPA- og MongoDB-annoteringer.

Som sædvanligt er eksempler tilgængelige på GitHub her til almindelige og JPA-kommentarer, og her til MongoDB-kommentarer.

Næste » Spring Bean Annotations « Tidligere forårstidsplankommentarer

streamalism.org