Este manual reúne e aprofunda todos os tópicos já abordados, apresentado de forma contínua, progressiva e extremamente detalhada, parágrafo por parágrafo, código por código, linha por linha. É o documento único e definitivo para estudo completo de Java e Spring Boot, do zero ao nível pleno/sênior em 2026.

**1. Preparação Inicial e Ambiente Profissional**  
Antes de qualquer código, configure o ambiente profissional. Baixe e instale o JDK 21 LTS da Adoptium Temurin (https://adoptium.net/), versão mais estável e recomendada para produção em 2026. Instale o IntelliJ IDEA Community Edition (gratuito) ou Ultimate (trial ou licença educacional). Adicione Maven 3.9+ (vem embutido no IntelliJ, mas verifique com mvn -version). Instale Git, Docker Desktop, Postman ou Insomnia para testes de API. No VS Code (opcional), instale as extensões Java Extension Pack (Microsoft), Spring Boot Tools (Pivotal), Lombok Annotations Support, SonarLint. Crie um projeto base acessando https://start.spring.io com as seguintes opções: Project = Maven, Language = Java, Spring Boot = 3.3.x, Group = com.wagner, Artifact = batismo-java, Java = 21. Marque dependências: Spring Web, Spring Data JPA, Spring Boot DevTools, Lombok, Spring Boot Actuator, Springdoc OpenAPI UI, PostgreSQL Driver, Validation, Spring Security (opcional no início). Baixe o zip, abra no IntelliJ e rode a classe principal para validar. Crie um arquivo application.yml na pasta src/main/resources com configuração profissional inicial:

```yaml
server:
  port: 8080
  error:
    include-message: always
    include-binding-errors: always

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/batismo_db
    username: postgres
    password: sua_senha_forte_aqui
    driver-class-name: org.postgresql.Driver
  jpa:
    hibernate:
      ddl-auto: update # mude para validate em produção
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        dialect: org.hibernate.dialect.PostgreSQLDialect
  main:
    banner-mode: off

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus

logging:
  level:
    org.springframework: INFO
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql: TRACE
```

**2. Java do Básico ao Avançado (Java 21+)**  
Comece com sintaxe básica. Declare variáveis: int idade = 30; String nome = "Wagner"; double salario = 3500.50; boolean ativo = true;. Use operadores: idade + 5, salario * 1.1, idade > 18. Estruturas de controle: if (idade >= 18) { System.out.println("Maior"); } else { ... }. Switch moderno (Java 14+): String resultado = switch (dia) { case 1 -> "Segunda"; default -> "Outro"; }; Loops: for (int i = 0; i < 10; i++) { ... }, while (condicao) { ... }, for (String item : lista) { ... }. Arrays: String[] nomes = {"Ana", "João"}; List<String> lista = new ArrayList<>(); lista.add("Maria");. Orientação a Objetos: class Pessoa { private String nome; public Pessoa(String nome) { this.nome = nome; } public String getNome() { return nome; } }. Herança: class Cliente extends Pessoa { private double limiteCredito; }. Interfaces: interface Pagavel { double calcularPagamento(); }. Exceções: try { int x = 10 / 0; } catch (ArithmeticException e) { System.out.println("Divisão por zero"); } finally { ... }. Java moderno: lambdas (lista.forEach(item -> System.out.println(item))); Stream API:

```java
List<Pessoa> pessoas = ...;
double mediaSalario = pessoas.stream()
    .filter(p -> p.getIdade() > 25)
    .mapToDouble(Pessoa::getSalario)
    .average()
    .orElse(0.0);
```

Records (imutáveis concisos): public record Produto(Long id, String nome, BigDecimal preco) {}. Sealed classes: public sealed interface Forma permits Circulo, Quadrado {}. Pattern matching: if (forma instanceof Circulo c) { System.out.println(c.raio()); }. Virtual Threads:

```java
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10000; i++) {
        executor.submit(() -> {
            Thread.sleep(1000); // simula I/O
            System.out.println(Thread.currentThread());
        });
    }
}
```

**3. Spring Boot – Camadas e Funcionalidades Principais**  
Crie controller: @RestController @RequestMapping("/api/produtos") public class ProdutoController { private final ProdutoService service; ... }. Endpoint GET: @GetMapping public List<ProdutoDTO> listar() { return service.listar(); }. POST: @PostMapping public ResponseEntity<ProdutoDTO> criar(@RequestBody @Valid ProdutoCreateDTO dto) { ProdutoDTO criado = service.criar(dto); return ResponseEntity.status(HttpStatus.CREATED).body(criado); }. Service: @Service @RequiredArgsConstructor public class ProdutoService { private final ProdutoRepository repo; public ProdutoDTO criar(ProdutoCreateDTO dto) { Produto p = mapper.toEntity(dto); p = repo.save(p); return mapper.toDTO(p); } }. Repository: public interface ProdutoRepository extends JpaRepository<Produto, Long> { List<Produto> findByPrecoGreaterThan(BigDecimal preco); }. Entidade: @Entity @Data public class Produto { @Id @GeneratedValue private Long id; private String nome; private BigDecimal preco; }. Validação DTO: @Data public class ProdutoCreateDTO { @NotBlank String nome; @Positive BigDecimal preco; }. Exception global: @RestControllerAdvice public class GlobalHandler { @ExceptionHandler(MethodArgumentNotValidException.class) public ResponseEntity<?> handleValidation(MethodArgumentNotValidException ex) { ... } }.

**4. Segurança Completa com JWT**  
SecurityConfig: @Configuration @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http.csrf().disable().authorizeRequests().antMatchers("/api/auth/**").permitAll().anyRequest().authenticated().and().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and().addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class); return http.build(); } }. JwtFilter (OncePerRequestFilter): extrai token do header Authorization, valida com JwtService, carrega UserDetails, seta Authentication no SecurityContextHolder. JwtService: 

```java
public String generateToken(UserDetails user) {
    return Jwts.builder()
        .setSubject(user.getUsername())
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + 86400000)) // 24h
        .signWith(Keys.hmacShaKeyFor(Decoders.BASE64.decode(SECRET_KEY)), SignatureAlgorithm.HS256)
        .compact();
}
```

**5. Boas Práticas, Clean Code e Arquitetura**  
Siga SOLID: Single Responsibility (cada classe faz uma coisa), Open-Closed (extensão sem modificação). Use nomes claros: calcularSalarioLiquido ao invés de calc. Estrutura hexagonal: domain (entidades puras), application (use cases), infrastructure (controllers, repositories JPA). Documente com Swagger: springdoc-openapi-ui adiciona /swagger-ui.html automaticamente.

**6. Observabilidade e Resiliência**  
Ative Micrometer: @Timed("produto.criar") no método. Resilience4j: @CircuitBreaker(name = "produtoService") em métodos Feign. RateLimiter: limite 100 req/minuto por IP.

**7. Microsserviços**  
Eureka: porta 8761, client fetch-registry false. Gateway: rotas lb://produto-service. Feign: @FeignClient com @CircuitBreaker.

**8. Otimização e Testes**  
N+1: use @EntityGraph(attributePaths = {"categoria"}). Testcontainers: @Container static PostgreSQLContainer postgres = ....

**9. Projeto Final e Portfólio**  
Construa e-commerce com auth, produto, pedido, pagamento. Deploy em Railway com Docker Compose, CI/CD GitHub Actions, Swagger, Prometheus/Grafana.

**10. Plano Final e Checklist**  
90–180 dias: refatorar projetos, implementar microsserviços, testes coverage 80%, aplicar 100+ vagas. Checklist: JDK 21, Spring Boot 3.3+, JWT, Clean Arch, Docker, CI/CD, 150+ LeetCode, LinkedIn otimizado.

Este é o manual completo, detalhado e unificado. Use diariamente para estudo e prática.