Forem: Jonathas Rocha

Lombok + Gradle + IntelliJ (Java 21) — Guia rápido

Jonathas Rocha — Fri, 21 Nov 2025 20:10:43 +0000

Passo a passo resumido para configurar o Lombok no IntelliJ com Gradle usando Java 21.

Instale o plugin Lombok no IntelliJ Settings → Plugins → Marketplace → Lombok → Install → Reinicie o IDE.
Habilite Annotation Processing Settings → Build, Execution, Deployment → Compiler → Annotation Processors → marque Enable annotation processing.
Configure o Java 21 (toolchain) no Gradle
Adicione o Lombok corretamente nas dependências (main e test) do build.gradle

dependencies {
  compileOnly 'org.projectlombok:lombok:1.18.38'
  annotationProcessor 'org.projectlombok:lombok:1.18.38'

  testCompileOnly 'org.projectlombok:lombok:1.18.38'
  testAnnotationProcessor 'org.projectlombok:lombok:1.18.38'

  // ... your others dependencies
}

Não use implementation para Lombok.

Sincronize e compile
No IntelliJ: clique em Load/Reload Gradle Changes (ícone do elefante).
No terminal:

./gradlew clean build
Teste rápido

import lombok.*;

@Data
@Builder
class Demo { private String name; }

Se Demo.builder() e getName() existirem, está tudo certo. Para validar, você poderá gerar uma classe de Teste, como no exemplo abaixo.

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class DemoTest {
    @Test
    void testBuilderAndGetter() {
        Demo demo = Demo.builder().name("Jonathas").build();
        assertEquals("Jonathas", demo.getName());
    }
}

Dica!!

Após alterar o build.gradle, sempre dê um clean + build ou Reload Gradle no IDE.

Busca de um valor em todas as tabelas e colunas no PostgreSQL 🐘

Jonathas Rocha — Tue, 21 Oct 2025 18:06:41 +0000

Fazer SELECT ... WHERE coluna ILIKE '%valor%' manualmente em dezenas de tabelas não é prático!

A solução!?

Podemos simplesmente percorrer todas as tabelas (ignorando views para evitar erros) e checar colunas de tipos textuais (varchar, text, char, json, jsonb).

O script abaixo cria uma tabela temporária com os resultados da busca.

DO $$
DECLARE
    r RECORD;
    v_sql   TEXT;
    v_needle TEXT := 'jonathasrocha';  -- termo a procurar
BEGIN
    -- tabela temporária para guardar achados
    CREATE TEMP TABLE IF NOT EXISTS search_hits (
        schema_name text,
        table_name  text,
        column_name text,
        row_count   integer
    ) ON COMMIT DROP;

    TRUNCATE search_hits;

    FOR r IN
        SELECT c.table_schema, c.table_name, c.column_name
        FROM information_schema.columns c
        JOIN information_schema.tables  t
          ON t.table_schema = c.table_schema
         AND t.table_name   = c.table_name
        WHERE t.table_type = 'BASE TABLE'
          AND c.table_schema NOT IN ('pg_catalog','information_schema')
          AND c.data_type IN ('character varying','text','character','json','jsonb')
    LOOP
        v_sql := format(
            'INSERT INTO search_hits(schema_name, table_name, column_name, row_count)
             SELECT %L, %L, %L, COUNT(*)
             FROM %I.%I
             WHERE %I::text ILIKE $1',
            r.table_schema, r.table_name, r.column_name,
            r.table_schema, r.table_name,
            r.column_name
        );

        BEGIN
            EXECUTE v_sql USING '%' || v_needle || '%';
        EXCEPTION
            WHEN others THEN
                RAISE NOTICE 'Ignorando %.% (%.%): %',
                    r.table_schema, r.table_name, r.column_name, SQLERRM;
        END;
    END LOOP;
END $$ LANGUAGE plpgsql;

-- Consulta na tabela de resultados
SELECT *
FROM search_hits
WHERE row_count > 0
ORDER BY row_count DESC, schema_name, table_name, column_name;

Exemplo da saída

O resultado será uma lista de schemas, tabelas e colunas onde o valor foi encontrado, junto com a quantidade de ocorrências:

 schema_name | table_name | column_name | row_count
-------------+------------+-------------+-----------
 public      | user       | email       |        2
 public      | orders     | client      |        1

Com esse snippet em praticidade, mapeando onde está um dado dentro do PostgreSQL.

Use sem rodeio e sem limites, vai por mim... Facilita muitoo!

👉 Já precisou “caçar” um dado perdido no banco e não soube como?

Configurando o Postgres e DBeaver no macOS através do Homebrew

Jonathas Rocha — Mon, 08 Sep 2025 15:49:59 +0000

Subir o PostgreSQL no macOS não é nadinha complicado. Com os passos certos, em minutos você terá o banco rodando e pronto para ser usado no DBeaver.

1. Verificando se o Postgres já está instalado

Primeiro, confirme se o cliente do PostgreSQL (psql) já existe:

psql --version

Se aparecer algo como psql (PostgreSQL) 14.12 (Homebrew), significa que o Postgres está instalado.

Caso não esteja, você pode instalar via Homebrew:

brew install postgresql@14

2. Iniciando o servidor do PostgreSQL

Para iniciar o Postgres como serviço no macOS:

brew services start postgresql@14

Se quiser rodar apenas no terminal, sem manter em background:

pg_ctl -D /opt/homebrew/var/postgresql@14 start

Verifique se o servidor está ativo:

brew services list | grep postgres

3. Lidando com erros comuns

Ao tentar conectar, talvez você encontre mensagens como:

Role inexistente:

FATAL: role "postgres" does not exist

Database inexistente:

FATAL: database "seu_usuario" does not exist

Isso significa que o cluster do Postgres foi iniciado sem as roles ou bancos padrões.

4. Inicializando o cluster manualmente

Se necessário, inicialize o cluster para garantir a estrutura básica:

initdb --locale=C -D /opt/homebrew/var/postgresql@14

E inicie novamente o servidor:

pg_ctl -D /opt/homebrew/var/postgresql@14 start

5. Criando a role e o banco

postgres

Agora conecte-se ao servidor:

psql -d postgres

Dentro do console do psql, crie a role e o banco de forma explícita:

CREATE ROLE postgres WITH LOGIN SUPERUSER PASSWORD 'sua_senha_aqui';
CREATE DATABASE postgres OWNER postgres;

Depois disso, você já consegue acessar normalmente:

psql -U postgres -h localhost

6. Conectando via DBeaver

Com o Postgres rodando e configurado, basta abrir o DBeaver e criar uma nova conexão:

Host: localhost
Porta: 5432
Database: postgres
Usuário: postgres
Senha: a que você definiu no passo anterior

Teste a conexão e pronto: o DBeaver estará conectado ao seu banco local.

Conclusão

Esse passo a passo é simples, mas cobre os erros mais comuns ao configurar o PostgreSQL no macOS via Homebrew.

Dicas práticas e lições da minha jornada até a certificação AWS Cloud Practitioner

Jonathas Rocha — Sat, 16 Aug 2025 00:40:57 +0000

Introdução: O Primeiro Passo na Jornada

A certificação AWS Cloud Practitioner é considerada a porta de entrada para o universo da AWS. Junto com a certificação voltada para Inteligência Artificial, ela compõe o nível mais básico da trilha de certificações da Amazon Web Services.

Mas como tudo na vida, temos que começar de algum lugar, certo? E com uma base sólida, podemos mirar nas próximas certificações que se alinham ao nosso plano de carreira.

Primeira Tentativa: A Bola na Trave

Minha primeira tentativa foi há alguns anos. Infelizmente, não consegui avançar naquela época. A bola bateu na trave, ameaçou entrar... e furou!

Na ocasião, obtive uma nota de 6,9 (7 é a nota necessária para aprovação). Apesar da frustração, essa experiência me trouxe percepções valiosas sobre estudo, preparação e resiliência.

Recomeço com Foco e Estratégia

Com essas lições em mente, decidi retomar os estudos com mais foco e constância. Aprendi muito sobre:

Compromisso com prazos
Técnicas de estudo
Constância e disciplina
Equilíbrio entre teoria e prática

Durante alguns meses, estudei por meio de simulados específicos da certificação. Usava a plataforma da UDEMY e também o curso em inglês AWS Certified Cloud Practitioner.

Minha rotina incluía:

Refazer questões erradas do simulado, por pelo menos duas vezes
Revisar rapidamente as questões acertadas
Estudar com prática usando o AWS SimuLearn
Estudar focado nos temas de dúvidas
Jogar o AWS Card Clash por pelo menos 2h durante a semana

Técnicas de Estudo (com moderação!)

Usei algumas técnicas de estudo que pretendo compartilhar em um artigo futuro. Mas deixo aqui um conselho: não perca muito tempo escolhendo a técnica perfeita. Faça uma pesquisa rápida, escolha uma abordagem e comece!

Não existe uma maneira melhor de estudar que funciona para todos, se adapte com a forma que você aprende melhor!

AWS Card Clash: Aprendizado com Diversão

Um recurso que me ajudou muito a conhecer os serviços da AWS foi o jogo de cartas “AWS Card Clash”, disponibilizado pela própria AWS.

Zerei três dos quatro módulos do game 🎮, e ele foi um ótimo aliado nos momentos de estudo mais estressantes ou desanimadores. Além de divertido, me ajudava a manter o entusiasmo e bater minhas metas.

Conclusão: Conquista e Reflexão

Essa jornada me ensinou que persistência e estratégia fazem toda a diferença. Hoje, comemoro essa conquista com a certeza de que estou mais preparado para os próximos passos na nuvem.

Se você está começando ou pensando em tentar a certificação, vá em frente! Comece pequeno, mas comece.

E claro, não posso deixar de agradecer à minha esposa e família, que esteve ao meu lado durante todo esse processo — apoiando, incentivando e celebrando comigo. 💙

Hibernate: Roteiro básico de implementação

Jonathas Rocha — Thu, 21 Jul 2022 02:44:51 +0000

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

📚

Entendendo e iniciando com Hibernate

Jonathas Rocha — Mon, 18 Jul 2022 02:54:26 +0000

Tabela de Conteúdos:

Introdução
Algumas informações referentes ao Hibernate
O que é Hibernate
Introdução ao Hibernate
Prós da utilização do Hibernate
Configuração

Introdução

Este post é uma explicação e exemplificação resumida sobre Hibernate e JPA. Ao final do artigo estão algumas referências, vídeos e repositórios caso você queira se aprofundar ainda mais no assunto. Sou o Jonathas, e desde ja lhe desejo bons estudos!

Informações referentes ao Hibernate

Licença: GNU Lesser General Public License (Open-source)
Surgimento: 23 de Maio de 2001
Desenvolvedora: Red Hat

Repositórios:
https://github.com/hibernate

Sobre o Hibernate

O Hibernate é uma framework de ORM para a linguagem de programação Java. ORM significa Object Relational Mapper, ou mapeador de objeto relacional. O Hibernate é uma ferramenta muito utilizada nos dias de hoje, sendo, a mais conhecida entre os frameworks de ORM para Java.

O Hibernate tem o propósito de unir a orientação a objetos e bancos relacionais de uma maneira muito mais simples e descomplicada.

O framework Hibernate é o mais conhecido, dentre os frameworks ORM para a linguagem Java.

Prós da utilização do Hibernate

Economia de esforço e preocupação
Gerar o código SQL para qualquer banco de dados relacional
Gera o código SQL a partir de anotações, sem gerar dor de cabeça aos desenvolvedores
Confiabilidade. O Hibernate está a muito tempo no mercado, utilizado por grandes empresas e com uma comunidade ativa
Podemos trocar o banco de dados utilizado sem ter que alterar o código-fonte
Alta performance
Manutenabilidade
Escalabilidade
Produtividade
Provedor JPA
Open Source

JPA

Java Persistence API (ou simplesmente JPA) é uma API padrão da linguagem Java que descreve uma interface comum para frameworks de persistência de dados. A JPA define um meio de mapeamento objeto-relacional para objetos Java simples e comuns, denominados beans de entidade.

A JPA, funciona através de qualquer framework ORM (Mapeamento Objeto Relacional) baseado na especificação JPA. Pode ser o framework Hibernate, EclipseLink, TopLink, OpenJpa, etc.

JPA é muito utilizado para conexão e acesso a banco de dados relacionais.

A ORM é a implementação da interface JPA. No nosso caso a ORM que utilizamos aqui neste artigo é o Hibernate.

Anotações no Hibernate (annotations)

Utilizamos anotações, para mapear modelos de base de dados. Possibilitando assim gerar alterações referentes as bases de dados, através das anotações.

As anotações são claras e intuitivas. Entre as anotações mais importantes temos o Entity, Table, Id e Column.

O @Entity, é utilizado para declarar uma entidade.
O @Table, é utilizado para declarar uma tabela no banco de dados.
O @id, é usado para declararmos o atributo id da nossa tabela.
O @Column, declaramos os atributos/colunas de uma tabela.

Prática (exemplo)

`Tecnologias e Ferramentas`

MySql Community
Java JDK
Intellij Community Edition 2022.1
SGBD de sua preferência (DbVisualizer, Workbench, DBeaver, etc)
Spring Boot (Maven Dependencies)
- Spring Web (Web)
- Spring Data JPA (SQL)
- Spring Data
- Hibernate
- MySQL Driver (SQL)

`Passo 01: Criação do projeto`

Vamos acessar a página oficial do Spring Initializr, através do link: https://start.spring.io/.

Em seguida Selecionamos o tipo do projeto Maven na parte 'Project'
Selecionamos Java, na parte 'Language'.
Selecionamos uma versão estável na parte 'Spring Boot', sendo a atual 2.7.1
Nomeamos o grupo, nome do projeto e afins
Selecionamos a versão do Java que estamos utilizando;
Selecionamos a dependencia Spring Data JPA (SQL)
Selecionamos a dependencia MySQL Driver (SQL)
Clicamos em 'Generate' e o projeto passa a ser baixado

`Passo 02: Abrindo o projeto no Intellij`

Vamos extrair o a pasta do projeto. Pode ser utilizado o WinRar, 7Zip, ou até mesmo alguma ferramenta nativa do sistema operacional que você estiver utilizando.

Em seguida abra seu projeto no Intellij, ou outra ferramenta de sua preferência como Eclipse, VSCode ou NetBeans.

New > Module from Existing Sources... > Selecionamos nosso projeto > Selecionamos "import..." Maven > Clícamos em 'create'

`Passo 03: Criando um banco de dados e testando conexão`

No meu caso, estarei utilizando o banco de dados MySQL Community e o SGBD Workbench.

Configure uma nova conexão no banco de dados, ou utilize uma existente. Teste a conexão do mesmo.

Crie um novo banco de dados com um nome de sua preferência e pronto!

`Passo 04: Configurando o application.properties no projeto`

No arquivo application.properties. Encontrando em 'src > main > resources'. Adicione o seguinte trecho de código:

spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://localhost:3306/tutorial
spring.datasource.username=root
spring.datasource.password=admin

Referencie seus dados conforme cada propriedade da configuração do seu banco de dados (porta, nome do banco, username, password (senha)).

`Passo 05: Estruturando o projeto`

`Passo 06: Criando 'Entities' e 'Repositories'`

`Passo 07: Testes - CRUD`

Referências:

Algaworks- Alexandre Afonso - Tutorial definitivo: JPA
Tidicas - JPA
Wikipedia - JPA (Java Persistence API)
DevMedia - JDBC
DevMedia - Introdução ao Hibernate 3.5
Medium - Eduardo Ribeiro - Hibernate com Java 11
Youtube - Expertos Tech- COMO CRIAR UMA API REST EM JAVA E SPRING BOOT PASSO A PASSO