Annotazioni sui dati di primavera

Questo articolo fa parte di una serie: • Annotazioni Spring Core

• Annotazioni Web primaverili

• Annotazioni Spring Boot

• Annotazioni di pianificazione della primavera

• Annotazioni Spring Data (articolo corrente) • Annotazioni Spring Bean

1. Introduzione

Spring Data fornisce un'astrazione sulle tecnologie di archiviazione dei dati. Pertanto, il nostro codice della logica di business può essere molto più indipendente dall'implementazione della persistenza sottostante. Inoltre, Spring semplifica la gestione dei dettagli di archiviazione dati dipendenti dall'implementazione.

In questo tutorial, vedremo le annotazioni più comuni dei progetti Spring Data, Spring Data JPA e Spring Data MongoDB.

2. Annotazioni sui dati di primavera comuni

2.1. @Transactional

Quando vogliamo configurare il comportamento transazionale di un metodo , possiamo farlo con:

@Transactional void pay() {}

Se applichiamo questa annotazione a livello di classe, allora funziona su tutti i metodi all'interno della classe. Tuttavia, possiamo ignorare i suoi effetti applicandolo a un metodo specifico.

Ha molte opzioni di configurazione, che possono essere trovate in questo articolo.

2.2. @NoRepositoryBean

A volte vogliamo creare interfacce di repository con l'unico obiettivo di fornire metodi comuni per i repository figlio .

Ovviamente, non vogliamo che Spring crei un bean di questi repository poiché non li inietteremo da nessuna parte. @NoRepositoryBean fa esattamente questo: quando contrassegniamo un'interfaccia figlia di org.springframework.data.repository.Repository , Spring non creerà un bean da essa.

Ad esempio, se vogliamo un metodo findById (ID id) opzionale in tutti i nostri repository, possiamo creare un repository di base:

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

Questa annotazione non influisce sulle interfacce figlie; quindi Spring creerà un bean per la seguente interfaccia del repository:

@Repository interface PersonRepository extends MyUtilityRepository {}

Si noti che l'esempio sopra non è necessario dalla versione 2 di Spring Data che include questo metodo in sostituzione del vecchio T findOne (ID id) .

2.3. @Param

Possiamo passare parametri denominati alle nostre query utilizzando @Param :

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

Nota che ci riferiamo al parametro con la sintassi : name .

Per ulteriori esempi, visita questo articolo.

2.4. @Id

@Id contrassegna un campo in una classe modello come chiave primaria:

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

Poiché è indipendente dall'implementazione, rende una classe del modello facile da usare con più motori di archivio dati.

2.5. @Transient

Possiamo usare questa annotazione per contrassegnare un campo in una classe modello come transitorio. Quindi il motore dell'archivio dati non leggerà o scriverà il valore di questo campo:

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

Come @Id , @Transient è anche l'implementazione indipendente, che lo rende comodo da usare con più implementazioni di memorizzare i dati.

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

Con queste annotazioni, possiamo controllare le nostre classi di modelli: Spring popola automaticamente i campi annotati con il principale che ha creato l'oggetto, lo ha modificato per ultimo, la data di creazione e l'ultima modifica:

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

Nota che se vogliamo che Spring popoli i principal, dobbiamo usare anche Spring Security.

Per una descrizione più completa, consulta questo articolo.

3. Annotazioni JPA Spring Data

3.1. @Query

Con @Query , possiamo fornire un'implementazione JPQL per un metodo di repository:

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

Inoltre, possiamo usare parametri denominati:

@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 questo articolo, abbiamo visto quali sono le annotazioni più importanti di cui abbiamo bisogno per gestire i dati in generale, utilizzando Spring. Inoltre, abbiamo esaminato le annotazioni JPA e MongoDB più comuni.

Come al solito, gli esempi sono disponibili su GitHub qui per le annotazioni comuni e JPA e qui per le annotazioni MongoDB.

Avanti » Annotazioni Spring Bean « Annotazioni Spring Scheduling precedenti