Validações do Jakarta Validation em Entidades

Nas classes anotadas com @Entity, as validações do Jakarta Validation (Bean Validation) podem ser aplicadas, mas existem algumas considerações importantes. Essas validações são feitas durante a persistência da entidade, ou seja, quando a entidade é salva, atualizada ou manipulada no banco de dados.

1️⃣ Validação no Construtor da Entidade com Jakarta Validation

Você pode usar as anotações de validação diretamente nos atributos ou no construtor da entidade. No entanto, vale destacar que a validação só será aplicada quando o Spring realizar a persistência da entidade, ou seja, no momento em que você salvar a entidade com o JPA.

---

Exemplo de validação no construtor de uma entidade

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;

@Entity
public class Autor {

    @Id
    private Long id;

    @NotBlank(message = "O nome é obrigatório")
    private String nome;

    @NotBlank(message = "O email é obrigatório")
    @Email(message = "Formato de email inválido")
    private String email;

    @NotBlank(message = "A descrição é obrigatória")
    @Size(max = 400, message = "A descrição não pode passar de 400 caracteres")
    private String descricao;

    private Instant instanteCriacao;

    public Autor(
            String nome,
            String email,
            String descricao
    ) {
        this.nome = nome;
        this.email = email;
        this.descricao = descricao;
        this.instanteCriacao = Instant.now();
    }

    // Getters e Setters
}

Quando a validação ocorre?

• Se você usar @Valid no controller (ou em outro ponto de entrada), a validação será executada antes de criar a entidade.
• Se você usar @NotBlank, @Size, @Email diretamente na entidade, a validação ocorrerá quando a entidade for persistida, ou seja, quando você salvar a entidade utilizando o EntityManager ou um Repository.

Exemplo de persistência com Spring Data JPA:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class AutorService {

    @Autowired
    private AutorRepository autorRepository;

    @Transactional
    public void cadastrarAutor(Autor autor) {
        // A validação ocorrerá aqui se a anotação @Valid for usada no Controller
        autorRepository.save(autor);
    }
}

---

2️⃣ Usando @Valid no Controller com @Entity

Quando você está recebendo um DTO ou um formulário via API, é comum realizar a validação antes de persistir a entidade. Para fazer isso, você pode usar @Valid diretamente no DTO e depois converter para a entidade anotada com @Entity.

import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import jakarta.validation.Valid;

@RestController
@RequestMapping("/autores")
@Validated
public class AutorController {

    @Autowired
    private AutorService autorService;

    @PostMapping
    public void cadastrarAutor(@RequestBody @Valid AutorRequest autorRequest) {
        Autor autor = autorRequest.toModel();
        autorService.cadastrarAutor(autor);
    }
}

---

3️⃣ Validação no Contexto do JPA e Hibernate

Quando você usa o Jakarta Validation em entidades JPA, a validação geralmente é disparada pelo Hibernate Validator (ou outro provider de validação). A configuração de validação é feita de forma transparente, mas você pode configurar para validar as entidades no momento de persistência ou atualização.

No entanto, o Hibernate Validator não valida as entidades automaticamente durante a construção do objeto (exemplo: ao criar uma instância no construtor), a não ser que seja explicitamente solicitado a validação (como no caso de usar @Valid ou @NotNull em um controller).

---

4️⃣ Exemplo de uso de @Valid e @Entity

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.validation.constraints.NotBlank;

@Entity
public class Autor {

    @Id
    private Long id;

    @NotBlank(message = "O nome é obrigatório")
    private String nome;

    public Autor(String nome) {
        this.nome = nome;
    }

    // Getter e Setter
}

No Controller:

import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import jakarta.validation.Valid;

@RestController
@RequestMapping("/autores")
public class AutorController {

    @Autowired
    private AutorService autorService;

    @PostMapping
    public void cadastrarAutor(@RequestBody @Valid Autor autor) {
        autorService.cadastrarAutor(autor);
    }
}

Se o nome não for preenchido, o Hibernate Validator disparará um erro e uma exceção de validação será lançada antes de a entidade ser persistida no banco de dados.

---

5️⃣ Benefícios de usar Jakarta Validation em @Entity:

• Garantia de consistência dos dados: Validações como @NotBlank, @Size, @Email garantem que os dados da entidade estejam no formato correto antes de serem persistidos.
• Integração com Spring: Quando você usa @Valid no Controller ou em outros pontos de entrada, a validação da entidade pode ser realizada automaticamente durante o ciclo de vida do objeto.
• Facilidade de manutenção: A validação declarativa permite que você centralize as regras de validação diretamente na classe de modelo (@Entity), facilitando a manutenção do código.

---

📌 Quando usar as anotações de validação dentro de entidades @Entity:

• Garantir consistência dos dados que serão persistidos no banco de dados.
• Validar parâmetros diretamente no modelo de dados, evitando que dados inválidos sejam persistidos.
• Integrar com a camada de validação do Spring para garantir que as entidades estejam corretas antes de serem manipuladas pelo JPA/Hibernate.

---

🎯 Resumo:

• @Entity pode ter anotações de validação (@NotBlank, @Size, @Email, etc.) para garantir que os dados estejam corretos no momento da persistência.
• @Valid no controller ajuda a validar os dados de entrada antes de criar e salvar a entidade.
• Hibernate Validator (ou o provedor de validação usado) é o responsável por disparar a validação no momento da persistência da entidade, mas pode ser configurado para garantir validações no momento da criação ou atualização.

Se você precisa validar dados antes da persistência, validação no Controller com @Valid é uma boa prática. Se a validação é mais ligada ao estado do modelo de dados e garante que a entidade nunca estará inconsistente, as anotações de validação no modelo de dados (entidade) são apropriadas.