📊 Relatório Comparativo Completo: Java (Spring Boot) ➔ Python (FastAPI)

Este relatório consolida a análise técnica e o mapeamento De / Para completo entre as implementações em Java (Spring Boot) e Python (FastAPI + SQLAlchemy 2.0) dos 3 projetos da trilha full-stack:

1. Controle de Gastos 01 (Interatividade com HTMX)
2. Lista de Tarefas 01 (API REST desacoplada em 4 camadas)
3. Biblioteca de Jogos 01 (Interface Web com Bootstrap 5 e formulários)

1. 🌐 Matriz Global da Stack: De / Para

2. 🔍 Análise Comparativa Detalhada por Projeto

Projeto 1: Controle de Gastos 01 (HTMX + Single Page Experience)

• Foco Didático: Renderização reativa de fragmentos HTML sem frameworks JavaScript pesados (React/Angular).
• Nível Simulado: Estagiário / Júnior.

flowchart LR
    subgraph Java_Flow ["☕ Versão Java"]
        J_Browser["Navegador (HTMX)"] -->|POST / DELETE| J_Controller["LancamentoController"]
        J_Controller -->|Spring Data| J_Repo["LancamentoRepository"]
        J_Controller -->|Fragmento| J_Thyme["index.html :: lista-lancamentos"]
    end

    subgraph Python_Flow ["🐍 Versão Python"]
        P_Browser["Navegador (HTMX / Swagger)"] -->|POST / DELETE| P_Routes["routes.py"]
        P_Routes -->|SQLAlchemy Session| P_DB["database.py (get_db)"]
        P_Routes -->|Fragmento| P_Jinja["partials/lista_lancamentos.html"]
    end

De / Para de Implementação:

Projeto 2: Lista de Tarefas 01 (API REST em Camadas Desacoplada)

• Foco Didático: Arquitetura limpa em camadas (Separation of Concerns), expondo endpoints RESTful com CORS aberto para múltiplos frontends (Web, Mobile, Desktop).
• Nível Simulado: Estagiário / Júnior.

flowchart TD
    subgraph Java_Architecture ["☕ Java 4-Layers"]
        JC["TarefaController (@RestController)"] --> JS["TarefaService (@Service)"]
        JS --> JR["TarefaRepository (JpaRepository)"]
        JR --> JM["Tarefa (@Entity)"]
    end

    subgraph Python_Architecture ["🐍 Python 4-Layers"]
        PR["tarefas.py (APIRouter)"] --> PS["TarefaService"]
        PS --> PRepo["TarefaRepository"]
        PRepo --> PM["Tarefa (SQLAlchemy Model)"]
    end

De / Para de Implementação:

Projeto 3: Biblioteca de Jogos 01 (Interface Web Bootstrap 5)

• Foco Didático: Aplicação web tradicional com renderização de formulários, controle de coleção e redirecionamentos HTTP (PRG: Post-Redirect-Get).
• Nível Simulado: Estagiário.

flowchart LR
    subgraph Java_Web ["☕ Java (Thymeleaf)"]
        JForm["Formulário HTML"] -->|POST /jogos/{id}/concluir| JCtrl["JogoController"]
        JCtrl -->|"save()"| JRep["JogoRepository"]
        JCtrl -->|Redirect| JRedir["redirect:/"]
    end

    subgraph Python_Web ["🐍 Python (Jinja2 + FastAPI)"]
        PForm["Formulário HTML"] -->|POST /jogos/{id}/concluir| PRoutes["routes.py"]
        PRoutes -->|"commit()"| PDB["Session (database.py)"]
        PRoutes -->|Redirect 303| PRedir["RedirectResponse(url='/', status=303)"]
    end

De / Para de Implementação:

3. 📂 Mapeamento Estrutural De / Para de Arquivos

3.1. Controle de Gastos

JAVA (javaweb_gastos_01_htmx)                          PYTHON (controledegastos_python_01)
-------------------------------------------------   -------------------------------------------------
controle-de-gastos/pom.xml                          controledegastos_python_01/requirements.txt
controle-de-gastos/Dockerfile                       controledegastos_python_01/Dockerfile
src/main/resources/application.properties           controledegastos_python_01/app/config.py + .env
src/main/resources/application-prod.properties      controledegastos_python_01/app/config.py (Neon URL)
.../model/Lancamento.java                           .../app/models.py (Lancamento)
.../model/TipoLancamento.java                       .../app/models.py (TipoLancamento Enum)
                                                    .../app/schemas.py (Pydantic DTOs)
.../repository/LancamentoRepository.java            .../app/database.py (Session SQLAlchemy / get_db)
.../controller/LancamentoController.java            .../app/routes.py (FastAPI Router)
.../ControleDeGastosApplication.java                .../app/main.py (FastAPI App & Lifespan)
src/main/resources/templates/index.html             .../app/templates/index.html
(fragmento dentro do index.html)                    .../app/templates/partials/lista_lancamentos.html
(sem testes automatizados na v1)                    .../tests/conftest.py + test_lancamentos.py
index.md (Guia didático)                            index.md (Guia didático atualizado)

3.2. Lista de Tarefas

JAVA (listadetarefas_01)                            PYTHON (listadetarefas_python_01)
-------------------------------------------------   -------------------------------------------------
listadetarefas-api/pom.xml                          listadetarefas_python_01/requirements.txt
listadetarefas-api/Dockerfile                       listadetarefas_python_01/Dockerfile
src/main/resources/application.properties           .../app/config.py + .env
.../tarefa/Tarefa.java                              .../app/models/tarefa.py
(sem DTOs explícitos na v1)                         .../app/schemas/tarefa.py (Create, Update, Response)
.../tarefa/TarefaRepository.java                    .../app/repositories/tarefa_repository.py
.../tarefa/TarefaService.java                       .../app/services/tarefa_service.py
.../tarefa/TarefaController.java                    .../app/routers/tarefas.py
.../ListadetarefasApiApplication.java               .../app/main.py (CORS + Lifespan)
(sem testes automatizados na v1)                    .../tests/conftest.py + test_tarefas_api.py
index.md (Guia didático)                            index.md (Guia didático atualizado)

3.3. Biblioteca de Jogos

JAVA (javaweb_jogos_01_crud)                           PYTHON (bibliotecajogos_python_01)
-------------------------------------------------   -------------------------------------------------
bibliotecajogos/pom.xml                             bibliotecajogos_python_01/requirements.txt
bibliotecajogos/Dockerfile                          bibliotecajogos_python_01/Dockerfile
src/main/resources/application.properties           .../app/config.py + .env
.../entity/Jogo.java                                .../app/models.py (Jogo)
                                                    .../app/schemas.py (JogoCreate, Response)
.../repository/JogoRepository.java                  .../app/database.py (Session SQLAlchemy)
.../controller/JogoController.java                  .../app/routes.py (Web + REST)
.../BibliotecajogosApplication.java                 .../app/main.py
src/main/resources/templates/jogos.html             .../app/templates/jogos.html (Bootstrap 5)
(sem testes automatizados na v1)                    .../tests/conftest.py + test_jogos.py
index.md (Guia didático)                            index.md (Guia didático atualizado)

4. 🚀 Tabela de Mapeamento de Endpoints e Ações HTTP

5. 💡 Diferenças Críticas & Ganhos na Versão Python

1. Documentação Swagger UI Integrada em Todos os Projetos:
   • Enquanto no Spring Boot é necessário adicionar dependências adicionais (springdoc-openapi-starter-webmvc-ui), o FastAPI expõe automaticamente o Swagger UI (/docs), ReDoc (/redoc) e a especificação OpenAPI JSON (/openapi.json) sem nenhuma configuração extra.
2. Tipagem e DTOs com Pydantic v2:
   • O Pydantic valida os tipos em tempo de execução e gera documentação automática. No Java, isso exigiria anotações manuais do Bean Validation (@NotNull, @Size) e classes de DTO separadas desde o primeiro dia.
3. Injeção de Dependência Leve:
   • Em vez de anotações mágicas de reflexão (@Autowired), o FastAPI utiliza Depends(), tornando o fluxo de dados e o ciclo de vida da conexão do banco 100% explícitos e fáceis de substituir em testes automatizados (app.dependency_overrides).
4. Suite de Testes com pytest Padronizada:
   • Os 3 projetos em Python contam com suítes de testes prontas em tests/, executando sobre bancos SQLite isolados em memória com StaticPool, garantindo velocidade instantânea nos testes de integração e validação de regressão.
5. Deploy Simples e Rápido:
   • O Dockerfile baseado em python:3.11-slim gera imagens leves com inicialização instantânea no Render, contornando os tempos maiores de inicialização (cold starts) típicos da JVM.