Integrando Javascript com Frameworks de Infra-estrutura como Node.js e Express

Configurar um servidor pronto para produção

Comece instalando Node.js de nodejs.org. Após a instalação, crie um diretório de projeto e inicialize um pacote.json:

mkdir my-backend
cd my-backend
npm init -y

Instalar Expresso como uma dependência:

npm install express

Para desenvolvimento, também instale para reiniciar automaticamente o servidor em alterações de arquivos:

npm install -D nodemon

Agora crie um arquivo com um servidor mínimo:

const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
 res.send('Hello, world!');
});

app.listen(PORT, () => {
 console.log(`Server running on port ${PORT}`);
});

Observe o uso de . Isso torna a aplicação portátil em diferentes ambientes – uma prática melhor para implantação.

Adicionando Variáveis de Ambiente

Use o pacote para carregar variáveis de ambiente de um arquivo :

npm install dotenv

Criar um ficheiro :

PORT=5000
DB_CONNECTION_STRING=mongodb://localhost:27017/myapp

Em , carregue a configuração no topo:

require('dotenv').config();

Este padrão mantém dados confidenciais fora de sua base de código e simplifica o gerenciamento de configuração.

Middleware: O Coração de Expresso

As funções do Middleware são os blocos de construção da lógica de aplicação Express. Eles têm acesso ao objeto de requisição, objeto de resposta e a função . Eles podem executar código, modificar a requisição/resposta, terminar o ciclo ou chamar o próximo middleware.

Casos comuns de uso incluem registro, autenticação, análise de corpos de solicitação e erros de manuseio.

Middleware incorporado

Express fornece várias funções de middleware incorporadas:

• – Processa as cargas JSON a chegar.
• – Analisar os corpos codificados por URL (de formulários HTML).
• – Serve arquivos estáticos como imagens, CSS e JavaScript do lado do cliente.

Exemplo com análise JSON:

app.use(express.json());

app.post('/api/users', (req, res) => {
 console.log(req.body); // Access parsed JSON
 res.json({ success: true });
});

Middleware Personalizado

Criar lógica reutilizável escrevendo o seu próprio middleware. Por exemplo, um registrador de pedidos:

const logger = (req, res, next) => {
 console.log(`${req.method} ${req.url} - ${new Date().toISOString()}`);
 next();
};

app.use(logger);

Questões de ordem: middleware é executado na ordem que é definida. Sempre coloque o middleware de gerenciamento de erros em último lugar, com quatro parâmetros:

app.use((err, req, res, next) => {
 console.error(err.stack);
 res.status(500).json({ error: 'Something broke!' });
});

APIs de roteamento e RESTful

Expressar mapas de roteamento Métodos HTTP e caminhos para funções do manipulador. Uma estrutura de roteamento limpa melhora a manutenção e escalabilidade.

Roteamento Básico

app.get('/api/items', (req, res) => {
 // return list of items
});

app.post('/api/items', (req, res) => {
 // create new item
});

app.put('/api/items/:id', (req, res) => {
 const { id } = req.params;
 // update item with given id
});

app.delete('/api/items/:id', (req, res) => {
 // delete item
});

Usando o Roteador Expresso para Modularidade

Para aplicações maiores, divida rotas em arquivos separados usando . Crie uma pasta e um arquivo :

const express = require('express');
const router = express.Router();

router.get('/', (req, res) => {
 res.json([{ id: 1, name: 'Sample Item' }]);
});

router.post('/', (req, res) => {
 // create logic
});

module.exports = router;

Em seguida, em :

const itemsRouter = require('./routes/items');
app.use('/api/items', itemsRouter);

Esta abordagem mantém o ponto de entrada limpo e as rotas logicamente agrupadas.

Conectando a uma Base de Dados

A maioria das infra- estruturas precisa persistir dados. As bases de dados populares NoSQL e SQL integram-se bem com Node.js.

MongoDB com Mongoose

Instalar o Mongoose, um ODM para o MongoDB:

npm install mongoose

Conecte-se no arquivo do servidor:

const mongoose = require('mongoose');

mongoose.connect(process.env.DB_CONNECTION_STRING)
 .then(() => console.log('Connected to MongoDB'))
 .catch(err => console.error('Connection error', err));

Define um esquema e modelo (por exemplo, [[FLT: 31]]]):

const mongoose = require('mongoose');

const itemSchema = new mongoose.Schema({
 name: { type: String, required: true },
 price: Number,
 created_at: { type: Date, default: Date.now }
});

module.exports = mongoose.model('Item', itemSchema);

Use o modelo em suas rotas:

const Item = require('./models/Item');

app.post('/api/items', async (req, res) => {
 try {
 const item = new Item(req.body);
 await item.save();
 res.status(201).json(item);
 } catch (err) {
 res.status(400).json({ error: err.message });
 }
});

PostgreSQL com nós pós- gres

Para bases de dados relacionais, use o pacote :

npm install pg

Criar um pool e uma consulta:

const { Pool } = require('pg');
const pool = new Pool({
 connectionString: process.env.DATABASE_URL
});

app.get('/api/users', async (req, res) => {
 const result = await pool.query('SELECT * FROM users');
 res.json(result.rows);
});

Considere usar um ORM como Sequelizar ou Knex para interações mais abstraídas.

Integração Frontend- Backend

Uma vez que a infra-estrutura serve dados via endpoints API, seu JavaScript frontend pode consumi-los usando a API ou bibliotecas como o Axios.

Obtendo do Expresso

Assumir que a sua API Express é executada em . Um script do lado do cliente (por exemplo, React, Vue ou HTML simples) pode recuperar dados:

fetch('http://localhost:3000/api/items')
 .then(response => {
 if (!response.ok) throw new Error('Network response error');
 return response.json();
 })
 .then(data => {
 console.log('Items:', data);
 // render data on page
 })
 .catch(err => console.error('Fetch error:', err));

Tratamento do CRS

Quando a interface e a infra- estrutura estiverem em diferentes portas ou domínios, você precisa ativar o Compartilhamento de Recursos Cross-Origin (CORS). Instale o pacote :

npm install cors

Em seguida, use-o como middleware:

const cors = require('cors');
app.use(cors()); // Allows all origins – restrict in production

Para a produção, configure origens específicas:

app.use(cors({
 origin: 'https://your-frontend-domain.com',
 methods: ['GET', 'POST']
}));

Melhores Práticas de Segurança

A integração da infra-estrutura introduz preocupações de segurança. Aplicar estas práticas:

• Helmet: Define vários cabeçalhos HTTP para proteger contra ataques comuns.
• Retardar limitante:Usar para prevenir abusos.
• Validação de entrada: Sanitar e validar entradas de usuário usando bibliotecas como ou .
• HTTPS: Sempre serve sobre HTTPS em produção.
• Autenticação:Use os Tokens Web JSON (JWT) ou autenticação baseada em sessão com .

Exemplo com Capacete:

const helmet = require('helmet');
app.use(helmet());

Exemplo com limitação de taxa:

const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
 windowMs: 15 * 60 * 1000, // 15 minutes
 max: 100
});
app.use('/api', limiter);

Erro no tratamento e registo

Aplicações de produção precisam de gerenciamento de erros robusto. Crie um middleware centralizado de manuseio de erros que registra erros e retorna respostas consistentes.

// Custom error handler
const errorHandler = (err, req, res, next) => {
 console.error('Error:', err.message);
 const statusCode = err.statusCode || 500;
 res.status(statusCode).json({
 error: err.message,
 stack: process.env.NODE_ENV === 'development' ? err.stack : undefined
 });
};

app.use(errorHandler);

Para o registo, utilizar em desenvolvimento e um registador mais estruturado como na produção:

npm install morgan winston

const morgan = require('morgan');
app.use(morgan('dev'));

Testando a Integração

Escreva testes para verificar se sua infraestrutura se comporta como esperado. As estruturas de teste populares incluem Jest e Mocha. Para testes de integração HTTP, use ] supertest.

Exemplo com o Jest e o Supertest

Instalar dependências dev:

npm install -D jest supertest

Criar um ficheiro de teste :

const request = require('supertest');
const app = require('./index'); // export app from index.js

describe('GET /api/items', () => {
 it('responds with JSON array', async () => {
 const res = await request(app)
 .get('/api/items')
 .expect('Content-Type', /json/)
 .expect(200);
 expect(Array.isArray(res.body)).toBe(true);
 });
});

Nota: Separe a definição do aplicativo do servidor que está ouvindo para evitar conflitos de portas durante os testes. Exportar o aplicativo e ouvir apenas quando o arquivo é executado diretamente:

if (require.main === module) {
 app.listen(PORT, () => {
 console.log(`Server running on port ${PORT}`);
 });
}
module.exports = app;

Considerações sobre a implantação

Ao implantar sua infraestrutura Node.js+Express, siga estas diretrizes:

• Use um gerenciador de processo como PM2 para manter o aplicativo vivo e lidar com clustering.
• Set environment variables na plataforma de hospedagem (por exemplo, Heroku, DigitalOcean, AWS Elastic Beanstalk).
• Ativar o registro e monitoramento com serviços como Logtail ou Datadog.
• Use um proxy reverso (Nginx, Caddy) para os cabeçalhos SSL terminação, cache e segurança.

Um padrão de implantação comum é manter a infraestrutura e frontend como projetos separados, comunicando através da API sobre HTTPS. Alternativamente, você pode servir os arquivos de compilação frontend via Express usando e lidar com catch-all rotas para suportar roteamento cliente-lado (por exemplo, React Router).

Otimização de desempenho

Node.js é mono-threaded, mas você ainda pode alcançar alto rendimento com estratégias adequadas:

• Use assync/await para todas as operações de E/S para evitar bloquear o loop do evento.
• Respostas de compressão com middleware.
• Cache respostas frequentes usando lojas de memória como Redis.
• Cluster o aplicativo em vários núcleos de CPU usando o módulo incorporado ou o modo de cluster PM2.

Exemplo com compressão:

const compression = require('compression');
app.use(compression());

Comunicação em tempo real com WebSockets

Express integra-se sem problemas com para permitir uma comunicação bidirecional orientada para eventos. Isto é ideal para aplicativos de chat, notificações ao vivo e ferramentas colaborativas.

npm install socket.io

Crie o servidor com suporte tanto HTTP quanto WebSocket:

const http = require('http');
const socketIo = require('socket.io');

const server = http.createServer(app);
const io = socketIo(server, { cors: { origin: '*' } });

io.on('connection', (socket) => {
 console.log('New client connected');
 socket.on('disconnect', () => console.log('Client disconnected'));
});

server.listen(PORT, () => console.log(`Server with WebSocket on port ${PORT}`));

O frontend pode se conectar a este servidor WebSocket e emitir/ouvir eventos usando a biblioteca .

Quadros e padrões de stack completo

Além da integração básica, muitas equipes adotam frameworks que combinam Node.js, Express e uma estrutura de frontend em uma pilha coesa. O mais comum é o MERN pilha (MongoDB, Express, React, Node.js). Outros incluem MEVN[[ (Vue) e MEAN[ (Angular).

Estas pilhas permitem que os desenvolvedores criem aplicativos completos do banco de dados para a UI, muitas vezes com modelos e tipos compartilhados. Por exemplo, você pode definir esquemas de Mongoose na infraestrutura e reutilizar a mesma lógica de validação na interface após converter para uma biblioteca de formulários.

Conclusão

Integrar JavaScript com Node.js e Express não é apenas sobre rodar código semelhante em ambos os lados – é sobre alavancar o poder total do ecossistema do JavaScript para construir aplicativos web coesos, mantendíveis e de alto desempenho. De uma configuração básica a padrões avançados como middleware, integração de banco de dados, autenticação e recursos em tempo real, a Express fornece a flexibilidade necessária para se adaptar aos diversos requisitos do projeto.

Ao dominar essas técnicas, você pode eliminar o descompasso de impedância entre a infraestrutura e a frontend, acelerar os ciclos de desenvolvimento e implantar aplicações que se dimensionam. Agora é a hora de colocar a teoria em prática: iniciar um novo projeto, experimentar com middleware, conectar um banco de dados e ver a integração ganhar vida.