Roteamento Simples
Roteamento Simples em Node.js refere-se ao processo de direcionamento de requisições HTTP para funções ou manipuladores específicos com base no caminho da URL e no método HTTP. Esse conceito é fundamental para o desenvolvimento de APIs, servidores web e aplicações de microsserviços, pois permite que os desenvolvedores organizem o código de forma clara, mantenham a escalabilidade e facilitem a manutenção.
O Roteamento Simples é utilizado quando é necessário fornecer respostas diferentes para requisições GET, POST ou outros métodos HTTP. No contexto do Node.js, ele está diretamente ligado a conceitos essenciais, como sintaxe, estruturas de dados, algoritmos e princípios de programação orientada a objetos (OOP). Compreender o roteamento simples permite que o desenvolvedor trate dados de entrada de maneira segura, envie respostas apropriadas com códigos de status HTTP e evite erros comuns, como vazamentos de memória ou manipulação inadequada de eventos assíncronos.
Neste tutorial, o leitor aprenderá a criar rotas GET e POST, processar dados de forma assíncrona, organizar a lógica de roteamento usando classes e funções modulares, além de aplicar boas práticas de desenvolvimento Node.js. Entender o roteamento simples é crucial para projetar sistemas escaláveis, seguros e de fácil manutenção dentro da arquitetura de software moderna.
Exemplo Básico
textconst http = require('http');
const url = require('url');
function handleRequest(req, res) {
const parsedUrl = url.parse(req.url, true);
const path = parsedUrl.pathname;
res.setHeader('Content-Type', 'application/json');
if (req.method === 'GET' && path === '/hello') {
res.statusCode = 200;
res.end(JSON.stringify({ message: 'Bem-vindo ao Node.js!' }));
} else if (req.method === 'POST' && path === '/data') {
let body = '';
req.on('data', chunk => {
body += chunk.toString();
});
req.on('end', () => {
res.statusCode = 200;
res.end(JSON.stringify({ received: JSON.parse(body) }));
});
} else {
res.statusCode = 404;
res.end(JSON.stringify({ error: 'Rota não encontrada' }));
}
}
const server = http.createServer(handleRequest);
server.listen(3000, () => {
console.log('Servidor rodando em [http://localhost:3000](http://localhost:3000)');
});No exemplo acima, usamos o módulo http para criar um servidor e o módulo url para analisar o caminho da requisição. A função handleRequest é chamada para cada requisição recebida. O path é extraído da URL e comparado com as rotas definidas. A propriedade req.method diferencia entre GET e POST.
Para a rota GET /hello, retornamos uma mensagem de boas-vindas em JSON. Na rota POST /data, os dados são recebidos de forma assíncrona usando os eventos req.on('data') e req.on('end'), e depois retornados ao cliente. Qualquer outra rota responde com código 404. Esse exemplo demonstra princípios de roteamento, processamento assíncrono e envio seguro de respostas em Node.js.
Exemplo Prático
textconst http = require('http');
const url = require('url');
const dataStore = [];
class Router {
constructor() {
this.routes = {};
}
register(method, path, handler) {
if (!this.routes[method]) {
this.routes[method] = {};
}
this.routes[method][path] = handler;
}
handle(req, res) {
const parsedUrl = url.parse(req.url, true);
const path = parsedUrl.pathname;
const method = req.method;
const routeHandler = this.routes[method] && this.routes[method][path];
if (routeHandler) {
routeHandler(req, res);
} else {
res.statusCode = 404;
res.end(JSON.stringify({ error: 'Rota não encontrada' }));
}
}
}
const router = new Router();
router.register('GET', '/items', (req, res) => {
res.setHeader('Content-Type', 'application/json');
res.end(JSON.stringify({ items: dataStore }));
});
router.register('POST', '/items', (req, res) => {
let body = '';
req.on('data', chunk => body += chunk.toString());
req.on('end', () => {
try {
const item = JSON.parse(body);
dataStore.push(item);
res.statusCode = 201;
res.end(JSON.stringify({ message: 'Item adicionado', item }));
} catch (err) {
res.statusCode = 400;
res.end(JSON.stringify({ error: 'JSON inválido' }));
}
});
});
const server = http.createServer((req, res) => router.handle(req, res));
server.listen(3000, () => console.log('Servidor rodando em [http://localhost:3000](http://localhost:3000)'));Neste exemplo avançado, a classe Router torna o roteamento modular e escalável. O método register armazena os manipuladores de rota por método HTTP e caminho, enquanto handle verifica a existência da rota e retorna 404 caso não exista. A rota GET /items retorna os itens armazenados e POST /items adiciona um novo item. O uso de try/catch garante que JSON inválido não quebre o servidor. Esse padrão demonstra princípios de OOP, modularidade, processamento assíncrono e tratamento seguro de erros.
As melhores práticas incluem definir corretamente o Content-Type, usar códigos de status HTTP apropriados, modularizar o roteamento via classes ou módulos, tratar erros com try/catch e processar dados de forma assíncrona. Erros comuns incluem uso de variáveis globais, ignorar eventos de erro, hardcoding de rotas ou métodos e não validar entradas.
Para depuração, ferramentas nativas do Node.js, logging e monitoramento de memória são úteis. Otimização envolve reduzir operações bloqueantes, reutilizar objetos e funções, e gerenciar eficientemente eventos. Em termos de segurança, validar entradas e proteger contra ataques de injeção são fundamentais.
📊 Tabela de Referência
| Node.js Element/Concept | Description | Usage Example |
|---|---|---|
| Router | Gerencia e distribui rotas de forma modular | router.register('GET', '/path', handler) |
| req.method | Método HTTP da requisição (GET, POST etc.) | if (req.method === 'POST') {...} |
| req.on('data') | Recebe dados de entrada de forma assíncrona | req.on('data', chunk => {...}) |
| res.end() | Envia a resposta e finaliza a requisição | res.end(JSON.stringify({ message: 'Concluído'})) |
| statusCode | Código de status HTTP da resposta | res.statusCode = 404 |
| Content-Type | Tipo de conteúdo da resposta HTTP | res.setHeader('Content-Type', 'application/json') |
Resumo e próximos passos: Compreender o Roteamento Simples permite gerenciar requisições HTTP, organizar rotas e métodos, processar dados assíncronos e construir respostas seguras. Modularização e tratamento de erros são fundamentais para criar APIs e aplicações web escaláveis. Próximos passos incluem o uso de middlewares, autenticação e frameworks avançados como Express.js ou Fastify para roteamento complexo. A prática constante e a exploração de documentação oficial, exemplos comunitários e desafios de programação são essenciais para consolidar o aprendizado.
🧠 Teste Seu Conhecimento
Teste Seu Conhecimento
Desafie-se com este questionário interativo e veja o quão bem você entende o tópico
📝 Instruções
- Leia cada pergunta cuidadosamente
- Selecione a melhor resposta para cada pergunta
- Você pode refazer o quiz quantas vezes quiser
- Seu progresso será mostrado no topo