Iniciando com Spring Data JPA

Em outro artigo nós vimos o que é o Spring Data e entendemos que o mesmo é um conjunto de frameworks com o objetivo de facilitar o processo de persistência de dados em aplicações Spring. Agora nós iremos falar de um dos seus subprojetos, o Spring Data JPA.

O que é o Spring Data JPA?

Curso Spring Framework - Fundamentos

Conhecer o curso

O Spring Data JPA é uma framework que faz parte do conjunto de projetos do Spring Data que tem como finalidade tornar a integração de aplicações Spring com a JPA (Java Persistence API), uma de suas principais vantagens é a capacidade que o mesmo possui para criar a camada de acesso aos dados sem a necessidade de termos que implementar manualmente as famosas classes de DAO (Data Access Object).

Assim como o projeto Spring Data possui interfaces que são utilizadas ao longo de todos os seus subprojetos, o Spring Data JPA também possui sua principal interface que geralmente iremos utilizar durante a criação da camada de persistência da nossa aplicação, essa interface é a JpaRepository.

Veja no diagrama abaixo quais os métodos definidos pela interface JpaRepository e como ela se relaciona com as interfaces do Spring Data:

Adição e configuração do Spring Data JPA

Curso Spring Framework - Spring Data JPA

Conhecer o curso

Agora que já entendemos o seu objetivo, veremos como podemos adiciona-lo e configura-lo em um projeto com o Spring Boot.

Assim como a esmagadora maioria dos projetos que compõem o ecossistema Spring temos em mãos um starter para adição do Spring Data JPA, então para que possamos adiciona-lo em um projeto Spring Boot basta que coloquemos o seu starter como dependência do projeto.

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <scope>runtime</scope>
</dependency>

Lembrando que não precisamos informar a versão dos starters oficiais do Spring Boot uma vez que o próprio Spring Boot define as versões a serem utilizadas. Outro ponto importante é a inclusão do driver de conexão com o banco de dados, neste exemplo estou utilizando o MySQL.

Com esse simples passo já teremos o Spring Data JPA disponível para uso em nosso projeto, porém também é necessário realizar a configuração de conexão com o banco de dados, uma vez que o mesmo não tem com adivinhar qual banco de dados estamos utilizando, onde o mesmo está localizado e quais as suas credenciais de acesso.

É possível realizar essa configuração de duas principais formas, a partir do arquivo de configuração do nosso projeto Spring Boot ou através de uma classe Java de configuração. Por motivos de simplicidade vamos realizar a configuração através do arquivo de configuração do projeto que é o application.properties que fica localizado no diretório src/main/resources.

# Configuração do DataSource
spring.datasource.url=jdbc:mysql://localhost:3306/conhecendo_spring_data_jpa
spring.datasource.username=root
spring.datasource.password=root

# Configuração do Hibernate
spring.jpa.hibernate.ddl-auto=update

# Configuração da JPA
spring.jpa.show-sql=true

Com isso nós estamos configurando três componentes do nosso projeto, o primeiro deles é o DataSource que possui as informações de conexão com o nosso banco de dados, através da chave spring.datasource.url nós configuramos qual a string de conexão no padrão JDBC (Java Database Connectivity) a ser utilizada, além disso também configuramos qual o usuário e senha de nosso banco de dados através das chaves spring.datasource.username e spring.datasource.password respectivamente.

O segundo componente configurado foi o Hibernate, aqui vai um ponto importante, o Spring Data JPA não é um JPA provider, logo, é necessário que tenhamos um JPA provider em nosso sistema, por padrão é utilizado o Hibernate para realizar este trabalho. Neste ponto estamos apenas configurando o ddl-auto através da chave de configuração spring.jpa.hibernate.ddl-auto.

E por fim o ultimo componente configurado foi a própria JPA, a única configuração da JPA que fizemos foi colocar como true a chave de configuração spring.jpa.show-sql, isso faz com que as queries SQL geradas pela nossa JPA provider sejam exibidas no console.

Os repositórios do Spring Data JPA

Curso Spring Framework - Tópicos Avançados

Conhecer o curso

Agora que sabemos o que é e como fazer adição do Spring Data JPA em nosso projeto vamos ver como de fato utilizar uma de suas principais funcionalidades, os repositórios.

Todos os projetos do Spring Data seguem um padrão de projeto chamado Repository, esse repository ou repositório conterá todo código necessário para que possamos realizar o acesso ao banco de dados, ou seja, um repositório tem a mesma funcionalidade de uma classe DAO, porém, a vantagem é que o Spring Data JPA irá gerar esse repositório de forma automática.

Então vamos ao código, inicialmente irei criar uma entidade da JPA, lembrando que uma entidade nada mais é que uma classe que segue o padrão Java Bean que irá representar uma tabela no banco de dados, essa entidade eu irei chamar de Cliente.

package br.com.treinaweb.conhecendospringdatajpa.entity;

import java.time.LocalDate;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Cliente {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 100)
    private String nome;

    @Column(nullable = false, unique = true)
    private String email;

    @Column(nullable = false)
    private LocalDate dataNascimento;

    public Cliente() {}

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public LocalDate getDataNascimento() {
        return dataNascimento;
    }

    public void setDataNascimento(LocalDate dataNascimento) {
        this.dataNascimento = dataNascimento;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Cliente other = (Cliente) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Cliente [id=" + id + ", nome=" + nome + "]";
    }

}

No código acima temos a nossa entidade Cliente, a mesma possui os atributos id do tipo Long, nome do tipo String, email do tipo String e dataNascimento do tipo LocalDate. Logo o Hibernate irá gerar uma tabela em nosso banco de dados com o mesmo nome da nossa classe contendo como coluna os atributos que foram definidos.

Agora que já temos a nossa entidade podemos então criar o nosso repositório que irá conter todos os métodos que irão nos permitir manipular os dados no nosso banco de dados. Para isso irei criar uma interface chamada ClienteRepository e essa interface irá estender a interface JpaRepository do Spring Data JPA.

package br.com.treinaweb.conhecendospringdatajpa.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import br.com.treinaweb.conhecendospringdatajpa.entity.Cliente;

public interface ClienteRepository extends JpaRepository<Cliente, Long> {

}

Veja que a nossa interface estende da interface principal do Spring Data JPA e nesse momento nós informamos os tipos genéricos T e ID, sendo que o tipo genérico T representa qual o tipo da nossa entidade, no caso a classe Cliente e o tipo genérico ID representa qual o tipo do id da nossa entidade, que no caso é do tipo Long.

Com isso nós já temos um repositório pronto para uso, mas nesse momento você pode estar se perguntando “A única coisa que criamos foi uma interface, não teríamos que também criar a implementação dessa interface para poder de fato utiliza-la?” e a resposta é não, não é preciso que façamos a implementação da interface, isso porque o próprio Spring Data JPA irá gerar uma classe que implementa a nossa interface assim que fizermos a injeção de dependências dessa interface em algum lugar do nosso projeto.

Conclusão

Nesse artigo vimos o que é o Spring Data JPA e como o mesmo pode nos auxiliar no uso da JPA em conjunto com Hibernate dentre de aplicações Spring, com isso já temos o conhecimento teórico necessário para entender como utilizar essa incrível framework dentro de nossos projetos.

Em um futuro artigo falarei um pouco mais como podemos utilizar os métodos de CRUD disponibilizados pelo Spring Data JPA na prática durante o desenvolvimento de uma API com o Spring Web MVC. Mas até lá você pode ler o artigo Criando uma API REST com o Spring Boot para ter uma introdução mais direto ao ponto de como o Spring Data JPA pode ser utilizado.