Backend HTTP 100% C++ puro sem frameworks externos. Tudo implementado do zero para aprendizado máximo!
Este projeto implementa um backend HTTP completo em C++ SEM usar frameworks prontos. Você vai aprender:
- Socket Programming - Como TCP/IP funciona na prática
- HTTP Protocol - Parsing manual de requests/responses
- JSON - Parser e serializer do zero
- Threading - Thread pools e concorrência
- Memory Management - RAII, smart pointers, zero leaks
- DDD - Domain-Driven Design em C++ puro
- Database - SQL direto com libpq (PostgreSQL)
cppBackend/
├── src/
│ ├── core/ # Fundações do sistema
│ │ ├── http/ # HTTP Server do zero
│ │ │ ├── Server.hpp # TCP Server
│ │ │ ├── Request.hpp # HTTP Request parser
│ │ │ ├── Response.hpp # HTTP Response builder
│ │ │ └── Router.hpp # URL routing
│ │ │
│ │ ├── json/ # JSON parser do zero
│ │ │ ├── Json.hpp # JSON parser/serializer
│ │ │ └── JsonValue.hpp # JSON value types
│ │ │
│ │ ├── database/ # Database layer
│ │ │ ├── Connection.hpp # DB connection pool
│ │ │ └── QueryBuilder.hpp # SQL query builder
│ │ │
│ │ ├── threading/ # Concorrência
│ │ │ ├── ThreadPool.hpp # Thread pool
│ │ │ └── Queue.hpp # Thread-safe queue
│ │ │
│ │ └── utils/ # Utilitários
│ │ ├── String.hpp # String helpers
│ │ ├── Logger.hpp # Logging
│ │ └── Crypto.hpp # Hash, encryption
│ │
│ ├── domains/ # Business logic (DDD)
│ │ ├── identity/ # Domain: Identity
│ │ │ ├── entities/ # User entity
│ │ │ ├── value_objects/ # Email, Password, etc
│ │ │ ├── repositories/ # Data access
│ │ │ ├── use_cases/ # Business operations
│ │ │ └── controllers/ # HTTP endpoints
│ │ │
│ │ └── commerce/ # Domain: Commerce
│ │ ├── entities/ # Product, Order
│ │ └── ...
│ │
│ ├── infrastructure/ # Implementações técnicas
│ │ ├── database/ # PostgreSQL implementation
│ │ ├── cache/ # Redis/Memory cache
│ │ └── security/ # JWT, bcrypt
│ │
│ └── main/
│ └── main.cpp # Entry point
│
├── include/ # Headers públicos
├── tests/ # Unit tests
├── build/ # Build output
├── lib/ # Bibliotecas externas
├── config/ # Configurações
└── docs/ # Documentação
Usamos APENAS bibliotecas de baixo nível (não frameworks):
# Obrigatórias
- libpq (PostgreSQL client C)
- pthread (POSIX threads)
# Opcionais (para produção)
- OpenSSL (HTTPS, crypto)
- zlib (compression)// Implementamos um servidor TCP que:
1. Escuta em uma porta (ex: 8080)
2. Aceita conexões (accept())
3. Lê dados do socket (recv())
4. Parseia HTTP request (manual!)
5. Roteia para handler correto
6. Executa business logic
7. Serializa resposta
8. Envia via socket (send())
9. Fecha conexão// Request HTTP é texto plano:
"GET /users/123 HTTP/1.1\r\n"
"Host: localhost:8080\r\n"
"Content-Type: application/json\r\n"
"\r\n"
"{ \"name\": \"John\" }"
// Você vai implementar parser que extrai:
- Method (GET, POST, etc)
- Path (/users/123)
- Headers (Host, Content-Type, etc)
- Body (JSON payload)// JSON é texto estruturado:
"{ \"name\": \"John\", \"age\": 30 }"
// Seu parser vai:
1. Tokenizar (lexer)
2. Construir árvore (parser)
3. Validar sintaxe
4. Criar objeto C++ navegável// Para alta concorrência:
1. Cria N threads na inicialização
2. Cada request vai para fila
3. Threads ociosos pegam da fila
4. Processam e devolvem resposta
5. Voltam para idle state// Business logic isolada:
Domain Entity -> Use Case -> Repository -> DB
// Exemplo:
User user = User::create(email, password); // Entity
userService.register(user); // Use Case
userRepo.save(user); // Repository# Windows (usando MSYS2)
pacman -S mingw-w64-x86_64-gcc
pacman -S mingw-w64-x86_64-cmake
pacman -S mingw-w64-x86_64-postgresql
# Linux (Ubuntu/Debian)
sudo apt install build-essential cmake libpq-dev
# macOS
brew install cmake postgresqlmkdir build
cd build
cmake ..
make -j$(nproc)./cppBackend
# Server starting at http://localhost:8080Recomendo implementar nesta ordem:
- ✅ Estrutura de diretórios
- ⏭️ HTTP Server básico (accept, recv, send)
- ⏭️ HTTP Request parser
- ⏭️ HTTP Response builder
- ⏭️ Router (URL matching)
- ⏭️ JSON lexer (tokenização)
- ⏭️ JSON parser (AST)
- ⏭️ JSON serializer
- ⏭️ JSON Value types
- ⏭️ Thread-safe queue
- ⏭️ Thread pool
- ⏭️ Connection handling
- ⏭️ Domain entities (User, Product)
- ⏭️ Value objects (Email, Password)
- ⏭️ Use cases
- ⏭️ Controllers
- ⏭️ PostgreSQL integration (libpq)
- ⏭️ Connection pooling
- ⏭️ Repositories
- ⏭️ Transactions
- ⏭️ HTTPS (OpenSSL)
- ⏭️ Authentication (JWT)
- ⏭️ Logging
- ⏭️ Error handling
- ⏭️ Performance tuning
- System calls (socket, bind, listen, accept)
- File descriptors
- Buffers e memory management
- Endianness (byte order)
- TCP/IP stack
- Threads vs processes
- Mutexes e locks
- Race conditions
- Deadlocks
- Thread-safe data structures
- TCP sockets
- HTTP protocol
- Keep-alive connections
- Request pipelining
- Stack vs heap
- RAII pattern
- Smart pointers
- Memory pools
- Zero-copy optimizations
Após otimizações, esperamos:
| Métrica | Target |
|---|---|
| Latência p50 | < 200µs |
| Latência p99 | < 2ms |
| Throughput | > 50K req/s |
| Memory | < 100MB |
| CPU | 1 core @ 50% |
- "TCP/IP Sockets in C" - Michael J. Donahoo
- "C++ Concurrency in Action" - Anthony Williams
- "Effective Modern C++" - Scott Meyers
# Verificar sockets abertos
netstat -tulnp | grep 8080
# Memory leaks
valgrind --leak-check=full ./cppBackend
# Profiling
perf record ./cppBackend
perf report
# GDB
gdb ./cppBackend
(gdb) break main
(gdb) run- Este é um projeto EDUCACIONAL - Não use em produção sem auditar
- Segurança - Implemente validação, sanitização, rate limiting
- Error Handling - Trate TODOS os erros (não assuma sucesso)
- Memory - Use smart pointers, evite raw pointers
- Testing - Escreva testes para tudo
- ✅ Estrutura criada
- ⏭️ Implementar HTTP Server básico
- ⏭️ Testar com
curl - ⏭️ Adicionar JSON parsing
- ⏭️ Implementar primeiro endpoint (GET /health)
Dificuldade: 🔥🔥🔥🔥🔥 (Expert)
Tempo Estimado: 2-3 meses para versão completa
Recompensa: Conhecimento profundo de como sistemas funcionam!
Vamos começar! 🚀