Hibernate: Roteiro básico de implementação

Bem vindo, Jonathas por aqui. Desde já, desejando bons estudos.

Segue um roteiro de implementação do Hibernate, para seus estudos 😎📚.

💻 Instalações

• Java
• PostgreSQL
• IDEA Java (Intellij, Eclipse ou NetBeans)
• SGBD (Dbeaver, PostgreSQL, etc)

Iniciando o projeto

Podemos iniciar o projeto a partir do Spring. Através da página do Spring Initializr.

Selecionando as seguintes dependências:

• Spring Data JPA (SQL)
• PostgreSQL Driver (SQL)
• Spring Web (Web)

Devemos selecionar Maven Project, como projeto. Temos também outras configurações para selecionarmos e configurarmos, como versões, nomes do projeto. Selecione de acordo a versão do Java em sua máquina 💻. O nome pode escolher como preferir também 😉.

Criação do banco

É necessário criarmos um banco de dados, que chamaremos depois nas configurações JDBC, XML, etc. Mas, não precisa se preocupar agora.

Vamos por parte!

Crie sua base de dados.

Caso esteja com dúvidas Acesse esse link, referente ao w3Schools, sobre criação de banco de dados.

Abrindo o projeto

No meu caso utilizo o Intellij community. Caso você utilize outra IDE, não se preocupe, abrir o projeto não é tão diferente.

Pelo Intellij.
Clicar em File > Abrir > 'Selecionamos nosso projeto' > 'Clicamos em abrir'.
Em seguida: File > New > Module From Existing Sources > 'Selecionamos nosso projeto' > Próximo > Import [...] - Maven > Create

Criando nossos fontes

Agora a parte boa! 🤠

Vamos criar nossas entidades.

Exemplo:

@Entity
@Table(name="usuario")
@Immutable
public class UsuarioEntity {

    @Id
    @NotNull
    @Column(name = "id")
    @GeneratedValue(strategy= GenerationType.AUTO)
    public Integer id;

    @NotNull
    @Column(length = 50)
    public String nome;

}

Aqui colocamos dois atributos (ops, colunas) no banco de dados. São o id (que é quase obrigatório) e o nome. Apenas para fixarmos a ideia.

• A anotação (@) Entity, é para definirmos entidades/tabelas no nosso banco.
• A anotação (@) Table(name="usuario") é para definirmos que é uma tabela e para passarmos o nome que essa tabela terá no banco de dados.
• A anotação (@) Id é para definirmos nosso id da tabela, ou identificador único (pk).
• A anotação (@) NotNull é para definirmos que não poderá ser nulo.
• A anotação (@) GeneratedValue(strategy= GenerationType.AUTO) é para definirmos que deverá gerar valores auto increments, ou seja, automáticos.

Esse foi um exemplo básico das infinitas possibilidades que o Hibernate proporciona 👀

O Hibernate permite ainda:

• Criar toda a estrutura do seu banco de dados
• Alterar todo o banco de dados através do código do próprio java
• Realizar filtros e selects em dados
• Entre outras infinitas possibilidades! 🌌🌌

Configuração 🛠

No arquivo application.properties, cole o seguinte:

spring.datasource.url= jdbc:postgresql://localhost:5432/nome_do_seu_banco_aqui
spring.datasource.username= postgres
spring.datasource.password= admin
spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation= true
spring.jpa.properties.hibernate.dialect= org.hibernate.dialect.PostgreSQLDialect
# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto= update

Configure a porta onde seu PostgreSQL está rodando, o nome do banco, nome de usuário e senha do banco.

Em seguida, faremos algumas configurações para rodar o SessionFactory no 'main', para podermos validar se nossa entidade funciona.

Crie um arquivo chamado hibernate.cfg.xml, na pasta do resources (a mesma pasta que está o application.properties).

Em seu arquivo hibernate.cfg.xml, cole o seguinte:

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>

        <property name="connection.url">jdbc:postgresql://localhost:5432/nome_do_seu_banco_aqui</property>
        <property name="connection.username">postgres</property>
        <property name="connection.password">admin</property>
        <property name="connection.driver_class">org.postgresql.Driver</property>

        <property name="dialect">org.hibernate.dialect.PostgreSQL10Dialect</property>
        <property name="hbm2ddl.auto">update</property>

        <property name="show_sql">true</property>
        <property name="format_sql">true</property>

        <property name="hibernate.current_session_context_class">thread</property>

        <mapping class="jonathas.javabasicapi.UserEntity" />

    </session-factory>
</hibernate-configuration>

WHAT!? Que isso? 🤨

Pois então, este é um arquivo .xml, para configuração do Session, que iremos utilizar para rodar alguns creates. Esse arquivo serve de referencia para a factory, encontrar a base de dados e persistir alterações!

Configure também nesse arquivo a porta onde seu PostgreSQL está rodando, o nome do banco, nome de usuário e senha do banco.

Gerando um create, e aparecendo na base de dados

A parte legal! 🥱

Nas nossas entidades, devemos gerar getters e setters. Devemos também gerar um construtor que irá receber argumentos (com exceção do id) para referir a nosso objeto/entidade. Veja abaixo o exemplo:

package jonathas.javabasicapi;

import com.sun.istack.NotNull;
import org.hibernate.annotations.Immutable;

import javax.persistence.*;

@Entity
@Table
@Immutable
public class UsuarioEntity {

    public UsuarioEntity(String nome) {
        this.nome = nome;
    }

    @Id
    @NotNull
    @Column(name = "id")
    @GeneratedValue(strategy= GenerationType.AUTO)
    public Integer id;

    @NotNull
    @Column(length = 50)
    public String nome;

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

}

Perceba que adicionamos o set e get do nome. Também adicionamos o construtor. Perceba que está mais fácil do que parecia...

Agora no seu Application (main), cole o seguinte:

SessionFactory sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();

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

        UsuarioEntity usuario = new UsuarioEntity();
        usuario.setName("jonas");

        session.persist(usuario);

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

Aqui referenciamos o arquivo de configuração que criamos, lembra, aquele .xml... Em seguida abrimos uma SessionFactory, que é a responsável por 'fabricar' nosso SQL pra gente.

Espero que dê tudo certo aí na sua máquina e rode 100%.

Aprofundando um pouco mais... 🧐

• Dê uma olhada nas dependências que estão no arquivo .pom, referente ao Maven
• Tente criar alguns relacionamentos entre tabelas utilizando o Hibernate

Próximos passos! 😮

Você pode estudar em seguida:

• Foreign Keys com Hibernate
• LAZY e EAGER
• JPA
• JDBC
• Repository
• REST
• Questões mais avançadas como Query DSL
• Entre outros. 🌌

⚠ Atenção!!

• Verifique os imports que está realizando!
• Se não deu certo, não se desespere, pode ser questões de versão, alguma coisa que acabou colando errado. Dê uma olhada no log e pesquise no Google, ou direto no StackOverFlow 😅. Afinal, nosso trabalho além de criar é arrumar bugs 🤣.

Enfim, parabéns por chegar até aqui. Espero que tenha aprendido muito! 😀

Se gostou me segue aqui e em outras redes!

GitHub
LinkedIn

📚