50 Perguntas Essenciais sobre Spring Framework para Desenvolvedores Java Sênior: Uma Jornada de Entrevista Técnica

🎭 Os Personagens da Nossa História

Marina Santos – Candidata a Desenvolvedora Java Sênior, 8 anos de experiência, especialista em Spring Framework, nervosa mas confiante em seu conhecimento técnico.

Carlos Mendoza – Arquiteto de Software, 12 anos de experiência, conhecido por fazer perguntas desafiadoras que testam não apenas conhecimento teórico, mas também experiência prática.

Ana Ribeiro – Tech Lead, 10 anos de experiência, focada em avaliar habilidades de design de sistemas e boas práticas de desenvolvimento.

Roberto Silva – Gerente de Engenharia, 15 anos de experiência, interessado em como o candidato se adapta a diferentes cenários e resolve problemas complexos.

🏢 O Cenário

Marina chegou à TechCorp Solutions, uma empresa de grande porte que desenvolve sistemas financeiros para bancos internacionais. A empresa migrou recentemente toda sua stack para Spring Boot 3.x e Spring Framework 6.x, implementando arquiteturas baseadas em microservices. A entrevista acontece em uma sala de conferências moderna, com Marina sentada diante de um painel de três especialistas técnicos.

🎯 A Entrevista Técnica: 50 Perguntas Fundamentais

Categoria 1: Spring Core e Fundamentos

Pergunta 1: O que é Inversão de Controle (IoC) e como o Spring implementa esse conceito?

Carlos: “Marina, vamos começar com os fundamentos. Explique-me o conceito de IoC e como o Spring o implementa.”

Resposta: A Inversão de Controle é um princípio de design onde o controle da criação e gerenciamento de objetos é transferido do código da aplicação para um framework externo. No Spring, isso é implementado através do IoC Container, que gerencia o ciclo de vida dos beans.

💡 Dica Técnica: O IoC Container do Spring é como um “gerente de recursos humanos” de uma empresa – ele sabe quem precisa de quem, quando contratar, quando demitir, e como conectar as pessoas certas para trabalhar juntas.

O Spring oferece duas implementações principais: BeanFactory (interface básica) e ApplicationContext (mais completa, com recursos como internacionalização e publicação de eventos). O container lê as configurações (via XML, anotações ou Java Config) e cria os beans conforme necessário.

Pergunta 2: Explique a diferença entre @Component, @Service, @Repository e @Controller.

Ana: “Excelente! Agora me fale sobre as anotações estereotipadas do Spring.”

Resposta: Todas essas anotações são especializações de @Component, mas cada uma tem um propósito semântico específico:

• @Component: Anotação genérica para qualquer bean gerenciado pelo Spring
• @Service: Indica que a classe contém lógica de negócio
• @Repository: Marca classes que acessam dados, oferecendo tradução automática de exceções
• @Controller: Identifica classes que lidam com requisições HTTP no padrão MVC

⚠️ Importante: Embora funcionalmente sejam equivalentes, usar a anotação correta melhora a legibilidade e permite que ferramentas de análise de código entendam melhor a arquitetura.

Pergunta 3: Como funciona a injeção de dependência no Spring 6.x?

Roberto: “E sobre DI? Quais são os mecanismos disponíveis?”

Resposta: O Spring 6.x oferece três tipos principais de injeção:

• Constructor Injection (recomendada): Injeta dependências através do construtor
• Setter Injection: Injeta através de métodos setter
• Field Injection: Injeta diretamente nos campos (desencorajada)

A Constructor Injection é preferida porque garante que o objeto seja criado em estado válido, facilita testes unitários e torna as dependências explícitas. No Spring 6.x, se uma classe tem apenas um construtor, a anotação @Autowired é opcional.

Pergunta 4: O que são Bean Scopes e quais estão disponíveis no Spring?

Carlos: “Falando em beans, quais são os escopos disponíveis?”

Resposta: Bean Scopes definem o ciclo de vida e a visibilidade dos beans. O Spring oferece:

• singleton (padrão): Uma única instância por container
• prototype: Nova instância a cada solicitação
• request: Uma instância por requisição HTTP (Web)
• session: Uma instância por sessão HTTP (Web)
• application: Uma instância por ServletContext (Web)
• websocket: Uma instância por sessão WebSocket

🔍 Analogia: Pense nos scopes como diferentes tipos de relacionamento: singleton é como ser casado (uma única instância), prototype é como ser solteiro (nova instância sempre), request é como um encontro (dura só uma requisição).

Pergunta 5: Explique o conceito de Profiles no Spring.

Ana: “Como você lida com diferentes ambientes de desenvolvimento?”

Resposta: Spring Profiles permite ativar diferentes configurações baseadas no ambiente. Você pode definir beans específicos para cada profile usando @Profile.

Os profiles são úteis para:

• Configurações de banco de dados (dev/test/prod)
• Níveis de log diferentes
• Integrações específicas por ambiente
• Configurações de segurança

Podem ser ativados via propriedades do sistema, variáveis de ambiente, ou programaticamente através de:

@Profile("development")
@Configuration
public class DevConfig {
    // Configurações específicas para desenvolvimento
}

Categoria 2: Spring Boot

Pergunta 6: Quais são as principais características do Spring Boot 3.x?

Roberto: “Vamos falar sobre Spring Boot. Quais são as novidades da versão 3.x?”

Resposta: O Spring Boot 3.x trouxe mudanças significativas:

• Java 17 como baseline: Aproveitando recursos como Records, Pattern Matching
• Jakarta EE: Migração de javax.* para jakarta.*
• Spring Native: Suporte nativo para GraalVM
• Observability: Melhor integração com Micrometer e rastreamento
• HTTP/2: Suporte aprimorado por padrão
• Configuração mais flexível: Novos recursos de binding de propriedades

⚡ Performance: O Spring Boot 3.x com GraalVM Native pode reduzir o tempo de inicialização em até 90% e o uso de memória em até 80%.

Pergunta 7: Como funciona o Auto-Configuration no Spring Boot?

Carlos: “Explique como o Spring Boot ‘magicamente’ configura tudo.”

Resposta: O Auto-Configuration usa uma combinação de:

• @EnableAutoConfiguration: Habilita a configuração automática
• Conditional Annotations: Como @ConditionalOnClass, @ConditionalOnMissingBean
• spring.factories: Arquivo que lista classes de configuração
• Starter Dependencies: Trazem dependências e configurações relacionadas

O processo analisa o classpath, verifica configurações existentes, e aplica configurações padrão onde apropriado. É como ter um assistente que prepara tudo baseado no que você tem disponível.

Pergunta 8: O que são Spring Boot Starters e como funcionam?

Ana: “Fale sobre os Starters do Spring Boot.”

Resposta: Starters são dependências “opinionated” que agregam bibliotecas relacionadas e configurações automáticas. Exemplos:

• spring-boot-starter-web: Inclui Spring MVC, Tomcat, Jackson
• spring-boot-starter-data-jpa: Inclui Hibernate, Spring Data JPA
• spring-boot-starter-security: Inclui Spring Security
• spring-boot-starter-test: Inclui JUnit, Mockito, Spring Test

🎯 Benefício: Reduzem significativamente o tempo de configuração inicial e garantem compatibilidade entre versões.

Pergunta 9: Como personalizar o comportamento do Spring Boot?

Roberto: “E quando você precisa customizar comportamentos padrão?”

Resposta: O Spring Boot oferece várias opções de customização:

• Properties/YAML: Configurações em application.properties ou application.yml
• @ConfigurationProperties: Binding type-safe de propriedades
• @Bean: Sobrescrever beans auto-configurados
• Conditional Beans: Usar condições para customizar comportamento
• Profiles: Diferentes configurações por ambiente
• Custom Auto-Configuration: Criar suas próprias configurações automáticas

A prioridade de configuração segue uma ordem específica, permitindo sobrescrever configurações conforme necessário.

Pergunta 10: Explique o conceito de Actuator e suas funcionalidades.

Carlos: “Como você monitora uma aplicação Spring Boot em produção?”

Resposta: O Spring Boot Actuator fornece endpoints para monitoramento e gerenciamento:

Endpoints principais:

• /health: Status da aplicação
• /metrics: Métricas de performance
• /info: Informações da aplicação
• /env: Variáveis de ambiente
• /loggers: Configuração de logs
• /httptrace: Rastreamento de requisições HTTP

🔒 Segurança: Em produção, sempre configure adequadamente a segurança dos endpoints do Actuator, expondo apenas o necessário e protegendo informações sensíveis.

Categoria 3: Spring Data

Pergunta 11: Como funciona o Spring Data JPA?

Ana: “Vamos falar sobre persistência. Explique o Spring Data JPA.”

Resposta: O Spring Data JPA simplifica a implementação de repositórios baseados em JPA. Principais características:

• Repository Interfaces: Apenas declare a interface, implementação é gerada automaticamente
• Query Methods: Métodos baseados em nomes (findByNomeAndIdade)
• Custom Queries: @Query para consultas específicas
• Specifications: Critérios dinâmicos para consultas complexas
• Auditing: Rastreamento automático de criação/modificação

🚀 Produtividade: Reduz código boilerplate em até 80% comparado ao JPA tradicional.

Pergunta 12: Qual a diferença entre @Transactional declarativa e programática?

Roberto: “Como você gerencia transações no Spring?”

Resposta: O Spring oferece dois tipos de gerenciamento transacional:

Declarativa (@Transactional):

• Mais limpa e legível
• Configuração via anotações
• Menos controle granular
• Recomendada para casos comuns

Programática (TransactionTemplate):

• Controle total sobre transações
• Mais verbosa
• Necessária para lógica transacional complexa
• Tratamento de erros mais específico

💡 Dica: Use declarativa como padrão e programática apenas quando precisar de controle específico sobre o comportamento transacional.

Pergunta 13: Explique os diferentes tipos de propagação transacional.

Carlos: “Quais são os tipos de propagação disponíveis?”

Resposta: O Spring oferece sete tipos de propagação:

• REQUIRED (padrão): Usa transação existente ou cria nova
• SUPPORTS: Usa transação existente, mas não cria nova
• MANDATORY: Exige transação existente, falha se não houver
• REQUIRES_NEW: Sempre cria nova transação
• NOT_SUPPORTED: Executa fora de transação
• NEVER: Falha se houver transação ativa
• NESTED: Cria transação aninhada

⚠️ Cuidado: REQUIRES_NEW pode causar deadlocks se não usado adequadamente, especialmente em cenários de alta concorrência.

Pergunta 14: Como implementar paginação e ordenação no Spring Data?

Ana: “Como você lida com grandes volumes de dados?”

Resposta: O Spring Data oferece suporte nativo através de:

• Pageable: Interface para paginação e ordenação
• Page: Resultado paginado com metadados
• Sort: Especificação de ordenação

Os repository methods podem receber Pageable como parâmetro e retornar Page. Isso é automaticamente traduzido para SQL com LIMIT/OFFSET apropriados.

public interface UserRepository extends JpaRepository<User, Long> {
    Page<User> findByStatus(String status, Pageable pageable);
}

🎯 Performance: Sempre use paginação em consultas que podem retornar muitos resultados para evitar OutOfMemoryError.

Pergunta 15: O que são Specifications e quando usá-las?

Roberto: “Como você constrói consultas dinâmicas?”

Resposta: Specifications implementam o padrão Specification para construir consultas JPA dinamicamente usando Criteria API. Benefícios:

• Type-safe: Verificação em tempo de compilação
• Reutilizáveis: Podem ser combinadas com AND/OR
• Flexíveis: Constroem consultas baseadas em condições
• Testáveis: Fácil de testar isoladamente

Ideais para cenários como filtros de pesquisa avançada, where clauses dinâmicas, e consultas condicionais complexas.

Categoria 4: Spring Security

Pergunta 16: Como funciona a arquitetura do Spring Security?

Carlos: “Vamos falar sobre segurança. Explique a arquitetura do Spring Security.”

Resposta: O Spring Security é baseado em uma cadeia de filtros (Filter Chain):

Componentes principais:

• SecurityFilterChain: Cadeia de filtros de segurança
• AuthenticationManager: Gerencia autenticação
• AuthenticationProvider: Implementa lógica de autenticação
• UserDetailsService: Carrega dados do usuário
• PasswordEncoder: Codifica/valida senhas
• SecurityContext: Armazena informações de segurança

🛡️ Segurança: Cada requisição passa por filtros que verificam autenticação, autorização, CSRF, etc.

Pergunta 17: Qual a diferença entre autenticação e autorização?

Ana: “Explique esses dois conceitos fundamentais.”

Resposta: São conceitos distintos mas relacionados:

Autenticação: “Quem você é?”

• Verifica identidade do usuário
• Login/senha, certificados, tokens
• Resultado: usuário autenticado ou não

Autorização: “O que você pode fazer?”

• Verifica permissões do usuário autenticado
• Roles, authorities, ACLs
• Resultado: acesso permitido ou negado

🔐 Analogia: Autenticação é como mostrar sua identidade na entrada de um prédio, autorização é ter o cartão correto para acessar andares específicos.

Pergunta 18: Como implementar JWT no Spring Security?

Roberto: “Como você trabalharia com tokens JWT?”

Resposta: JWT (JSON Web Token) no Spring Security requer:

Componentes necessários:

• JwtAuthenticationFilter: Intercepta requisições e valida tokens
• JwtTokenProvider: Gera e valida tokens JWT
• AuthenticationEntryPoint: Lida com erros de autenticação
• Configuração de Security: Define endpoints públicos/privados

Fluxo típico:

1. Login → Gera JWT
2. Cliente armazena token
3. Requisições incluem token no header
4. Filter valida token
5. Acesso permitido/negado

⚡ Vantagem: Stateless, escalável, não requer sessão no servidor.

Pergunta 19: O que é CORS e como configurá-lo no Spring?

Carlos: “Como você lida com requisições cross-origin?”

Resposta: CORS (Cross-Origin Resource Sharing) permite que aplicações web façam requisições para domínios diferentes. Configuração no Spring:

Opções de configuração:

• @CrossOrigin: Nível de controller/método
• WebMvcConfigurer: Configuração global
• CorsConfigurationSource: Configuração programática
• Spring Security: Integração com security chain

🌐 Uso comum: SPAs (React, Angular, Vue) fazendo requisições para APIs REST em domínios diferentes.

Pergunta 20: Explique o conceito de Method Security.

Ana: “Como você protege métodos específicos?”

Resposta: Method Security permite proteger métodos individuais usando anotações:

Anotações principais:

• @PreAuthorize: Avalia antes da execução
• @PostAuthorize: Avalia depois da execução
• @Secured: Verifica roles específicas
• @RolesAllowed: Padrão JSR-250

Suporta SpEL (Spring Expression Language) para expressões complexas e pode acessar parâmetros do método e contexto de segurança.

Categoria 5: Spring MVC

Pergunta 21: Como funciona o padrão MVC no Spring?

Roberto: “Explique a arquitetura MVC do Spring.”

Resposta: O Spring MVC implementa o padrão Model-View-Controller:

Componentes principais:

• DispatcherServlet: Front Controller que roteia requisições
• HandlerMapping: Mapeia URLs para controllers
• Controller: Processa requisições e retorna ModelAndView
• ViewResolver: Resolve views lógicas para implementações
• View: Renderiza resposta final

Fluxo de requisição:

1. DispatcherServlet recebe requisição
2. HandlerMapping encontra controller
3. Controller processa e retorna ModelAndView
4. ViewResolver resolve view
5. View renderiza resposta

🎯 Flexibilidade: Permite múltiplas estratégias de mapeamento, resolução de views e renderização.

Pergunta 22: Qual a diferença entre @Controller e @RestController?

Carlos: “Quando usar cada uma dessas anotações?”

Resposta: Ambas servem para criar endpoints, mas com comportamentos diferentes:

@Controller:

• Retorna views (JSP, Thymeleaf)
• Requer @ResponseBody para retornar dados
• Usado em aplicações web tradicionais

@RestController:

• Combinação de @Controller + @ResponseBody
• Retorna dados diretamente (JSON, XML)
• Usado em APIs REST
• Serialização automática de objetos

💡 Dica: Use @RestController para APIs e @Controller para aplicações web com renderização server-side.

Pergunta 23: Como funciona a validação no Spring MVC?

Ana: “Como você valida dados de entrada?”

Resposta: O Spring MVC integra-se com Bean Validation (JSR-303/JSR-380):

Anotações comuns:

• @NotNull, @NotEmpty, @NotBlank: Validações de nulidade
• @Size, @Min, @Max: Validações de tamanho
• @Email, @Pattern: Validações de formato
• @Valid: Ativa validação em cascata

Processo:

1. Anotações no model/DTO
2. @Valid no parâmetro do controller
3. BindingResult captura erros
4. Tratamento customizado de erros

🔍 Validação: Sempre valide dados no servidor, independente da validação client-side.

Pergunta 24: Explique o conceito de Content Negotiation.

Roberto: “Como uma API pode retornar diferentes formatos?”

Resposta: Content Negotiation permite que a mesma API retorne diferentes formatos baseado na requisição:

Estratégias:

• Accept Header: Cliente especifica formato preferido
• URL Extension: .json, .xml no final da URL
• Request Parameter: ?format=json
• Path Variable: /api/users/{id}.json

O Spring usa HttpMessageConverter para serializar/deserializar automaticamente entre formatos (JSON, XML, etc.).

🌍 Flexibilidade: Permite suportar múltiplos clientes com diferentes necessidades de formato.

Pergunta 25: Como implementar upload de arquivos no Spring MVC?

Carlos: “Como você lida com upload de arquivos?”

Resposta: O Spring MVC oferece suporte nativo através de MultipartFile:

Configuração necessária:

• MultipartResolver: Configura processamento de multipart
• @RequestParam MultipartFile: Recebe arquivo no controller
• Configurações de tamanho: Limites de arquivo e requisição

Considerações importantes:

• Validação de tipo de arquivo
• Controle de tamanho
• Armazenamento seguro
• Tratamento de erros

⚠️ Segurança: Sempre valide tipo, tamanho e conteúdo dos arquivos enviados.

Categoria 6: Spring AOP

Pergunta 26: O que é Programação Orientada a Aspectos e como o Spring implementa?

Ana: “Explique AOP e sua implementação no Spring.”

Resposta: AOP (Aspect-Oriented Programming) permite separar concerns transversais do código de negócio:

Conceitos fundamentais:

• Aspect: Modulariza concerns transversais
• Join Point: Pontos de execução do programa
• Pointcut: Seleciona join points específicos
• Advice: Código executado em join points
• Weaving: Processo de aplicar aspects

Implementação no Spring:

• Proxy-based: Usa proxies dinâmicos (JDK ou CGLIB)
• @Aspect: Define aspects
• @Around, @Before, @After: Tipos de advice

🎯 Uso comum: Logging, segurança, transações, caching, monitoramento.

Pergunta 27: Quais são os tipos de Advice disponíveis?

Roberto: “Explique os diferentes tipos de advice.”

Resposta: O Spring AOP oferece cinco tipos de advice:

• @Before: Executa antes do método
• @AfterReturning: Executa após retorno bem-sucedido
• @AfterThrowing: Executa quando exceção é lançada
• @After: Executa sempre após o método (finally)
• @Around: Controle total sobre execução

💡 Poder: @Around é o mais poderoso, permitindo executar código antes e depois, modificar parâmetros e controlar se o método será executado.

Pergunta 28: Como escrever expressões Pointcut eficientes?

Carlos: “Como você define onde os aspects devem ser aplicados?”

Resposta: Pointcuts usam expressões para selecionar join points:

Designadores principais:

• execution(): Métodos específicos
• within(): Tipos específicos
• @annotation(): Métodos com anotações
• args(): Métodos com parâmetros específicos
• bean(): Beans específicos

Exemplo de expressão:

@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceLayer() {}

⚡ Performance: Pointcuts eficientes reduzem overhead, especialmente em aplicações com muitos join points.

Pergunta 29: Quando usar AOP vs Interceptors vs Filters?

Ana: “Qual a diferença entre essas abordagens?”

Resposta: Cada abordagem tem seu escopo específico:

AOP:

• Qualquer bean do Spring
• Concerns transversais
• Baseado em proxies

Interceptors:

• Requisições HTTP específicas
• Pré/pós-processamento de controllers
• Parte do Spring MVC

Filters:

• Todas as requisições HTTP
• Nível de servlet
• Executa antes do Spring MVC

🎯 Escolha: Use Filter para processamento geral HTTP, Interceptor para lógica MVC, e AOP para concerns de negócio.

Pergunta 30: Explique as limitações do AOP no Spring.

Roberto: “Quais são as limitações que devemos conhecer?”

Resposta: O Spring AOP tem limitações importantes:

Limitações técnicas:

• Self-invocation: Chamadas internas não são interceptadas
• Proxy-based: Apenas métodos públicos são interceptados
• Performance: Overhead de proxy em cada chamada
• Final classes: Não podem ser “proxied” pelo CGLIB

Soluções alternativas:

• AspectJ: Weaving em tempo de compilação
• Refactoring: Extrair lógica para beans separados
• @Configurable: Para objetos criados com new

Categoria 7: Spring Cloud e Microservices

Pergunta 31: Como o Spring Cloud facilita o desenvolvimento de microservices?

Carlos: “Vamos falar sobre microservices. Como o Spring Cloud ajuda?”

Resposta: O Spring Cloud oferece ferramentas para desafios comuns em microservices:

Componentes principais:

• Service Discovery: Eureka, Consul
• Load Balancing: Ribbon, Spring Cloud LoadBalancer
• Circuit Breaker: Hystrix, Resilience4j
• API Gateway: Spring Cloud Gateway
• Configuration: Spring Cloud Config
• Tracing: Sleuth, Zipkin

🏗️ Infraestrutura: Abstrai complexidades de infraestrutura distribuída, permitindo foco na lógica de negócio.

Pergunta 32: Explique o padrão Circuit Breaker.

Ana: “Como você lida com falhas em chamadas externas?”

Resposta: O Circuit Breaker protege contra falhas em cascata:

Estados do circuit breaker:

• Closed: Funcionamento normal
• Open: Falhas frequentes, rejeita chamadas
• Half-Open: Testa se serviço se recuperou

Benefícios:

• Prevenção de falhas em cascata
• Tempo de resposta previsível
• Degradação graceful
• Recuperação automática

🔄 Analogia: Como um disjuntor elétrico que “desarma” quando há sobrecarga, protegendo o sistema.

Pergunta 33: Como funciona o Spring Cloud Gateway?

Roberto: “Explique o papel de um API Gateway.”

Resposta: O Spring Cloud Gateway atua como ponto de entrada único:

Funcionalidades:

• Roteamento: Direciona requisições para serviços
• Filtros: Transformações de request/response
• Autenticação: Centralizada para todos os serviços
• Rate Limiting: Controle de taxa de requisições
• Monitoramento: Métricas centralizadas

Vantagens:

• Simplifica cliente (um único endpoint)
• Centraliza concerns transversais
• Facilita versionamento de APIs
• Permite evolução independente dos serviços

Pergunta 34: O que é Service Discovery e por que é importante?

Carlos: “Como os microservices se encontram?”

Resposta: Service Discovery permite que serviços se localizem dinamicamente:

Tipos:

• Client-side: Cliente consulta registro de serviços
• Server-side: Load balancer consulta registro
• Service mesh: Infraestrutura gerencia descoberta

Benefícios:

• Escalabilidade dinâmica
• Failover automático
• Configuração simplificada
• Deployment independente

🗺️ Analogia: Como um GPS que sempre sabe onde estão os serviços disponíveis e qual o melhor caminho.

Pergunta 35: Explique o conceito de Distributed Tracing.

Ana: “Como você debugga problemas em sistemas distribuídos?”

Resposta: Distributed Tracing rastreia requisições através de múltiplos serviços:

Conceitos:

• Trace: Jornada completa de uma requisição
• Span: Unidade de trabalho individual
• Trace ID: Identificador único da requisição
• Span ID: Identificador único da operação

Ferramentas:

• Sleuth: Instrumentação automática
• Zipkin: Visualização de traces
• Jaeger: Plataforma de tracing
• OpenTracing: Padrão de APIs

🔍 Debug: Essencial para identificar gargalos e problemas em arquiteturas complexas.

Categoria 8: Testes com Spring

Pergunta 36: Como estruturar testes em aplicações Spring?

Roberto: “Fale sobre estratégias de teste no Spring.”

Resposta: O Spring oferece suporte abrangente para testes:

Tipos de teste:

• Unit Tests: Testes isolados de componentes
• Integration Tests: Testes com contexto Spring
• Web Tests: Testes de controllers
• Data Tests: Testes de repositórios

Anotações principais:

• @SpringBootTest: Testes de integração completos
• @WebMvcTest: Testes de web layer
• @DataJpaTest: Testes de repositories
• @MockBean: Mocks gerenciados pelo Spring

🎯 Pirâmide: Muitos testes unitários, alguns de integração, poucos end-to-end.

Pergunta 37: Qual a diferença entre @Mock e @MockBean?

Carlos: “Explique essas duas anotações para mocking.”

Resposta: Ambas criam mocks, mas em contextos diferentes:

@Mock (Mockito):

• Cria mock simples do Mockito
• Usado em testes unitários
• Não integra com contexto Spring
• Mais rápido e leve

@MockBean (Spring Boot):

• Cria mock e adiciona ao contexto Spring
• Substitui bean existente no contexto
• Usado em testes de integração
• Integração completa com Spring

💡 Escolha: Use @Mock para testes unitários puros e @MockBean quando precisar integrar com o contexto Spring.

Pergunta 38: Como testar componentes que usam @Transactional?

Ana: “Como você testa métodos transacionais?”

Resposta: Testes transacionais têm comportamento especial:

Comportamento padrão:

• @Transactional em testes faz rollback automático
• Isolamento entre testes
• Dados não persistem após teste

Controle de transações:

• @Rollback(false): Persiste dados
• @Commit: Força commit
• @Sql: Executa scripts SQL
• TestTransaction: Controle programático

🔄 Isolamento: Rollback automático garante que testes não interferem uns nos outros.

Pergunta 39: Explique o conceito de Test Slices.

Roberto: “O que são Test Slices e quando usá-los?”

Resposta: Test Slices carregam apenas partes específicas do contexto Spring:

Tipos principais:

• @WebMvcTest: Apenas web layer
• @DataJpaTest: Apenas repositories e JPA
• @JsonTest: Apenas serialização JSON
• @RestClientTest: Apenas REST clients

Benefícios:

• Testes mais rápidos
• Isolamento de responsabilidades
• Foco em camadas específicas
• Menos configuração necessária

⚡ Performance: Test slices inicializam muito mais rápido que @SpringBootTest completo.

Pergunta 40: Como implementar testes de integração eficientes?

Carlos: “Quais as melhores práticas para testes de integração?”

Resposta: Testes de integração eficientes seguem práticas específicas:

Estratégias:

• @DirtiesContext: Controla reutilização de contexto
• @TestConfiguration: Configurações específicas para testes
• TestContainers: Bancos de dados reais em containers
• @ActiveProfiles: Perfis específicos para testes

Otimizações:

• Reutilizar contexto Spring quando possível
• Usar banco em memória para testes rápidos
• Agrupar testes por contexto similar
• Paralelizar execução quando apropriado

Categoria 9: Performance e Monitoramento

Pergunta 41: Como monitorar performance de aplicações Spring?

Ana: “Quais ferramentas você usa para monitoramento?”

Resposta: O Spring oferece várias opções para monitoramento:

Ferramentas nativas:

• Micrometer: Métricas de aplicação
• Actuator: Endpoints de monitoramento
• Spring Boot Admin: Interface web para monitoramento
• JMX: Java Management Extensions

Métricas importantes:

• Throughput: Requisições por segundo
• Latency: Tempo de resposta
• Error Rate: Taxa de erros
• Resource Usage: CPU, memória, conexões

📊 Observabilidade: Combine métricas, logs e tracing para visibilidade completa.

Pergunta 42: Como otimizar o startup time de aplicações Spring Boot?

Roberto: “Como reduzir o tempo de inicialização?”

Resposta: Várias estratégias podem acelerar o startup:

Otimizações:

• Lazy Initialization: @Lazy para beans não essenciais
• Exclude Auto-configurations: Remover configurações desnecessárias
• Profile-specific beans: Carregar apenas beans necessários
• GraalVM Native: Compilação nativa

Configurações:

• spring.jpa.defer-datasource-initialization: Adiar inicialização JPA
• spring.jpa.hibernate.ddl-auto: Otimizar criação de schema
• logging.level.root: Reduzir logs desnecessários

⚡ Performance: GraalVM Native pode reduzir startup time de segundos para milissegundos.

Pergunta 43: Explique estratégias de caching no Spring.

Carlos: “Como você implementa cache em aplicações Spring?”

Resposta: O Spring oferece abstração poderosa para caching:

Anotações principais:

• @Cacheable: Armazena resultado no cache
• @CacheEvict: Remove entrada do cache
• @CachePut: Atualiza cache incondicionalmente
• @Caching: Combina múltiplas operações

Providers suportados:

• ConcurrentHashMap: Simples, in-memory
• EhCache: Avançado, configurável
• Redis: Distribuído, persistente
• Hazelcast: Distribuído, in-memory

💾 Estratégia: Escolha provider baseado em requisitos de distribuição e persistência.

Pergunta 44: Como configurar connection pooling eficiente?

Ana: “Quais são as melhores práticas para pools de conexão?”

Resposta: Connection pooling é crucial para performance:

Configurações importantes:

• maximum-pool-size: Máximo de conexões
• minimum-idle: Mínimo de conexões idle
• connection-timeout: Timeout para obter conexão
• idle-timeout: Timeout para conexões idle
• max-lifetime: Tempo máximo de vida da conexão

Pools recomendados:

• HikariCP: Padrão no Spring Boot, alta performance
• Tomcat JDBC: Alternativa robusta
• DBCP2: Apache Commons pool

🔧 Tuning: Monitore métricas do pool e ajuste baseado na carga real.

Pergunta 45: Explique o conceito de Reactive Programming no Spring.

Roberto: “Como funciona o Spring WebFlux?”

Resposta: Spring WebFlux oferece programação reativa:

Conceitos fundamentais:

• Non-blocking: Não bloqueia threads
• Event-driven: Baseado em eventos
• Backpressure: Controle de fluxo
• Reactive Streams: Padrão para processamento assíncrono

Componentes principais:

• Mono: Stream de 0 ou 1 elemento
• Flux: Stream de 0 a N elementos
• RouterFunction: Roteamento funcional
• WebClient: Cliente HTTP reativo

🚀 Escalabilidade: Suporta milhares de conexões concorrentes com poucos threads.

Categoria 10: Configuração e Deployment

Pergunta 46: Como gerenciar configurações em diferentes ambientes?

Carlos: “Qual sua estratégia para configuração multi-ambiente?”

Resposta: O Spring oferece várias estratégias para configuração:

Hierarquia de propriedades:

• application.properties: Configurações base
• application-{profile}.properties: Específicas do perfil
• Variáveis de ambiente: Override dinâmico
• Command line args: Precedência máxima

Estratégias avançadas:

• Spring Cloud Config: Configuração centralizada
• Vault: Gerenciamento de secrets
• Kubernetes ConfigMaps: Configuração em containers
• @ConfigurationProperties: Binding type-safe

🔐 Segurança: Nunca coloque senhas em código ou arquivos versionados.

Pergunta 47: Explique o conceito de Externalized Configuration.

Ana: “Como você externaliza configurações?”

Resposta: Externalized Configuration permite modificar comportamento sem recompilar:

Benefícios:

• Flexibilidade: Mudanças sem redeploy
• Segurança: Secrets fora do código
• Ambientes: Configuração específica por ambiente
• Manutenção: Configuração centralizada

Fontes de configuração:

• Properties files: Arquivos de propriedades
• Environment variables: Variáveis de sistema
• Command line: Argumentos da linha de comando
• Remote config: Configuração remota

📋 Precedência: Command line > Environment > Properties files > Defaults.

Pergunta 48: Como implementar health checks eficientes?

Roberto: “Como você monitora a saúde da aplicação?”

Resposta: Health checks são essenciais para monitoramento:

Tipos de health checks:

• Liveness: Aplicação está executando
• Readiness: Aplicação está pronta para tráfego
• Custom: Verificações específicas do negócio

Implementação:

• HealthIndicator: Interface para checks customizados
• ReactiveHealthIndicator: Versão reativa
• HealthContributor: Agrupamento de indicadores
• CompositeHealthContributor: Múltiplos indicadores

🏥 Monitoramento: Health checks permitem que orquestradores (K8s, Docker) tomem decisões automáticas.

Pergunta 49: Explique estratégias de deployment para aplicações Spring Boot.

Carlos: “Quais são as opções de deployment?”

Resposta: O Spring Boot oferece múltiplas opções de deployment:

Formatos de deployment:

• Fat JAR: Arquivo executável independente
• WAR: Deploy em application servers
• Docker: Containerização
• Native: Compilação nativa com GraalVM

Estratégias:

• Blue-Green: Ambientes paralelos
• Canary: Rollout gradual
• Rolling: Atualização incremental
• A/B Testing: Testes com usuários reais

🚀 Cloud Native: Containers e orchestração são o futuro do deployment.

Pergunta 50: Como implementar logging estruturado e observabilidade?

Ana: “Qual sua abordagem para logging e observabilidade?”

Resposta: Logging estruturado e observabilidade são fundamentais:

Logging estruturado:

• JSON format: Logs estruturados
• Correlation IDs: Rastreamento de requisições
• Log levels: Apropriados por ambiente
• Centralized logging: ELK Stack, Splunk

Observabilidade (3 pilares):

• Metrics: Micrometer, Prometheus
• Logs: Logback, JSON format
• Tracing: Sleuth, Zipkin, Jaeger

Configuração:

logging:
  level:
    com.example: DEBUG
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
management:
  metrics:
    export:
      prometheus:
        enabled: true

📊 Insights: Observabilidade permite identificar problemas antes que afetem usuários.

🎯 Conclusão da Entrevista

Roberto: “Marina, parabéns! Você demonstrou conhecimento profundo do Spring Framework. Suas respostas foram técnicas, mas também mostraram experiência prática. Estamos impressionados com sua compreensão tanto dos fundamentos quanto das tecnologias mais avançadas.”

Ana: “Especialmente gostei de como você relacionou os conceitos teóricos com cenários reais. Isso mostra maturidade técnica e experiência em projetos complexos.”

Carlos: “As analogias que você usou demonstram não só conhecimento técnico, mas também capacidade de comunicação – essencial para um desenvolvedor sênior.”

Marina sorri, aliviada e confiante. A preparação intensa valeu a pena, e ela sabe que está pronta para os desafios que a esperam na TechCorp Solutions.

📚 Glossário de Termos

📖 Referências e Recursos Adicionais

Documentação Oficial

• Spring Framework Documentation
• Spring Boot Documentation
• Spring Security Documentation
• Spring Data JPA Documentation

Guias e Tutoriais

• Spring Getting Started Guides
• Baeldung Spring Tutorials
• Spring Boot Best Practices

Cursos e Certificações

• Spring Professional Certification
• Pivotal Spring Training

Livros Recomendados

• “Spring in Action” by Craig Walls
• “Pro Spring 5” by Iuliana Cosmina
• “Spring Boot in Action” by Craig Walls
• “Spring Security in Action” by Laurentiu Spilca

🔧 Troubleshooting: Problemas Comuns e Soluções

Problema 1: CircularDependencyException

Sintoma: Erro ao inicializar aplicação com dependências circulares
Solução:

• Use @Lazy em uma das dependências
• Refatore o design para eliminar dependência circular
• Use @PostConstruct para inicialização tardia

Problema 2: NoSuchBeanDefinitionException

Sintoma: Bean não encontrado pelo Spring
Solução:

• Verifique se a classe está anotada corretamente
• Confirme se o pacote está no component scan
• Valide configurações de profile

Problema 3: LazyInitializationException

Sintoma: Erro ao acessar propriedades lazy de entidades JPA
Solução:

• Use @Transactional no método que acessa a propriedade
• Implemente fetch join na consulta
• Configure eager loading para a propriedade

Problema 4: OptimisticLockingFailureException

Sintoma: Conflito de versionamento em entidades
Solução:

• Implemente retry logic
• Use @Version adequadamente
• Considere pessimistic locking para casos críticos

Problema 5: SecurityFilterChain não aplicado

Sintoma: Configuração de segurança não funciona
Solução:

• Verifique ordem dos filtros
• Confirme se @EnableWebSecurity está presente
• Valide matcher patterns nos endpoints

Problema 6: Serialization/Deserialization errors

Sintoma: Erro na conversão JSON
Solução:

• Configure Jackson adequadamente
• Use @JsonIgnore ou @JsonProperty
• Implemente custom serializers quando necessário

Problema 7: Connection Pool Exhausted

Sintoma: Aplicação não consegue conexões de banco
Solução:

• Aumente maximum-pool-size
• Identifique e fixe connection leaks
• Configure timeouts adequadamente

Problema 8: Out of Memory em produção

Sintoma: Aplicação consome muita memória
Solução:

• Profile com ferramentas como JProfiler
• Otimize queries para evitar N+1
• Configure heap size adequadamente

Problema 9: Startup lento

Sintoma: Aplicação demora para inicializar
Solução:

• Use @Lazy para beans não essenciais
• Exclua auto-configurations desnecessárias
• Profile startup com Spring Boot Actuator

Problema 10: Testes flaky

Sintoma: Testes passam/falham inconsistentemente
Solução:

• Use @DirtiesContext adequadamente
• Implemente proper setup/teardown
• Evite dependências entre testes