Spring Data-annotaties

Dit artikel maakt deel uit van een reeks: • Spring Core Annotations

• Spring Web-annotaties

• Spring Boot-annotaties

• Annotaties voor voorjaarsplanning

• Annotaties met lentegegevens (huidig ​​artikel) • Annotaties van lentebonen

1. Inleiding

Spring Data biedt een abstractie van technologieën voor gegevensopslag. Daarom kan onze bedrijfslogica veel onafhankelijker zijn van de onderliggende persistentie-implementatie. Spring vereenvoudigt ook de afhandeling van implementatie-afhankelijke details van gegevensopslag.

In deze zelfstudie zien we de meest voorkomende annotaties van de Spring Data-, Spring Data JPA- en Spring Data MongoDB-projecten.

2. Algemene annotaties met Spring Data

2.1. @Transactional

Als we dat willen configureer het transactiegedrag van een methode, we kunnen het doen met:

@Transactional ongeldig betalen () {}

Als we deze annotatie op klasniveau toepassen, werkt het op alle methoden binnen de klas. We kunnen de effecten ervan echter opheffen door het op een specifieke methode toe te passen.

Het heeft veel configuratie-opties, die u in dit artikel kunt vinden.

2.2. @NoRepositoryBean

Soms willen we repository-interfaces maken met het enige doel om gemeenschappelijke methoden voor de onderliggende repositories te bieden.

We willen natuurlijk niet dat Spring een boon van deze repositories maakt, omdat we ze nergens zullen injecteren. @NoRepositoryBean doet precies dit: wanneer we een onderliggende interface van org.springframework.data.repository.Repository, De lente zal er geen boon van maken.

Als we bijvoorbeeld een Optioneel findById (ID id) methode in al onze repositories, kunnen we een basisrepository maken:

@NoRepositoryBean-interface MyUtilityRepository breidt CrudRepository uit {Optioneel findById (ID id); }

Deze annotatie heeft geen invloed op de onderliggende interfaces; Daarom zal Spring een bean maken voor de volgende repository-interface:

@Repository-interface PersonRepository breidt MyUtilityRepository uit {}

Merk op dat het bovenstaande voorbeeld niet nodig is sinds Spring Data versie 2, die deze methode bevat ter vervanging van de oudere T findOne (ID id).

2.3. @Param

We kunnen benoemde parameters doorgeven aan onze query's met @Param:

@Query ("VAN Persoon p WAAR p.name =: naam") Persoon findByName (@Param ("naam") Stringnaam);

Merk op dat we naar de parameter verwijzen met de :naam syntaxis.

Bezoek dit artikel voor meer voorbeelden.

2.4. @ID kaart

@ID kaart markeert een veld in een modelklasse als de primaire sleutel:

klasse Persoon {@Id Lange id; // ...}

Omdat het implementatie-onafhankelijk is, maakt het een modelklasse gemakkelijk te gebruiken met meerdere datastore-engines.

2.5. @Transient

We kunnen deze annotatie gebruiken om een ​​veld in een modelklasse als tijdelijk te markeren. Daarom zal de data store-engine de waarde van dit veld niet lezen of schrijven:

klasse Persoon {// ... @Transient int leeftijd; // ...}

Leuk vinden @ID kaart, @Transient is ook implementatie-onafhankelijk, wat het gemakkelijk maakt om te gebruiken met meerdere datastore-implementaties.

2.6. @Gemaakt door, @BuienRadarNL, @CreatedDate, @LastModifiedDate

Met deze annotaties kunnen we onze modelklassen controleren: Spring vult automatisch de geannoteerde velden met de opdrachtgever die het object heeft gemaakt, het laatst heeft gewijzigd en de datum van creatie en laatste wijziging:

openbare klasse Persoon {// ... @CreatedBy Gebruiker creator; @LastModifiedBy User modifier; @CreatedDate Datum createdAt; @LastModifiedDate Datum gewijzigdAt; // ...}

Merk op dat als we willen dat Spring de principals bevolkt, we ook Spring Security moeten gebruiken.

Bezoek dit artikel voor een uitgebreidere beschrijving.

3. Spring Data JPA-annotaties

3.1. @Query

Met @Query, kunnen we een JPQL-implementatie bieden voor een repository-methode:

@Query ("SELECTEER AANTAL (*) VAN Persoon p") lang getPersonCount ();

We kunnen ook benoemde parameters gebruiken:

@Query ("VAN Persoon p WAAR p.name =: naam") Persoon findByName (@Param ("naam") Stringnaam);

Bovendien kunnen we native SQL-query's gebruiken als we de nativeQuery argument voor waar:

@Query (value = "SELECTEER AVG (p.age) VAN persoon p", nativeQuery = true) int getAverageAge ();

Bezoek dit artikel voor meer informatie.

3.2. @Procedure

Met Spring Data JPA kunnen we eenvoudig opgeslagen procedures oproepen vanuit repositories.

Eerst moeten we de repository op de entiteitsklasse declareren met behulp van standaard JPA-annotaties:

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

Hierna kunnen we ernaar verwijzen in de repository met de naam die we hebben gedeclareerd in het naam argument:

@Procedure (name = "count_by_name") lang getCountByName (@Param ("name") Stringnaam);

3.3. @Slot

We kunnen de vergrendelingsmodus configureren wanneer we een repository-querymethode uitvoeren:

@Lock (LockModeType.NONE) @Query ("SELECTEER AANTAL (*) VAN Persoon p") lang getPersonCount ();

De beschikbare vergrendelingsmodi:

  • LEZEN
  • SCHRIJVEN
  • OPTIMISTISCH
  • OPTIMISTIC_FORCE_INCREMENT
  • PESSIMISTIC_READ
  • PESSIMISTIC_WRITE
  • PESSIMISTIC_FORCE_INCREMENT
  • GEEN

3.4. @Wijzigen

We kunnen gegevens wijzigen met een repository-methode als we deze annoteren met @Wijzigen:

@Modifying @Query ("UPDATE Persoon p SET p.name =: naam WAAR p.id =: id") ongeldige changeName (@Param ("id") lange id, @Param ("naam") Stringnaam);

Bezoek dit artikel voor meer informatie.

3.5. @EnableJpaRepositories

Om JPA-repositories te gebruiken, moeten we dit aangeven bij Spring. We kunnen dit met @EnableJpaRepositories.

Merk op dat we deze annotatie moeten gebruiken met @Configuratie:

@Configuration @EnableJpaRepositories klasse PersistenceJPAConfig {}

Spring gaat op zoek naar repositories in de subpakketten hiervan @Configuratie klasse.

We kunnen dit gedrag veranderen met de basePackages argument:

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

Merk ook op dat Spring Boot dit automatisch doet als het Spring Data JPA op het klassenpad vindt.

4. Spring Data Mongo-annotaties

Spring Data maakt het werken met MongoDB veel gemakkelijker. In de volgende secties zullen we de meest basale functies van Spring Data MongoDB verkennen.

Ga voor meer informatie naar ons artikel over Spring Data MongoDB.

4.1. @Document

Deze annotatie markeert een klasse als een domeinobject dat we in de database willen behouden:

@Document class Gebruiker {}

Het stelt ons ook in staat om de naam te kiezen van de collectie die we willen gebruiken:

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

Merk op dat deze annotatie het Mongo-equivalent is van @Entiteit in JPA.

4.2. @Veld

Met @Veld, kunnen we de naam configureren van een veld dat we willen gebruiken wanneer MongoDB het document aanhoudt:

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

Merk op dat deze annotatie het Mongo-equivalent is van @Kolom in JPA.

4.3. @Query

Met @Querykunnen we een zoekvraag geven op een MongoDB-repository-methode:

@Query ("{'naam':? 0}") Lijst findUsersByName (tekenreeksnaam);

4.4. @EnableMongoRepositories

Om MongoDB-repositories te gebruiken, moeten we dit aangeven bij Spring. We kunnen dit met @EnableMongoRepositories.

Merk op dat we deze annotatie moeten gebruiken met @Configuratie:

@Configuration @EnableMongoRepositories klasse MongoConfig {}

Spring gaat op zoek naar repositories in de subpakketten hiervan @Configuratie klasse. We kunnen dit gedrag veranderen met de basePackages argument:

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

Merk ook op dat Spring Boot dit automatisch doet als het Spring Data MongoDB vindt op het klassenpad.

5. Conclusie

In dit artikel hebben we gezien wat de belangrijkste annotaties zijn die we nodig hebben om met Spring om te gaan met gegevens in het algemeen. Daarnaast hebben we gekeken naar de meest voorkomende JPA- en MongoDB-annotaties.

Zoals gewoonlijk zijn hier voorbeelden op GitHub beschikbaar voor algemene en JPA-annotaties, en hier voor MongoDB-annotaties.

De volgende » Spring Bean-annotaties « Eerdere annotaties voor voorjaarsplanning