Desvendando o Hibernate: torne o mapeamento objeto-relacional fácil em Java

Rocketseat

5 min de leitura

Conheça o Rocketseat Para Empresas

Oferecemos soluções personalizadas para empresas de todos os portes.

No desenvolvimento de aplicações Java, uma das maiores dores de cabeça é lidar com a complexidade de bancos de dados relacionais. Felizmente, o Hibernate chegou para simplificar este processo. Mas o que exatamente é o Hibernate, como ele funciona e por que ele é tão popular entre os desenvolvedores? Prepare-se para descobrir e dar os primeiros passos com essa ferramenta poderosa.

O que é Hibernate?

O Hibernate é um framework de mapeamento objeto-relacional (ORM) para Java que atua como um intermediário entre objetos da linguagem e tabelas de banco de dados. Em vez de escrever SQL manualmente, você pode usar o Hibernate para traduzir automaticamente objetos Java em comandos SQL e vice-versa.

Imagine nunca mais precisar escrever longas consultas SQL para tarefas simples. Esse é o poder do Hibernate!

Benefícios do Hibernate

Se você está se perguntando por que deveria usar o Hibernate, aqui estão alguns dos principais benefícios:

Abstração do SQL: elimina a necessidade de escrever consultas SQL complexas.

Portabilidade: o mesmo código pode ser usado com diferentes bancos de dados, bastando configurar o dialeto correto.

Produtividade: reduz o tempo de desenvolvimento ao permitir que você foque na lógica da aplicação.

Manutenção: com o mapeamento centralizado, qualquer alteração no banco de dados reflete facilmente na aplicação.

Segurança: minimiza riscos de ataques como SQL Injection, pois utiliza consultas parametrizadas.

Como o Hibernate funciona?

O Hibernate utiliza uma combinação de anotações e/ou arquivos de configuração XML para mapear as classes Java às tabelas do banco de dados. Aqui está um panorama básico:

Configuração: o Hibernate é configurado com detalhes do banco de dados e as classes mapeadas.

Session Factory: um objeto que gerencia sessões responsáveis por conexões ao banco.

Sessão: uma conexão ativa para realizar operações no banco, como salvar ou recuperar dados.

Mapeamento: anotações ou XML definem como os atributos das classes correspondem às colunas do banco.

Operações CRUD: salvar, ler, atualizar e deletar registros utilizando os métodos do Hibernate.

Exemplo prático: configurando o Hibernate

Configuração inicial

Adicione as dependências do Hibernate ao seu projeto usando o Maven ou Gradle. No Maven, por exemplo:


<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>6.2.7.Final</version>
</dependency>

Configuração de banco

Um arquivo hibernate.cfg.xml básico pode parecer assim:


<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/seu_banco</property>
        <property name="hibernate.connection.username">usuario</property>
        <property name="hibernate.connection.password">senha</property>
    </session-factory>
</hibernate-configuration>

Mapeando uma entidade

Aqui está como mapear uma classe Java para uma tabela no banco:


@Entity
@Table(name = "usuarios")
public class Usuario {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "nome")
    private String nome;

    @Column(name = "email")
    private String email;

    // Getters e Setters
}

Operações CRUD no Hibernate

Salvando dados


try (Session session = sessionFactory.openSession()) {
    session.beginTransaction();

    Usuario usuario = new Usuario();
    usuario.setNome("Diego");
    usuario.setEmail("diego@example.com");

    session.save(usuario);
    session.getTransaction().commit();
}

Buscando dados


try (Session session = sessionFactory.openSession()) {
    Usuario usuario = session.get(Usuario.class, 1L);
    System.out.println(usuario.getNome());
}

Hibernate Query Language (HQL)

Com o HQL, você pode fazer consultas baseadas em objetos Java, como neste exemplo:


String hql = "FROM Usuario WHERE email = :email";
Query<Usuario> query = session.createQuery(hql, Usuario.class);
query.setParameter("email", "diego@example.com");
Usuario usuario = query.getSingleResult();

Mapeamento objeto-relacional no Hibernate

Uma das maiores forças do Hibernate é o suporte a diferentes tipos de mapeamento:

Relacionamento um para um


@Entity
public class Pessoa {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToOne
    @JoinColumn(name = "endereco_id")
    private Endereco endereco;
}

Relacionamento um para muitos


@Entity
public class Pedido {
    @OneToMany(mappedBy = "pedido", cascade = CascadeType.ALL)
    private List<Item> itens;
}

Relacionamento muitos para muitos


@Entity
public class Curso {
    @ManyToMany
    @JoinTable(
        name = "curso_estudante",
        joinColumns = @JoinColumn(name = "curso_id"),
        inverseJoinColumns = @JoinColumn(name = "estudante_id")
    )
    private Set<Estudante> estudantes;
}

Herança e polimorfismo

O Hibernate suporta herança entre entidades, simplificando modelos complexos:


@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Pessoa {
    @Id
    private Long id;
    private String nome;
}

@Entity
public class Funcionario extends Pessoa {
    private String cargo;
}

Transações no Hibernate

As transações são cruciais para garantir a integridade e a consistência dos dados. O Hibernate utiliza a API de transações do Java para gerenciar essas operações.

Exemplo prático: transferência bancária


public void transferir(Long contaOrigemId, Long contaDestinoId, double valor) {
    Transaction tx = null;
    try (Session session = sessionFactory.openSession()) {
        tx = session.beginTransaction();

        Conta origem = session.get(Conta.class, contaOrigemId);
        Conta destino = session.get(Conta.class, contaDestinoId);

        origem.sacar(valor);
        destino.depositar(valor);

        tx.commit();
    } catch (Exception e) {
        if (tx != null && tx.isActive()) {
            tx.rollback();
        }
        // Log e tratamento da exceção
    }
}

Importância:

Atomicidade: tudo ou nada.

Consistência: o banco sempre reflete um estado válido.

Isolamento: evita interferências entre transações concorrentes.

Durabilidade: alterações persistem após confirmação.

Gerenciamento de sessões e transações

Gerenciar corretamente as sessões e transações é crucial para manter a integridade dos dados e a eficiência da aplicação. Um mau gerenciamento pode levar a vazamentos de recursos e inconsistências no banco de dados.

Exemplo de código com tratamento adequado de exceções e fechamento de recursos:


Transaction transaction = null;
try (Session session = sessionFactory.openSession()) {
    transaction = session.beginTransaction();

    Usuario usuario = new Usuario();
    usuario.setNome("Diego");
    usuario.setEmail("diego@example.com");

    session.save(usuario);
    transaction.commit();
} catch (Exception e) {
    if (transaction != null && transaction.isActive()) {
        transaction.rollback();
    }
    logger.error("Erro ao salvar usuário", e);
    // Aqui você pode adicionar lógica para reverter transações ou outras ações de recuperação
}

Explicação:

try-with-resources: o bloco try (Session session = sessionFactory.openSession()) garante que a sessão será fechada automaticamente ao final do bloco, mesmo que ocorra uma exceção.

Transaction management: inicia uma transação com session.beginTransaction() e a confirma com transaction.commit(). Em caso de falha, a transação pode ser revertida dentro do bloco catch.

Tratamento de exceções: captura qualquer exceção que ocorra durante a operação, permitindo que a aplicação lide com erros de forma controlada.

Melhores práticas:

Sempre feche a sessão: utilize try-with-resources ou um bloco finally para garantir que a sessão seja fechada.

Gerencie transações com cuidado: certifique-se de que transações sejam confirmadas (commit) ou revertidas (rollback) apropriadamente.

Tratamento de exceções: implemente um sistema de logs ou notificações para monitorar e responder a erros.

Cache no Hibernate

Para otimizar o desempenho, o Hibernate implementa dois níveis de cache:

Primeiro nível: ativado por padrão, armazena dados dentro da sessão.

Segundo nível: compartilhado entre sessões e configurável com ferramentas como Ehcache.

Configuração de Cache:


<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhcacheRegionFactory</property>

Detalhes sobre Cache no Hibernate

O cache é uma ferramenta poderosa para melhorar o desempenho da sua aplicação, reduzindo o número de acessos ao banco de dados.

Primeiro nível de Cache (Session Cache)

Descrição: ativado por padrão, armazena entidades dentro do escopo da sessão atual.

Uso: não requer configuração adicional.

Limitação: não compartilha dados entre diferentes sessões.

Segundo nível de Cache (Session Factory Cache)

Descrição: compartilha entidades entre diferentes sessões e transações.

Vantagens:

Reduz chamadas ao banco de dados para entidades frequentemente acessadas.
Melhora significativamente o desempenho em aplicações de grande escala.

Requer configuração: precisa ser explicitamente ativado e configurado.

Configurando o Cache de segundo nível

Escolha um provedor de Cache: Ehcache, Infinispan, Hazelcast, entre outros.

Adicione dependências: inclua a biblioteca do provedor no seu projeto.

Configure o Hibernate: atualize o arquivo hibernate.cfg.xml ou persistence.xml.

Exemplo com Ehcache:

Dependência Maven:


<!-- Dependência para o Hibernate -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>6.2.7.Final</version>
</dependency>

<!-- Dependência para o Ehcache -->
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.10.9</version>
</dependency>

Configuração no hibernate.cfg.xml:


<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">
    org.hibernate.cache.ehcache.EhcacheRegionFactory
</property>

Anotando entidades para Cache:


@Entity
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Produto {
    // atributos e métodos
}

Estratégias de concorrência

READ_ONLY: para entidades que não mudam, como tabelas de referência.

NONSTRICT_READ_WRITE: permite leitura e escrita, mas não garante isolamento total.

READ_WRITE: garante que os dados sejam atualizados de forma consistente.

TRANSACTIONAL: usa transações do banco de dados para gerenciar o cache.

O que é Hibernate?

Imagine nunca mais precisar escrever longas consultas SQL para tarefas simples. Esse é o poder do Hibernate!

Benefícios do Hibernate

Se você está se perguntando por que deveria usar o Hibernate, aqui estão alguns dos principais benefícios:

Abstração do SQL: elimina a necessidade de escrever consultas SQL complexas.

Portabilidade: o mesmo código pode ser usado com diferentes bancos de dados, bastando configurar o dialeto correto.

Produtividade: reduz o tempo de desenvolvimento ao permitir que você foque na lógica da aplicação.

Manutenção: com o mapeamento centralizado, qualquer alteração no banco de dados reflete facilmente na aplicação.

Segurança: minimiza riscos de ataques como SQL Injection, pois utiliza consultas parametrizadas.

Como o Hibernate funciona?

O Hibernate utiliza uma combinação de anotações e/ou arquivos de configuração XML para mapear as classes Java às tabelas do banco de dados. Aqui está um panorama básico:

Configuração: o Hibernate é configurado com detalhes do banco de dados e as classes mapeadas.

Session Factory: um objeto que gerencia sessões responsáveis por conexões ao banco.

Sessão: uma conexão ativa para realizar operações no banco, como salvar ou recuperar dados.

Mapeamento: anotações ou XML definem como os atributos das classes correspondem às colunas do banco.

Operações CRUD: salvar, ler, atualizar e deletar registros utilizando os métodos do Hibernate.

Exemplo prático: configurando o Hibernate

Configuração inicial

Adicione as dependências do Hibernate ao seu projeto usando o Maven ou Gradle. No Maven, por exemplo:


<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>6.2.7.Final</version>
</dependency>

Configuração de banco

Um arquivo hibernate.cfg.xml básico pode parecer assim:


<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/seu_banco</property>
        <property name="hibernate.connection.username">usuario</property>
        <property name="hibernate.connection.password">senha</property>
    </session-factory>
</hibernate-configuration>

Mapeando uma entidade

Aqui está como mapear uma classe Java para uma tabela no banco:


@Entity
@Table(name = "usuarios")
public class Usuario {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "nome")
    private String nome;

    @Column(name = "email")
    private String email;

    // Getters e Setters
}

Operações CRUD no Hibernate

Salvando dados


try (Session session = sessionFactory.openSession()) {
    session.beginTransaction();

    Usuario usuario = new Usuario();
    usuario.setNome("Diego");
    usuario.setEmail("diego@example.com");

    session.save(usuario);
    session.getTransaction().commit();
}

Buscando dados


try (Session session = sessionFactory.openSession()) {
    Usuario usuario = session.get(Usuario.class, 1L);
    System.out.println(usuario.getNome());
}

Hibernate Query Language (HQL)

Com o HQL, você pode fazer consultas baseadas em objetos Java, como neste exemplo:


String hql = "FROM Usuario WHERE email = :email";
Query<Usuario> query = session.createQuery(hql, Usuario.class);
query.setParameter("email", "diego@example.com");
Usuario usuario = query.getSingleResult();

Mapeamento objeto-relacional no Hibernate

Uma das maiores forças do Hibernate é o suporte a diferentes tipos de mapeamento:

Relacionamento um para um


@Entity
public class Pessoa {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToOne
    @JoinColumn(name = "endereco_id")
    private Endereco endereco;
}

Relacionamento um para muitos


@Entity
public class Pedido {
    @OneToMany(mappedBy = "pedido", cascade = CascadeType.ALL)
    private List<Item> itens;
}

Relacionamento muitos para muitos


@Entity
public class Curso {
    @ManyToMany
    @JoinTable(
        name = "curso_estudante",
        joinColumns = @JoinColumn(name = "curso_id"),
        inverseJoinColumns = @JoinColumn(name = "estudante_id")
    )
    private Set<Estudante> estudantes;
}

Herança e polimorfismo

O Hibernate suporta herança entre entidades, simplificando modelos complexos:


@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Pessoa {
    @Id
    private Long id;
    private String nome;
}

@Entity
public class Funcionario extends Pessoa {
    private String cargo;
}

Transações no Hibernate

As transações são cruciais para garantir a integridade e a consistência dos dados. O Hibernate utiliza a API de transações do Java para gerenciar essas operações.

Exemplo prático: transferência bancária


public void transferir(Long contaOrigemId, Long contaDestinoId, double valor) {
    Transaction tx = null;
    try (Session session = sessionFactory.openSession()) {
        tx = session.beginTransaction();

        Conta origem = session.get(Conta.class, contaOrigemId);
        Conta destino = session.get(Conta.class, contaDestinoId);

        origem.sacar(valor);
        destino.depositar(valor);

        tx.commit();
    } catch (Exception e) {
        if (tx != null && tx.isActive()) {
            tx.rollback();
        }
        // Log e tratamento da exceção
    }
}

Importância:

Atomicidade: tudo ou nada.

Consistência: o banco sempre reflete um estado válido.

Isolamento: evita interferências entre transações concorrentes.

Durabilidade: alterações persistem após confirmação.

Gerenciamento de sessões e transações

Exemplo de código com tratamento adequado de exceções e fechamento de recursos:


Transaction transaction = null;
try (Session session = sessionFactory.openSession()) {
    transaction = session.beginTransaction();

    Usuario usuario = new Usuario();
    usuario.setNome("Diego");
    usuario.setEmail("diego@example.com");

    session.save(usuario);
    transaction.commit();
} catch (Exception e) {
    if (transaction != null && transaction.isActive()) {
        transaction.rollback();
    }
    logger.error("Erro ao salvar usuário", e);
    // Aqui você pode adicionar lógica para reverter transações ou outras ações de recuperação
}

Explicação:

try-with-resources: o bloco try (Session session = sessionFactory.openSession()) garante que a sessão será fechada automaticamente ao final do bloco, mesmo que ocorra uma exceção.

Transaction management: inicia uma transação com session.beginTransaction() e a confirma com transaction.commit(). Em caso de falha, a transação pode ser revertida dentro do bloco catch.

Tratamento de exceções: captura qualquer exceção que ocorra durante a operação, permitindo que a aplicação lide com erros de forma controlada.

Melhores práticas:

Sempre feche a sessão: utilize try-with-resources ou um bloco finally para garantir que a sessão seja fechada.

Gerencie transações com cuidado: certifique-se de que transações sejam confirmadas (commit) ou revertidas (rollback) apropriadamente.

Tratamento de exceções: implemente um sistema de logs ou notificações para monitorar e responder a erros.

Cache no Hibernate

Para otimizar o desempenho, o Hibernate implementa dois níveis de cache:

Primeiro nível: ativado por padrão, armazena dados dentro da sessão.

Segundo nível: compartilhado entre sessões e configurável com ferramentas como Ehcache.

Configuração de Cache:


<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhcacheRegionFactory</property>

Detalhes sobre Cache no Hibernate

O cache é uma ferramenta poderosa para melhorar o desempenho da sua aplicação, reduzindo o número de acessos ao banco de dados.

Primeiro nível de Cache (Session Cache)

Descrição: ativado por padrão, armazena entidades dentro do escopo da sessão atual.

Uso: não requer configuração adicional.

Limitação: não compartilha dados entre diferentes sessões.

Segundo nível de Cache (Session Factory Cache)

Descrição: compartilha entidades entre diferentes sessões e transações.

Vantagens:

Reduz chamadas ao banco de dados para entidades frequentemente acessadas.
Melhora significativamente o desempenho em aplicações de grande escala.

Requer configuração: precisa ser explicitamente ativado e configurado.

Configurando o Cache de segundo nível

Escolha um provedor de Cache: Ehcache, Infinispan, Hazelcast, entre outros.

Adicione dependências: inclua a biblioteca do provedor no seu projeto.

Configure o Hibernate: atualize o arquivo hibernate.cfg.xml ou persistence.xml.

Exemplo com Ehcache:

Dependência Maven:


<!-- Dependência para o Hibernate -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>6.2.7.Final</version>
</dependency>

<!-- Dependência para o Ehcache -->
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.10.9</version>
</dependency>

Configuração no hibernate.cfg.xml:


<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">
    org.hibernate.cache.ehcache.EhcacheRegionFactory
</property>

Anotando entidades para Cache:


@Entity
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Produto {
    // atributos e métodos
}

Estratégias de concorrência

READ_ONLY: para entidades que não mudam, como tabelas de referência.

NONSTRICT_READ_WRITE: permite leitura e escrita, mas não garante isolamento total.

READ_WRITE: garante que os dados sejam atualizados de forma consistente.

TRANSACTIONAL: usa transações do banco de dados para gerenciar o cache.

O que é Hibernate?

Imagine nunca mais precisar escrever longas consultas SQL para tarefas simples. Esse é o poder do Hibernate!

Benefícios do Hibernate

Se você está se perguntando por que deveria usar o Hibernate, aqui estão alguns dos principais benefícios:

Abstração do SQL: elimina a necessidade de escrever consultas SQL complexas.

Portabilidade: o mesmo código pode ser usado com diferentes bancos de dados, bastando configurar o dialeto correto.

Produtividade: reduz o tempo de desenvolvimento ao permitir que você foque na lógica da aplicação.

Manutenção: com o mapeamento centralizado, qualquer alteração no banco de dados reflete facilmente na aplicação.

Segurança: minimiza riscos de ataques como SQL Injection, pois utiliza consultas parametrizadas.

Como o Hibernate funciona?

O Hibernate utiliza uma combinação de anotações e/ou arquivos de configuração XML para mapear as classes Java às tabelas do banco de dados. Aqui está um panorama básico:

Configuração: o Hibernate é configurado com detalhes do banco de dados e as classes mapeadas.

Session Factory: um objeto que gerencia sessões responsáveis por conexões ao banco.

Sessão: uma conexão ativa para realizar operações no banco, como salvar ou recuperar dados.

Mapeamento: anotações ou XML definem como os atributos das classes correspondem às colunas do banco.

Operações CRUD: salvar, ler, atualizar e deletar registros utilizando os métodos do Hibernate.

Exemplo prático: configurando o Hibernate

Configuração inicial

Adicione as dependências do Hibernate ao seu projeto usando o Maven ou Gradle. No Maven, por exemplo:


<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>6.2.7.Final</version>
</dependency>

Configuração de banco

Um arquivo hibernate.cfg.xml básico pode parecer assim:


<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/seu_banco</property>
        <property name="hibernate.connection.username">usuario</property>
        <property name="hibernate.connection.password">senha</property>
    </session-factory>
</hibernate-configuration>

Mapeando uma entidade

Aqui está como mapear uma classe Java para uma tabela no banco:


@Entity
@Table(name = "usuarios")
public class Usuario {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "nome")
    private String nome;

    @Column(name = "email")
    private String email;

    // Getters e Setters
}

Operações CRUD no Hibernate

Salvando dados


try (Session session = sessionFactory.openSession()) {
    session.beginTransaction();

    Usuario usuario = new Usuario();
    usuario.setNome("Diego");
    usuario.setEmail("diego@example.com");

    session.save(usuario);
    session.getTransaction().commit();
}

Buscando dados


try (Session session = sessionFactory.openSession()) {
    Usuario usuario = session.get(Usuario.class, 1L);
    System.out.println(usuario.getNome());
}

Hibernate Query Language (HQL)

Com o HQL, você pode fazer consultas baseadas em objetos Java, como neste exemplo:


String hql = "FROM Usuario WHERE email = :email";
Query<Usuario> query = session.createQuery(hql, Usuario.class);
query.setParameter("email", "diego@example.com");
Usuario usuario = query.getSingleResult();

Mapeamento objeto-relacional no Hibernate

Uma das maiores forças do Hibernate é o suporte a diferentes tipos de mapeamento:

Relacionamento um para um


@Entity
public class Pessoa {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToOne
    @JoinColumn(name = "endereco_id")
    private Endereco endereco;
}

Relacionamento um para muitos


@Entity
public class Pedido {
    @OneToMany(mappedBy = "pedido", cascade = CascadeType.ALL)
    private List<Item> itens;
}

Relacionamento muitos para muitos


@Entity
public class Curso {
    @ManyToMany
    @JoinTable(
        name = "curso_estudante",
        joinColumns = @JoinColumn(name = "curso_id"),
        inverseJoinColumns = @JoinColumn(name = "estudante_id")
    )
    private Set<Estudante> estudantes;
}

Herança e polimorfismo

O Hibernate suporta herança entre entidades, simplificando modelos complexos:


@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Pessoa {
    @Id
    private Long id;
    private String nome;
}

@Entity
public class Funcionario extends Pessoa {
    private String cargo;
}

Transações no Hibernate

As transações são cruciais para garantir a integridade e a consistência dos dados. O Hibernate utiliza a API de transações do Java para gerenciar essas operações.

Exemplo prático: transferência bancária


public void transferir(Long contaOrigemId, Long contaDestinoId, double valor) {
    Transaction tx = null;
    try (Session session = sessionFactory.openSession()) {
        tx = session.beginTransaction();

        Conta origem = session.get(Conta.class, contaOrigemId);
        Conta destino = session.get(Conta.class, contaDestinoId);

        origem.sacar(valor);
        destino.depositar(valor);

        tx.commit();
    } catch (Exception e) {
        if (tx != null && tx.isActive()) {
            tx.rollback();
        }
        // Log e tratamento da exceção
    }
}

Importância:

Atomicidade: tudo ou nada.

Consistência: o banco sempre reflete um estado válido.

Isolamento: evita interferências entre transações concorrentes.

Durabilidade: alterações persistem após confirmação.

Gerenciamento de sessões e transações

Exemplo de código com tratamento adequado de exceções e fechamento de recursos:


Transaction transaction = null;
try (Session session = sessionFactory.openSession()) {
    transaction = session.beginTransaction();

    Usuario usuario = new Usuario();
    usuario.setNome("Diego");
    usuario.setEmail("diego@example.com");

    session.save(usuario);
    transaction.commit();
} catch (Exception e) {
    if (transaction != null && transaction.isActive()) {
        transaction.rollback();
    }
    logger.error("Erro ao salvar usuário", e);
    // Aqui você pode adicionar lógica para reverter transações ou outras ações de recuperação
}

Explicação:

try-with-resources: o bloco try (Session session = sessionFactory.openSession()) garante que a sessão será fechada automaticamente ao final do bloco, mesmo que ocorra uma exceção.

Transaction management: inicia uma transação com session.beginTransaction() e a confirma com transaction.commit(). Em caso de falha, a transação pode ser revertida dentro do bloco catch.

Tratamento de exceções: captura qualquer exceção que ocorra durante a operação, permitindo que a aplicação lide com erros de forma controlada.

Melhores práticas:

Sempre feche a sessão: utilize try-with-resources ou um bloco finally para garantir que a sessão seja fechada.

Gerencie transações com cuidado: certifique-se de que transações sejam confirmadas (commit) ou revertidas (rollback) apropriadamente.

Tratamento de exceções: implemente um sistema de logs ou notificações para monitorar e responder a erros.

Cache no Hibernate

Para otimizar o desempenho, o Hibernate implementa dois níveis de cache:

Primeiro nível: ativado por padrão, armazena dados dentro da sessão.

Segundo nível: compartilhado entre sessões e configurável com ferramentas como Ehcache.

Configuração de Cache:


<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhcacheRegionFactory</property>

Detalhes sobre Cache no Hibernate

O cache é uma ferramenta poderosa para melhorar o desempenho da sua aplicação, reduzindo o número de acessos ao banco de dados.

Primeiro nível de Cache (Session Cache)

Descrição: ativado por padrão, armazena entidades dentro do escopo da sessão atual.

Uso: não requer configuração adicional.

Limitação: não compartilha dados entre diferentes sessões.

Segundo nível de Cache (Session Factory Cache)

Descrição: compartilha entidades entre diferentes sessões e transações.

Vantagens:

Reduz chamadas ao banco de dados para entidades frequentemente acessadas.
Melhora significativamente o desempenho em aplicações de grande escala.

Requer configuração: precisa ser explicitamente ativado e configurado.

Configurando o Cache de segundo nível

Escolha um provedor de Cache: Ehcache, Infinispan, Hazelcast, entre outros.

Adicione dependências: inclua a biblioteca do provedor no seu projeto.

Configure o Hibernate: atualize o arquivo hibernate.cfg.xml ou persistence.xml.

Exemplo com Ehcache:

Dependência Maven:


<!-- Dependência para o Hibernate -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>6.2.7.Final</version>
</dependency>

<!-- Dependência para o Ehcache -->
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.10.9</version>
</dependency>

Configuração no hibernate.cfg.xml:


<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">
    org.hibernate.cache.ehcache.EhcacheRegionFactory
</property>

Anotando entidades para Cache:


@Entity
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Produto {
    // atributos e métodos
}

Estratégias de concorrência

READ_ONLY: para entidades que não mudam, como tabelas de referência.

NONSTRICT_READ_WRITE: permite leitura e escrita, mas não garante isolamento total.

READ_WRITE: garante que os dados sejam atualizados de forma consistente.

TRANSACTIONAL: usa transações do banco de dados para gerenciar o cache.

Conheça o Rocketseat Para Empresas

Oferecemos soluções personalizadas para empresas de todos os portes.

Rocketseat

Ecossistema de educação contínua referência em programação e Inteligência Artificial.

Artigos_

Explore conteúdos relacionados

Descubra mais artigos que complementam seu aprendizado e expandem seu conhecimento.

NewsletterReceba conteúdos inéditos e novidades gratuitamente