TOC

Anotações de dados do Spring

Anotações de dados do Spring

1. Introdução

O Spring Data fornece uma abstração sobre as tecnologias de armazenamento de dados. Portanto, nosso código de lógica de negócios pode ser muito mais independente da implementação de persistência subjacente. Além disso, o Spring simplifica o tratamento de detalhes dependentes da implementação do armazenamento de dados.

Neste tutorial, veremos as anotações mais comuns dos projetos Spring Data, Spring Data JPA e Spring Data MongoDB.

2. Anotações comuns de dados do Spring

2.1. @Transactional

Quando queremosconfigure the transactional behavior of a method, podemos fazer isso com: 

@Transactional
void pay() {}

Se aplicarmos esta anotação no nível da classe, ela funcionará em todos os métodos dentro da classe. No entanto, podemos substituir seus efeitos aplicando-o a um método específico.

Possui várias opções de configuração, que podem ser encontradas emthis article.

2.2. @NoRepositoryBean

Sometimes we want to create repository interfaces with the only goal of providing common methods for the child repositories.

Claro, não queremos que o Spring crie um bean desses repositórios, já que não os injetaremos em lugar nenhum. @NoRepositoryBean  faz exatamente isso: quando marcamos uma interface filha deorg.springframework.data.repository.Repository, o Spring não criará um bean a partir dela.

Por exemplo, se quisermos um smethodOptional<T> findById(ID id) em todos os nossos repositórios, podemos criar um repositório base: 

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

Esta anotação não afeta as interfaces filhas; portanto, o Spring criará um bean para a seguinte interface de repositório: 

@Repository
interface PersonRepository extends MyUtilityRepository {}

Observe que o exemplo acima não é necessário desde a versão 2 do Spring Data, que inclui este método substituindo o antigoT findOne(ID id).

2.3. @Param

Podemos passar parâmetros nomeados para nossas consultas usando@Param: 

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

Observe que nos referimos ao parâmetro com a sintaxe:name s.

Para obter mais exemplos, visitethis article.

2.4. @Id

@Id marca um campo em uma classe de modelo como a chave primária: 

class Person {

    @Id
    Long id;

    // ...

}

Uma vez que é independente da implementação, torna uma classe de modelo fácil de usar com vários mecanismos de armazenamento de dados.

2.5. @Transient

Podemos usar esta anotação para marcar um campo em uma classe de modelo como transitório. Portanto, o mecanismo de armazenamento de dados não lerá ou escreverá o valor deste campo: 

class Person {

    // ...

    @Transient
    int age;

    // ...

}

Como@Id,@Transient  também é independente da implementação, o que o torna conveniente para uso com várias implementações de armazenamento de dados.

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

Com essas anotações, podemos auditar nossas classes de modelo: o Spring preenche automaticamente os campos anotados com o principal que criou o objeto, o modificou pela última vez, a data da criação e a última modificação: 

public class Person {

    // ...

    @CreatedBy
    User creator;

    @LastModifiedBy
    User modifier;

    @CreatedDate
    Date createdAt;

    @LastModifiedDate
    Date modifiedAt;

    // ...

}

Observe que, se quisermos que o Spring preencha os principais, também precisamos usar o Spring Security.

Para uma descrição mais completa, visitethis article.

3. Anotações da JPA de dados da primavera

3.1. @Query

Com@Query, podemos fornecer uma implementação JPQL para um método de repositório: 

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

Além disso, podemos usar parâmetros nomeados: 

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

Além disso, podemos usar consultas SQL nativas, se definirmos o argumentonativeQuery paratrue: 

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

Para obter mais informações, visitethis article.

3.2. @Procedure

Com Spring Data JPA, podemos facilmente chamar procedimentos armazenados de repositórios.

Primeiro, precisamos declarar o repositório na classe de entidade usando anotações JPA padrão: 

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

Depois disso, podemos nos referir a ele no repositório com o nome que declaramos no sargumentoname : 

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

3.3. @Lock

Podemos configurar o modo de bloqueio quando executamos um método de consulta de repositório: 

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

Os modos de bloqueio disponíveis:

  • READ

  • ESCREVER

  • OTIMISTA

  • OPTIMISTIC_FORCE_INCREMENT

  • PESSIMISTIC_READ

  • PESSIMISTIC_WRITE

  • PESSIMISTIC_FORCE_INCREMENT

  • NONE

3.4. @Modifying

Podemos modificar os dados com um método de repositório se anotarmos com@Modifying: 

@Modifying
@Query("UPDATE Person p SET p.name = :name WHERE p.id = :id")
void changeName(@Param("id") long id, @Param("name") String name);

Para obter mais informações, visitethis article.

3.5. @EnableJpaRepositories

Para usar repositórios JPA, precisamos indicá-lo para Spring. Podemos fazer isso com@EnableJpaRepositories.

Observe que temos que usar esta anotação com@Configuration: 

@Configuration
@EnableJpaRepositories
class PersistenceJPAConfig {}

O Spring irá procurar por repositórios nos subpacotes deste sclass@Configuration .

Podemos alterar esse comportamento com o sargumentobasePackages : 

@Configuration
@EnableJpaRepositories(basePackages = "org.example.persistence.dao")
class PersistenceJPAConfig {}

Observe também que o Spring Boot faz isso automaticamente se encontrar o Spring Data JPA no caminho de classe.

4. Anotações do Spring Data Mongo

O Spring Data facilita o trabalho com o MongoDB. Nas próximas seções, exploraremos os recursos mais básicos do Spring Data MongoDB.

Para obter mais informações, visite nossoarticle about Spring Data MongoDB.

4.1. @Document

Esta anotação marca uma classe como sendo um objeto de domínio que queremos persistir no banco de dados: 

@Document
class User {}

Também nos permite escolher o nome da coleção que queremos usar: 

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

Observe que essa anotação é o equivalente Mongo de@Entity in JPA.

4.2. @Field

Com@Field, podemos configurar o nome de um campo que queremos usar quando o MongoDB persistir no documento: 

@Document
class User {

    // ...

    @Field("email")
    String emailAddress;

    // ...

}

Observe que essa anotação é o equivalente Mongo de@Column in JPA.

4.3. @Query

Com@Query, podemos fornecer uma consulta de localização em um método de repositório MongoDB: 

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

4.4. @EnableMongoRepositories

Para usar os repositórios do MongoDB, precisamos indicá-lo para o Spring. Podemos fazer isso com@EnableMongoRepositories.

Observe que temos que usar esta anotação com@Configuration: 

@Configuration
@EnableMongoRepositories
class MongoConfig {}

O Spring irá procurar por repositórios nos subpacotes deste sclass@Configuration . Podemos alterar esse comportamento com o sargumentobasePackages : 

@Configuration
@EnableMongoRepositories(basePackages = "org.example.repository")
class MongoConfig {}

Observe também que o Spring Boot faz isso automaticamente se encontrar o Spring Data MongoDB no caminho de classe.

5. Conclusão

Neste artigo, vimos quais são as anotações mais importantes que precisamos para lidar com dados em geral, usando o Spring. Além disso, analisamos as anotações JPA e MongoDB mais comuns.

Como de costume, os exemplos estão disponíveis no GitHubhere para anotações comuns e JPA ehere para anotações MongoDB.

Related