Hibernate: Roteiro básico de implementação
Tags: java, hibernate, sql, devs
Published: 2022-07-21 02:44:51

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](https://start.spring.io/).

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. 

![Criando banco](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d8aricov1vgt5ek2o4m9.png)

Caso esteja com dúvidas [Acesse esse link](https://www.w3schools.com/sql/sql_create_db.asp), 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](https://github.com/jonathasrochadesouza)
[LinkedIn](https://www.linkedin.com/in/jonathasrochadesouza/)

📚