Spring Data JPA - O que eu preciso saber para começar? Um papo sobre Mapeamento de Banco de Dados Relacionais com Java e Spring Boot Framework

#Spring Framework
#MySQL
#Java

Fala, Dev. Hoje, decidi fazer um artigo sobre o Spring Boot JPA, utilizando as famosas anotations, para explicar um pouco do poder desta tecnologia e suas vantagens.

Para quem não conhece o Spring Boot, ele possui vários módulos. Alguns deles são:

Spring Web
Spring DevTools
Spring Data
Spring Security

E mais alguns outros. Mas, hoje, falaremos do módulo Spring Data, que possui a dependência JPA (Java Persistence API), para fazer o mapeamento de bancos de dados relacionais, usando Java, sem precisar usar códigos SQL/MySQL.

Mas, antes de começarmos, você sabe como se fazia antigamente, digo... antes do spring data jpa?

Depois de criar um diagrama entidade relacionamento, que continha todos os todas as tabelas com suas colunas a serem preenchidas, que representavam um banco de dados, os Devs Back-End Java, utilizam a linguagem para criar as classes responsáveis por receber os dados do usuário e então, passar esses dados para o banco de dados.

Entretanto, como se fazia tudo separada, a chance de ocorrer erros aumentava, assim como, a complexidade de configurações de arquivos, e bibliotecas, para poder se conectar ao banco de dados e utilizar seus recursos.

Com o Spring Boot Data JPA, podemos criar uma classe em Java, como já estamos habituados e inserir alguns anotações em cima do nome da classe e dos atributos, para mapear tais dados, em tabelas e colunas. Veja alguns deles abaixo:

@Entity
@Table
@Id
@GeneratedValue
@Column
@ManyToOne
@OneToMany
@JoinColumn
@Temporal
@Transient

Se você já trabalhou com banco de dados MySQL, vai notar alguma semelhante nos nomes. Mas, como não sabemos qual banco de dados relacional vamos utilizar (SQL, MySQL, PostgreSQL), essas anotações, por baixo dos panos, no Spring Data JPA, preparam os acessos de acordo com o banco a ser utilizado, ou seja, para o Dev, esses detalhes se transformam em abstrações.

Agora, não preciso mais saber qual é o código específico para criar uma tabela no banco de dados Mysql, SQL, PostegreSQL. O que eu preciso fazer é só criar a classe e informar a anotação Entity, acima dela, que indica que a classe referida irá gerar uma tabela no banco de dados.

Como isso vai acontecer... para o Dev já não importa, pois o que queremos é ter a tabela para armazenar os dados. Detalhes de configuração não são relevantes, e o Spring Boot chega para cumprir esse papel. A sua função é acelerar o Start do projeto, sem precisar perder tempo configurando ferramentas, e já poder iniciar no desenvolvimento da lógica do negócio da aplicação. O foco é no problema e em gerar a solução.

Veja abaixo um exemplo de mapeamento de uma classe Java, para um banco de dados relacional, usando as anotações do JPA. Acredito que não precisará de explicações mais profundas, pois o próprio código se explica. Confira:

----------------------------

import java.util.Date;

import javax.persistence.*;

@Entity

@Table(name = "pessoa")

public class Pessoa {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

@Column(name = "id_pessoa")

private Long id;

@Column(name = "nome")

private String nome;

@Column(name = "data_nascimento")

@Temporal(TemporalType.DATE)

private Date dataNascimento;

@Enumerated(EnumType.STRING)

@Column(name = "genero")

private Genero genero;

@Lob

@Column(name = "foto")

private byte[] foto;

@Transient

private int idade;

// getters e setters

}

enum Genero {

MASCULINO,

FEMININO,

OUTRO

}

-------------------------

Ao executar o código acima, se o banco de dados for MySQL, então, será criada uma tabela de nome pessoa, que terá as colunas id, nome, data_nascimento, genero e foto. A anotação @Transient informa que o atributo abaixo dele não irá virar uma coluna da tabela.

Logo, você pode usar essa mesma classe, para instanciar objetos na sua aplicação para salvar, bastará informar apenas o nome do objeto criado.

Toda a complexidade para pegar o objeto, identificar os dados preenchidos nos seus atributos com os métodos do tipo get, e mandar esse dados para uma query sql, para que então, sejam mandados para o banco de dados... isso se transforma numa abstração gerenciada pelo Spring Boot.

Assim, a produtividade aumenta e os projetos sobem para produção mais rápido.

No Spring Boot, quando trabalhamos com o Maven, temos um arquivo chamado pom.xml. Este arquivo é responsável pelas dependências, ou seja, ele é quem busca as bibliotecas necessárias para o projeto, seja lá onde elas estejam armazenadas na web.

Um exemplo de código que importa a biblioteca do mysql, para trabalhar com java, mais conhecido como mysqlconnector.jar é:

-----------------------------------

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency>

</dependencies>

-----------------

Este simples código, através do Spring, neste arquivo pom.xml, gerenciado pelo Maven, baixa a dependência para a pasta do projeto e a prepara para ser acessada.

Feito isso, basta editar o arquivo application.properties, que já é gerado vazio, na criação do projeto com Spring Boot, usando o Maven. A configuração de acesso ao banco de dados fica isolado do Java, e assim, é mais fácil de gerenciar, através deste arquivo. Veja abaixo como ficaria o acesso:

----------------

spring.datasource.url=jdbc:mysql://localhost:3306/meubanco?useSSL=false&serverTimezone=UTC

spring.datasource.username=meuusuario

spring.datasource.password=minhasenha

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.hibernate.ddl-auto=update

spring.jpa.show-sql=true

spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

------------

Para quem já criou projetos Java envolvendo o MySQL, vai identificar muito deste nomes que estão em negrito. Com isso, já podemos criar bancos de dados, usando Java e MySQL, sem precisar criar códigos SQL, para inserir, atualizar, deletar e pesquisar dados, tal como, não temos mais a necessidade de criar tabelas via terminal, criando chaves primarias e estrangeiras, via SQL, pois, já podemos mapear isso no Java, com as anotações que citamos no começo do artigo (@Id, @ManyToOne, @OneToMany, @JoinColum).

Lembrando que cada uma dessas anotações, pode receber seus respectivos atributos, tal como, name que é informado dentro da notação @Column para informar o nome da coluna a ser criada na tabela.

Em resumo, tendo como exemplo o MySQL, um código assim:

CREATE TABLE cliente (

id INT PRIMARY KEY AUTO_INCREMENT,

nome VARCHAR(100) NOT NULL,

email VARCHAR(100) NOT NULL UNIQUE,

idade INT,

data_cadastro DATETIME DEFAULT CURRENT_TIMESTAMP

);

Pode ser facilmente criado como no exemplo citada acima, através de uma classe Java cheia de anotações. Assim, as anotações são esses @ que são seguidos do nome do que deseja alterar(Coluna, Id, Tabela, Entidade... tal como Column, Id, Table, Entity).

Hoje, ao meu ver... é só questão de se adaptar ao novo modelo de criação de código, onde se coloca a responsabilidade na tecnologia, para gerenciar o que ela precisa gerenciar, enquanto nós, os Devs, nos preocupamos apenas com o pensamento puramente lógico, de criar as funcionalidade que irão interagir com a aplicação e gerenciar os dados.

Uma anotação que é interessante e ajuda a manipular as funções SQL por baixo dos panos é o @Repository que gerencia uma interface, que herda as características e métodos do JPA, e abstrai os códigos SQL, de forma simples de usar.

Ou seja, ao invés de dar um comando como: Insert into pessoas(nome, idade) values('olival', 29); Basta apenas dizer: repository.save(pessoa);

Bem mais simples né?!

Gostou da ideia?

O que achou da visão?

Já interagiu com essa tecnologia?