Frühlingsdatenanmerkungen

Dieser Artikel ist Teil einer Reihe: • Spring Core Annotations

• Spring Web Annotations

• Spring Boot-Anmerkungen

• Anmerkungen zur Frühlingsplanung

• Spring Data Annotations (aktueller Artikel) • Spring Bean Annotations

1. Einleitung

Spring Data bietet eine Abstraktion über Datenspeichertechnologien. Daher kann unser Geschäftslogikcode viel unabhängiger von der zugrunde liegenden Persistenzimplementierung sein. Außerdem vereinfacht Spring die Handhabung implementierungsabhängiger Details der Datenspeicherung.

In diesem Lernprogramm werden die häufigsten Anmerkungen zu den Projekten Spring Data, Spring Data JPA und Spring Data MongoDB angezeigt.

2. Allgemeine Anmerkungen zu Federdaten

2.1. @Transactional

Wenn wir das Transaktionsverhalten einer Methode konfigurieren möchten , können wir dies tun mit:

@Transactional void pay() {}

Wenn wir diese Annotation auf Klassenebene anwenden, funktioniert sie für alle Methoden innerhalb der Klasse. Wir können die Auswirkungen jedoch überschreiben, indem wir sie auf eine bestimmte Methode anwenden.

Es gibt viele Konfigurationsoptionen, die in diesem Artikel zu finden sind.

2.2. @NoRepositoryBean

Manchmal möchten wir Repository-Schnittstellen mit dem einzigen Ziel erstellen, gemeinsame Methoden für die untergeordneten Repositorys bereitzustellen .

Natürlich möchten wir nicht, dass Spring eine Bean dieser Repositories erstellt, da wir sie nirgendwo injizieren. @NoRepositoryBean macht genau das: Wenn wir eine untergeordnete Schnittstelle von org.springframework.data.repository.Repository markieren , erstellt Spring keine Bean daraus.

Wenn wir beispielsweise eine optionale findById- Methode (ID id) in allen unseren Repositorys verwenden möchten , können wir ein Basis-Repository erstellen:

@NoRepositoryBean interface MyUtilityRepository extends CrudRepository { Optional findById(ID id); }

Diese Anmerkung wirkt sich nicht auf die untergeordneten Schnittstellen aus. Daher erstellt Spring eine Bean für die folgende Repository-Schnittstelle:

@Repository interface PersonRepository extends MyUtilityRepository {}

Beachten Sie, dass das obige Beispiel seit Spring Data Version 2 nicht erforderlich ist, in der diese Methode das ältere T findOne (ID-ID) ersetzt .

2.3. @Param

Wir können benannte Parameter mit @Param an unsere Abfragen übergeben :

@Query("FROM Person p WHERE p.name = :name") Person findByName(@Param("name") String name);

Beachten Sie, dass wir auf den Parameter mit der Syntax : name verweisen .

Weitere Beispiele finden Sie in diesem Artikel.

2.4. @Ich würde

@Id markiert ein Feld in einer Modellklasse als Primärschlüssel:

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

Da es implementierungsunabhängig ist, ist eine Modellklasse mit mehreren Datenspeicher-Engines einfach zu verwenden.

2.5. @Transient

Mit dieser Annotation können wir ein Feld in einer Modellklasse als vorübergehend markieren. Daher kann die Datenspeicher-Engine den Wert dieses Felds nicht lesen oder schreiben:

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

Wie @Id , @Transient ist auch die Umsetzung unabhängig, die es bequem macht mit mehreren Datenspeichern - Implementierungen zu verwenden.

2.6. @CreatedBy , @LastModifiedBy , @CreatedDate , @LastModifiedDate

Mit diesen Anmerkungen können wir unsere Modellklassen prüfen: Spring füllt die mit Anmerkungen versehenen Felder automatisch mit dem Prinzipal, der das Objekt erstellt, zuletzt geändert hat, sowie mit dem Erstellungsdatum und der letzten Änderung:

public class Person { // ... @CreatedBy User creator; @LastModifiedBy User modifier; @CreatedDate Date createdAt; @LastModifiedDate Date modifiedAt; // ... }

Beachten Sie, dass wir auch Spring Security verwenden müssen, wenn Spring die Principals füllen soll.

Eine ausführlichere Beschreibung finden Sie in diesem Artikel.

3. Spring Data JPA-Anmerkungen

3.1. @Abfrage

Mit @Query können wir eine JPQL-Implementierung für eine Repository-Methode bereitstellen:

@Query("SELECT COUNT(*) FROM Person p") long getPersonCount();

Wir können auch benannte Parameter verwenden:

@Query("FROM Person p WHERE p.name = :name") Person findByName(@Param("name") String name);

Besides, we can use native SQL queries, if we set the nativeQuery argument to true:

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

For more information, please visit this article.

3.2. @Procedure

With Spring Data JPA we can easily call stored procedures from repositories.

First, we need to declare the repository on the entity class using standard JPA annotations:

@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 Person {}

After this, we can refer to it in the repository with the name we declared in the name argument:

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

3.3. @Lock

We can configure the lock mode when we execute a repository query method:

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

The available lock modes:

  • READ
  • WRITE
  • OPTIMISTIC
  • OPTIMISTIC_FORCE_INCREMENT
  • PESSIMISTIC_READ
  • PESSIMISTIC_WRITE
  • PESSIMISTIC_FORCE_INCREMENT
  • NONE

3.4. @Modifying

We can modify data with a repository method if we annotate it with @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 more information, please visit this article.

3.5. @EnableJpaRepositories

To use JPA repositories, we have to indicate it to Spring. We can do this with @EnableJpaRepositories.

Note, that we have to use this annotation with @Configuration:

@Configuration @EnableJpaRepositories class PersistenceJPAConfig {}

Spring will look for repositories in the sub packages of this @Configuration class.

We can alter this behavior with the basePackages argument:

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

Also note, that Spring Boot does this automatically if it finds Spring Data JPA on the classpath.

4. Spring Data Mongo Annotations

Spring Data makes working with MongoDB much easier. In the next sections, we'll explore the most basic features of Spring Data MongoDB.

For more information, please visit our article about Spring Data MongoDB.

4.1. @Document

This annotation marks a class as being a domain object that we want to persist to the database:

@Document class User {}

It also allows us to choose the name of the collection we want to use:

@Document(collection = "user") class User {}

Note, that this annotation is the Mongo equivalent of @Entity in JPA.

4.2. @Field

With @Field, we can configure the name of a field we want to use when MongoDB persists the document:

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

Note, that this annotation is the Mongo equivalent of @Column in JPA.

4.3. @Query

With @Query, we can provide a finder query on a MongoDB repository method:

@Query("{ 'name' : ?0 }") List findUsersByName(String name);

4.4. @EnableMongoRepositories

To use MongoDB repositories, we have to indicate it to Spring. We can do this with @EnableMongoRepositories.

Note, that we have to use this annotation with @Configuration:

@Configuration @EnableMongoRepositories class MongoConfig {}

Spring will look for repositories in the sub packages of this @Configuration class. We can alter this behavior with the basePackages argument:

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

Also note, that Spring Boot does this automatically if it finds Spring Data MongoDB on the classpath.

5. Conclusion

In diesem Artikel haben wir gesehen, welche Anmerkungen die wichtigsten sind, die wir für den allgemeinen Umgang mit Daten mithilfe von Spring benötigen. Darüber hinaus haben wir uns die häufigsten JPA- und MongoDB-Anmerkungen angesehen.

Wie üblich sind hier auf GitHub Beispiele für allgemeine und JPA-Anmerkungen und hier für MongoDB-Anmerkungen verfügbar.

Weiter » Spring Bean Annotations « Vorherige Spring Scheduling Annotations