Forem: Uiratan Cavalcante

Design Orientado a Comportamento em Java: Strategy, Lambdas e Design Moderno em Java

Uiratan Cavalcante — Sat, 28 Feb 2026 02:11:40 +0000

Grande parte dos desenvolvedores Java utiliza lambdas diariamente sem refletir muito sobre o que está acontecendo por trás delas. A sintaxe é simples, elegante e econômica. No entanto, essa simplicidade esconde uma série de decisões de design, conceitos de programação funcional e mecanismos sofisticados da JVM.

Para entender lambdas de verdade, é preciso começar antes delas.

O problema concreto

Considere uma classe de domínio simples que representa uma transação bancária:

public class BankTransaction {

    private final LocalDate date;
    private final double amount;
    private final String description;

    public BankTransaction(LocalDate date, double amount, String description) {
        this.date = date;
        this.amount = amount;
        this.description = description;
    }

    public LocalDate getDate() { return date; }
    public double getAmount() { return amount; }
    public String getDescription() { return description; }
}

Agora imagine que precisamos calcular o total movimentado em um determinado mês:

public double calculateTotalInMonth(Month month) {

    double result = 0;

    for (BankTransaction tx : bankTransactions) {
        if (tx.getDate().getMonth() == month) {
            result += tx.getAmount();
        }
    }

    return result;
}

O parâmetro month é um java.time.Month, um enum introduzido no Java 8 junto com a nova API de datas. Ele representa meses do ano de forma tipada e segura.

Esse método resolve o problema de forma direta. Ele percorre a lista, verifica uma condição e acumula valores. É simples e perfeitamente aceitável. O ponto interessante surge quando começamos a imaginar variações do mesmo cálculo: total por descrição, total acima de determinado valor, contagem de transações, maior valor do mês, e assim por diante.

Se observarmos com atenção, perceberemos que a estrutura do algoritmo — percorrer e acumular — permanece invariável. O que se altera é apenas a regra aplicada a cada elemento.

Esse detalhe é mais importante do que parece.

Separando estrutura de comportamento

Quando a estrutura do algoritmo permanece constante e apenas a regra muda, estamos diante de um cenário clássico para aplicação do padrão Strategy.

O padrão Strategy consiste em encapsular um comportamento variável em um objeto separado e passá-lo para quem executa a lógica estrutural. Em vez de codificar a regra diretamente no método, delegamos essa responsabilidade a um componente externo.

Podemos definir esse contrato da seguinte forma:

@FunctionalInterface
public interface BankTransactionSummarizer {
    double summarize(double accumulator, BankTransaction bankTransaction);
}

Essa interface descreve uma regra de acumulação: dado um valor atual (accumulator) e uma transação, ela retorna o novo acumulador.

Aqui surge o conceito de interface funcional.

Interface funcional e sua origem

Uma interface funcional é simplesmente uma interface com um único método abstrato. O conceito não é novo; o que surgiu no Java 8 foi o reconhecimento formal dele e a anotação @FunctionalInterface, que permite ao compilador validar essa restrição.

Exemplos clássicos da própria JDK incluem Runnable, Callable, Comparator e Function<T,R>. Todas possuem apenas um método abstrato.

O motivo pelo qual isso é relevante é que uma interface com um único método pode representar, conceitualmente, uma função. Isso abre espaço para tratar comportamento como um valor.

Antes do Java 8: classes anônimas

Antes das lambdas, implementar esse contrato exigia uma classe anônima:

public double calculateTotalInMonth(Month month) {

    return summarizeTransactions(
        new BankTransactionSummarizer() {
            @Override
            public double summarize(double acc, BankTransaction tx) {
                if (tx.getDate().getMonth() == month) {
                    return acc + tx.getAmount();
                }
                return acc;
            }
        }
    );
}

Uma classe anônima é uma classe sem nome declarado explicitamente, definida e instanciada no mesmo ponto. Ela existe desde o Java 1.1 e sempre foi o mecanismo padrão para passar comportamento como argumento.

Note que o conceito fundamental já estava presente: comportamento sendo passado como parâmetro. O problema era a verbosidade.

Programação funcional: o ponto central

Quando falamos em programação funcional, não estamos falando apenas de sintaxe enxuta. Estamos falando de um paradigma no qual funções são tratadas como valores.

Em termos práticos, isso significa que podemos:

Passar funções como parâmetros
Retornar funções
Compor funções
Trabalhar com estruturas imutáveis

Passar comportamento como parâmetro é central porque eleva o nível de abstração do design. Em vez de escrever múltiplas variações de um mesmo algoritmo, definimos a estrutura uma única vez e variamos apenas a lógica aplicada.

Essa é a essência do que estamos fazendo ao separar o loop da regra.

A chegada das lambdas

Com o Java 8, a classe anônima pode ser substituída por:

public double calculateTotalInMonth(Month month) {
    return summarizeTransactions(
        (acc, tx) ->
            tx.getDate().getMonth() == month
                ? acc + tx.getAmount()
                : acc
    );
}

A expressão (acc, tx) -> ... é apenas uma forma reduzida de implementar o método summarize.

Não é um novo tipo de objeto. Não é um novo conceito de orientação a objetos. É uma forma sintática mais natural de representar algo que já existia: a implementação de uma interface com único método.

Closure: capturando o contexto

Observe que a lambda utiliza a variável month, mesmo ela não sendo parâmetro da função.

Isso é um exemplo de closure.

Closure é uma função que captura variáveis do escopo externo. Em Java, apenas variáveis finais ou efetivamente finais podem ser capturadas. O valor é preservado no momento da criação da lambda.

Internamente, isso significa que o valor capturado é armazenado como um campo do objeto gerado dinamicamente.

Conceitualmente, é como se o compilador produzisse algo equivalente a:

class LambdaImpl implements BankTransactionSummarizer {

    private final Month month;

    LambdaImpl(Month month) {
        this.month = month;
    }

    public double summarize(double acc, BankTransaction tx) {
        if (tx.getDate().getMonth() == month) {
            return acc + tx.getAmount();
        }
        return acc;
    }
}

O que acontece no bytecode

Compile a classe e execute:

javap -c -p NomeDaClasse

Você verá algo semelhante a:

public double calculateTotalInMonth(java.time.Month);
  Code:
     0: aload_0
     1: aload_1
     2: invokedynamic #2,  0
     7: invokevirtual #3
    10: dreturn

A instrução relevante é invokedynamic.

Ela foi introduzida no Java 7, mas passou a ser usada amplamente no Java 8 para dar suporte a lambdas. Diferentemente das classes anônimas, lambdas não geram automaticamente um .class separado. Em vez disso, o compilador gera um método sintético contendo o corpo da lambda e utiliza invokedynamic para que a JVM crie dinamicamente a implementação da interface em tempo de execução, via LambdaMetafactory.

Esse mecanismo permite otimizações mais sofisticadas pelo JIT, além de reduzir o custo estrutural que existia com classes anônimas tradicionais.

Conclusão

Quando você escreve uma lambda simples para somar valores, está aplicando uma sequência de conceitos que atravessam múltiplos níveis da linguagem:

Encapsulamento de comportamento (Strategy)
Interface funcional
Programação funcional
Closure
Geração dinâmica via invokedynamic

A linha parece simples, mas ela é o ponto de convergência entre design de software e engenharia de linguagem.

Entender isso muda a forma como enxergamos o código. Lambdas deixam de ser apenas uma forma elegante de escrever menos e passam a ser uma ferramenta consciente de modelagem de comportamento.

Parte 3: Adicionando Multi-Tenancy por Coluna Discriminadora

Uiratan Cavalcante — Sat, 28 Feb 2026 01:56:06 +0000

Introdução

Multi-tenancy é uma técnica que permite que uma única aplicação sirva a múltiplos "tenants" (inquilinos), isolando seus dados de forma lógica ou física. Surgiu com o crescimento do SaaS na década de 2000 e é essencial em plataformas como Slack e HubSpot. Existem três abordagens principais no Hibernate: SCHEMA (schemas separados), DATABASE (bancos separados), e DISCRIMINATOR (coluna discriminadora). Aqui, usaremos a estratégia de Coluna Discriminadora, onde uma coluna tenant_id na tabela users identifica o tenant de cada registro.

Nesta parte, vamos adicionar multi-tenancy ao sistema da Parte 2, usando o tenant_id já persistido para gerenciar o contexto do tenant por requisição. Implementaremos um TenantContext para armazenar o tenant_id atual e um TenantFilter para defini-lo dinamicamente, mantendo o H2 em memória como banco. O isolamento será lógico (baseado em tenant_id), mas não automático — isso dependerá de ajustes manuais em queries ou filtros adicionais, que mencionaremos como opcional.

Configuração Inicial

`pom.xml`

Mesma configuração da Parte 2 — sem alterações.

`application.yml`

Mesma configuração da Parte 2 — sem alterações, pois não usamos multiTenancy: SCHEMA ou TenantIdentifierResolver para o Hibernate neste caso.

Resumo do Fluxo Geral

Autenticação: O usuário é autenticado via Google (como nas partes anteriores).
Contexto do Tenant: O TenantFilter extrai o sub do usuário autenticado e define o TenantContext.
Persistência: Já feita na Parte 2, o tenant_id está no banco como parte da entidade User.
Resposta: O HomeController usa o TenantContext para retornar o tenant_id junto com o JWT.
Limpeza: O TenantFilter limpa o TenantContext após a requisição.

Passo a Passo

1. Manter o `SecurityConfig` como Está

package com.example.slotty.security;

import com.nimbusds.jose.jwk.JWKSet;
import com.nimbusds.jose.jwk.RSAKey;
import com.nimbusds.jose.jwk.source.JWKSource;
import com.nimbusds.jose.jwk.source.ImmutableJWKSet;
import com.nimbusds.jose.proc.SecurityContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.oauth2.jwt.JwtEncoder;
import org.springframework.security.oauth2.jwt.NimbusJwtEncoder;
import org.springframework.security.web.SecurityFilterChain;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.UUID;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    private CustomOAuth2UserService customOAuth2UserService;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(AbstractHttpConfigurer::disable)
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/oauth2/**", "/login/oauth2/**", "/error", "/favicon.ico", "/").permitAll()
                .anyRequest().authenticated()
            )
            .oauth2Login(oauth2 -> oauth2
                .defaultSuccessUrl("/home", true)
                .failureUrl("/error?error=true")
                .userInfoEndpoint(userInfo -> userInfo.oidcUserService(customOAuth2UserService))
            )
            .logout(logout -> logout.logoutSuccessUrl("/").permitAll())
            .build();
    }

    @Bean
    public JwtEncoder jwtEncoder() {
        JWKSource<SecurityContext> jwkSource = getJwkSource();
        return new NimbusJwtEncoder(jwkSource);
    }

    private JWKSource<SecurityContext> getJwkSource() {
        KeyPair keyPair = generateRsaKey();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        RSAKey rsaKey = new RSAKey.Builder(publicKey)
            .privateKey(privateKey)
            .keyID(UUID.randomUUID().toString())
            .build();
        JWKSet jwkSet = new JWKSet(rsaKey);
        return new ImmutableJWKSet<>(jwkSet);
    }

    private KeyPair generateRsaKey() {
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048);
            return keyPairGenerator.generateKeyPair();
        } catch (Exception ex) {
            throw new IllegalStateException("Erro ao gerar RSA KeyPair", ex);
        }
    }
}

Nota: Nenhuma mudança é necessária, pois o CustomOAuth2UserService já foi integrado na Parte 2.

2. Manter a Entidade `User` e o `UserRepository`

Sem alterações — a entidade e o repositório da Parte 2 já incluem tenant_id.

3. Atualizar o `CustomOAuth2UserService` para Usar `TenantContext`

package com.example.slotty.security;

import com.example.slotty.tenant.TenantContext;
import com.example.slotty.user.User;
import com.example.slotty.user.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.oauth2.client.oidc.userinfo.OidcUserRequest;
import org.springframework.security.oauth2.client.oidc.userinfo.OidcUserService;
import org.springframework.security.oauth2.core.OAuth2AuthenticationException;
import org.springframework.security.oauth2.core.oidc.user.OidcUser;
import org.springframework.stereotype.Service;

@Service
public class CustomOAuth2UserService extends OidcUserService {
    private final UserRepository userRepository;

    @Autowired
    public CustomOAuth2UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public OidcUser loadUser(OidcUserRequest userRequest) throws OAuth2AuthenticationException {
        OidcUser oidcUser = super.loadUser(userRequest);
        String id = oidcUser.getSubject();
        String email = oidcUser.getEmail();
        String name = oidcUser.getFullName();

        TenantContext.setCurrentTenant(id); // Define o tenant temporariamente

        try {
            userRepository.findById(id)
                .orElseGet(() -> {
                    User newUser = new User();
                    newUser.setId(id);
                    newUser.setEmail(email);
                    newUser.setName(name);
                    newUser.setTenantId(id);
                    return userRepository.save(newUser);
                });
        } finally {
            TenantContext.clear(); // Limpa após a operação
        }

        return oidcUser;
    }
}

loadUser(): Agora define o TenantContext com o sub durante a persistência, embora isso seja mais útil na Parte 3 para o filtro. O finally limpa o contexto.

4. Criar o `TenantContext`

package com.example.slotty.tenant;

public class TenantContext {
    private static final ThreadLocal<String> currentTenant = new ThreadLocal<>();

    public static void setCurrentTenant(String tenant) {
        currentTenant.set(tenant); // Armazena o tenant_id na thread atual
    }

    public static String getCurrentTenant() {
        return currentTenant.get(); // Retorna o tenant_id atual
    }

    public static void clear() {
        currentTenant.remove(); // Remove o tenant_id da thread
    }
}

ThreadLocal: Usa um armazenamento por thread para isolar o tenant_id entre requisições concorrentes.
setCurrentTenant, getCurrentTenant, clear: Métodos para manipular o contexto do tenant.

5. Criar o `TenantFilter`

package com.example.slotty.tenant;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.oauth2.core.user.OAuth2User;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

@Component
public class TenantFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication != null && authentication.getPrincipal() instanceof OAuth2User) {
            OAuth2User oAuth2User = (OAuth2User) authentication.getPrincipal();
            String tenantId = oAuth2User.getAttribute("sub");
            TenantContext.setCurrentTenant(tenantId); // Define o tenant para a requisição
        }
        try {
            filterChain.doFilter(request, response); // Executa o próximo filtro ou controlador
        } finally {
            TenantContext.clear(); // Limpa o contexto
        }
    }
}

doFilterInternal:
- SecurityContextHolder.getContext().getAuthentication(): Acessa o objeto de autenticação preenchido pelo Spring Security.
- instanceof OAuth2User: Verifica se o principal é um usuário OAuth2/OIDC.
- getAttribute("sub"): Extrai o sub como tenant_id.
- TenantContext.setCurrentTenant(): Define o tenant_id para uso durante a requisição.
- filterChain.doFilter(): Passa a requisição adiante (ex.: para o HomeController).
- finally: Limpa o TenantContext para evitar interferência entre threads.

6. Atualizar o `HomeController`

package com.example.slotty.controller;

import com.example.slotty.tenant.TenantContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.oauth2.core.oidc.user.OidcUser;
import org.springframework.security.oauth2.jwt.JwtClaimsSet;
import org.springframework.security.oauth2.jwt.JwtEncoder;
import org.springframework.security.oauth2.jwt.JwtEncoderParameters;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.Instant;
import java.util.HashMap;
import java.util.Map;

@RestController
public class HomeController {

    @Autowired
    private JwtEncoder jwtEncoder;

    @GetMapping("/home")
    public ResponseEntity<Map<String, String>> home(@AuthenticationPrincipal OidcUser oidcUser) {
        Instant now = Instant.now();
        JwtClaimsSet claims = JwtClaimsSet.builder()
            .issuer("self")
            .issuedAt(now)
            .expiresAt(now.plusSeconds(3600))
            .subject(oidcUser.getSubject())
            .claim("email", oidcUser.getEmail())
            .claim("name", oidcUser.getFullName())
            .build();

        String jwt = jwtEncoder.encode(JwtEncoderParameters.from(claims)).getTokenValue();

        Map<String, String> response = new HashMap<>();
        response.put("message", "Welcome " + oidcUser.getFullName());
        response.put("tenantId", TenantContext.getCurrentTenant()); // Adiciona o tenant_id
        response.put("jwt", jwt);
        return ResponseEntity.ok(response);
    }

    @GetMapping("/")
    public String root() {
        return "Bem-vindo à página inicial!";
    }
}

home(): Inclui o tenantId no retorno, obtido do TenantContext definido pelo TenantFilter.

7. Testar o Sistema

Execute mvn spring-boot:run.
Acesse http://localhost:8080/home.
Após login, você verá:

  {
    "message": "Welcome Uira Teste",
    "tenantId": "104976604334039049008",
    "jwt": "eyJraWQiOiJhYjNkZGYy..."
  }

Detalhamento Técnico do Fluxo

Filtro: O TenantFilter é registrado na cadeia de filtros do Spring (FilterChainProxy) e executado antes do controlador. Ele usa o SecurityContextHolder para acessar o OAuth2User autenticado.
Contexto: O TenantContext usa ThreadLocal para garantir que o tenant_id seja único por requisição, essencial em um servidor multithread como o Tomcat.
Isolamento: Como estamos usando multi-tenancy por coluna discriminadora sem filtros automáticos no Hibernate, o isolamento de dados não é aplicado nas queries do UserRepository. O tenant_id é apenas armazenado e retornado, mas não restringe acesso automaticamente.

Opcional para Isolamento Completo:

Adicionar um filtro Hibernate:

  @Entity
  @FilterDef(name = "tenantFilter", parameters = @ParamDef(name = "tenantId", type = String.class))
  @Filter(name = "tenantFilter", condition = "tenant_id = :tenantId")
  public class User { ... }

Habilitar o filtro no repositório:

  @Repository
  public interface UserRepository extends JpaRepository<User, String> {
      default void enableTenantFilter(String tenantId) {
          Session session = entityManager.unwrap(Session.class);
          session.enableFilter("tenantFilter").setParameter("tenantId", tenantId);
      }
  }

Outras Formas de Fazer

Multi-Tenancy por Schema:
- Como: Usa multiTenancy: SCHEMA e TenantIdentifierResolver para criar schemas por tenant.
- Vantagens: Isolamento físico, maior segurança.
- Desvantagens: Complexidade de gerenciamento.
Multi-Tenancy por Banco Separado:
- Como: Configura um DataSource dinâmico por tenant.
- Vantagens: Isolamento completo.
- Desvantagens: Alto custo de infraestrutura.

Muito obrigado por chegar ao fim desta jornada sobre multi-tenancy por coluna discriminadora no Spring Boot! 🎉

Espero que as explicações técnicas tenham esclarecido como gerenciar tenants de forma lógica e simples. O que achou dessa solução com TenantContext e TenantFilter? 🧠

Deixe seu comentário com opiniões ou sugestões abaixo ✍️, e sinta-se à vontade para compartilhar este post com outros desenvolvedores interessados em arquiteturas multi-tenant 📲.

Até a próxima aventura tecnológica! 🚀

DSA - Arrays/Strings - Técnica Two Pointers (Dois Ponteiros) — Guia Completo para Entrevistas Técnicas

Uiratan Cavalcante — Fri, 11 Jul 2025 12:31:11 +0000

O que é a técnica Two Pointers e sua intuição

Two Pointers é uma técnica que utiliza dois índices (ou ponteiros) para percorrer e manipular estruturas de dados (geralmente arrays ou listas) simultaneamente, geralmente movendo-os em direções diferentes ou na mesma direção, para resolver problemas relacionados a busca, comparação, remoção, ou combinação de elementos.

Intuição:

Em vez de usar um loop aninhado (O(n²)), você usa dois ponteiros que interagem para reduzir a complexidade.
Eles aproveitam propriedades como ordenação ou padrão no problema para avançar os ponteiros de forma inteligente.
Permite resolver problemas que envolvem comparações entre pares, janelas deslizantes ou reorganização de elementos em tempo linear.

Vantagens da técnica Two Pointers

Aspecto	Vantagens
Complexidade	Reduz de O(n²) para O(n) em muitos casos
Performance	Menos comparações desnecessárias
Uso de memória	Espaço extra constante O(1), geralmente in-place
Simplicidade	Código elegante e direto, fácil de entender

Quando e como identificar que a técnica se aplica

Quando usar Two Pointers:

Problemas envolvendo arrays ordenados ou que podem ser ordenados.
Buscar pares ou subarrays que satisfaçam uma condição (ex: soma, diferença).
Movimentação simultânea para detectar duplicatas, anagramas, ou partições.
Resolver problemas de janelas deslizantes.
Manipular dados in-place para remover ou reorganizar elementos.

Como identificar:

Tem dois índices que precisam caminhar juntos ou em direções opostas.
Pode evitar loops aninhados com um controle inteligente dos ponteiros.
O problema exige comparar pares de elementos ou varrer sublistas de forma dinâmica.

Explicação visual e textual passo a passo

Suponha um array ordenado:

[1, 3, 4, 5, 7, 9, 12]
  ^                    ^
 left                right

Objetivo: Encontrar se existe um par cuja soma seja 10.

Passos:

Inicialize left no início (0) e right no fim (array.length - 1).
Calcule soma = array[left] + array[right].
Se soma == 10 → sucesso, retorne os índices.
Se soma > 10 → diminuir soma movendo right para a esquerda (right--).
Se soma < 10 → aumentar soma movendo left para a direita (left++).
Repita até left >= right.

Assim, você percorre o array uma única vez, com complexidade O(n).

5 Exemplos em Java com explicações detalhadas

1. Encontrar se existe um par com soma igual a alvo (array ordenado)

public boolean twoSumSorted(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left < right) {
        int sum = nums[left] + nums[right];
        if (sum == target) {
            return true; // par encontrado
        } else if (sum < target) {
            left++; // aumentar soma
        } else {
            right--; // diminuir soma
        }
    }
    return false; // não encontrado
}

Passo a passo:

left começa no início, right no fim.
Soma os elementos.
Dependendo da soma, move o ponteiro adequado para tentar alcançar o alvo.
Para um array ordenado, esta técnica é eficiente e evita checar todos pares (O(n²)).

2. Remover duplicatas de um array ordenado in-place

public int removeDuplicates(int[] nums) {
    if (nums.length == 0) return 0;
    int slow = 0; // slow pointer para posição da próxima escrita
    for (int fast = 1; fast < nums.length; fast++) {
        if (nums[fast] != nums[slow]) {
            slow++;
            nums[slow] = nums[fast];
        }
    }
    return slow + 1; // novo tamanho do array sem duplicatas
}

Passo a passo:

slow aponta para o índice onde o próximo número único será colocado.
fast percorre todos os elementos.
Quando encontra um valor diferente, avança slow e atualiza o valor.
Complexidade O(n), memória O(1).

3. Verificar se duas strings são anagramas usando Two Pointers (após ordenar)

import java.util.Arrays;

public boolean isAnagram(String s, String t) {
    if (s.length() != t.length()) return false;
    char[] arrS = s.toCharArray();
    char[] arrT = t.toCharArray();
    Arrays.sort(arrS);
    Arrays.sort(arrT);

    int left = 0, right = arrS.length - 1;
    while (left < arrS.length) {
        if (arrS[left] != arrT[left]) return false;
        left++;
    }
    return true;
}

Explicação:

Ordena ambas as strings.
Percorre ambas simultaneamente com um ponteiro (poderia usar dois, mas um é suficiente aqui).
Se algum caractere difere, não é anagrama.

4. Encontrar o maior subarray com soma <= k (janela deslizante)

public int maxSubArrayLen(int[] nums, int k) {
    int left = 0, sum = 0, maxLen = 0;
    for (int right = 0; right < nums.length; right++) {
        sum += nums[right];
        while (sum > k) {
            sum -= nums[left];
            left++;
        }
        maxLen = Math.max(maxLen, right - left + 1);
    }
    return maxLen;
}

Passo a passo:

right expande a janela.
Soma os elementos dentro da janela.
Se soma ultrapassa k, move left para reduzir.
Mantém controle do tamanho máximo da janela válida.
Complexidade O(n).

5. Intercalar dois arrays ordenados in-place (suposição: espaço extra disponível no final do primeiro array)

public void merge(int[] nums1, int m, int[] nums2, int n) {
    int i = m - 1, j = n - 1, k = m + n - 1;
    while (i >= 0 && j >= 0) {
        if (nums1[i] > nums2[j]) {
            nums1[k--] = nums1[i--];
        } else {
            nums1[k--] = nums2[j--];
        }
    }
    while (j >= 0) {
        nums1[k--] = nums2[j--];
    }
}

Passo a passo:

Ponteiros i e j percorrem os arrays de trás para frente.
Ponteiro k indica a posição de inserção no resultado.
Insere o maior elemento entre nums1[i] e nums2[j].
Assim, evita sobrescrever dados úteis.
Complexidade O(m+n), espaço O(1).

Comparações com outras abordagens

Abordagem	Complexidade	Uso de memória	Quando usar
Dois ponteiros	O(n)	O(1)	Arrays ordenados, busca pares
Loop aninhado (brute force)	O(n²)	O(1)	Pequenos datasets ou protótipos
HashSet/HashMap	O(n)	O(n)	Para checar existência rápida, mas usa mais memória
Ordenação + Two Pointers	O(n log n) (pela ordenação) + O(n)	O(1) ou O(n) dependendo da ordenação	Quando entrada não ordenada e possível ordenar

Dicas específicas para entrevistas técnicas

Identifique se o array ou string está ordenado: é um sinal clássico para usar dois ponteiros.
Se precisar encontrar pares ou subarrays, pense em ponteiros para delimitar intervalos.
Explique sua abordagem claramente para o entrevistador.
Caso não tenha array ordenado, veja se é possível ordenar (custo pode ser justificado).
Escreva código limpo, use nomes claros para ponteiros (left, right, slow, fast).
Lembre de cobrir casos de borda (arrays vazios, elementos iguais, etc).
Pratique bastante problemas clássicos que usam esta técnica.
Quando a questão envolver manipulação in-place, pense se é possível resolver com Two Pointers.
Evite loops aninhados sem necessidade, tente sempre pensar se Two Pointers pode reduzir complexidade.

Exercícios recomendados do LeetCode (com links e dificuldade)

Easy: 26. Remove Duplicates from Sorted Array
Easy: 167. Two Sum II - Input Array Is Sorted
Medium: 344. Reverse String (uso clássico de dois ponteiros para inversão in-place)
Medium: 209. Minimum Size Subarray Sum (janela deslizante)
Medium: 15. 3Sum (usar two pointers após ordenar para achar trios que somam zero)

Checklist para uso da técnica Two Pointers

[ ] A estrutura de dados é um array ou string?
[ ] Os dados estão ordenados ou podem ser ordenados?
[ ] O problema envolve encontrar pares, trios, subarrays ou reorganização?
[ ] Posso evitar loops aninhados usando dois índices móveis?
[ ] Posso avançar os ponteiros de forma condicional para reduzir complexidade?
[ ] O problema exige solução in-place para economizar espaço?
[ ] Considerei os casos extremos e fronteiras (array vazio, único elemento)?
[ ] Minha movimentação dos ponteiros está correta (não estou pulando elementos)?
[ ] Está clara a lógica para o entrevistador (fale durante a implementação)?
[ ] Testei mentalmente com exemplos simples?

📢 Implementando Eventos com Spring: Um Exemplo Prático 🚀

Uiratan Cavalcante — Thu, 03 Apr 2025 01:05:38 +0000

Introdução

Imagine que você está desenvolvendo um sistema de streaming de música. Sempre que um usuário assina o serviço, queremos realizar várias ações automaticamente, como enviar um e-mail de boas-vindas, conceder um período de teste gratuito e atualizar o status da assinatura.

Em vez de acoplar essas ações diretamente no fluxo de cadastro, podemos utilizar eventos para manter o código mais organizado, flexível e desacoplado. Vamos ver como o Spring pode nos ajudar a fazer isso automaticamente! 😃

🎯 O Problema de Negócio

Ao cadastrar um novo assinante, precisamos executar diversas ações:

Enviar um e-mail de boas-vindas 📩
Conceder um período de teste grátis 🎁
Atualizar o status do usuário ✅

Uma abordagem ingênua seria simplesmente chamar esses métodos diretamente dentro do fluxo de cadastro, mas isso criaria forte acoplamento entre as ações. Queremos um sistema mais flexível, onde possamos adicionar ou remover eventos sem modificar a lógica principal.

🛠️ Implementação com Eventos

Utilizaremos o Spring para gerenciar automaticamente os eventos e suas respectivas ações.

1️⃣ Definição da Classe Assinatura

Criamos a classe Assinatura que representa um usuário assinante:

public class Assinatura {
    private String usuario;

    public Assinatura(String usuario) {
        this.usuario = usuario;
    }

    public String getUsuario() {
        return usuario;
    }
}

2️⃣ Definição da Interface do Evento

Primeiro, criamos uma interface que define o contrato para todos os eventos que devem ser executados após um novo cadastro:

public interface EventoNovaAssinatura {
    void processa(Assinatura assinatura);
}

Essa interface será implementada por todas as classes que precisam reagir a uma nova assinatura.

3️⃣ Implementação dos Eventos

Agora, implementamos as ações específicas que devem ocorrer ao criar uma nova assinatura.

📩 Enviar e-mail de boas-vindas

@Service
public class EmailBoasVindas implements EventoNovaAssinatura {
    @Override
    public void processa(Assinatura assinatura) {
        System.out.println("[EMAIL] Bem-vindo, " + assinatura.getUsuario() + "! Sua assinatura foi ativada.");
    }
}

🎁 Conceder teste gratuito

@Service
public class TesteGratis implements EventoNovaAssinatura {
    @Override
    public void processa(Assinatura assinatura) {
        System.out.println("[TESTE GRÁTIS] Usuário " + assinatura.getUsuario() + " recebeu um período de teste de 7 dias!");
    }
}

✅ Atualizar status da assinatura

@Service
public class AtualizaStatus implements EventoNovaAssinatura {
    @Override
    public void processa(Assinatura assinatura) {
        System.out.println("[STATUS] Assinatura de " + assinatura.getUsuario() + " ativada com sucesso!");
    }
}

4️⃣ Classe que Orquestra os Eventos

Criamos um serviço que gerencia a execução dos eventos automaticamente:

@Service
public class EventosNovaAssinatura {
    @Autowired
    private Set<EventoNovaAssinatura> eventos;

    public void processa(Assinatura assinatura) {
        eventos.forEach(evento -> evento.processa(assinatura));
    }
}

Aqui, o Spring automaticamente injeta todos os beans que implementam EventoNovaAssinatura no Set<EventoNovaAssinatura> eventos. Isso significa que sempre que adicionarmos uma nova implementação, ela será registrada sem precisar modificar nada no código principal! 🎉

🎯 Como o Spring Injeta Automaticamente os Eventos?

O Spring escaneia automaticamente todas as classes anotadas com @Service que implementam a interface EventoNovaAssinatura. Ele injeta todas essas instâncias no Set<EventoNovaAssinatura> eventos, garantindo que todos os eventos sejam processados corretamente sem precisar de configuração manual.

Isso segue o princípio da inversão de controle e permite adicionar novos eventos sem modificar o código principal, tornando o sistema mais modular e fácil de manter. ✅

Opções de Expansão com Eventos

O uso de eventos nos permite adicionar novas ações de forma simples. Algumas possíveis implementações que poderiam ser adicionadas ao nosso fluxo:

📦 Integração com mensagerias: Publicar eventos no RabbitMQ ou Kafka para processamentos assíncronos.
🔔 Notificações push: Enviar notificações para o celular do usuário.
💳 Cobrança automática: Integrar com um sistema de pagamentos para ativar a cobrança recorrente.
📊 Registro de métricas: Enviar dados para um sistema de monitoramento, como o Prometheus.
🛠 Customizações avançadas: Criar um workflow que permita aos administradores ativar ou desativar eventos dinamicamente.

🛠 Padrões e Princípios

🔄 Padrão Observer

No nosso exemplo, utilizamos o Padrão Observer, onde a classe EventosNovaAssinatura age como um sujeito que notifica um conjunto de observadores (EventoAssinaturaConfirmada). Esse padrão permite desacoplar a lógica de notificação do fluxo principal, garantindo que novas ações possam ser adicionadas sem modificar código existente.

Isso se alinha ao Princípio Aberto-Fechado (OCP - Open/Closed Principle), pois podemos adicionar novos eventos sem modificar a implementação de EventosNovaAssinatura. Basta criar uma nova classe que implemente EventoAssinaturaConfirmada, e o Spring automaticamente a registrará.

🔌 Inversão de Controle e Injeção de Dependências

O Spring faz o gerenciamento automático das dependências ao injetar dinamicamente todas as implementações de EventoAssinaturaConfirmada dentro do Set<EventoAssinaturaConfirmada> eventoAssinaturaConfirmada. Isso elimina a necessidade de instanciar manualmente esses objetos, facilitando a escalabilidade e testabilidade do código.

Essa abordagem segue o Princípio da Inversão de Dependência (DIP - Dependency Inversion Principle), pois as classes de alto nível (EventosNovaAssinatura) não dependem diretamente das implementações concretas dos eventos, mas sim da abstração (EventoAssinaturaConfirmada).

🏗 Princípio da Responsabilidade Única (SRP - Single Responsibility Principle)

Cada classe do nosso código tem uma única responsabilidade:

EventosNovaAssinatura: responsável por processar assinaturas e notificar os eventos.
NotificacaoEmail: envia um e-mail confirmando a assinatura.
GerarRelatorio: atualiza o sistema com um novo relatório.
Assinatura: representa uma assinatura com status de confirmação.

Esse design modular melhora a organização do código e facilita a manutenção, pois cada classe foca em uma única tarefa.

📚 Conclusão

Com essa abordagem, conseguimos um sistema flexível, modular e extensível, permitindo adicionar novas notificações sem modificar código existente. O uso do Padrão Observer, combinado com a injeção de dependências do Spring, nos ajuda a manter um código alinhado aos princípios do SOLID, melhorando a testabilidade, manutenção e escalabilidade da aplicação.

Se gostou desse conteúdo, compartilhe com outros desenvolvedores e ajude a disseminar boas práticas no desenvolvimento Java! 💡

Parte 2: Adicionando Usuários ao Sistema de Login com Google

Uiratan Cavalcante — Fri, 28 Mar 2025 02:19:30 +0000

Introdução

Após configurar o login com Google na Parte 1, o próximo passo natural é persistir os dados dos usuários em um banco de dados para uso posterior, como personalização ou rastreamento.

Persistir usuários autenticados é uma prática comum em aplicações web, permitindo que informações como email e nome sejam armazenadas e reutilizadas sem depender exclusivamente dos tokens retornados pelo provedor de identidade. Historicamente, isso evoluiu com o crescimento das aplicações SaaS, onde dados de usuários passaram a ser fundamentais para funcionalidades específicas.

Nesta parte, vamos adicionar uma camada de persistência ao nosso sistema de login com Google, usando o Spring Data JPA e o banco H2 em memória. O objetivo é salvar os dados do usuário (como sub, email e name) na primeira autenticação, mantendo o código simples e aproveitando ao máximo as ferramentas do Spring, como JpaRepository e OidcUserService.

Configuração Inicial

Atualize as dependências do projeto, adicionando:

spring-boot-starter-data-jpa: Inclui Hibernate e Spring Data para persistência.
h2: Banco em memória para simplificar o tutorial.

`pom.xml`

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>

Configure o banco H2 em memória e JPA, adicionando:

datasource: Configura o H2 em memória com testdb como nome do banco.
jpa.hibernate.ddl-auto: update: O Hibernate cria ou atualiza a tabela users com base na entidade.

`application.yml`

spring:  
  datasource:
    url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1
    driver-class-name: org.h2.Driver
    username: sa
    password:
  jpa:
    hibernate:
      ddl-auto: update

Resumo do Fluxo Geral

Autenticação: O usuário faz login via Google, redirecionado por /oauth2/authorization/google.
Callback: O Spring processa o código retornado em /login/oauth2/code/google e chama CustomOAuth2UserService.
Persistência: O CustomOAuth2UserService verifica se o usuário existe no banco e, se não, o cria usando UserRepository.
Resposta: O HomeController retorna o JWT e uma mensagem, sem alterações relacionadas a persistência.

Passo a Passo

Vamos criar a entidade que mapeará os Usuários:

@Entity e @Table: Define a entidade mapeada para a tabela users. Aqui anotação @Table é importante pois ter uma entidade com o nome User poderá causar conflitos com o banco de dados.
@Id: Marca id como chave primária (preenchida com o sub do Google).
@Column(name = "tenant_id", nullable = false): Inclui a coluna tenant_id, que será usada na Parte 3 para multi-tenancy. Por ora, será preenchida com o mesmo valor do id.

E o seu repositório que nos fornece já métodos prontos de persistência:

JpaRepository<User, String>: Fornece métodos como findById, save, etc., usando String como tipo da chave.
findByEmail: Método derivado opcional, mas não essencial neste momento.

1. Criar a Entidade `User`

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "users")
public class User {
    @Id
    private String id;

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

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

    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

2. Criar o Repositório (`UserRepository`)

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface UserRepository extends JpaRepository<User, String> {
    Optional<User> findByEmail(String email); // Método extra, não usado aqui
}

Agora criaremos nosso serviço customizado CustomOAuth2UserService que realiza a persistência e recuperação do usuário do banco de dados:

loadUser(OidcUserRequest userRequest):
- super.loadUser(): Executa o fluxo OIDC padrão, obtendo dados do user-info-uri do Google.
- getSubject(), getEmail(), getFullName(): Extrai os atributos do OidcUser.
- findById(id).orElseGet(): Busca o usuário pelo id (o sub); se não existir, cria um novo e salva no banco via save().
- SQL Gerado: Algo como INSERT INTO users (id, email, name) VALUES (?, ?, ?).
- Retorna o OidcUser para o Spring Security continuar o fluxo de autenticação.

3. Criar o `CustomOAuth2UserService`

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.oauth2.client.oidc.userinfo.OidcUserRequest;
import org.springframework.security.oauth2.client.oidc.userinfo.OidcUserService;
import org.springframework.security.oauth2.core.OAuth2AuthenticationException;
import org.springframework.security.oauth2.core.oidc.user.OidcUser;
import org.springframework.stereotype.Service;

@Service
public class CustomOAuth2UserService extends OidcUserService {
    private final UserRepository userRepository;

    @Autowired
    public CustomOAuth2UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public OidcUser loadUser(OidcUserRequest userRequest) throws OAuth2AuthenticationException {
        OidcUser oidcUser = super.loadUser(userRequest);
        String id = oidcUser.getSubject();
        String email = oidcUser.getEmail();
        String name = oidcUser.getFullName();

        userRepository.findById(id)
            .orElseGet(() -> {
                User newUser = new User();
                newUser.setId(id);
                newUser.setEmail(email);
                newUser.setName(name);
                return userRepository.save(newUser);
            });

        return oidcUser;
    }
}

Agora podemos atualizar nossas configurações de segurança retirando o método oidcUserService() e injetando nosso CustomOAuth2UserService:

securityFilterChain(HttpSecurity http): Integra o customOAuth2UserService para processar o usuário após o login.
Nota: Mantém a estrutura da Parte 1, mas agora usa o serviço customizado.

4. Atualizar o `SecurityConfig`

import com.nimbusds.jose.jwk.JWKSet;
import com.nimbusds.jose.jwk.RSAKey;
import com.nimbusds.jose.jwk.source.JWKSource;
import com.nimbusds.jose.jwk.source.ImmutableJWKSet;
import com.nimbusds.jose.proc.SecurityContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.oauth2.jwt.JwtEncoder;
import org.springframework.security.oauth2.jwt.NimbusJwtEncoder;
import org.springframework.security.web.SecurityFilterChain;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.UUID;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    private CustomOAuth2UserService customOAuth2UserService;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(AbstractHttpConfigurer::disable)
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/oauth2/**", "/login/oauth2/**", "/error", "/favicon.ico", "/").permitAll()
                .anyRequest().authenticated()
            )
            .oauth2Login(oauth2 -> oauth2
                .defaultSuccessUrl("/home", true)
                .failureUrl("/error?error=true")
                // Atualização do oidcUserService
                .userInfoEndpoint(userInfo -> userInfo.oidcUserService(customOAuth2UserService))
            )
            .logout(logout -> logout.logoutSuccessUrl("/").permitAll())
            .build();
    }

    @Bean
    public JwtEncoder jwtEncoder() {
        JWKSource<SecurityContext> jwkSource = getJwkSource();
        return new NimbusJwtEncoder(jwkSource);
    }

    private JWKSource<SecurityContext> getJwkSource() {
        KeyPair keyPair = generateRsaKey();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        RSAKey rsaKey = new RSAKey.Builder(publicKey)
            .privateKey(privateKey)
            .keyID(UUID.randomUUID().toString())
            .build();
        JWKSet jwkSet = new JWKSet(rsaKey);
        return new ImmutableJWKSet<>(jwkSet);
    }

    private KeyPair generateRsaKey() {
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048);
            return keyPairGenerator.generateKeyPair();
        } catch (Exception ex) {
            throw new IllegalStateException("Erro ao gerar RSA KeyPair", ex);
        }
    }
}

5. Sem alterações em `HomeController`

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.oauth2.core.oidc.user.OidcUser;
import org.springframework.security.oauth2.jwt.JwtClaimsSet;
import org.springframework.security.oauth2.jwt.JwtEncoder;
import org.springframework.security.oauth2.jwt.JwtEncoderParameters;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.Instant;
import java.util.HashMap;
import java.util.Map;

@RestController
public class HomeController {

    @Autowired
    private JwtEncoder jwtEncoder;

    @GetMapping("/home")
    public ResponseEntity<Map<String, String>> home(@AuthenticationPrincipal OidcUser oidcUser) {
        Instant now = Instant.now();
        JwtClaimsSet claims = JwtClaimsSet.builder()
            .issuer("self")
            .issuedAt(now)
            .expiresAt(now.plusSeconds(3600))
            .subject(oidcUser.getSubject())
            .claim("email", oidcUser.getEmail())
            .claim("name", oidcUser.getFullName())
            .build();

        String jwt = jwtEncoder.encode(JwtEncoderParameters.from(claims)).getTokenValue();

        Map<String, String> response = new HashMap<>();
        response.put("message", "Welcome " + oidcUser.getFullName());
        response.put("jwt", jwt);
        response.put("message", "Welcome " + oidcUser.getGivenName());
        response.put("email", oidcUser.getEmail());
        response.put("givenName", oidcUser.getGivenName());
        response.put("familyName", oidcUser.getFamilyName());
        response.put("picture", oidcUser.getPicture());
        response.put("emailVerified", oidcUser.getEmailVerified().toString());
        response.put("issuer", oidcUser.getIssuer().toString());
        response.put("issuedAt", oidcUser.getIssuedAt().toString());
        response.put("expiresAt", oidcUser.getExpiresAt().toString());
        return ResponseEntity.ok(response);
    }

    @GetMapping("/")
    public String root() {
        return "Bem-vindo à página inicial!";
    }
}

6. Testar o Sistema

Execute mvn spring-boot:run.
Acesse http://localhost:8080/home.
Após login, o usuário é salvo no H2 e você verá algo como:

  {
    "message": "Welcome Uira Teste",
    "jwt": "eyJraWQiOiJhYjNkZGYy..."
  }

Para conferir se os dados foram persistidos no banco de dados, basta criar um simples endpoint que retorna a lita de usuários:

7. Sem alterações em `HomeController`

@RestController
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public List<User> users(@AuthenticationPrincipal OidcUser oidcUser) {
        return userRepository.findAll();
    }
}

Acesse http://localhost:8080/users.
Você verá a listagem dos usuários que foram salvos no banco de dados:

[
  {
    "id": "8547986604334038964715",
    "email": "teste@gmail.com",
    "name": "teste teste"
  }
]

Dica Bônus

Para ver os logs das operações realizadas pelo hibernate e do fluxo realizado entre o Spring e o Google, basta adicionar estas configurações ao application.yml:

`application.yml`

spring:
  jpa:
    properties:
      hibernate:
        format_sql: true
        show_sql: true

logging:
  level:
    org.springframework.security: DEBUG

No console da aplicação você poderá ver algo como:

2025-03-27T23:08:58.449-03:00 DEBUG 19672 --- [nio-8080-exec-1] o.s.security.web.FilterChainProxy        : Securing GET /home
2025-03-27T23:08:58.450-03:00 DEBUG 19672 --- [nio-8080-exec-1] o.s.s.w.a.AnonymousAuthenticationFilter  : Set SecurityContextHolder to anonymous SecurityContext
2025-03-27T23:08:58.451-03:00 DEBUG 19672 --- [nio-8080-exec-1] o.s.s.w.s.HttpSessionRequestCache        : Saved request http://localhost:8080/home?continue to session
2025-03-27T23:08:58.451-03:00 DEBUG 19672 --- [nio-8080-exec-1] s.w.a.DelegatingAuthenticationEntryPoint : Trying to match using And [Not [RequestHeaderRequestMatcher [expectedHeaderName=X-Requested-With, expectedHeaderValue=XMLHttpRequest]], Not [And [Or [Ant [pattern='/login'], Ant [pattern='/favicon.ico']], And [Not [RequestHeaderRequestMatcher [expectedHeaderName=X-Requested-With, expectedHeaderValue=XMLHttpRequest]], MediaTypeRequestMatcher [contentNegotiationStrategy=org.springframework.web.accept.ContentNegotiationManager@38f24018, matchingMediaTypes=[application/xhtml+xml, image/*, text/html, text/plain], useEquals=false, ignoredMediaTypes=[*/*]]]]], org.springframework.security.config.annotation.web.configurers.oauth2.client.OAuth2LoginConfigurer$$Lambda/0x0000027fca963ce8@65fa0784]
2025-03-27T23:08:58.451-03:00 DEBUG 19672 --- [nio-8080-exec-1] s.w.a.DelegatingAuthenticationEntryPoint : Match found! Executing org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint@53cd9cb6
2025-03-27T23:08:58.451-03:00 DEBUG 19672 --- [nio-8080-exec-1] o.s.s.web.DefaultRedirectStrategy        : Redirecting to http://localhost:8080/oauth2/authorization/google
2025-03-27T23:08:58.455-03:00 DEBUG 19672 --- [nio-8080-exec-3] o.s.security.web.FilterChainProxy        : Securing GET /oauth2/authorization/google
2025-03-27T23:08:58.456-03:00 DEBUG 19672 --- [nio-8080-exec-3] o.s.s.web.DefaultRedirectStrategy        : Redirecting to https://accounts.google.com/o/oauth2/v2/auth?response_type=code&client_id=990849046214-2a6587e3mlrdiq9sjg3eist47cglr601.apps.googleusercontent.com&scope=openid%20profile%20email&state=irMOadAkAJlWOghuSv_h1dnHYoyHR3TN4vJN8lRj2Pc%3D&redirect_uri=http://localhost:8080/login/oauth2/code/google&nonce=JOBvBAx4-hWGrjEgZHk7Me0rqOHhfe1Pbj7PS_B9inc

Perceba o fluxo gerado pela aplicação:

Do filtro de segurança aplicado ao acessar /home: Securing GET /home
Até o redirecionamento para a página de login do Google: Redirecting to https://accounts.google
Passando pela verificação da existência do usuário e sua inclusão:

Hibernate: 
    select
        u1_0.id,
        u1_0.email,
        u1_0.name 
    from
        users u1_0 
    where
        u1_0.id=?

Hibernate: 
    insert 
    into
        users
        (email, name, id) 
    values
        (?, ?, ?)

Outras Abordagens Ao H2

Persistência com Banco Externo (ex.: PostgreSQL):
- Como: Configura um DataSource para PostgreSQL em vez de H2.
- Vantagens: Persistência permanente, escalabilidade.
- Desvantagens: Requer configuração adicional (ex.: Docker).
Armazenamento em Cache (ex.: Redis):
- Como: Usa Redis para salvar dados temporariamente em vez de um banco relacional.
- Vantagens: Mais rápido, ideal para dados voláteis.
- Desvantagens: Não persistente, menos adequado para dados críticos.

Agradeço por seguir até aqui e explorar como adicionar persistência de usuários ao nosso sistema de login com Google! 🙌

Foi um prazer detalhar cada passo e mostrar como o Spring Data JPA simplifica esse processo. O que achou dessa implementação com H2? 💡

Compartilhe suas impressões ou dúvidas nos comentários 📢 e, se curtiu, passe o tutorial adiante para quem possa se beneficiar 🌐.

Na Parte 3, vamos introduzir o multi-tenancy — nos vemos lá! ⏳

Parte 1: Criando um Sistema de Login com Google e JWT no Spring Boot

Uiratan Cavalcante — Fri, 28 Mar 2025 01:14:02 +0000

Introdução

O login social é uma abordagem moderna para autenticação que utiliza serviços de terceiros, como Google, Facebook ou GitHub, para identificar usuários. Ele é baseado em protocolos como OAuth 2.0, que nasceu em 2006 como um framework de autorização, e OpenID Connect (OIDC), uma camada de autenticação sobre o OAuth 2.0 lançada em 2014.

Esses padrões permitem que aplicações deleguem a autenticação a provedores confiáveis, reduzindo a complexidade de gerenciar senhas e aumentando a segurança com infraestrutura consolidada.

Vamos construir um sistema de login com o Google usando Spring Boot e Spring Security, gerando um JSON Web Token (JWT) para encapsular as informações do usuário autenticado?

O foco será no Google, mas outros serviços compatíveis com OIDC incluem Microsoft Azure AD, Okta, Auth0 e Keycloak — todos seguindo o mesmo padrão de troca de tokens e fornecimento de dados via userinfo.

Usaremos ao máximo as classes prontas do Spring, como OidcUserService e JwtEncoder, que encapsulam lógicas testadas e otimizadas, evitando reinventar a roda.

Por que login social? Além de simplificar a UX (sem formulários de senha), ele aproveita autenticação multifator (MFA) e outros recursos de segurança dos provedores, tornando-o ideal para aplicações modernas.

Credenciais do Google

Caso não possua, crie as credenciais no Google.

Acesse o Google Cloud Console
- Vá para console.cloud.google.com.
- Faça login com sua conta Google.
Crie ou Selecione um Projeto
- No topo, clique no menu de projetos (ao lado de "Google Cloud") e selecione "New Project".
- Dê um nome (ex.: "MySpringBootApp"), escolha a organização (se aplicável) e clique em "Create".
- Selecione o projeto recém-criado no menu de projetos.
Habilite a API do Google
- No menu lateral, vá para "APIs & Services" > "Library".
- Pesquise por "Google OAuth" ou "Google API" e habilite a "Google+ API" ou "People API" (necessária para userinfo com profile e email).
Configure a Tela de Consentimento OAuth
- No menu lateral, vá para "APIs & Services" > "OAuth consent screen".
- Escolha o tipo de usuário:
  - Internal: Apenas usuários da sua organização.
  - External: Qualquer usuário com conta Google (mais comum para testes).
- Preencha os campos obrigatórios:
  - App name: Nome da sua aplicação (ex.: "MySpringBootApp").
  - User support email: Seu email.
  - Developer contact information: Seu email.
- Em "Scopes", adicione openid, profile, e email.
- Salve e continue.
Crie as Credenciais
- No menu lateral, vá para "APIs & Services" > "Credentials".
- Clique em "Create Credentials" e selecione "OAuth 2.0 Client IDs".
- Configure:
  - Application type: "Web application".
  - Name: Um nome para identificar (ex.: "Spring Boot Client").
  - Authorized JavaScript origins: Deixe em branco (não necessário para Spring Boot).
  - Authorized redirect URIs: Adicione a URI de callback do seu app, como http://localhost:8080/login/oauth2/code/google (padrão do Spring Boot).
- Clique em "Create".
Obtenha as Credenciais
- Após criar, você verá o Client ID e o Client Secret.

Configurando o projeto

Tenha no seu projeto as dependências necessárias:

spring-boot-starter-web: Inclui Tomcat e Spring MVC para criar endpoints REST.
spring-boot-starter-oauth2-client: Fornece suporte a OAuth 2.0 e OIDC, com filtros como OAuth2AuthorizationRequestRedirectFilter.
nimbus-jose-jwt: Biblioteca para criar JWTs assinados com algoritmos como RS256.

`pom.xml`

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-oauth2-client</artifactId>
        </dependency>
        <dependency>
            <groupId>com.nimbusds</groupId>
            <artifactId>nimbus-jose-jwt</artifactId>
            <version>9.37</version>
        </dependency>
    </dependencies>

Configure as credenciais do Google no projeto (criadas anteriormente):

client-id e client-secret: Credenciais únicas do Google para identificar sua aplicação.
scope: Define os dados solicitados (openid para autenticação, profile para nome/foto, email para email).
provider.google: Endpoints padrão do Google para autorização, tokens e informações do usuário.

`application.yml`

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: [seu-client-id-do-google]
            client-secret: [seu-client-secret-do-google]
            scope:
              - openid
              - profile
              - email
            redirect-uri: http://localhost:8080/login/oauth2/code/google
server:
  port: 8080
  servlet:
    session:
      tracking-modes: cookie  # Usa apenas cookies, não URL

Fluxo Geral da Aplicação

Requisição Inicial: O usuário acessa /home, uma rota protegida.
Redirecionamento OAuth2: O filtro OAuth2AuthorizationRequestRedirectFilter detecta a falta de autenticação e redireciona para /oauth2/authorization/google.
Autorização no Google: O Google exibe a tela de login/consentimento e retorna um código para /login/oauth2/code/google.
Troca de Tokens: O Spring usa o código para obter access_token e id_token do Google via token-uri.
Carregamento do Usuário: O OidcUserService consulta o user-info-uri e retorna um OidcUser.
Geração do JWT: O HomeController cria um JWT com os dados do usuário e retorna ao cliente.

Show Me The Code!

1. Configurar o Spring Security (`SecurityConfig`)

import com.nimbusds.jose.jwk.JWKSet;
import com.nimbusds.jose.jwk.RSAKey;
import com.nimbusds.jose.jwk.source.JWKSource;
import com.nimbusds.jose.jwk.source.ImmutableJWKSet;
import com.nimbusds.jose.proc.SecurityContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.oauth2.client.oidc.userinfo.OidcUserService;
import org.springframework.security.oauth2.jwt.JwtEncoder;
import org.springframework.security.oauth2.jwt.NimbusJwtEncoder;
import org.springframework.security.web.SecurityFilterChain;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.UUID;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http, OidcUserService oidcUserService) throws Exception {
        return http
            .csrf(AbstractHttpConfigurer::disable) // Desativa proteção CSRF (adequado para APIs REST)
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/oauth2/**", "/login/oauth2/**", "/error", "/favicon.ico", "/").permitAll() // Rotas públicas
                .anyRequest().authenticated() // Todas as outras exigem autenticação
            )
            .oauth2Login(oauth2 -> oauth2
                .defaultSuccessUrl("/home", true) // Após login, vai para /home
                .failureUrl("/error?error=true") // Em caso de erro
                .userInfoEndpoint(userInfo -> userInfo.oidcUserService(oidcUserService())) // Define o serviço de usuário
            )
            .logout(logout -> logout.logoutSuccessUrl("/").permitAll()) // Logout redireciona para raiz
            .build();
    }

    @Bean
    public OidcUserService oidcUserService() {
        return new OidcUserService(); // Serviço padrão para carregar dados do usuário via OIDC
    }

    @Bean
    public JwtEncoder jwtEncoder() {
        JWKSource<SecurityContext> jwkSource = getJwkSource();
        return new NimbusJwtEncoder(jwkSource); // Encoder para gerar JWTs assinados
    }

    private JWKSource<SecurityContext> getJwkSource() {
        KeyPair keyPair = generateRsaKey();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        RSAKey rsaKey = new RSAKey.Builder(publicKey)
            .privateKey(privateKey)
            .keyID(UUID.randomUUID().toString()) // Identificador único da chave
            .build();
        JWKSet jwkSet = new JWKSet(rsaKey); // Conjunto de chaves JWK
        return new ImmutableJWKSet<>(jwkSet); // Fonte imutável de chaves
    }

    private KeyPair generateRsaKey() {
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048); // Tamanho da chave para segurança
            return keyPairGenerator.generateKeyPair(); // Gera par público/privado
        } catch (Exception ex) {
            throw new IllegalStateException("Erro ao gerar RSA KeyPair", ex);
        }
    }
}

securityFilterChain(HttpSecurity http, OidcUserService oidcUserService):
- Configura a cadeia de filtros de segurança.
- csrf.disable(): Remove proteção CSRF, pois estamos usando tokens (não formulários).
- authorizeHttpRequests: Define regras de acesso — /oauth2/** e /login/oauth2/** são rotas internas do OAuth2, /error e /favicon.ico são utilitárias, e / é a página inicial pública.
- oauth2Login: Ativa o fluxo OIDC, redirecionando para /home após sucesso e usando o oidcUserService.
- logout: Limpa a sessão e redireciona para /.
oidcUserService(): Retorna um serviço padrão que consulta o user-info-uri do Google e retorna um OidcUser com atributos como sub, email, e name.
jwtEncoder(): Cria um encoder que usa o JWKSource para assinar JWTs com RS256.
getJwkSource(): Monta um JWKSet com uma chave RSA, encapsulada em um ImmutableJWKSet para ser usada pelo encoder.
generateRsaKey(): Usa o algoritmo RSA com 2048 bits para gerar um par de chaves seguro.

2. Criar o Controlador (`HomeController`)

import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.oauth2.core.oidc.user.OidcUser;
import org.springframework.security.oauth2.jwt.JwtClaimsSet;
import org.springframework.security.oauth2.jwt.JwtEncoder;
import org.springframework.security.oauth2.jwt.JwtEncoderParameters;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.Instant;
import java.util.HashMap;
import java.util.Map;

@RestController
public class HomeController {

    private final JwtEncoder jwtEncoder;

    public HomeController(JwtEncoder jwtEncoder) {
        this.jwtEncoder = jwtEncoder; // Injetado pelo Spring
    }

    @GetMapping("/home")
    public ResponseEntity<Map<String, String>> home(@AuthenticationPrincipal OidcUser oidcUser) {
        Instant now = Instant.now();
        JwtClaimsSet claims = JwtClaimsSet.builder()
            .issuer("self") // Identifica o emissor do token
            .issuedAt(now) // Data de emissão
            .expiresAt(now.plusSeconds(3600)) // Expira em 1 hora
            .subject(oidcUser.getSubject()) // ID único do usuário
            .claim("email", oidcUser.getEmail()) // Email do usuário
            .claim("name", oidcUser.getFullName()) // Nome completo
            .build();

        String jwt = jwtEncoder.encode(JwtEncoderParameters.from(claims)).getTokenValue(); // Gera o JWT assinado

        Map<String, String> response = new HashMap<>();
        response.put("message", "Welcome " + oidcUser.getFullName());
        response.put("jwt", jwt);
        return ResponseEntity.ok(response);
    }

    @GetMapping("/")
    public String root() {
        return "Bem-vindo à página inicial!";
    }
}

HomeController(JwtEncoder jwtEncoder): O construtor recebe o JwtEncoder via injeção de dependência.
home(@AuthenticationPrincipal OidcUser oidcUser):
- @AuthenticationPrincipal: Extrai o OidcUser do SecurityContext, preenchido pelo Spring Security após o login.
- JwtClaimsSet.builder(): Cria um conjunto de reivindicações (claims) para o JWT, incluindo iss, iat, exp, sub, e claims customizados (email, name).
- jwtEncoder.encode(): Usa a chave privada RSA do JWKSource para assinar o JWT com RS256, retornando uma string no formato header.payload.signature.
- ResponseEntity.ok(): Retorna um JSON com a mensagem e o JWT.
root(): Endpoint público simples para a raiz.

3. Testar o Sistema

Execute mvn spring-boot:run.
Acesse http://localhost:8080/home.
O fluxo redireciona ao Google, e após login, retorna:

  {
    "message": "Welcome Uira Teste",
    "jwt": "eyJraWQiOiJhYjNkZGYy..."
  }

Outras Formas de Fazer

Senhas Tradicionais com Spring Security:
- Como: Usa UserDetailsService e autenticação por formulário com um banco de usuários.
- Vantagens: Total controle local, sem dependência externa.
- Desvantagens: Complexidade de gerenciar senhas, sem integração social nativa.
Auth0 como Provedor:
- Como: Substitui o Google por Auth0, configurando-o no application.yml.
- Vantagens: Suporte a múltiplos provedores, painel de gerenciamento.
- Desvantagens: Custo adicional, menos controle sobre o backend.

Espero que este artigo tenha sido útil para entender o fluxo de autenticação e como aproveitar as ferramentas do framework.

O que achou dessa abordagem? Deixe seu feedback nos comentários abaixo 📝 e, se gostou, compartilhe com amigos ou colegas via redes sociais 🚀 que também estão explorando Spring Security e OAuth2.

Na próxima parte, vamos adicionar persistência de usuários — até lá! 👋

Design by Contract: Como Aumentar a Confiabilidade do Seu Código 🚀

Uiratan Cavalcante — Sat, 08 Feb 2025 22:38:36 +0000

Se você já se deparou com bugs difíceis de rastrear ou sistemas que parecem quebrar sem motivo aparente, sabe como a confiabilidade do código é crucial. E se eu te disser que existe uma técnica que pode ajudar a evitar muitos desses problemas? Estou falando do Design by Contract (DbC), uma abordagem que pode transformar a forma como você desenvolve software.

Neste post, vamos explorar o que é Design by Contract, como ele funciona e por que você deveria considerá-lo no seu próximo projeto. Vamos lá? 👨‍💻👩‍💻

O Que é Design by Contract? 🤔

O Design by Contract é uma técnica de desenvolvimento de software que define claramente as responsabilidades entre diferentes partes do código. A ideia central é que cada método ou função tenha um "contrato" que especifica:

Pré-condições: O que deve ser verdadeiro antes do método ser executado.
Pós-condições: O que deve ser verdadeiro após a execução do método.
Invariantes de classe: Condições que devem ser mantidas verdadeiras durante todo o ciclo de vida de um objeto.

Essa abordagem foi popularizada por Bertrand Meyer, autor do livro "Object-Oriented Software Construction", e é amplamente utilizada para aumentar a robustez e a clareza do código.

Por Que Usar Design by Contract? 💡

Imagine que você está construindo um sistema de pagamentos. Um método que processa pagamentos precisa garantir que:

Antes de executar: O valor do pagamento seja positivo (pré-condição).
Depois de executar: O saldo da conta seja atualizado corretamente (pós-condição).
Sempre: O saldo nunca seja negativo (invariante de classe).

Se essas condições forem claramente definidas e validadas, você reduz drasticamente a chance de erros e facilita a manutenção do código. Legal, né? 😎

Pré-Condições: O Ponto de Partida 🛑

As pré-condições são verificações feitas antes da execução de um método. Elas garantem que os parâmetros de entrada atendam às expectativas. Por exemplo:

public void adicionarPagamento(Pagamento pagamento) {
    if (pagamento == null || pagamento.getValor() <= 0) {
        throw new IllegalArgumentException("Pagamento inválido!");
    }
    // Lógica para adicionar o pagamento
}

Aqui, estamos garantindo que o pagamento não seja nulo e que o valor seja positivo. Se essas condições não forem atendidas, o método nem tenta executar, evitando problemas futuros.

Pós-Condições: Garantindo o Resultado ✅

As pós-condições verificam se o estado do sistema ou o retorno do método está correto após a execução. Por exemplo:

public void aceitarConvite(Convite convite) {
    if (convite.getDataAceite() != null) {
        throw new IllegalStateException("Convite já aceito!");
    }
    // Lógica para aceitar o convite
    if (convite.getDataAceite() == null) {
        throw new IllegalStateException("Data de aceite não foi definida!");
    }
}

Aqui, garantimos que o convite só pode ser aceito uma vez e que a data de aceite seja definida corretamente.

Invariantes de Classe: A Consistência do Objeto 🧱

As invariantes de classe são condições que devem ser mantidas verdadeiras durante todo o ciclo de vida de um objeto. Por exemplo:

public class Usuario {
    private String nome;
    private List<Agenda> agendas;

    public Usuario(String nome) {
        this.nome = nome;
        this.agendas = new ArrayList<>();
        this.agendas.add(new Agenda(nome)); // Invariante: Todo usuário tem uma agenda
    }

    public void adicionarAgenda(Agenda agenda) {
        if (agenda == null) {
            throw new IllegalArgumentException("Agenda inválida!");
        }
        this.agendas.add(agenda);
    }
}

Aqui, garantimos que todo usuário tenha pelo menos uma agenda associada, independentemente do método chamado.

Design by Contract vs. Programação Defensiva 🛡️

A programação defensiva envolve a verificação excessiva de condições (como múltiplos ifs), o que pode levar a código redundante e complexo. Já o Design by Contract propõe uma abordagem mais clara e direta, evitando verificações desnecessárias e focando em restrições bem definidas.

Por exemplo, em vez de fazer:

if (lista != null && !lista.isEmpty()) {
    // Lógica
}

Você pode simplesmente definir que a lista não pode ser nula ou vazia como pré-condição:

public void processarLista(List<String> lista) {
    if (lista == null || lista.isEmpty()) {
        throw new IllegalArgumentException("Lista inválida!");
    }
    // Lógica
}

Integrando com Testes Automatizados 🧪

Os testes automatizados podem verificar pós-condições, mas não substituem a necessidade de pré-condições no código. A combinação de pré-condições e testes automatizados aumenta ainda mais a confiabilidade do sistema.

Por exemplo, em um teste automatizado:

@Test
public void testAdicionarPagamento() {
    SistemaPagamento sistema = new SistemaPagamento();
    sistema.adicionarPagamento(new Pagamento(100.0));
    assertEquals(100.0, sistema.getSaldo());
}

Aqui, estamos verificando se o saldo foi atualizado corretamente após a adição de um pagamento.

Quando Usar Exceções? 🚨

Exceções devem ser usadas para situações excepcionais e inesperadas, como parâmetros inválidos ou erros de sistema. Situações esperadas (como estoque insuficiente) devem ser tratadas com retornos claros, não com exceções.

Por exemplo:

public Resultado abaterEstoque(int quantidade) {
    if (quantidade > estoqueDisponivel) {
        return new Resultado("Estoque insuficiente");
    }
    // Lógica para abater o estoque
    return new Resultado("Estoque abatido com sucesso");
}

Conclusão: Por Que Adotar Design by Contract? 🎯

O Design by Contract é uma técnica poderosa para aumentar a confiabilidade e a qualidade do código. Ao definir claramente as pré-condições, pós-condições e invariantes de classe, você pode:

Antecipar erros: Evitar bugs antes que eles aconteçam.
Facilitar a manutenção: Tornar o código mais claro e fácil de entender.
Melhorar a robustez: Garantir que o sistema funcione corretamente em diferentes cenários.

Então, que tal começar a aplicar essas técnicas no seu próximo projeto? Seu código (e sua sanidade mental) agradecem! 😉

Aprendizados e Insights Chave 🔑

Confiabilidade é fundamental: A qualidade do código está diretamente ligada à sua confiabilidade.
Pré-condições são essenciais: Verificar as condições de entrada dos métodos é a forma mais eficaz de prevenir erros.
Invariantes garantem consistência: Condições que devem sempre ser verdadeiras ajudam a manter o estado do objeto consistente.
Exceções para situações excepcionais: Use exceções apenas para erros inesperados, não para fluxos de negócio normais.
Combine DbC com testes automatizados: A integração de pré-condições e testes automatizados maximiza a confiabilidade do sistema.

E aí, gostou do post? Já usa Design by Contract nos seus projetos? Compartilhe suas experiências nos comentários! 👇

DesignByContract #QualidadeDeCódigo #DesenvolvimentoDeSoftware #ProgramaçãoOrientadaAObjetos

Validando CPF e CNPJ com uma Annotation Customizada em Java

Uiratan Cavalcante — Thu, 06 Feb 2025 21:42:20 +0000

No mundo do desenvolvimento de software, validações são um aspecto essencial para garantir que os dados inseridos pelos usuários estejam corretos. Em Java, você pode criar validações personalizadas para diferentes cenários. Neste post, vamos aprender como criar uma annotation customizada para validar documentos como CPF e CNPJ utilizando o pacote javax.validation.

O que vamos fazer?

Vamos criar uma annotation chamada @CPFCNPJ que pode ser aplicada em campos que recebem um CPF ou CNPJ. A annotation vai utilizar um validador customizado, chamado DocumentoValidator, que será responsável por verificar se o valor inserido é válido de acordo com as regras do CPF ou CNPJ.

Passo 1: Criando a Annotation `@CPFCNPJ`

Primeiramente, criamos a annotation que será usada para marcar os campos que precisam ser validados. Aqui está o código da annotation:

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Constraint(validatedBy = DocumentoValidator.class) // Indica qual será o validador
@Target({ ElementType.FIELD }) // Aplica-se a campos
@Retention(RetentionPolicy.RUNTIME) // Disponível em tempo de execução
public @interface CPFCNPJ {
    String message() default "Documento inválido"; // Mensagem padrão de erro
    Class<?>[] groups() default {}; // Para agrupar validações
    Class<? extends Payload>[] payload() default {}; // Para adicionar dados adicionais ao validador
}

Neste código:

A annotation @Constraint associa a annotation @CPFCNPJ ao validador DocumentoValidator.
A annotation pode ser aplicada a campos com @Target({ ElementType.FIELD }).
A mensagem de erro padrão é "Documento inválido", mas pode ser personalizada.
groups e payload são utilizados em validações mais avançadas, mas não são necessários para este exemplo básico.

Passo 2: Criando o Validador `DocumentoValidator`

Agora, vamos criar a classe DocumentoValidator, que será responsável por validar os documentos CPF e CNPJ. Ela implementa a interface ConstraintValidator, que recebe a annotation e o tipo de dado a ser validado (no nosso caso, uma string que representa o CPF ou CNPJ).

Aqui está o código do DocumentoValidator:

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class DocumentoValidator implements ConstraintValidator<CPFCNPJ, String> {

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if (value == null || value.isEmpty()) {
            return false; // Se o campo for nulo ou vazio, é considerado inválido
        }

        return validarDocumento(value); // Chama o método que valida CPF ou CNPJ
    }

    private static boolean validarCPF(String cpf) {
        if (cpf == null || cpf.length() != 11 || !cpf.matches("[0-9]{11}")) {
            return false;
        }

        if (cpf.matches("(\\d)\\1{10}")) {
            return false; // Não permite CPFs com números repetidos
        }

        int soma = 0;
        int peso = 10;
        for (int i = 0; i < 9; i++) {
            soma += Character.getNumericValue(cpf.charAt(i)) * peso--;
        }

        int digito1 = 11 - (soma % 11);
        if (digito1 == 10 || digito1 == 11) digito1 = 0;

        soma = 0;
        peso = 11;
        for (int i = 0; i < 10; i++) {
            soma += Character.getNumericValue(cpf.charAt(i)) * peso--;
        }

        int digito2 = 11 - (soma % 11);
        if (digito2 == 10 || digito2 == 11) digito2 = 0;

        return digito1 == Character.getNumericValue(cpf.charAt(9)) && digito2 == Character.getNumericValue(cpf.charAt(10));
    }

    private static boolean validarCNPJ(String cnpj) {
        if (cnpj == null || cnpj.length() != 14 || !cnpj.matches("[0-9]{14}")) {
            return false;
        }

        if (cnpj.matches("(\\d)\\1{13}")) {
            return false; // Não permite CNPJs com números repetidos
        }

        int soma = 0;
        int[] peso1 = {5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
        for (int i = 0; i < 12; i++) {
            soma += Character.getNumericValue(cnpj.charAt(i)) * peso1[i];
        }

        int digito1 = 11 - (soma % 11);
        if (digito1 == 10 || digito1 == 11) digito1 = 0;

        soma = 0;
        int[] peso2 = {6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
        for (int i = 0; i < 13; i++) {
            soma += Character.getNumericValue(cnpj.charAt(i)) * peso2[i];
        }

        int digito2 = 11 - (soma % 11);
        if (digito2 == 10 || digito2 == 11) digito2 = 0;

        return digito1 == Character.getNumericValue(cnpj.charAt(12)) && digito2 == Character.getNumericValue(cnpj.charAt(13));
    }

    private static boolean validarDocumento(String documento) {
        if (documento == null) {
            return false;
        }

        documento = documento.replaceAll("[^0-9]", "");  // Remove caracteres não numéricos

        if (documento.length() == 11) {
            return validarCPF(documento);
        } else if (documento.length() == 14) {
            return validarCNPJ(documento);
        }

        return false;  // Se o comprimento não for nem 11 nem 14, retorna inválido
    }
}

Passo 3: Utilizando a Annotation

Agora que já criamos a annotation e o validador, podemos aplicá-los em um modelo de dados. Por exemplo, vamos validar um CPF ou CNPJ em um campo de um DTO (Data Transfer Object).

import javax.validation.constraints.NotEmpty;

public class UsuarioDTO {

    @CPFCNPJ(message = "CPF ou CNPJ inválido") // Aplica a validação customizada
    @NotEmpty(message = "Documento não pode ser vazio")
    private String documento;

    // Getters e Setters

    public String getDocumento() {
        return documento;
    }

    public void setDocumento(String documento) {
        this.documento = documento;
    }
}

Passo 4: Realizando a Validação

Para realizar a validação, você pode usar o Validator do Bean Validation. Aqui está um exemplo simples de como validar a classe UsuarioDTO:

import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import javax.validation.ConstraintViolation;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        UsuarioDTO usuario = new UsuarioDTO();
        usuario.setDocumento("123.456.789-09");  // Insira o CPF ou CNPJ a ser validado

        // Cria o validador
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();

        // Valida o objeto
        Set<ConstraintViolation<UsuarioDTO>> violations = validator.validate(usuario);

        // Verifica se há erros
        for (ConstraintViolation<UsuarioDTO> violation : violations) {
            System.out.println(violation.getMessage());  // Exibe a mensagem de erro
        }
    }
}

Conclusão

Neste post, mostramos como criar uma annotation customizada para validar CPF e CNPJ em Java. Utilizamos a especificação Bean Validation (JSR 303) para criar a annotation @CPFCNPJ, um validador DocumentoValidator e mostramos como aplicar e utilizar a validação em um campo de um modelo de dados.

Com isso, você pode facilmente validar CPFs e CNPJs em seus projetos Java, mantendo o código limpo e reutilizável.

📚 Guia de Consultas com `EntityManager` no Java: JPQL, SQL e DTOs

Uiratan Cavalcante — Wed, 05 Feb 2025 17:14:45 +0000

Ao trabalhar com JPA (Java Persistence API) em aplicações Java, o EntityManager se torna a ferramenta essencial para manipular as entidades e interagir com o banco de dados. O EntityManager oferece várias maneiras de consultar dados, cada uma com suas características e impactos na performance, segurança, facilidade de uso e flexibilidade.

Neste post, vamos explorar quatro abordagens populares de consulta de dados com EntityManager:

Usando JPQL (Java Persistence Query Language)
Usando SQL Puro (Native Query)
Usando JPQL com DTO (Data Transfer Object)
Usando SQL Puro com DTO

Além disso, faremos uma comparação entre as abordagens, levando em conta independência do banco, segurança, performance, facilidade de uso, flexibilidade e a estrutura JSON ao usar essas abordagens em controllers.

🔹 1. Usando JPQL no `EntityManager`

O JPQL é a linguagem de consulta do JPA que permite realizar consultas diretamente sobre as entidades Java, ao invés de usar SQL tradicional. O EntityManager torna o uso do JPQL muito simples e flexível, pois abstrai a necessidade de escrever SQL diretamente.

Exemplo de código JPQL:

EntityManager em = entityManagerFactory.createEntityManager();
List<Livro> livros = em.createQuery("SELECT l FROM Livro l WHERE l.nome LIKE :nome", Livro.class)
                        .setParameter("nome", "%Java%")
                        .getResultList();

✅ Vantagens do JPQL

Independência do Banco: Como o JPQL é baseado nas entidades Java, a consulta é independente do banco de dados. Isso facilita a portabilidade entre diferentes SGBDs.
Segurança: Ao utilizar JPQL com EntityManager, você protege sua aplicação contra SQL Injection, pois a consulta é executada através do JPA.
Facilidade de Uso: O JPQL é simples de escrever e entender, já que as consultas são feitas com base nas entidades e seus atributos.

❌ Desvantagens do JPQL

Performance: Para consultas complexas e de alto volume de dados, o JPQL pode não ser tão otimizado quanto o SQL puro.
Flexibilidade Limitada: Algumas funcionalidades específicas de SQL não estão disponíveis em JPQL, como a manipulação direta de tabelas e recursos avançados do banco.

🔹 2. Usando SQL Puro no `EntityManager`

SQL Puro (ou Native Query) permite que você escreva consultas SQL diretamente, sem as abstrações do JPA. Isso dá total controle sobre a consulta e pode ser muito útil para otimizar o desempenho em consultas complexas.

Exemplo de código SQL Puro:

EntityManager em = entityManagerFactory.createEntityManager();
List<Object[]> result = em.createNativeQuery("SELECT * FROM livro WHERE nome LIKE :nome")
                          .setParameter("nome", "%Java%")
                          .getResultList();

✅ Vantagens do SQL Puro

Alta Performance: O SQL Puro é mais eficiente para consultas complexas ou que exigem otimizações específicas do banco de dados.
Flexibilidade: Ele permite o uso de todas as funcionalidades avançadas do SQL, como JOINs, GROUP BY, HAVING, etc.
Controle Total: Você pode escrever consultas específicas para o banco, o que pode trazer grandes benefícios de desempenho.

❌ Desvantagens do SQL Puro

Dependência do Banco: O código SQL pode ser dependente de um banco específico, dificultando a portabilidade entre diferentes SGBDs.
Segurança: Caso não sejam feitos os devidos tratamentos, o SQL Puro pode ser mais suscetível a SQL Injection, especialmente se os parâmetros não forem bem sanitizados.

🔹 3. Usando JPQL com DTO

Quando você precisa de um JSON estruturado para enviar dados de uma forma organizada, ou quando não quer carregar dados desnecessários, a utilização de DTOs (Data Transfer Objects) junto com JPQL é uma excelente abordagem. Isso permite retornar somente os dados necessários, otimizando a transferência de dados e a estruturação das informações.

Exemplo de código JPQL com DTO:

EntityManager em = entityManagerFactory.createEntityManager();
List<LivroDTO> livros = em.createQuery("SELECT new com.exemplo.LivroDTO(l.id, l.nome) FROM Livro l", LivroDTO.class)
                           .getResultList();

✅ Vantagens do JPQL com DTO

Independência do Banco: A consulta continua sendo independente de banco, pois o JPQL não depende de SQL específico do banco.
Segurança: O uso de DTO ajuda a evitar SQL Injection, pois a consulta é gerada pelo JPA.
Estrutura JSON: Ideal para APIs REST, pois retorna dados em uma estrutura bem definida (DTO) que pode ser facilmente convertida em JSON.

❌ Desvantagens do JPQL com DTO

Menos Eficiente: Para grandes volumes de dados, a criação de DTOs pode impactar na performance, já que um novo objeto precisa ser instanciado para cada linha retornada.
Complexidade: Requer a criação de DTOs, o que pode aumentar a complexidade do código e demandar mais manutenção.

🔹 4. Usando SQL Puro com DTO

Quando você precisa de consultas SQL avançadas, mas ainda deseja retornar os resultados em uma estrutura mais limpa, como um DTO, pode combinar SQL Puro com DTOs. Isso oferece o melhor dos dois mundos: controle sobre a consulta e uma estrutura organizada para os dados.

Exemplo de código SQL Puro com DTO:

EntityManager em = entityManagerFactory.createEntityManager();
List<LivroDTO> livros = em.createNativeQuery("SELECT l.id, l.nome FROM livro l WHERE l.nome LIKE :nome", LivroDTO.class)
                           .setParameter("nome", "%Java%")
                           .getResultList();

✅ Vantagens do SQL Puro com DTO

Performance: Consultas SQL puras podem ser otimizadas para o banco de dados específico, proporcionando maior performance.
Flexibilidade: Você tem controle total sobre a consulta SQL, incluindo recursos avançados e específicos do banco.
Estruturação JSON: Retorna dados estruturados em DTO, facilitando o uso em APIs e controladores.

❌ Desvantagens do SQL Puro com DTO

Dependência do Banco: Como a consulta é feita em SQL puro, ela pode ser dependente de características específicas do banco de dados, como dialetos SQL.
Segurança: Sem a devida precaução, o SQL Puro pode ser vulnerável a SQL Injection, caso os parâmetros não sejam corretamente tratados.

📊 Comparação Geral

Método	Independente do Banco?	Segurança	Performance	Facilidade de Uso	Flexibilidade	Estrutura JSON
JPQL (`Object[]`)	✅ Sim	✅ Sim	⚠️ Menos eficiente em grandes volumes	✅ Simples	❌ Limitado	❌ Requer conversão
SQL Puro (`Native Query`)	❌ Não	❌ Pode ser inseguro	✅ Melhor para queries complexas	✅ Simples	✅ Alta	❌ Requer conversão
JPQL com DTO	✅ Sim	✅ Sim	⚠️ Menos eficiente em grandes volumes	❌ Requer DTO	⚠️ Moderada	✅ Facilita a estruturação JSON
SQL Puro com DTO	❌ Não	❌ Pode ser inseguro	✅ Melhor para queries complexas	❌ Requer DTO	✅ Alta	✅ Facilita a estruturação JSON

🚀 Conclusão: Qual Usar?

Usar JPQL (Object[]) → Quando precisar de uma solução rápida, simples e independente do banco.
Usar SQL Puro (Native Query) → Quando a performance for crítica ou quando a consulta exigir recursos avançados específicos do banco de dados.
Usar DTO com JPQL → Quando precisar de uma estruturação JSON melhor e uma solução mais segura e escalável.
Usar SQL Puro com DTO → Quando precisar de consultas complexas e alto desempenho, mas ainda desejar uma estrutura de dados organizada (JSON ou DTO).

Se for algo simples, JPQL com Object[] já resolve. Se for algo grande e complexo, SQL puro pode ser mais eficiente. E se precisar de estruturação melhor, DTO é o ideal! 🚀

Como injetar EntityManager com Spring: @PersistenceContext x Construtor

Uiratan Cavalcante — Wed, 05 Feb 2025 15:42:55 +0000

A diferença entre usar @PersistenceContext e injetar EntityManager via construtor depende principalmente do mecanismo de injeção de dependência do Spring e da forma como o EntityManager é gerenciado.

1️⃣ Usando `@PersistenceContext`

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.stereotype.Repository;

@Repository
public class MeuRepositorio {

    @PersistenceContext
    private EntityManager entityManager;

    public void salvar(Entidade entidade) {
        entityManager.persist(entidade);
    }
}

🔹 Como funciona?

@PersistenceContext é a anotação padrão do JPA para injeção do EntityManager.
O Spring detecta essa anotação e injeta um EntityManager gerenciado pelo contexto de persistência.
Normalmente, esse EntityManager é transacional e atrelado à transação do Spring.

✅ Vantagens

✔️ Garante que o EntityManager é gerenciado corretamente pelo Spring.

✔️ Facilita a integração com o JPA sem necessidade de configuração adicional.

✔️ Garante que a instância do EntityManager pertence ao escopo correto da transação.

❌ Desvantagens

❌ Não permite injeção via construtor (dificulta testes unitários sem Spring).

❌ Não pode ser usado em atributos final (impede imutabilidade).

2️⃣ Injetando `EntityManager` via Construtor

import javax.persistence.EntityManager;
import org.springframework.stereotype.Repository;

@Repository
public class MeuRepositorio {

    private final EntityManager entityManager;

    public MeuRepositorio(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public void salvar(Entidade entidade) {
        entityManager.persist(entidade);
    }
}

🔹 Como funciona?

O Spring injeta o EntityManager diretamente no construtor da classe.
Funciona porque o Spring Boot gerencia o EntityManagerFactory e fornece um EntityManager apropriado como dependência.

✅ Vantagens

✔️ Permite injeção via construtor, facilitando testes unitários sem Spring.

✔️ Torna os campos final, favorecendo imutabilidade e injeção de dependências explícita.

✔️ Reduz o acoplamento com a API do JPA (@PersistenceContext não é necessário).

❌ Desvantagens

❌ Depende da configuração automática do Spring para fornecer um EntityManager.

❌ Se usado fora do contexto correto, pode resultar em TransactionRequiredException.

🔥 Qual Opção Escolher?

Critério	`@PersistenceContext`	Injeção via Construtor
Gerenciamento do Spring	Sim (injeção automática)	Sim (injeção automática)
Escopo da Transação	Automático	Depende do contexto do Spring
Facilidade de Teste	Mais difícil (precisa de `@Mock` ou Spring)	Mais fácil (injeção direta)
Imutabilidade	Não suporta `final`	Suporta `final`
Padrão Recomendado	Antigo, mas ainda funcional	Recomendado para Clean Architecture

✅ Se você está seguindo boas práticas modernas (Clean Architecture, DDD, SOLID, imutabilidade), use injeção via construtor.

✅ Se você precisa de compatibilidade com um código legado ou quer um EntityManager sempre atrelado ao contexto de persistência do JPA, @PersistenceContext é uma escolha válida.

Como criar uma Annotation que realize validação personalizada para garantir valores únicos no banco de dados com Java

Uiratan Cavalcante — Tue, 04 Feb 2025 18:20:58 +0000

Se você já desenvolveu aplicações Java, provavelmente já se deparou com a necessidade de garantir que um determinado valor seja único no banco de dados. Por exemplo, ao cadastrar um usuário, você pode querer garantir que o e-mail ou nome de usuário não esteja duplicado. Neste post, vou te mostrar como criar uma validação personalizada em Java para garantir que um campo seja único no banco de dados, usando anotações e o framework de validação do Bean Validation (JSR 380).

Vamos seguir um passo a passo simples e prático para implementar essa solução.

Passo 1: Criar a Anotação Personalizada

A primeira etapa é criar uma anotação personalizada que será usada para marcar os campos que devem ser validados como únicos.

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Constraint(validatedBy = UniqueValueValidator.class) // Define a classe que implementa a validação
@Target({ ElementType.FIELD }) // A anotação pode ser usada apenas em campos
@Retention(RetentionPolicy.RUNTIME) // A anotação estará disponível em tempo de execução
public @interface UniqueValue {
    String message() default "Este valor já existe no banco de dados"; // Mensagem padrão de erro

    Class<?>[] groups() default {}; // Grupos de validação (opcional)

    Class<? extends Payload>[] payload() default {}; // Payload para metadados (opcional)

    String fieldName(); // Nome do campo que será validado

    Class<?> domainClass(); // Classe da entidade que contém o campo
}

O que essa anotação faz?

@Constraint: Define que a anotação será validada pela classe UniqueValueValidator.
@Target: Restringe o uso da anotação a campos (ElementType.FIELD).
@Retention: Garante que a anotação esteja disponível em tempo de execução.
message(): Define a mensagem de erro padrão.
fieldName() e domainClass(): Parâmetros obrigatórios que indicam o nome do campo e a classe da entidade que será validada.

Passo 2: Implementar a Lógica de Validação

Agora, vamos implementar a classe que contém a lógica de validação. Essa classe deve implementar a interface ConstraintValidator.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;

import javax.persistence.EntityManager;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.util.List;

public class UniqueValueValidator implements ConstraintValidator<UniqueValue, String> {

    private String fieldName; // Nome do campo a ser validado
    private Class<?> domainClass; // Classe da entidade

    @Autowired
    private EntityManager entityManager; // EntityManager para consultas no banco de dados

    @Override
    public void initialize(UniqueValue constraintAnnotation) {
        // Inicializa os valores do campo e da classe de domínio
        this.fieldName = constraintAnnotation.fieldName();
        this.domainClass = constraintAnnotation.domainClass();
    }

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        // Se o valor for vazio, considera válido
        if (StringUtils.isEmpty(value)) {
            return true;
        }

        // Cria a consulta SQL para verificar se o valor já existe
        String query = String.format("SELECT 1 FROM %s WHERE %s = :value", domainClass.getSimpleName(), fieldName);

        // Executa a consulta
        List<?> result = entityManager.createQuery(query)
                .setParameter("value", value)
                .getResultList();

        // Se a lista estiver vazia, o valor é único
        return result.isEmpty();
    }
}

O que essa classe faz?

initialize(): Inicializa os valores do campo e da classe de domínio a partir da anotação.
isValid(): Verifica se o valor já existe no banco de dados. Se o valor for único, retorna true; caso contrário, retorna false.
EntityManager: Usado para realizar consultas no banco de dados.

Passo 3: Usar a Anotação na Entidade

Agora que temos a anotação e o validador, podemos usá-los em uma entidade JPA. Por exemplo, para garantir que o campo email na entidade User seja único:

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @UniqueValue(fieldName = "email", domainClass = User.class, message = "Este e-mail já está em uso")
    private String email;

    // Outros campos, getters e setters
}

O que isso faz?

A anotação @UniqueValue é aplicada ao campo email.
Quando um novo usuário for cadastrado, o validador verificará se o e-mail já existe no banco de dados.
Se o e-mail já existir, a validação falhará e a mensagem "Este e-mail já está em uso" será exibida.

Passo 4: Testar a Validação

Para testar a validação, você pode criar um controlador REST que recebe um objeto User e valida os dados antes de salvar no banco de dados.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

@RestController
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @PostMapping("/users")
    public String createUser(@Valid @RequestBody User user) {
        userRepository.save(user);
        return "Usuário cadastrado com sucesso!";
    }
}

O que isso faz?

O método createUser recebe um objeto User no corpo da requisição.
A anotação @Valid ativa a validação automática do Bean Validation.
Se o e-mail já existir no banco de dados, uma exceção de validação será lançada e a mensagem de erro será retornada.

Conclusão

Criar uma validação personalizada para garantir valores únicos no banco de dados é uma tarefa comum no desenvolvimento de aplicações Java. Com a abordagem apresentada, você pode criar uma solução reutilizável e flexível, aplicando a validação de forma declarativa em suas entidades.

Essa técnica pode ser estendida para validar outros tipos de campos e regras de negócio, tornando seu código mais robusto e seguro. Experimente implementar essa solução em seus projetos e veja como ela pode simplificar a validação de dados!

Se tiver dúvidas ou sugestões, deixe um comentário abaixo. Até a próxima! 🚀

Dicas Extras:

Certifique-se de que o EntityManager esteja corretamente configurado no seu projeto Spring.
Use mensagens de erro personalizadas para melhorar a experiência do usuário.
Teste a validação em diferentes cenários para garantir que ela funcione como esperado.

Espero que este post tenha sido útil! 😊

Criando um Validador Genérico no Spring Boot

Uiratan Cavalcante — Tue, 04 Feb 2025 17:33:29 +0000

Ao trabalhar com validações em Spring Boot, muitas vezes precisamos garantir que certos campos sejam únicos no banco de dados. No entanto, criar validadores individuais para cada entidade pode resultar em código repetitivo e de difícil manutenção. Neste post, vamos explorar como criar um validador genérico reutilizável para qualquer campo que precise ser único.

O Problema

Temos duas entidades no sistema:

Categoria, onde o campo nome deve ser único.
Autor, onde o campo email deve ser único.

Ao invés de criar validadores separados para cada caso, podemos construir um validador genérico que possa ser reutilizado para qualquer entidade.

Criando o Validador Genérico

1. Implementação do Validador

Criamos a classe CampoUnicoValidator<T>, que verifica se um campo já existe no banco de dados:

public class CampoUnicoValidator<T> implements Validator {

    private final Function<T, String> campoExtractor;
    private final Function<String, Boolean> existeNoBanco;
    private final String campoNome;
    private final Class<T> targetClass;

    public CampoUnicoValidator(Function<T, String> campoExtractor,
                               Function<String, Boolean> existeNoBanco,
                               String campoNome,
                               Class<T> targetClass) {
        this.campoExtractor = campoExtractor;
        this.existeNoBanco = existeNoBanco;
        this.campoNome = campoNome;
        this.targetClass = targetClass;
    }

    @Override
    public boolean supports(Class<?> clazz) {
        return targetClass.isAssignableFrom(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        if (errors.hasErrors()) {
            return;
        }

        @SuppressWarnings("unchecked")
        T request = (T) target;
        String valor = campoExtractor.apply(request);

        if (existeNoBanco.apply(valor)) {
            errors.rejectValue(campoNome, null, "Já existe um registro com este " + campoNome + ": " + valor);
        }
    }
}

Como funciona?

campoExtractor: Função que extrai o valor do campo a ser validado.
existeNoBanco: Função que verifica no repositório se o valor já existe.
campoNome: Nome do campo para exibir mensagens de erro.
targetClass: Classe da requisição associada ao validador.

Dessa forma, podemos reusar essa lógica para qualquer entidade!

2. Criando Beans para os Validadores

Agora, criamos os beans para injetar os validadores nos controladores.

@Configuration
public class ValidadoresConfig {

    @Bean
    public CampoUnicoValidator<NovoAutorRequest> emailUnicoValidator(AutorRepository autorRepository) {
        return new CampoUnicoValidator<>(
                NovoAutorRequest::email,
                autorRepository::existsByEmail,
                "email",
                NovoAutorRequest.class
        );
    }

    @Bean
    public CampoUnicoValidator<NovaCategoriaRequest> nomeUnicoValidator(CategoriaRepository categoriaRepository) {
        return new CampoUnicoValidator<>(
                NovaCategoriaRequest::nome,
                categoriaRepository::existsByNome,
                "nome",
                NovaCategoriaRequest.class
        );
    }
}

Isso permite injetar validadores personalizados em diferentes controladores.

3. Usando o Validador no `CategoriasController`

@RestController
public class CategoriasController {

    private final EntityManager entityManager;
    private final CampoUnicoValidator<NovaCategoriaRequest> nomeUnicoCategoriaValidator;

    public CategoriasController(
            final EntityManager entityManager,
            final CampoUnicoValidator<NovaCategoriaRequest> nomeUnicoCategoriaValidator) {
        this.entityManager = entityManager;
        this.nomeUnicoCategoriaValidator = nomeUnicoCategoriaValidator;
    }

    @InitBinder
    public void init(WebDataBinder binder) {
        binder.addValidators(nomeUnicoCategoriaValidator);
    }

    @PostMapping("/categorias")
    @ResponseStatus(HttpStatus.OK)
    @Transactional
    public String criarCategoria(@RequestBody @Valid NovaCategoriaRequest novaCategoriaRequest) {
        Categoria novaCategoria = novaCategoriaRequest.toModel();
        entityManager.persist(novaCategoria);
        return novaCategoria.toString();
    }
}

O método @InitBinder registra o validador para ser executado antes da requisição ser processada.

4. Usando o Validador no `AutoresController`

@RestController
public class AutoresController {

    private final EntityManager entityManager;
    private final CampoUnicoValidator<NovoAutorRequest> emailUnicoAutorValidator;

    public AutoresController(
            final EntityManager entityManager,
            final CampoUnicoValidator<NovoAutorRequest> emailUnicoAutorValidator) {
        this.entityManager = entityManager;
        this.emailUnicoAutorValidator = emailUnicoAutorValidator;
    }

    @InitBinder
    public void init(WebDataBinder binder) {
        binder.addValidators(emailUnicoAutorValidator);
    }

    @PostMapping(value = "/autores")
    @Transactional
    @ResponseStatus(HttpStatus.OK)
    public String criaAutor(@RequestBody @Valid NovoAutorRequest novoAutorRequest) {
        Autor novoAutor = novoAutorRequest.toModel();
        entityManager.persist(novoAutor);
        return novoAutor.toString();
    }
}

Conclusão

Com essa abordagem, conseguimos:
✅ Criar um validador genérico e reutilizável.
✅ Evitar código repetitivo em controladores.
✅ Registrar os validadores automaticamente via @Bean.
✅ Validar qualquer campo único em diferentes entidades sem criar classes separadas para cada caso.

Essa é uma solução elegante e escalável para validações de unicidade no Spring Boot! 🚀

Forem: Uiratan Cavalcante

Design Orientado a Comportamento em Java: Strategy, Lambdas e Design Moderno em Java

O problema concreto

Separando estrutura de comportamento

Interface funcional e sua origem

Antes do Java 8: classes anônimas

Programação funcional: o ponto central

A chegada das lambdas

Closure: capturando o contexto

O que acontece no bytecode

Conclusão

Parte 3: Adicionando Multi-Tenancy por Coluna Discriminadora

Introdução

Configuração Inicial

pom.xml

application.yml

Resumo do Fluxo Geral

Passo a Passo

1. Manter o SecurityConfig como Está

2. Manter a Entidade User e o UserRepository

3. Atualizar o CustomOAuth2UserService para Usar TenantContext

4. Criar o TenantContext

5. Criar o TenantFilter

6. Atualizar o HomeController

7. Testar o Sistema

Detalhamento Técnico do Fluxo

Outras Formas de Fazer

DSA - Arrays/Strings - Técnica Two Pointers (Dois Ponteiros) — Guia Completo para Entrevistas Técnicas

O que é a técnica Two Pointers e sua intuição

Vantagens da técnica Two Pointers

Quando e como identificar que a técnica se aplica

Quando usar Two Pointers:

Como identificar:

Explicação visual e textual passo a passo

5 Exemplos em Java com explicações detalhadas

1. Encontrar se existe um par com soma igual a alvo (array ordenado)

2. Remover duplicatas de um array ordenado in-place

3. Verificar se duas strings são anagramas usando Two Pointers (após ordenar)

4. Encontrar o maior subarray com soma <= k (janela deslizante)

5. Intercalar dois arrays ordenados in-place (suposição: espaço extra disponível no final do primeiro array)

Comparações com outras abordagens

Dicas específicas para entrevistas técnicas

Exercícios recomendados do LeetCode (com links e dificuldade)

Checklist para uso da técnica Two Pointers

📢 Implementando Eventos com Spring: Um Exemplo Prático 🚀

Introdução

🎯 O Problema de Negócio

🛠️ Implementação com Eventos

1️⃣ Definição da Classe Assinatura

2️⃣ Definição da Interface do Evento

3️⃣ Implementação dos Eventos

📩 Enviar e-mail de boas-vindas

🎁 Conceder teste gratuito

✅ Atualizar status da assinatura

4️⃣ Classe que Orquestra os Eventos

🎯 Como o Spring Injeta Automaticamente os Eventos?

Opções de Expansão com Eventos

🛠 Padrões e Princípios

🔄 Padrão Observer

🔌 Inversão de Controle e Injeção de Dependências

🏗 Princípio da Responsabilidade Única (SRP - Single Responsibility Principle)

📚 Conclusão

Parte 2: Adicionando Usuários ao Sistema de Login com Google

Introdução

Configuração Inicial

pom.xml

application.yml

Resumo do Fluxo Geral

Passo a Passo

1. Criar a Entidade User

2. Criar o Repositório (UserRepository)

3. Criar o CustomOAuth2UserService

4. Atualizar o SecurityConfig

5. Sem alterações em HomeController

6. Testar o Sistema

7. Sem alterações em HomeController

Dica Bônus

application.yml

Outras Abordagens Ao H2

Parte 1: Criando um Sistema de Login com Google e JWT no Spring Boot

`pom.xml`

`application.yml`

1. Manter o `SecurityConfig` como Está

2. Manter a Entidade `User` e o `UserRepository`

3. Atualizar o `CustomOAuth2UserService` para Usar `TenantContext`

4. Criar o `TenantContext`

5. Criar o `TenantFilter`

6. Atualizar o `HomeController`

`pom.xml`

`application.yml`

1. Criar a Entidade `User`

2. Criar o Repositório (`UserRepository`)

3. Criar o `CustomOAuth2UserService`

4. Atualizar o `SecurityConfig`

5. Sem alterações em `HomeController`

7. Sem alterações em `HomeController`

`application.yml`

`pom.xml`

`application.yml`

1. Configurar o Spring Security (`SecurityConfig`)

2. Criar o Controlador (`HomeController`)

Passo 1: Criando a Annotation `@CPFCNPJ`

Passo 2: Criando o Validador `DocumentoValidator`

🔹 1. Usando JPQL no `EntityManager`

🔹 2. Usando SQL Puro no `EntityManager`

1️⃣ Usando `@PersistenceContext`

2️⃣ Injetando `EntityManager` via Construtor