CRUD com JPA e Hibernate – Java

Fala, meu cod3r e minha cod3r. Nesse artigo, vou mostrar pra você como fazer o famoso CRUD (Create, Read, Update, Delete) utilizando JPA e sua implementação mais famosa: HIbernate. Esse conhecimento é crucial pra você que quer se tornar um programador Java.

Vamos começar pelo começo. Hibernate é um framework ORM(Object-Relational Mapping) e foi, inclusive, a primeira tecnologia para esse propósito em Java. Portanto, sua popularização fez com que a Oracle convidasse seus criadores para determinarem uma interface comum para frameworks de persistência de dados que quisessem disponibilizar seus serviços, e essa interface comum é hoje o que conhecemos como JPA. Ou seja, Hibernate é um framework que implementa o JPA, não se esqueçam disso.

Partindo pro projeto

O que vou usar:

• Java 11
• Hibernate 5
• Eclipse IDE
• MySQL workbench 8.0
• Maven
• Amor e carinho

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.

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.

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.

Conclusão

Por fim, esse foi um projeto bem simples para mostrar operações básicas utilizando JPA e Hibernate. Se você quiser a continuação com queries mais avançadas, não deixe de comentar! E claro que se houver algum problema no seu projeto deixe nos comentários também, prometo dar uma força.

Caso você queira se aprofundar e prefira vídeo aulas, nosso Curso de Java cobre detalhadamente HIbernate e JPA :

https://www.cod3r.com.br/courses/java-2020-completo

Pessoal, por hoje é só, espero que seja útil!