• Anotaciones web de Spring
• Anotaciones de Spring Boot
• Anotaciones de programación de primavera
• Anotaciones de datos de Spring (artículo actual) • Anotaciones de Spring Bean
1. Introducción
Spring Data proporciona una abstracción sobre las tecnologías de almacenamiento de datos. Por lo tanto, nuestro código de lógica empresarial puede ser mucho más independiente de la implementación de persistencia subyacente. Además, Spring simplifica el manejo de los detalles del almacenamiento de datos que dependen de la implementación.
En este tutorial, veremos las anotaciones más comunes de los proyectos Spring Data, Spring Data JPA y Spring Data MongoDB.
2. Anotaciones de datos comunes de Spring
2.1. @Transaccional
Cuando queremos configurar el comportamiento transaccional de un método , podemos hacerlo con:
@Transactional void pay() {}Si aplicamos esta anotación a nivel de clase, entonces funciona en todos los métodos dentro de la clase. Sin embargo, podemos anular sus efectos aplicándolo a un método específico.
Tiene muchas opciones de configuración, que se pueden encontrar en este artículo.
2.2. @NoRepositorioBean
A veces queremos crear interfaces de repositorio con el único objetivo de proporcionar métodos comunes para los repositorios secundarios .
Por supuesto, no queremos que Spring cree un bean de estos repositorios ya que no los inyectaremos en ningún lado. @NoRepositoryBean hace exactamente esto: cuando marcamos una interfaz secundaria de org.springframework.data.repository.Repository , Spring no creará un bean a partir de ella.
Por ejemplo, si queremos un método findById (ID id) opcional en todos nuestros repositorios, podemos crear un repositorio base:
@NoRepositoryBean interface MyUtilityRepository extends CrudRepository { Optional findById(ID id); }Esta anotación no afecta a las interfaces secundarias; por lo tanto, Spring creará un bean para la siguiente interfaz de repositorio:
@Repository interface PersonRepository extends MyUtilityRepository {}Tenga en cuenta que el ejemplo anterior no es necesario desde la versión 2 de Spring Data, que incluye este método que reemplaza al antiguo T findOne (ID id) .
2.3. @Param
Podemos pasar parámetros con nombre a nuestras consultas usando @Param :
@Query("FROM Person p WHERE p.name = :name") Person findByName(@Param("name") String name);Tenga en cuenta que nos referimos al parámetro con la sintaxis : name .
Para obtener más ejemplos, visite este artículo.
2.4. @Carné de identidad
@Id marca un campo en una clase modelo como clave principal:
class Person { @Id Long id; // ... }Dado que es independiente de la implementación, hace que una clase de modelo sea fácil de usar con varios motores de almacenamiento de datos.
2.5. @Transitorio
Podemos usar esta anotación para marcar un campo en una clase de modelo como transitorio. Por lo tanto, el motor del almacén de datos no leerá ni escribirá el valor de este campo:
class Person { // ... @Transient int age; // ... }Al igual que @Id , @Transient también es independiente de la implementación, lo que lo hace conveniente para usar con múltiples implementaciones de almacenamiento de datos.
2.6. @CreatedBy , @LastModifiedBy , @CreatedDate , @LastModifiedDate
Con estas anotaciones, podemos auditar nuestras clases modelo: Spring llena automáticamente los campos anotados con el principal que creó el objeto, lo modificó por última vez y la fecha de creación y última modificación:
public class Person { // ... @CreatedBy User creator; @LastModifiedBy User modifier; @CreatedDate Date createdAt; @LastModifiedDate Date modifiedAt; // ... }Tenga en cuenta que si queremos que Spring complete los principales, también debemos usar Spring Security.
Para obtener una descripción más detallada, visite este artículo.
3. Anotaciones de Spring Data JPA
3.1. @Consulta
Con @Query , podemos proporcionar una implementación JPQL para un método de repositorio:
@Query("SELECT COUNT(*) FROM Person p") long getPersonCount();Además, podemos usar parámetros con nombre:
@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
En este artículo, vimos cuáles son las anotaciones más importantes que necesitamos para tratar con datos en general, usando Spring. Además, analizamos las anotaciones más comunes de JPA y MongoDB.
Como de costumbre, hay ejemplos disponibles en GitHub aquí para anotaciones comunes y JPA, y aquí para anotaciones MongoDB.
Siguiente » Anotaciones de Spring Bean « Anotaciones de programación de Spring anteriores