CRUD com JPA e Hibernate – Java

Partindo pro projeto

O que vou usar:

 Java 11

 Hibernate 5

 Eclipse IDE

 MySQL workbench 8.0

 Maven

Primeiro passo
Primeiramente, vamos criar o schema no MySQL workbench. Então, basta clicar com o direito na coluna esquerda e selecionar a

opção de create schema. Aqui, chamei o schema de jpa_exemplo; você, porém, pode chamar do que quiser.

Clique em Apply ali em baixo

Segundo passo
Em seguida, vamos abrir o Eclipse e criar um novo projeto Maven. File > New > Other > Maven Project.

Na janela que abrir, marque a caixinha que diz “Create a simple project” e dê next.
Adicione descrição se quiser

Group Id: A identificação da organização responsável pelo projeto.

Artifact Id: O nome o do projeto.

Name: Um nome que pode ser mais amigável para identificar o projeto (não é obrigatório).

Logo depois, vamos adicionar as dependências do Hibernate e do MySQL connector no arquivo pom.xml:

<project xmlns="<http://maven.apache.org/POM/4.0.0>"
xmlns:xsi="<http://www.w3.org/2001/XMLSchema-instance>"
xsi:schemaLocation="<http://maven.apache.org/POM/4.0.0>
<https://maven.apache.org/xsd/maven-4.0.0.xsd>">
<modelVersion>4.0.0</modelVersion>

<groupId>br.com.cod3r</groupId>
<artifactId>GerenciadorNinja</artifactId>
 <version>0.0.1-SNAPSHOT</version>
<name>CrudHIbernateJpa</name>

<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>

<dependencies>

<!-- [<https://mvnrepository.com/artifact/org.hibernate/hibernate-
core>](<https://mvnrepository.com/artifact/org.hibernate/hibernate-core>) -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.6.5.Final</version>
</dependency>

<!-- [<https://mvnrepository.com/artifact/mysql/mysql-connector-java>]
(<https://mvnrepository.com/artifact/mysql/mysql-connector-java>) -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>

<!-- <https://mvnrepository.com/artifact/org.hibernate/hibernate-
entitymanager> -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.6.5.Final</version>
</dependency>

</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.2</version> <!-- or whatever current version
-->
<configuration>
<source>11</source>
<target>11</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

OBS: Mude as versões do java de acordo com a que vc está usando

Por fim, para concluir essa parte de configuração, vamos criar o arquivo persistence.xml, que determina as configurações de

persistência do projeto. Não precisa decorar nada disso, há bastante exemplos desse arquivo no Google; basta fazer as

substituições.

O nosso ficará assim:

Obs: em resources crie uma pasta chamada META-INF e somente dentro dela crie seu persistence.xml

<persistence xmlns="<http://java.sun.com/xml/ns/persistence>"
xmlns:xsi="<http://www.w3.org/2001/XMLSchema-instance>"
xsi:schemaLocation="<http://java.sun.com/xml/ns/persistence>
<http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd>"
version="2.0">
<!-- unidade de persistencia -->
<persistence-unit name="jpa_exemplo">
<!-- Implementação do JPA, no nessa caso Hibernate -->
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<!-- Aqui são listadas todas as entidades -->
<class></class>
<properties>
<!-- Propriedades JDBC -->
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver" />
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/jpa_exemplo
?useTimezone=true&amp;serverTimezone=UTC" />
<property name="javax.persistence.jdbc.user" value="root" />
<property name="javax.persistence.jdbc.password"
value="123456" />
<!-- Configurações específicas do Hibernate -->
<property name="hibernate.dialect"
value="org.hibernate.dialect.MySQL5InnoDBDialect" />
<property name="hibernate.hbm2ddl.auto" value="update" />
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.format_sql" value="true" />
</properties>
</persistence-unit>
</persistence>

Terceiro passo: Criação do DAO

Agora, vamos concentrar nossas operações no banco de dados em uma classe chamada DAO (Data Access Object) que, como o

próprio nome diz, será responsável pelo acesso aos dados.

Aqui teremos os métodos do CRUD.

Criação do Entity Manager

Na primeira parte do nosso DAO, criaremos o EntityManager, que é o responsável pela persistência dos nossos dados. Para isso,

precisamos de um EntityManagerFactory que nos permite criá-lo.

Primeiramente, crie um pacote chamado infra; dentro desse pacote, estabeleça uma nova classe chamada DAO. O começo ficará

assim:

package infra;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class DAO<E> {

private static EntityManagerFactory emf;

private EntityManager em;
private Class<E> entidade;
 static {
try {
emf = Persistence.createEntityManagerFactory("jpa_exemplo");
} catch (Exception e) {
throw new RuntimeException(e.getMessage());
}
}

public DAO(Class<E> entidade) {

this.entidade = entidade;
em = emf.createEntityManager();
}
}

Nesse código tem, basicmente, o necessário para a criação de um objeto de persistência, faltando apenas passar uma

entidade(classe) para o construtor do DAO.

Quarto passo: Criação da Entidade

Comece criando um novo pacote chamado modelo, e dentro desse pacote vou criar a classe Ninja. Seu projeto e sua classe Ninja

deverão estar assim:

 ”@”Entity: Essa anotação diz que essa classe será uma entidade JPA, uma tabela será criado no nosso db.

 “@”Table: Aqui eu digo que o nome da tabela criada será “ninjas”

 “@”Id: Diz que tal atributo será a primary key dessa tabela

 “@”GeneratedValue: Define a estratégia que o id vai usar, escolhemos IDENTITY para gerar em ordem crescente

automaticamente para nós.

Crie uma classe Teste e coloque o seguinte código:

import infra.DAO;
import modelo.Ninja;

public class Testes {

public static void main(String[] args) {

Ninja naruto = new Ninja("Naruto", "Ninjutsu", "Konoha", 30, false);
DAO<Ninja> daoNinja = new DAO<>(Ninja.class);

Ao dar Run as Java App, nossa tabela será criada lá no MySQL, ainda sem o naruto nela.

Quinto Passo: Criação dos Métodos CRUD no DAO

Agora, o que nós vamos fazer é criar os métodos das nossas operações lá no DAO. E queremos métodos para criar um ninja,

editar, excluir e obter pelo Id.

Antes, precisamos de métodos para abrir a transação com o db e uma pra fechar. Adicione esse código no seu DAO.

public DAO<E> abrir() {

em.getTransaction().begin();
return this;
}

public DAO<E> fechar() {

em.getTransaction().commit();
return this;
}

Percebam que o que fazemos no método abrir() é pegar a transação no nosso EntityManager e dar o begin (começar). Já no

fechar() pegamos a transação e damos o commit, que irá fechá-la.

Create Ninja
Em seguida, para criar um novo ninja na tabela, vamos usar um método do EntityManager chamado persist, que recebe a entidade

a ser persistida. Nosso método ficou assim:

public DAO<E> create(E entidade) {

em.persist(entidade);
return this;
}

Agora vamos voltar a nossa classe Teste pra ver se, agora, conseguimos criar o Naruto e o Shikamaru na tabela. Com esse código:

public class Testes {

public static void main(String[] args) {

Ninja naruto = new Ninja("Naruto", "Ninjutsu", "Konoha", 30, false);
Ninja shikamaru = new Ninja("Shikamaru", "Ninjutsu", "Konoha", 29,
true);
DAO<Ninja> daoNinja = new DAO<>(Ninja.class);
 daoNinja.abrir()
.create(naruto)
.create(shikamaru)
.fechar();
}
}

Os dois devem aparecer na sua tabela de ninjas!

Obter pelo Id
Bom, voltemos pro DAO para criar esse método. Para encontrar um ninja, vamos usar o método do EM chamado find que recebe

dois argumentos, o Id e a classe que estamos trabalhando. Mas perceba que agora retornamos uma Entidade E e não um DAO<E>:

public E encontrarPeloId(Object id) {

return em.find(entidade, id);
}

Abra sua tabela para ver o Id do ninja que você quer buscar e, em seguida, faça na classe teste:

obs: Apague o código anterior que cria os ninjas

System.out.println(daoNinja.encontrarPeloId(3).getNome());

No meu caso, Naruto foi printado no console. Se você quiser um informação completa, crie o método toString() na classe Ninja,

dessa forma não precisará do getNome.

Deletar pelo Id
Aqui não é tão simples quanto o create, mas vamos usar nosso método de encontrar pelo Id e passar o ninja encontrado para o

método remove() do EM.

public DAO<E> delete(int id) {

DAO<E> dao = new DAO<E>(entidade);
E ninjaEncontrado = dao.encontrarPeloId(id);
em.remove(em.contains(ninjaEncontrado) ? ninjaEncontrado :
em.merge(ninjaEncontrado));
return this;
}

No entanto, repare que eu faço um operador ternário para ver se o ninjaEncontrado está no EM atual. Se estiver ótimo, retornamos

ele; se não estiver, basta fazer um merge() do ninjaEncontrado para o EM atual.

Na classe Teste exclui o Naruto, (afinal não gosto dele…):

public static void main(String[] args) {

Ninja naruto = new Ninja("Naruto", "Ninjutsu", "Konoha", 30, false);
Ninja shikamaru = new Ninja("Shikamaru", "Ninjutsu", "Konoha", 29,
true);
DAO<Ninja> daoNinja = new DAO<>(Ninja.class);
 daoNinja.abrir()
.delete(3)
.fechar();
}

Método atualizar()
Agora, para atualizar, a gente vai fazer um pouco diferente: estávamos trabalhando com generics no nosso DAO até agora; nesse

novo método, vou usar nossa classe Ninja.

public Ninja atualizar(int id, String nome, String habilidade, String aldeia, Boolean
aposentado, int idade) {
DAO<E> dao = new DAO<E>(entidade);
dao.abrir();

Ninja ninja = (Ninja) dao.encontrarPeloId(id);

ninja.setNome(nome);
ninja.setHabilidade(habilidade);
ninja.setAldeia(aldeia);
ninja.setAposentado(aposentado);
ninja.setIdade(idade);

em.merge(ninja);

dao.fechar();

return ninja;
}

Nesse método, eu abri uma transação, encontrei o ninja pelo id e setei seus atributos com as informações que vamos passar como

parâmetros. Depois, é só dar um merge nesse ninja já alterado e fechar a transação.

Para testar ficou bem simples:

public static void main(String[] args) {

DAO<Ninja> daoNinja = new DAO<>(Ninja.class)
daoNinja.atualizar(4, "Itachi", "Genjutsu", "Nao tem", true, 25);
}

Nosso Shikamaru se tornou Itachi. Verifique sua tabela.