S01L11 – Operação CURD do Hibernate – Excluir

html

Operações CRUD do Hibernate: Excluindo Registros com Facilidade
Tabela de Conteúdos

Introdução ........................................... 1
Entendendo Operações CRUD ..... 3
Configurando o Hibernate para Exclusão .. 5
Implementando a Operação de Exclusão .. 7

Análise do Código ............................ 8


Executando a Aplicação ............... 12
Melhores Práticas para Excluir Registros .. 15
Conclusão ............................................ 18


Introdução
Bem-vindo ao guia abrangente sobre a realização de delete operations using Hibernate em aplicações Java. Como parte das operações CRUD (Create, Read, Update, Delete) do Hibernate, a funcionalidade delete é crucial para gerenciar os dados de sua aplicação de maneira eficaz. Este eBook irá conduzi-lo através das etapas necessárias para excluir registros de seu banco de dados de forma contínua usando Hibernate. Seja você um iniciante ou um desenvolvedor com conhecimentos básicos, este guia foi elaborado para ajudá-lo a dominar o processo de exclusão com clareza e precisão.

Entendendo Operações CRUD
Antes de mergulhar no processo de exclusão, é essencial compreender o contexto mais amplo das operações CRUD dentro do Hibernate.
O que é CRUD?
CRUD significa Create, Read, Update, and Delete—as quatro funções básicas do armazenamento persistente. O Hibernate, como uma ferramenta de Object-Relational Mapping (ORM), facilita essas operações permitindo que os desenvolvedores interajam com o banco de dados usando objetos Java.


Operação
Descrição
Método do Hibernate


Create
Inserir novos registros
session.save()


Read
Recuperar registros existentes
session.get()


Update
Modificar registros existentes
session.update()


Delete
Remover registros
session.delete()


Importância da Operação Delete
A operação delete é fundamental para manter a integridade dos dados e garantir que registros obsoletos ou desnecessários não poluam seu banco de dados. A implementação adequada assegura que as exclusões sejam tratadas de forma eficiente e segura, prevenindo perda de dados não intencional.

Configurando o Hibernate para Exclusão
Antes de implementar a operação delete, certifique-se de que sua configuração do Hibernate está corretamente configurada.
Pré-requisitos

Java Development Kit (JDK) instalado
Hibernate bibliotecas adicionadas ao seu projeto
Banco de Dados (por exemplo, MySQL, PostgreSQL) configurado
Entity Classes definidas (por exemplo, Users.java)
Arquivo de Configuração do Hibernate (hibernate.cfg.xml) configurado

Estrutura do Projeto




		
		
			
			
Java
			
			HibernateCRUD/
├── src/
│   └── main/
│       ├── java/
│       │   └── org/
│       │       └── studyeasy/
│       │           ├── App.java
│       │           └── entity/
│       │               └── Users.java
│       └── resources/
│           └── hibernate.cfg.xml
├── pom.xml
└── README.md
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						HibernateCRUD/
├── src/
│   └── main/
│       ├── java/
│       │   └── org/
│       │       └── studyeasy/
│       │           ├── App.java
│       │           └── entity/
│       │               └── Users.java
│       └── resources/
│           └── hibernate.cfg.xml
├── pom.xml
└── README.md
					
				
			
		


Arquivo de Configuração (hibernate.cfg.xml)
Certifique-se de que seu hibernate.cfg.xml está corretamente configurado com os detalhes de conexão necessários ao banco de dados e mapeamentos.




		
		
			
			
Java
			
			&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"&gt;
&lt;hibernate-configuration&gt;
   &lt;session-factory&gt;
      &lt;!-- Configurações de conexão com o banco de dados --&gt;
      &lt;property name="connection.driver_class"&gt;com.mysql.cj.jdbc.Driver&lt;/property&gt;
      &lt;property name="connection.url"&gt;jdbc:mysql://localhost:3306/yourdb&lt;/property&gt;
      &lt;property name="connection.username"&gt;root&lt;/property&gt;
      &lt;property name="connection.password"&gt;password&lt;/property&gt;

      &lt;!-- Configurações do pool de conexão JDBC --&gt;
      &lt;property name="connection.pool_size"&gt;1&lt;/property&gt;

      &lt;!-- Dialeto SQL --&gt;
      &lt;property name="dialect"&gt;org.hibernate.dialect.MySQLDialect&lt;/property&gt;

      &lt;!-- Exibir todo SQL executado no stdout --&gt;
      &lt;property name="show_sql"&gt;true&lt;/property&gt;

      &lt;!-- Dropar e recriar o esquema do banco de dados na inicialização --&gt;
      &lt;property name="hbm2ddl.auto"&gt;update&lt;/property&gt;

      &lt;!-- Classes de mapeamento --&gt;
      &lt;mapping class="org.studyeasy.entity.Users"/&gt;
   &lt;/session-factory&gt;
&lt;/hibernate-configuration&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
				
						&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"&gt;
&lt;hibernate-configuration&gt;
   &lt;session-factory&gt;
      &lt;!-- Configurações de conexão com o banco de dados --&gt;
      &lt;property name="connection.driver_class"&gt;com.mysql.cj.jdbc.Driver&lt;/property&gt;
      &lt;property name="connection.url"&gt;jdbc:mysql://localhost:3306/yourdb&lt;/property&gt;
      &lt;property name="connection.username"&gt;root&lt;/property&gt;
      &lt;property name="connection.password"&gt;password&lt;/property&gt;
 
      &lt;!-- Configurações do pool de conexão JDBC --&gt;
      &lt;property name="connection.pool_size"&gt;1&lt;/property&gt;
 
      &lt;!-- Dialeto SQL --&gt;
      &lt;property name="dialect"&gt;org.hibernate.dialect.MySQLDialect&lt;/property&gt;
 
      &lt;!-- Exibir todo SQL executado no stdout --&gt;
      &lt;property name="show_sql"&gt;true&lt;/property&gt;
 
      &lt;!-- Dropar e recriar o esquema do banco de dados na inicialização --&gt;
      &lt;property name="hbm2ddl.auto"&gt;update&lt;/property&gt;
 
      &lt;!-- Classes de mapeamento --&gt;
      &lt;mapping class="org.studyeasy.entity.Users"/&gt;
   &lt;/session-factory&gt;
&lt;/hibernate-configuration&gt;
					
				
			
		



Implementando a Operação de Exclusão
Com a configuração em vigor, vamos aprofundar a implementação da operação delete usando Hibernate.
Passo 1: Definir a Entity Class
Certifique-se de que sua classe de entidade (Users.java) está corretamente anotada e mapeada para sua tabela no banco de dados.




		
		
			
			
Java
			
			package org.studyeasy.entity;

import javax.persistence.*;

@Entity
@Table(name = "users")
public class Users {
    
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name = "user_id")
    private int id;
    
    @Column(name = "username")
    private String username;

    // Construtores
    public Users() {}

    public Users(String username) {
        this.username = username;
    }

    // Getters and Setters
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }

    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
				
						package org.studyeasy.entity;
 
import javax.persistence.*;
 
@Entity
@Table(name = "users")
public class Users {
    
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name = "user_id")
    private int id;
    
    @Column(name = "username")
    private String username;
 
    // Construtores
    public Users() {}
 
    public Users(String username) {
        this.username = username;
    }
 
    // Getters and Setters
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
 
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
}
					
				
			
		


Passo 2: Criar o Método Delete em App.java
Implemente a funcionalidade delete dentro da sua classe principal da aplicação.




		
		
			
			
Java
			
			package org.studyeasy;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.studyeasy.entity.Users;

public class App {
    public static void main(String[] args) {
        // Criar SessionFactory
        SessionFactory factory = new Configuration()
                                 .configure("hibernate.cfg.xml")
                                 .addAnnotatedClass(Users.class)
                                 .buildSessionFactory();

        // Criar Session
        Session session = factory.getCurrentSession();

        try {
            // Iniciar uma transação
            session.beginTransaction();

            // Especificar o ID do usuário a ser excluído
            int userIdToDelete = 3;

            // Recuperar o objeto usuário
            Users user = session.get(Users.class, userIdToDelete);

            // Excluir o usuário se existir
            if (user != null) {
                session.delete(user);
                System.out.println("Deleted user with ID: " + userIdToDelete);
            } else {
                System.out.println("User with ID " + userIdToDelete + " not found.");
            }

            // Commit da transação
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
				
						package org.studyeasy;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.studyeasy.entity.Users;
 
public class App {
    public static void main(String[] args) {
        // Criar SessionFactory
        SessionFactory factory = new Configuration()
                                 .configure("hibernate.cfg.xml")
                                 .addAnnotatedClass(Users.class)
                                 .buildSessionFactory();
 
        // Criar Session
        Session session = factory.getCurrentSession();
 
        try {
            // Iniciar uma transação
            session.beginTransaction();
 
            // Especificar o ID do usuário a ser excluído
            int userIdToDelete = 3;
 
            // Recuperar o objeto usuário
            Users user = session.get(Users.class, userIdToDelete);
 
            // Excluir o usuário se existir
            if (user != null) {
                session.delete(user);
                System.out.println("Deleted user with ID: " + userIdToDelete);
            } else {
                System.out.println("User with ID " + userIdToDelete + " not found.");
            }
 
            // Commit da transação
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}
					
				
			
		


Análise do Código
Vamos analisar o código de App.java passo a passo para entender como a operação delete é executada.

Criação do SessionFactory
    




		
		
			
			
Java
			
			SessionFactory factory = new Configuration()
                         .configure("hibernate.cfg.xml")
                         .addAnnotatedClass(Users.class)
                         .buildSessionFactory();
			
				
					
				
					1
2
3
4
				
						SessionFactory factory = new Configuration()
                         .configure("hibernate.cfg.xml")
                         .addAnnotatedClass(Users.class)
                         .buildSessionFactory();
					
				
			
		



Configura o Hibernate usando o arquivo hibernate.cfg.xml.
Adiciona a classe anotada Users.
Constrói o SessionFactory, responsável por criar sessões.


Iniciação da Session
    




		
		
			
			
Java
			
			Session session = factory.getCurrentSession();
			
				
					
				
					1
				
						Session session = factory.getCurrentSession();
					
				
			
		



Obtém a sessão atual a partir do SessionFactory.


Gerenciamento de Transação
    




		
		
			
			
Java
			
			session.beginTransaction();
			
				
					
				
					1
				
						session.beginTransaction();
					
				
			
		



Inicia uma nova transação. Todas as operações entre beginTransaction() e commit() fazem parte desta transação.


Recuperando o Usuário para Excluir
    




		
		
			
			
Java
			
			int userIdToDelete = 3;
Users user = session.get(Users.class, userIdToDelete);
			
				
					
				
					1
2
				
						int userIdToDelete = 3;
Users user = session.get(Users.class, userIdToDelete);
					
				
			
		



Especifica o userId do registro a ser excluído.
Recupera o objeto Users correspondente ao userId especificado.


Excluindo o Usuário
    




		
		
			
			
Java
			
			if (user != null) {
    session.delete(user);
    System.out.println("Deleted user with ID: " + userIdToDelete);
} else {
    System.out.println("User with ID " + userIdToDelete + " not found.");
}
			
				
					
				
					1
2
3
4
5
6
				
						if (user != null) {
    session.delete(user);
    System.out.println("Deleted user with ID: " + userIdToDelete);
} else {
    System.out.println("User with ID " + userIdToDelete + " not found.");
}
					
				
			
		



Verifica se o usuário existe.
Se o usuário for encontrado, invoca session.delete(user) para remover o registro do banco de dados.
Exibe uma mensagem de confirmação.


Commit da Transação
    




		
		
			
			
Java
			
			session.getTransaction().commit();
			
				
					
				
					1
				
						session.getTransaction().commit();
					
				
			
		



Faz o commit da transação, tornando a exclusão permanente no banco de dados.


Fechando o SessionFactory
    




		
		
			
			
Java
			
			factory.close();
			
				
					
				
					1
				
						factory.close();
					
				
			
		



Fecha o SessionFactory para liberar recursos.



Saída Esperada
Ao executar a aplicação, você deverá ver a seguinte saída no console:




		
		
			
			
Java
			
			Deleted user with ID: 3
			
				
					
				
					1
				
						Deleted user with ID: 3
					
				
			
		


Se o usuário com ID 3 não existir, a saída será:




		
		
			
			
Java
			
			User with ID 3 not found.
			
				
					
				
					1
				
						User with ID 3 not found.
					
				
			
		



Executando a Aplicação
Para executar a operação delete, siga estes passos:

Garantir a Conectividade com o Banco de Dados

Verifique se o servidor do banco de dados está em execução.
Confirme que o hibernate.cfg.xml possui os detalhes de conexão corretos.


Compilar a Aplicação
Use sua IDE preferida (por exemplo, Eclipse, IntelliJ) ou ferramentas de linha de comando para compilar o projeto.

Executar a Classe App.java
Execute a classe App. O Hibernate iniciará a sessão, realizará a operação delete e fará o commit da transação.

Verificar a Exclusão

Verifique seu banco de dados para confirmar que o usuário com ID 3 foi excluído.
Alternativamente, você pode executar uma operação de leitura para tentar buscar o usuário excluído.




Melhores Práticas para Excluir Registros
Excluir registros de um banco de dados é uma operação sensível. Adotar as melhores práticas garante a integridade dos dados e a estabilidade da aplicação.
1. Validar Antes da Exclusão
Sempre verifique se o registro existe antes de tentar excluí-lo. Isso previne exceções e garante que sua aplicação lide com casos onde o registro pode não estar presente.




		
		
			
			
Java
			
			if (user != null) {
    session.delete(user);
} else {
    // Tratar o caso onde o usuário não existe
}
			
				
					
				
					1
2
3
4
5
				
						if (user != null) {
    session.delete(user);
} else {
    // Tratar o caso onde o usuário não existe
}
					
				
			
		


2. Usar Transações Inteligentemente
Encapsule suas operações delete dentro de transações. Isso permite que você faça rollback das mudanças em caso de falhas, mantendo a consistência do banco de dados.




		
		
			
			
Java
			
			try {
    session.beginTransaction();
    // Realizar operação delete
    session.getTransaction().commit();
} catch (Exception e) {
    session.getTransaction().rollback();
}
			
				
					
				
					1
2
3
4
5
6
7
				
						try {
    session.beginTransaction();
    // Realizar operação delete
    session.getTransaction().commit();
} catch (Exception e) {
    session.getTransaction().rollback();
}
					
				
			
		


3. Tratar Cascading Deletes Adequadamente
Se seus relacionamentos de entidades exigirem cascading deletes, certifique-se de que seus mapeamentos do Hibernate estão configurados corretamente para lidar com registros dependentes.




		
		
			
			
Java
			
			@OneToMany(mappedBy="user", cascade=CascadeType.ALL)
private Set<Order> orders;
			
				
					
				
					1
2
				
						@OneToMany(mappedBy="user", cascade=CascadeType.ALL)
private Set<Order> orders;
					
				
			
		


4. Implementar Soft Deletes Quando Necessário
Às vezes, você pode não querer excluir registros permanentemente. Implementar soft deletes (marcar registros como inativos) pode ajudar em cenários onde a recuperação de dados pode ser necessária.




		
		
			
			
Java
			
			@Entity
public class Users {
    // Outros campos

    @Column(name = "active")
    private boolean active;

    // Getter e Setter
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						@Entity
public class Users {
    // Outros campos
 
    @Column(name = "active")
    private boolean active;
 
    // Getter e Setter
}
					
				
			
		


5. Registrar Atividades de Exclusão
Mantenha logs das operações delete para rastrear mudanças e auxiliar em processos de depuração ou auditoria.




		
		
			
			
Java
			
			System.out.println("Deleted user with ID: " + userIdToDelete);
			
				
					
				
					1
				
						System.out.println("Deleted user with ID: " + userIdToDelete);
					
				
			
		



Conclusão
Excluir registros usando Hibernate é uma operação direta, mas poderosa, essencial para uma gestão robusta de dados em aplicações Java. Seguindo a abordagem estruturada delineada neste guia—configurando o Hibernate, implementando o método de exclusão e aderindo às melhores práticas—você pode garantir que as exclusões sejam tratadas de forma eficiente e segura.
Principais Pontos:

Compreender o papel das operações CRUD dentro do Hibernate.
Configurar corretamente o Hibernate e suas classes de entidade.
Implementar a lógica de exclusão com validação e gerenciamento de transações.
Seguir as melhores práticas para manter a integridade dos dados e a estabilidade da aplicação.

Inicie sua jornada com Hibernate com confiança e aproveite a operação delete para manter um banco de dados limpo e eficiente.
Note: That this article is AI generated.
Operação	Descrição	Método do Hibernate
Create	Inserir novos registros	session.save()
Read	Recuperar registros existentes	session.get()
Update	Modificar registros existentes	session.update()
Delete	Remover registros	session.delete()