Introdução ao Hibernate
Foto de Luis P.
Por: Luis P.
16 de Janeiro de 2025

Introdução ao Hibernate

Mapeamento Objeto-Relacional (ORM)

Java Hibernate orm

O Hibernate é um framework de Mapeamento Objeto-Relacional (ORM) que facilita a interação entre aplicações Java e bancos de dados. Ele abstrai a complexidade de escrever consultas SQL diretamente, permitindo que os desenvolvedores manipulem dados em um banco de forma transparente, usando objetos Java.

Neste artigo, exploraremos os conceitos básicos do Hibernate, como configurar o framework e realizar operações CRUD.


Benefícios do Hibernate

  1. Abstração do SQL: Permite manipular dados diretamente como objetos, eliminando a necessidade de escrever consultas SQL manualmente.
  2. Independência de Banco de Dados: Suporte a múltiplos bancos de dados com mudanças mínimas de configuração.
  3. Gerenciamento de Cache: Oferece suporte a caching para melhorar o desempenho.
  4. Validação Automática: Integração com Bean Validation para validação de dados.
  5. Suporte a Consultas Avançadas: Inclui a Hibernate Query Language (HQL) e Criteria API.

Configurando o Hibernate

1. Dependências Maven

Adicione as dependências necessárias no arquivo pom.xml:

<dependencies>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>6.2.2.Final</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate.validator</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>8.0.0.Final</version>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

2. Configuração do Arquivo hibernate.cfg.xml

Crie o arquivo de configuração no diretório src/main/resources:

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">org.h2.Driver</property>
        <property name="hibernate.connection.url">jdbc:h2:mem:testdb</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password"></property>
        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
    </session-factory>
</hibernate-configuration>

Criando uma Entidade Hibernate

As entidades são classes Java mapeadas para tabelas no banco de dados. Use as anotações do pacote javax.persistence para definir o mapeamento.

Exemplo de Entidade

import jakarta.persistence.*;

@Entity
@Table(name = "produtos")
public class Produto {

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

    @Column(nullable = false)
    private String nome;

    @Column(nullable = false)
    private Double preco;

    // Getters e Setters
    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 Double getPreco() {
        return preco;
    }

    public void setPreco(Double preco) {
        this.preco = preco;
    }
}

Operações CRUD com Hibernate

1. Configurando o SessionFactory

O SessionFactory é responsável por criar sessões para interagir com o banco de dados.

Exemplo:

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            return new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void shutdown() {
        getSessionFactory().close();
    }
}

2. Inserindo um Registro

import org.hibernate.Session;

public class Main {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();

        Produto produto = new Produto();
        produto.setNome("Notebook");
        produto.setPreco(3000.0);

        session.save(produto);
        session.getTransaction().commit();
        session.close();
    }
}

3. Lendo Registros

import org.hibernate.Session;

public class Main {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSessionFactory().openSession();

        Produto produto = session.get(Produto.class, 1L);
        if (produto != null) {
            System.out.println("Produto: " + produto.getNome());
        }

        session.close();
    }
}

4. Atualizando um Registro

import org.hibernate.Session;

public class Main {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();

        Produto produto = session.get(Produto.class, 1L);
        if (produto != null) {
            produto.setPreco(3200.0);
            session.update(produto);
        }

        session.getTransaction().commit();
        session.close();
    }
}

5. Deletando um Registro

import org.hibernate.Session;

public class Main {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();

        Produto produto = session.get(Produto.class, 1L);
        if (produto != null) {
            session.delete(produto);
        }

        session.getTransaction().commit();
        session.close();
    }
}

Boas Práticas com Hibernate

  1. Use Cache: Configure o cache de segundo nível para melhorar o desempenho.
  2. Valide os Dados: Utilize Bean Validation para validar os campos das entidades.
  3. Gerencie Sessões Corretamente: Sempre feche as sessões para evitar vazamentos de recursos.
  4. Escreva Consultas Otimizadas: Use HQL ou Criteria para consultas avançadas.
  5. Evite Configurações Padrão: Ajuste as configurações de acordo com as necessidades do projeto.

O Hibernate simplifica significativamente o desenvolvimento de aplicações Java que interagem com bancos de dados. Ao adotar boas práticas e entender seus principais recursos, você pode criar sistemas robustos e escaláveis. Experimente o Hibernate em seu próximo projeto e aproveite o poder do mapeamento objeto-relacional!

Luis P.
Luis P.
Boa Ventura / PB
Responde em 20 min
Identidade verificada
1ª hora grátis
5,0
nota média
1
avaliação
R$ 40
por hora
Graduação: Licenciatura em Computação (UEPB - Universidade Estadual da Paraíba)
Java para Web, Java - Springboot, Testes em Java
Professor de informática, português e inglês. Formado em computação e letras inglês/português. Servidor público aprovado em 3 concursos.

Confira artigos similares

Aprenda sobre qualquer assunto