Forem: Alex Reis

O que são generics?

Alex Reis — Thu, 12 Feb 2026 11:00:00 +0000

Generics são uma funcionalidade introduzida no Java 5 que permite criar classes, interfaces e métodos que trabalham com diferentes tipos de dados. Eles eliminam a necessidade de conversões explícitas (casts) e ajudam a detectar erros em tempo de compilação.

Antes do Java 5, as coleções tratavam tudo como Object. Isso gerava dois problemas:

Casting Excessivo: Você tinha que fazer cast (String) toda vez que tirava algo da lista.
Insegurança: Nada impedia você de colocar um Integer numa lista que deveria ser só de String. O erro só estourava na cara do usuário (Runtime).

// Código antigo
List lista = new ArrayList(); // Lista "crua" (Raw Type)
lista.add("Olá");
lista.add(10); // O compilador deixa passar!

// O erro só acontece AQUI, quando o programa está rodando:
String texto = (String) lista.get(1); // ClassCastException!

// Código novo com Generics
List<String> lista = new ArrayList<>();
lista.add("Olá");
// lista.add(10); // O compilador NEM DEIXA compilar. Erro na hora!

String texto = lista.get(0); // Sem necessidade de cast manual.

Variáveis de tipo

Generics permitem que classes e métodos operem em objetos de vários tipos, garantindo a segurança em tempo de compilação (Compile-time safety).

Usamos letras maiúsculas por convenção para representar esses tipos genéricos:

T: Type (Tipo genérico)
E: Element (usado em Collections)
K, V: Key, Value (usado em Maps)

Classe Genérica

Uma classe genérica utiliza um parâmetro de tipo representado por <T>, que funciona como um placeholder para o tipo real.

// <T> define que esta classe aceita um parâmetro de tipo
public class Caixa<T> {
    private T conteudo;

    public void guardar(T conteudo) {
        this.conteudo = conteudo;
    }

    public T abrir() {
        return conteudo;
    }
}

public class AulaGenerics {
    public static void main(String[] args) {
        // Caixa que só aceita Strings
        Caixa<String> caixaDeTexto = new Caixa<>();
        caixaDeTexto.guardar("Segredo");
        // caixaDeTexto.guardar(123); // Erro de compilação!

        // Caixa que só aceita Inteiros
        Caixa<Integer> caixaDeNumeros = new Caixa<>();
        caixaDeNumeros.guardar(100);
    }
}

<T> é substituído por String ou Integer no momento da criação do objeto.

Wildcards

Os wildcards (?) são usados para representar tipos desconhecidos em generics. Eles são úteis para criar métodos que aceitam diferentes tipos de coleções.

<?>: Qualquer coisa.
<? extends T> (Upper Bounded): Aceita T ou qualquer filho de T.
- Uso: Quando você quer apenas LER dados (Get).
<? super T> (Lower Bounded): Aceita T ou qualquer pai de T.
- Uso: Quando você quer ESCREVER dados (Add).

Exemplo Prático

public class Wildcards {

    // Aceita lista de Number OU QUALQUER FILHO (Integer, Double...)
    // Só consigo LER com segurança (sei que tudo ali é Number)
    public static double somarLista(List<? extends Number> lista) {
        double soma = 0;
        for (Number n : lista) { // Posso ler como Number
            soma += n.doubleValue();
        }
        // lista.add(10); // ERRO! Não posso adicionar nada (não sei se é lista de Double ou Integer)
        return soma;
    }

    public static void main(String[] args) {
        List<Integer> inteiros = new ArrayList<>();
        inteiros.add(1);
        inteiros.add(2);

        List<Double> doubles = new ArrayList<>();
        doubles.add(1.5);
        doubles.add(2.5);

        // O método aceita ambos!
        System.out.println(somarLista(inteiros));
        System.out.println(somarLista(doubles));
    }
}

Type Erasure

Generics só existem para o Compilador. Depois que o código vira .class (Bytecode), o Java apaga todas as informações de Generics e substitui por Object (ou pelo limite superior) e insere os casts automaticamente.

Isso significa que, em tempo de execução, List<String> e List<Integer> são a mesma classe (List). Isso foi feito para manter compatibilidade com versões antigas do Java.

Interfaces Funcionais

Alex Reis — Wed, 11 Feb 2026 11:38:56 +0000

Uma interface funcional é definida como uma interface que não é declarada como selada (sealed) e pode conter métodos default e static mas possui exatamente um método abstrato (além dos métodos da classe Object).

Além da maneira tradicional (declarando e instanciando uma classe), instâncias de interfaces funcionais podem ser criadas de forma mais concisa utilizando expressões lambda e referências de método.

Existe ainda a anotação @FunctionalInterface que serve para indicar que uma interface deve ser funcional. Se uma interface for anotada dessa forma, mas não atender aos requisitos (como ter mais de um método abstrato), o compilador gerará um erro. No entanto, ela é opcional.

Para evitar que tenhamos que criar uma nova interface toda vez que precisarmos de uma função simples, o Java fornece um pacote padrão com as interfaces funcionais mais comuns (java.util.function). As quatro principais são:

Predicate<T>: Recebe um argumento e retorna um boolean.
- Uso: Filtros e condicionais.
- Método abstrato: test(T t)
Consumer<T>: Recebe um argumento e não retorna nada (void).
- Uso: Impressão de dados, gravação em banco, efeitos colaterais.
- Método abstrato: accept(T t)
Function<T, R>: Recebe um argumento do tipo T e retorna um resultado do tipo R.
- Uso: Transformação de dados (mapeamento).
- Método abstrato: apply(T t)
Supplier<T>: Não recebe argumentos e retorna um resultado do tipo T.
- Uso: Factories, geração preguiçosa (lazy) de dados.
- Método abstrato: get()

Exemplo prático

import java.util.function.Predicate;

// 1. Definindo uma Interface Funcional Customizada
@FunctionalInterface
interface ConversorTexto {
    String converter(String texto); // Único método abstrato

    // Método default não quebra a regra de interface funcional
    default void imprimirLog() {
        System.out.println("Executando conversão...");
    }
}

public class AulaInterfaces {
    public static void main(String[] args) {

        // --- USO DA INTERFACE CUSTOMIZADA ---

        // Implementação clássica (Classe Anônima) - O jeito antigo
        ConversorTexto gritarClassico = new ConversorTexto() {
            @Override
            public String converter(String texto) {
                return texto.toUpperCase() + "!!!";
            }
        };

        // Implementação com Lambda - O jeito moderno
        // O compilador infere que 's' é o argumento de 'converter'
        ConversorTexto gritarLambda = s -> s.toUpperCase() + "!!!";

        System.out.println(gritarLambda.converter("bom dia")); 
        // Saída: BOM DIA!!!


        // --- USO DE INTERFACE PADRÃO (Predicate) ---

        // Predicate verifica uma condição
        Predicate<Integer> isPar = numero -> numero % 2 == 0;

        validarNumero(10, isPar); // Passando comportamento como argumento
        validarNumero(7, isPar);
    }

    // Método que aceita um comportamento (Predicate) como parâmetro
    public static void validarNumero(int n, Predicate<Integer> regra) {
        if (regra.test(n)) {
            System.out.println(n + " passou na regra.");
        } else {
            System.out.println(n + " não passou na regra.");
        }
    }
}

Leituras Complementares

Documentação Oficial Oracle: Pacote java.util.function.
Livro: "Java 8 in Action" (Raoul-Gabriel Urma) - Capítulo sobre Lambdas.
Artigo: "Functional Interfaces in Java" no Baeldung.

O que são Expressões Lambdas?

Alex Reis — Tue, 10 Feb 2026 11:34:59 +0000

Você sabe o que são Expressões Lambdas (Lambda Expressions)? As Expressões Lambda, introduzidas no Java 8, permitem que você trate "comportamento" como se fosse um dado.

Segunda a Java Language Specification: As expressões lambda são estruturas semelhantes a métodos que fornecem uma lista de parâmetros formais e um corpo (que pode ser uma expressão ou um bloco de código) expressos em termos desses parâmetros

Antes do Java 8, se você quisesse passar um pedaço de código para ser executado (ex: num clique de botão ou numa Thread), você precisava criar uma Classe Anônima.

Jeito velho:

// Criando uma Thread antiga
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Executando tarefa...");
    }
}).start();

Jeito novo:

// "() ->" significa: Sem argumentos, execute isso.
new Thread(() -> System.out.println("Executando tarefa...")).start();

O principal objetivo de uma expressão lambda é produzir uma instância de uma interface funcional (uma interface que possui exatamente um método abstrato).
Elas oferecem uma sintaxe muito mais concisa do que as declarações de classes anônimas. ### Sintaxe e estrutura Uma expressão lambda é composta de três partes. Pense nela como uma função sem nome. A sintaxe básica é composta por: (Parâmetros) -> { Corpo }.
Sem parâmetros: () -> System.out.println("Oi");
Um parâmetro: (s) -> System.out.println(s); (Pode omitir parênteses se for só um).
Múltiplos parâmetros: Devem estar entre parênteses. Exemplo: (x, y) -> x + y.
Parâmetros não nomeados: É possível usar o caractere _ (underscore) para declarar um parâmetro cujo valor não será utilizado no corpo da lambda.
Com retorno: (a, b) -> { return a + b; }
Simplificado: (a, b) -> a + b (Se só tiver uma linha, não precisa de {} nem da palavra return).

Você pode declarar os tipos dos parâmetros (exclusivamente para todos ou nenhum) ou deixar que o compilador os infira a partir do contexto da interface funcional.

Regras de Uso e Contexto

Onde usar: Devem ocorrer apenas em contextos de atribuição, de invocação (como argumentos de métodos) ou de cast (conversão explícita). O Java só permite Lambda quando o tipo esperado é uma Interface Funcional.

Captura de Variáveis: Uma lambda pode acessar variáveis locais do escopo ao seu redor, desde que essas variáveis sejam finais ou efetivamente finais (ou seja, seu valor nunca mude após a inicialização).

Exemplo prático

List<String> nomes = Arrays.asList("Ana", "Pedro", "Ze", "Maria");

// Jeito Antigo (Classe Anônima)
Collections.sort(nomes, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
});

// Jeito Novo
// O Java sabe que s1 e s2 são Strings (Inferência de Tipo)
Collections.sort(nomes, (s1, s2) -> Integer.compare(s1.length(), s2.length()));

Method Reference

Muitas vezes, uma expressão Lambda não faz nada além de chamar um método que já existe, você pode deixar o código ainda mais limpo usando o operador "quatro pontos" (::).
Por exemplo: s -> System.out.println(s). Perceba que o parâmetro s é apenas repassado para o método println. Não há lógica adicional.

Exemplos:

// Lambda: numero -> Math.abs(numero)
Function<Integer, Integer> valorAbsoluto = Math::abs;

// O objeto 'System.out' já existe.
// Lambda: s -> System.out.println(s)
Consumer<String> impressora = System.out::println;

// Aqui, o método toUpperCase é chamado NA instância da String passada
// Lambda: s -> s.toUpperCase()
Function<String, String> maiuscula = String::toUpperCase;

// Exemplo composto:
List<String> nomes = Arrays.asList("java", "python", "c");
// A String "java" chama o método compareTo passando "python"
nomes.sort(String::compareTo); 

// Lambda: () -> new String()
Supplier<String> novaString = String::new;

Referência

The Java Language Specification, Java SE 24 Edition

Entendendo Flyway

Alex Reis — Mon, 27 Oct 2025 10:30:00 +0000

Nota: Isto não é um artigo, são minhas anotações de estudo sobre o que é o Flyway, que resolvi postar.

O Flyway é uma ferramenta de versionamento de banco de dados.
Ele ajuda a controlar e aplicar mudanças no esquema do banco (migrations) de forma segura e automatizada — assim como o Git controla versões de código. Ele é específico para banco de dados relacionais.

Scripts

Você cria arquivos SQL chamados migrations. Cada um representa uma mudança no banco. Eles seguem uma convenção de nome:

V1__create_message_table.sql
V2__create_room_table.sql

V é de versão e o número (1, 2) diz a ordem em que devem ser executados.

Tabela de controle

Quando o Flyway roda pela primeira vez, ele cria uma tabela dentro do seu banco, chamada por padrão de:

flyway_schema_history

Essa tabela guarda o histórico de todas as migrações aplicadas.

Execução

Quando a aplicação inicia (ou quando você roda o comando flyway migrate), o Flyway faz o seguinte:

Lê todos os arquivos de migração disponíveis na pasta configurada (por exemplo, db/migration/);
Compara com a tabela flyway_schema_history do banco;
Executa apenas os scripts que ainda não foram aplicados, em ordem crescente de versão. ### Controle de integridade O Flyway guarda também um checksum (hash) de cada script. Se alguém altera um script antigo (por exemplo, muda V2__create_room_table.sql depois de aplicado), o Flyway detecta a diferença e gera erro — pra evitar inconsistência entre versões do banco. ### Repetição e rollback As migrations são pensadas para serem irreversíveis (você cria novas versões em vez de apagar ou alterar antigas). Se precisar “voltar atrás”, cria um novo script que desfaz a alteração anterior (em vez de alterar o antigo). ## Spring Boot O Spring Boot detecta automaticamente o Flyway durante a inicialização se o projeto tiver a dependência no pom.xml. ### Inicialização Quando o Spring Boot inicia, ele faz algo nesta ordem:
Cria a conexão com o banco (DataSource).
Antes de carregar seus repositórios, entidades JPA, etc., ele chama o Flyway.
O Flyway:
- Cria (se não existir) a tabela flyway_schema_history.
- Procura por scripts na pasta padrão classpath:db/migration/.
- Aplica os que ainda não estão marcados como executados.
- Só depois disso o Spring continua inicializando o restante da aplicação. Isso garante que o banco já esteja na versão certa antes de qualquer entidade JPA tentar interagir com ele.

Dentro do projeto você cria algo assim:

src
└── main
    ├── java/...
    └── resources
        └── db
            └── migration
                ├── V1__create_table_users.sql
                ├── V2__add_column_email.sql
                └── V3__insert_initial_data.sql

Cada arquivo é uma migration. Quando a aplicação sobe, o Flyway lê esses arquivos e aplica o que falta.

Configuração do `application.properties`

Você pode personalizar a configuração:

spring.flyway.enabled=true
spring.flyway.locations=classpath:db/migration
spring.flyway.baseline-on-migrate=true
spring.flyway.user=postgres
spring.flyway.password=1234
spring.flyway.url=jdbc:postgresql://localhost:5432/meubanco

Relacionamentos Bidirecionais vs Unidirecionais no Spring JPA

Alex Reis — Thu, 21 Aug 2025 11:52:04 +0000

Recentemente eu estava desenvolvendo um projeto pessoal de API para gerenciamento de lojas, mas tive dificuldasde ao tentar modelar os relacionamentos entre as entidades. O problema estava em entender qual melhor abordagem bidirecional ou unidirecional. Este artigo demonstra as conclusões que tive ao estudar vantagens e casos de uso dos tipos de relacionamento e o uso de fetch do Spring Data JPA.

Relacionamentos: Navegação e Complexidade

Relacionamentos Bidirecionais: Flexibilidade com Responsabilidade

Os relacionamentos bidirecionais permitem navegação em ambas as direções, criando uma conexão completa entre entidades. Por exemplo, em um sistema de e-commerce, tanto um Pedido pode acessar seu Cliente quanto um Cliente pode listar todos os seus Pedidos.

Vantagens dos relacionamentos bidirecionais:

Navegação intuitiva: Facilita a escrita de código mais legível e expressivo
Flexibilidade de consultas: Permite acessar dados relacionados de qualquer direção
Adequado para interfaces ricas: Ideal para dashboards e sistemas que exigem contexto completo

Desvantagens:

Complexidade no mapeamento: Requer atenção especial ao definir o lado proprietário da relação usando mappedBy
Risco de inconsistências: Necessita sincronização cuidadosa quando ambos os lados são modificados
Possível impacto na performance: Pode gerar joins desnecessários se não for bem configurado

Relacionamentos Unidirecionais: Simplicidade e Performance

Os relacionamentos unidirecionais oferecem uma abordagem mais simples, onde apenas uma entidade conhece a outra. Um Produto pode conhecer sua Categoria, mas a Categoria não mantém referência direta aos produtos.

Vantagens dos relacionamentos unidirecionais:

Simplicidade arquitetural: Menor complexidade de implementação e manutenção
Performance otimizada: Redução de joins automáticos desnecessários
Melhor encapsulamento: Evita exposição desnecessárias de entidades

Limitações:

Navegação restrita: Consultas reversas exigem joins manuais ou queries customizadas
Menos flexibilidade: Pode requerer refatoração se novos casos de uso surgirem

Estratégias de Carregamento: Eager vs Lazy

FetchType.EAGER: Carregamento Imediato

O carregamento eager traz os dados relacionados junto com a consulta principal, usando joins SQL ou múltiplas consultas.

@OneToMany(fetch = FetchType.EAGER)
private List<Pedido> pedidos;

Cenários adequados para EAGER:

Relações pequenas que são sempre utilizadas
Casos onde a LazyInitializationException seria problemática
Entidades com poucos relacionamentos

FetchType.LAZY: Carregamento Sob Demanda

O carregamento lazy utiliza proxies que são resolvidos apenas quando os dados são efetivamente acessados.

@OneToMany(fetch = FetchType.LAZY)
private List<Pedido> pedidos;

Cenários adequados para LAZY:

Relações grandes ou que não são sempre utilizadas
Sistemas com foco em performance
APIs REST que utilizam DTOs para controle de dados expostos

Tomada de Decisão

Escolhendo a Direção do Relacionamento

Cenário	Recomendação
Navegação frequente em ambas as direções	Bidirecional
Domínios fortemente conectados (Aluno ↔ Curso)	Bidirecional
APIs com consumo unidirecional	Unidirecional
Foco em performance e simplicidade	Unidirecional

Definindo a Estratégia de Fetch

Situação	Estratégia
Entidades com muitas relações	LAZY
Relações sempre utilizadas	EAGER (com cuidado)
APIs REST com DTOs	LAZY
Operações em batch	LAZY com JOIN FETCH controlado

Abordagem Recomendada: Evolução Gradual

A melhor prática é começar com relacionamentos unidirecionais e fetch LAZY, evoluindo conforme necessário:

Inicie simples: Implemente relacionamentos unidirecionais com LAZY loading
Monitore o uso: Identifique padrões de acesso aos dados
Evolua quando necessário: Adicione navegação bidirecional apenas quando houver justificativa concreta
Otimize seletivamente: Use EAGER apenas para relações comprovadamente críticas

Conclusão

A modelagem de relacionamentos no Spring JPA é uma arte que equilibra flexibilidade, performance e manutenibilidade. Relacionamentos unidirecionais com carregamento lazy oferecem um ponto de partida sólido, permitindo evolução baseada em necessidades reais do sistema.

A chave está em evitar over-engineering inicialmente, para sim construir uma base sólida que possa crescer organicamente com os requisitos do projeto. Monitore a performance, documente as decisões arquiteturais e mantenha a flexibilidade para ajustes futuros.

O que é JWT?

Alex Reis — Mon, 09 Jun 2025 11:00:00 +0000

JWT

JSON Web Token (JWT) é um padrão (RFC 7519) para transmitir informações de forma segura entre partes como um objeto JSON. Ele é compacto e autoassinado. As informações contidas nele são assinadas digitalmente, garantindo que os dados não sejam alterados durante a transmissão. A estrutura de um JSON Web Token normalmente é Header.Payload.Signature.

1. Header (Cabeçalho)

Contém os metadados do token.
Tipicamente, consiste em duas partes: o tipo do token, que é sempre "JWT", e o algoritmo de assinatura que está sendo usado (HS256, RS256 ou ECDSA).
É codificado em Base64Url.

2. Payload (Carga)

Contém as claims, que são declarações sobre a entidade (geralmente o usuário) e dados adicionais.
As informações no payload, embora protegidas contra adulteração, são legíveis por qualquer pessoa que possua o token decodificado.
O payload é codificado em Base64Url.

3. Signature (Assinatura)

Garante integridade e autenticidade do token.
É gerada utilizando o cabeçalho (já codificado), o payload codificado, uma chave secreta (para algoritmos simétricos como HMAC) ou um par de chaves pública/privada (para algoritmos assimétricos como RSA ou ECDSA) e o algoritmo especificado no cabeçalho.
O processo envolve aplicar o algoritmo escolhido à concatenação de cabeçalho e payload codificados, usando a chave.
Também é codificada em Base64Url.

A concatenação dessas três partes codificadas em Base64Url, separadas por pontos, forma o JSON Web Token.

Fluxo de funcionamento do JWT

O fluxo de funcionamento do JWT geralmente ocorre da seguinte forma:

Login do Usuário: O cliente envia as credenciais de login do usuário (geralmente via navegador) para o servidor.
Geração do JWT pelo servidor: Se as credenciais são válidas, o servidor faz a verificação das credenciais. Então, o servidor cria um JWT contendo dados sobre o usuário (conhecidos como "claims" no payload) e assina usando uma chave secreta.
Envio do token para o cliente: O JWT é enviado de volta para o cliente e armazenado geralmente em localStorage ou em um cookie.
Cliente inclui o token em requisições subsequentes: Sempre que o cliente deseja acessar rotas protegidas ou recursos restritos, ele inclui o JWT no cabeçalho HTTP da requisição, mais comumente no cabeçalho Authorization usando o esquema Bearer token.
Verificação do Token pelo Servidor: Ao receber uma requisição com um JWT no cabeçalho Authorization, o servidor (ou as rotas protegidas) verifica a validade do token JWT. A verificação inclui validar a estrutura,o formato, e conteúdo do token (validação) e confirma a autenticidade e integridade do token através da verificação da assinatura (verificação).

Boas práticas com JWT

Use HTTPS: Transmita JWTs apenas por conexões seguras para prevenir ataques man-in-the-middle.
Defina tempo de expiração: Evite tokens de longa duração que possam ser explorados.
Use armazenamento seguro: Armazene JWTs de forma segura (por exemplo, cookies HttpOnly em vez de localStorage).

Referências

Como funciona o DNS?

Alex Reis — Wed, 04 Jun 2025 11:00:00 +0000

O que é DNS

O Domain Name System (DNS) é a lista telefônica da Internet. O DNS converte os nomes de domínio (legíveis por humanos, como www.google.com) em endereços IP (que os computadores usam para se comunicar).

Cada dispositivo conectado à Internet tem um IP único que as outras máquinas usam para localizar o dispositivo. Os servidores DNS eliminam a necessidade de humanos terem de memorizar endereços IP.

Servidores de DNS envolvidos no carregamento de uma página da Internet

Recursor de DNS: O recursor é responsável por fazer solicitações adicionais para atender à consulta de DNS do cliente. Pode ser imaginado como uma bibliotecária que foi solicitada a procurar um livro específico.
Servidor raiz: Primeira etapa da tradução (resolução) do host. Pode ser imaginado como um índice em uma biblioteca que aponta para as estantes de livros.
Nameserver TLD: Pense no servidor de domínio de nível superior (TLD) como uma estante de livros específica em uma biblioteca. É o próximo passo se não busca de um endereço IP específico e hospeda a última parte de um hostname.
Nameserver autoritativo: Pode ser imaginado como um dicionário em uma estante de livros, no qual um nome específico pode ser traduzido em sua definição. Se tiver acesso ao registro solicitado, o nameserver autoritativo retorna o endereço IP do hostname solicitado de volta ao recursor de DNS que fez a solicitação inicial.

Etapas de uma pesquisa de DNS

Quando o usuário digita uma URL no navegador, o sistema verifica se o IP do domínio já está salvo em cache (no navegador, no sistema operacional ou no roteador). Se já estiver em cache, ele usa o IP diretamente e o processo termina aqui. Senão a consulta parte para a próxima etapa.
A consulta é recebida por um resolvedor de DNS recursivo, que pode ter o IP em cache e então responde direto. Caso contrário, consulta o servidor raiz.
O servidor raiz responde ao resolvedor com o endereço de um servidor de TLD, como .com, .org, .br.
O resolvedor faz uma solicitação ao TLD.
O servidor de TLD responde com o endereço IP do servidor autoritativo, o nameserver do domínio (como google.com).
O resolvedor recursivo envia uma consulta ao nameserver do domínio.
O endereço IP é então retornado ao resolvedor partindo do nameserver.
O resolvedor de DNS responde ao navegador com o endereço IP do site.
A conexão com o site é realizada via HTTP.

Referência

What is dns

Como o protocolo HTTP funciona?

Alex Reis — Wed, 21 May 2025 11:00:00 +0000

Sempre que você acessa um site pode notar que a URL exibida no navegador é algo como https://dev.to, você sabe que dev.to é o endereço do site, a localização dele na web. Mas o que são as letrinhas HTTPS ou HTTP antes do endereço? Neste artigo vamos entender o que é o HTTP, para quê serve e como funciona.

O que é HTTP

O Hyper Transfer Text Protocol, ou HTPP, é um protocolo de transferência de documentos de hipermídia da camada de aplicação. Ele foi projeto para comunicação entre clientes e servidores, mas também pode ser usado para outros fins, como comunicação máquina a máquina, acesso programático a APIs e muito mais. Ele é enviado por TCP ou por conexção TCP criptografada por TLS ou SSL, o HTTPS utiliza esta camada adicional de segurança. Confira mais detalhes da história do HTTP.

Aspectos do HTTP

O HTTP segue o modelo cliente-servidor, no qual clientes (na maioria das vezes um navegador web) e servidores se comunicam por meio de mensagens individuais. As mensagens enviadas pelo cliente, as solicitações ou requisições, são chamadas de requests e as mensagens enviadas como resposta pelo servidor são chamadas responses.

O HTTP é stateless, isso significa que ele não guarda qualquer dado entre requisições, cada requisição do cliente é tratada de forma independente. Porém ele não é sesionless, a adição de cookies HTTP permitem que os aplicações web armazenem quantidades limitadas de dados e lembrem informações de estado.

Como funciona o HTTP

O cliente, um navegador web geralmente, faz uma requisição a um servidor para obter um recurso como uma página HTML, imagens ou arquivos. Neste momento é aberta uma conexão ente os dois. Na requisição HTTP é explicitado o método pretendido e o caminho do recurso desejado.

O servidor recebe essa solicitação, busca o recurso e ao encontrar responde ao navegador uma mensagem contendo o recurso e informações adicionais no cabeçalho da mensagem HTTP.

O cliente recebe a resposta do servior, e encerra a conexão.

Mensagens HTTP

As mensagens HTTP, conforme definido em HTTP/1.1 e anteriores, são legíveis por humanos. No HTTP/2, essas mensagens são incorporadas em uma estrutura binária, um quadro, permitindo otimizações como compactação de cabeçalhos e multiplexação.

Requisições

Exemplo de requisição HTTP:

GET / HTTP/1.1
Host: meusite.com
Accept-Language: en-US

GET é o método HTTP.
/ é o caminho do recurso a ser buscado.
HTTP/1.1 a versão do protocolo.
O Hoste Accept-Language são parte do cabeçalho HTTP e fornecem informações adicionais sobre navegador e preferências de conteúdo.
Ainda pode conter um corpo para alguns métodos como o POST, que contém o recurso enviado.

Respostas

Exemplo de resposta:

HTTP/1.1 200 OK
Date: Wed, 09 MAY 2025 01:58:00 GMT
Content-Length: 1999
Content-Type: text/html; charset=UTF-8

HTTP/1.1 a versão do protocolo HTTP que eles seguem.
200 um código de status, indicando que a solicitação foi bem-sucedida.
OK uma mensagem de status, uma breve descrição não autorizada do código de status.
Cabeçalhos HTTP, como aqueles para solicitações.
Opcionalmente, um corpo que contém o recurso buscado.

Métodos HTTP

O HTTP define um conjunto de certos métodos de solicitação para enviar mensagens indicando a finalidade da solicitação e o que é esperado em caso de sucesso.

GET

Este método tem finalidade de solicitar um recurso especifico. É usado para recuperar dados e não deve conter conteúdo no corpo da solicitação.

POST

Este método indica que a solicitação faz a publicação de um recurso no servidor.

PUT

Substitui todas as entidades do recurso alvo pelo conteúdo do corpo da solicitação.

PATCH

Faz modificações parciais em um recurso, que ao contrário do PUT substituí um recurso por inteiro.

DELETE

Este método excluí o recurso.

CONNECT

Estabele um túnel para o servidor identificado pelo recurso alvo.

OPTIONS

Descreve opções de comunição para o recurso alvo.

Conclusão

E então chegamos ao fim deste texto, espero que eu tenha conseguido explicar minimamente o que é o HTTP e que tenha ajudado a você leitor. Abraços.

Referências:

Hi brazilian people, I wrote this shell script begginers tutorial and I hope you like it.

Alex Reis — Mon, 03 Mar 2025 13:56:19 +0000

Introdução ao Shell Script

Alex Reis ・ Mar 3 '25

#programming #devops #linux #braziliandevs

Introdução ao Shell Script

Alex Reis — Mon, 03 Mar 2025 11:00:00 +0000

Shell Script é uma linguagem de script usada para automatizar tarefas no terminal do Linux/Unix.

Um Shell Script é um arquivo contendo comandos do terminal que podem ser executados como um programa. Ele usa interpretadores como bash, sh ou zsh.

Criando um shell script

Crie um arquivo arquivo .sh:

touch meu_script.sh

Abra o arquivo no editor.
Adicione o código:

#!/bin/bash
echo "Olá mundo!"

Shell scripts começam com um shebang, ele informa que o script deve ser interpretado pelo Bash. Você pode usar outra interpretador shell como #!/bin/sh.

echo é um comando usado para exibir uma mensagem no terminal.

Dê permissão de execução ao script:

chmod +x meu_script.sh

Execute o script:

./meu_script.sh

Variáveis e Entrada do Usuário

Podemos criar variáveis e interagir com o usuário:

#!/bin/bash
nome="Alex"
echo "Olá, $nome!"

echo "Qual é o seu nome?"
read usuario
echo "Bem-vindo, $usuario!"

Variáveis são definidas com = sem espaços ao redor do =. Para usar uma variável colocamos $ antes de seu nome. Podemos fazer atribuições do tipo:

pais=Brasil
novo_pais=$pais

O comando read permite capturar uma entrada do usuário.

Condicionais

#!/bin/bash
echo "Digite um número"
read numero

if [ $numero -gt 10 ]; then
    echo "O númeor é maior que 10."
else
    echo "O número é menor ou igual a 10."
fi

No shell script usamos [] para testar condições. Operadores comuns são:

-eq -> igual a (==)
-ne -> diferente de (!=)
-gt -> maior que (>)
-lt -> menor que (<)
-ge -> maior ou igual (>=)
-le -> menor ou igual (<=)
-a -> AND (operador lógico)
-o -> OR (operador lógico)

Laços de repetição

For loop

#!/bin/bash
for i in {1..5}; do
    echo "Número: $i"
done

While loop

#!/bin/bash
contador=1
while [ $contador -le 5 ]; do
    echo "Contador: $contador"
    ((contador++))
done

Usamos ((expressão++)) para incrementar valores.

Funções

Podemos criar funções:

#!/bin/bash
diz_ola() {
    echo "Olá, $1!"
}

diz_ola "Alex"
diz_ola "Maria"

O $1 é usado para indicar o primeiro argumento passado, e não está restrito ser usado em funções.

Trabalhando com arquivos e diretórios

Criar, ler e manipular arquivos:

#!/bin/bash
echo "Criando um arquivo..."
echo "Este é um arquivo de teste." > teste.txt

echo "Conteúdo do arquivo:"
cat teste.txt

A expressão echo "texto" > texto.txt escreve um text dentro de um arquivo.

caté usado para exibir o conteúdo de um arquivo.

Existem muitos outros comandos e coisas possiveís que se pode fazer com shell script mas esta é uma introdução básica.

Estruturas de Dados: Heap

Alex Reis — Mon, 13 Jan 2025 11:00:00 +0000

Heap é uma lista linear onde cada elemento armazena um dado e sua prioridade de modo que:

H[i] > H[2i], (ou H[i] < H[i/2])
H[i] > H[2i+1], Para 1 <= i <= n.

Exemplo: [33, 32, 38, 31, 29, 26, 25, 30, 27]

Essa estrutra pode ser representada visualmente na forma de uma árvore binaria, onde cada nó possui prioridade maior que seus dois filhos, se existirem. Na memória a estrutra está disposta como uma lista linear sequencial.

As condições anteriormente descritas implicam que o elemento de maior prioridade sempre é o primeiro, ou seja, a raiz da árvore.

seleção: O(1)
inserção: O(log n)
remoção: O(log n)
alteração: O(log n)
construção: O(n)

Alteração de prioridade

De modo geral, uma operação que se deseja realizar no heap está associada a "subir" ou "descer" num caminho da árvore. Associa-se então o aumento de prioridade à "subida" e a diminuição à "descida". OS algoritmos correspondentes a estas operações são:

Algoritmo subir() recursivo

    subir(i)
        j := i/2
        se j >= 1 então
            se H[j].chave < H[i].chave então
                torcar (H[j], H[i])
                subir(j)

Algoritmo subir() iterativo

    subir(i)
        j := i/2
        enquanto j >= 1 e H[j].chave < H[i].chave
            torcar H[j] <=> H[i]
            i := j
            j := i/2

Algoritmo descer() recursivo

    descer(i,n)
        j := 2*i
        se j <= n então
            se j < n então
                se H[j].chave < H[j+1].chave então
                    j := j+1
            se H[i].chave < H[j].chave então
                trocar (H[i], H[j])
                descer(j,n)

Algoritmo descer() iterativo

    descer(i,n)
        j := 2*i
        enquanto j <= n faça
            se j < n então
                se H[j].chave < H[j+1].chave então
                    j := j+1
            se H[i].chave < H[j].chave então
                trocar (H[i], H[j])
                i := j
                j := 2*i
            senão
                j := n+1

As complexidades dos algoritmos subir() e descer() recursivos são as mesmas de percorrer o caminho de uma árvore binária completa: O(log n)

Inserção de elemento

Suponha a inserção de um novo elemento, a lista agora passará a ter n+1 elementos. Obviamente o lista não respeita mais a propriedade de heap. O procedimento a seguir corrige esse problema.

    inserir(x)
        H[n+1] := x
        n := n+1
        subir(n)

Complexidade igual ao algoritmo subir(): O(log n)

Remoção de elemento

A remoção é feita sempre com o de maior prioridade, logo a sua posição fica vazia e a lista passa a ter n-1 elementos, o último elemento então deve preenche-la mas como sua prioridade está deslocada a lista deve ser corrigida.

    remover()
        se n != 0 então
            H[1] := H[n]
            n := n-1
            descer(1, n)
        senão "lista vazia"

A complexidade desse algoritmo depende do algoritmo descer(): O(log n)

Construção de um heap

Observando que toda lista ordenada corresponde a um heap, podemos construir um através da ordenação de uma lista.

    construirHeap()
        para i := 2 até n faça
            subir(i)

Complexidade O(n log n)

Uma solução alternativa é descrita observando que para um nó sem filhos satisfaz as propriedades de heap, isto é, todo nó alocado a partir da posição n/2 + 1. Por essa razão, na construção de um heap os únicos nós relevantes são os internos da árvore. Estes devem ter suas prioridades verificadas e acertadas.

    construirHeapOtimizado()
        para i := n/2 até 1 faça
            descer(i,n)

Complexidade linear: O(n)

Referência

Livro: Estruturas de Dados e seus Algoritmos

Estruturas de Dados: Árvores

Alex Reis — Mon, 06 Jan 2025 17:05:50 +0000

Uma árvore T é um conjunto finito de elementos denominados nós tais que:

T = {0}, a árvore é dita vazia ou
existe um nó especial chamado raiz de T(r(T)); os nós restantes constituem um conjunto vazio ou são dividios em m >= 1 conjuntos disjuntos não vazios, as subárvores.

Um conjunto de árvores forma uma floresta. Se v é um nó de T, a notação T(v) indica uma subárvore de T com raiz v.

Os nós raízes w1, w2, ..., wj das subárvores de T(v) são chamados filhos de v. Se z é filho de w1 então w2 é tio de z e v é avô de z. O número de filhos de um nó é chamado de grau de saída desse nó. Se x pertence à subárvore T(v), x é descendente de v, e v, ancestral de x. Um nó que não possuí descendentes próprios é chamado de folha. Toda árvore com n > 1 nós possuí no mínimo 1 e no máximo n - 1 folhas. Um nó não folha é dito interior.

Uma sequência de nós distintos v1, v2, ..., vk, tal que existe sempre entre nós consecutivos a relação "é filho de" ou "é pai de", é denominada caminho da árvore. O comprimento k do caminho é a quantidade de pares da relação ao longo do caminho. Nível de um nó v é o número de nós do caminho da raiz até o nó v. O nível da raiz portanto é 1. A altura de um nó v é o número de nós do maior caminho v até um dos seus descentes. A altura da árvore T é igual ao nível máximo de seus nós. Representa-se a altura de T por T(h).

Uma árvore ordenada é aquela na qual os filhos de cada nó estão ordenados. Assume-se que tal ordenação se desenvolva da esquerda para a direita.

Árvores Binárias

Dentre as ávores, as binárias, são as mais comuns.
Uma árvore binária T é um conjunto finito de elementos denominados nós tais que:

T = {0}, a árvore é dita vazia ou
existe um nó especial chamado raiz de T(r(T)); os nós restantes são dividios em dois subconjuntos disjuntos, Te(r(T)) e Td(r(T)) a subárvore esquerda e a direita da raiz, respectivamente, as quais também são binárias.

A raiz da subárvore esquerda (direita) de um nó v, se existir, é denominada filho esquerdo (direito) de v. Naturalmente, o esquerdo pode existir sem o direito e vice-versa.

O número de subárvores esquerdas e direitas vazias em uma árvore binária com n > 0 nós é n + 1.

Uma árvore estritamente binária é uma árvore binária em que cada nó possui 0 ou 2 filhos. Uma árvore binária completa é aquela que apresenta a seguinte propriedade: se v é um nó tal que alguma subárvore de v é vazia, então v se localiza ou no último (maior) ou no penúltimo nível da árvore. Uma árvore binária cheia é aquela em que, se v é um nó com alguma de suas subárvores vazias, então v se localiza no último nível.

A árvore binária que possui altura máxima é aquela cujos nós interiores possuem exatamente uma subárvore vazia. Essas árvores são denominadas zigue-zague. Naturalmente, a altura de uma árvore zigue-zague é igual a n. Por outro lado, uma árvore completa sempre apresenta altura mínima.

Seja T uma árvore binária completa com n > 0 nós. Então T possui altura h mínima. Além disso, h = 1 + log n.

Uma árvore m-ária T, m ≥ 2, é um conjunto finito de elementos, denominados nós ou vértices, tais que

T = Ø e a árvore é dita vazia, ou
contém um nó especial chamado raiz de T(r(T)), e os restantes podem ser sempre divididos em m subconjuntos disjuntos, as i-ésimas subárvores de r(T), 1 ≤ i ≤ m, as quais são também árvores m-árias.

A raiz da i-ésima subárvore de um nó v de T, se existir, é denominada i-ésimo filho de v. Naturalmente, a árvore m-ária é uma generalização da árvore binária em que cada nó possui m subárvores. A árvore m-ária possui uma ordenação implícita nas subárvores de cada nó, mesmo que algumas ou todas essas subárvores sejam vazias.

Analogamente ao caso binário, podem-se definir árvore estritamente m-ária, árvore m-ária completa e cheia.

O armazenamento de árvores pode utilizar alocação sequencial ou encadeada. Sendo a árvore uma estrutura mais complexa do que listas lineares, as vantagens na utilização da alocação encadeada prevalecem.

Em árvores binárias cada nó deve possuir dois campos de ponteiros, esq e dir, que apontam para as suas subárvores esquerda e direita respectivamente. O ponteiro ptraiz indica a raiz da árvore. Necessita-se, então, de 2*n* + 1 (os dois campos mencionados e o campo com as informações do nó) unidades de memória para representar uma árvore binária com n nós.

Percurso em Árvores Binárias

Para percorrer uma árvore deve-se visitar cada um de seus nós. Visitar um nó significa operar de alguma forma, com a informação a ele relativa.

O percurso em pré-ordem segue recursivamente os seguintes passos, para cada subárvore da árvore:

visitar a raiz
percorrer sua subárvore esquerda, em pré ordem;
percorrer sua subárvore direita, em pré ordem;

A variavel pt, parametro do procedimento, é um ponteiro que indica a raiz da subárvore que está sendo considerada na chamada atual. Em cada chamada, somente esse nó é analisado. Após a visita, é verificada a existência de uma subárvore esquerda. Se verdadeiro, então a chamada recursiva percorrerá toda essa subárvore antes de ir para a subárvore direita.

A versão não recursiva deve manter atualizados os caminhos percorridos a partir da raiz da árvore. Um forma de fazer isso é utilizando uma pilha. O nó é visitado ao ser colocado na pilha, enquanto que a retirada da pilha indica o final da visita cuja raiz é o nó considerado. Além disso, deve ser armazenada a direção do percurso, isto é, se o caminho tomado é é referente à subárvore esquerda ou direita. O nó só é retirado da pilha após ambos os caminhos percorridos.

procedimento pre(pt)
    se pt != null então
        visita(pt)
        pre(pt.esq)
        pre(pt.dir)

procedimento preNaoRecursivo(T)
    pt := T.raiz
    se pt == null então "arvore vazia"
    Pilha p = {}
    empilhar(p, pt)

    enquanto(p != null)
        pt := desempilhar(p)
        visita(pt)

        se pt.dir() != null então empilhar(p, pt.dir)
        se pt.esq() != null então empilhar(p, pt.esq)

O percurso em ordem simetrica segues os passos:

percorrer sua subárvore esquerda, em ordem simétrica;
visitar a raiz
percorrer sua subárvore direita, em ordem simétrica;

procedimento simet(pt)
    se pt != null então
        simet(pt.esq)
        visita(pt)
        simet(pt.dir)

procedimento simetNaoRecursivo(T)
    pt := T
    se pt == null então "arvore vaiza"
    Pilha p = {}
    empilhar(p, pt)

    enquanto(p != null)
        se pt.dir() != null então empilhar(p, pt.dir)
        se pt.esq() != null então empilhar(p, pt.esq)

    enquanto(p != null)
        pt := desempilhar(p)
        visitar(pt)

Uma terceira alternativa de percurso, o percurso pós-ordem:

percorrer a subárvore esquerda, em pós-ordem
percorrer a subárvore direita, em pós-ordem
visitar a raiz

procedimento pos(pt)
    se pt != null então
        pos(pt.esq)
        pos(pt.dir)
        visitar(pt)

Referência

Livro: Estruturas de Dados e seus Algoritmos

Forem: Alex Reis

O que são generics?

Variáveis de tipo

Classe Genérica

Wildcards

Exemplo Prático

Type Erasure

Interfaces Funcionais

Exemplo prático

Leituras Complementares

O que são Expressões Lambdas?

Regras de Uso e Contexto

Exemplo prático

Method Reference

Exemplos:

Referência

Entendendo Flyway

Scripts

Tabela de controle

Execução

Configuração do application.properties

Relacionamentos Bidirecionais vs Unidirecionais no Spring JPA

Relacionamentos: Navegação e Complexidade

Relacionamentos Bidirecionais: Flexibilidade com Responsabilidade

Relacionamentos Unidirecionais: Simplicidade e Performance

Estratégias de Carregamento: Eager vs Lazy

FetchType.EAGER: Carregamento Imediato

FetchType.LAZY: Carregamento Sob Demanda

Tomada de Decisão

Escolhendo a Direção do Relacionamento

Definindo a Estratégia de Fetch

Abordagem Recomendada: Evolução Gradual

Conclusão

O que é JWT?

JWT

1. Header (Cabeçalho)

2. Payload (Carga)

3. Signature (Assinatura)

Fluxo de funcionamento do JWT

Boas práticas com JWT

Referências

Como funciona o DNS?

O que é DNS

Servidores de DNS envolvidos no carregamento de uma página da Internet

Etapas de uma pesquisa de DNS

Referência

Como o protocolo HTTP funciona?

O que é HTTP

Aspectos do HTTP

Como funciona o HTTP

Mensagens HTTP

Requisições

Respostas

Métodos HTTP

GET

POST

PUT

PATCH

DELETE

CONNECT

OPTIONS

Conclusão

Hi brazilian people, I wrote this shell script begginers tutorial and I hope you like it.

Introdução ao Shell Script

Alex Reis ・ Mar 3 '25

Introdução ao Shell Script

Criando um shell script

Variáveis e Entrada do Usuário

Condicionais

Laços de repetição

Funções

Trabalhando com arquivos e diretórios

Estruturas de Dados: Heap

Alteração de prioridade

Inserção de elemento

Remoção de elemento

Construção de um heap

Referência

Estruturas de Dados: Árvores

Árvores Binárias

Configuração do `application.properties`