El conocimiento es el nuevo dinero.
Aprender es la nueva manera en la que inviertes
Acceso Cursos

Arquitectura dirigida por eventos en Node.js

La arquitectura dirigida por eventos (EDA) se ha convertido en un potente paradigma para crear sistemas escalables, con capacidad de respuesta y poco acoplados.

· 6 min de lectura
Arquitectura dirigida por eventos en Node.js

En Node.js, EDA juega un papel fundamental, aprovechando su naturaleza asíncrona y sus capacidades de control de eventos para crear aplicaciones eficientes y robustas.

Vamos a profundizar en las complejidades de la Arquitectura Dirigida por Eventos en Node.js explorando sus conceptos básicos, beneficios y ejemplos prácticos.

Para más información, visite Codenestors

Componentes clave en la arquitectura dirigida por eventos de Node.js:

Módulo EventEmitter


El módulo EventEmitter es el elemento central de la arquitectura basada en eventos de Node.js, ya que permite la creación de objetos capaces de emitir y gestionar eventos.

Si tu quieres aprender nodejs recuerda que tenemos curso, o puedes visita el siguiente video

Este módulo es un elemento fundamental para integrar patrones basados en eventos en las aplicaciones. Entre las funcionalidades clave de EventEmitter se incluyen:

Registro de Eventos


Los objetos que heredan de EventEmitter pueden registrar escuchadores de eventos para eventos específicos que deseen seguir.

Esto implica asociar una función (listener) con un nombre de evento designado.

Emisión de eventos


Utilizando el método emit() dentro del EventEmitter, las instancias pueden emitir eventos, indicando acciones particulares o cambios de estado.

Esto desencadena la invocación de todos los oyentes registrados asignados a ese evento.

Eventos personalizados


Los desarrolladores tienen la capacidad de crear eventos personalizados en sus aplicaciones, definiendo nombres de eventos únicos para significar diversas acciones o sucesos del sistema.

const EventEmitter = require('events');
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
// Event listener for 'customEvent'
myEmitter.on('customEvent', (arg1, arg2) => {
  console.log('Event received with arguments:', arg1, arg2);
});
// Emitting the 'customEvent'
myEmitter.emit('customEvent', 'Hello', 'World');

En este ejemplo, se crea una clase personalizada MyEmitter, que hereda de EventEmitter. Se añade un escuchador de eventos para el evento 'customEvent', que registra los argumentos recibidos cuando se emite el evento mediante emit().

Eventos


Dentro de Node.js, los eventos se erigen como sucesos esenciales reconocidos y gestionados dentro de las aplicaciones, encapsulando distintas acciones o modificaciones en el estado del sistema. Las características clave de los eventos abarcan:

Tipos de eventos


Los eventos abarcan un conjunto diverso de acciones o transiciones, incluyendo actualizaciones de datos, interacciones del usuario, errores del sistema o eventos del ciclo de vida.

Nombres de los eventos


Los eventos se identifican habitualmente mediante cadenas que transmiten su propósito o naturaleza. El uso de nombres de eventos claros y descriptivos favorece una mejor comprensión y mantenimiento de la base de código.

Carga útil del evento


Los eventos tienen la capacidad de transportar datos o información complementaria, lo que se denomina carga útil del evento. Estos datos, transmitidos junto con los eventos, permiten a los oyentes ejecutar acciones específicas, aprovechando la información contextual derivada del evento.

const http = require('http');
const server = http.createServer((req, res) => {
 if (req.url === '/home') {
 res.writeHead(200, { 'Content-Type': 'text/plain' });
 res.end('Welcome to the home page!');
 } else if (req.url === '/about') {
 res.writeHead(200, { 'Content-Type': 'text/plain' });
 res.end('About us page.\n');
 } else {
 res.writeHead(404, { 'Content-Type': 'text/plain' });
 res.end('Page not found!');
 }
});
// Listening for the 'request' event
server.on('request', (req, res) => {
 console.log(`Request received for URL: ${req.url}`);
});
server.listen(3000, () => {
 console.log('Server running on port 3000');
});

En este ejemplo, el servidor HTTP emite un evento 'request' cada vez que recibe una petición. El método on() se utiliza para escuchar este evento, permitiendo el registro de la URL solicitada.

Escuchadores


Los escuchadores, como funciones vinculadas a eventos específicos, se activan en respuesta a la activación de sus correspondientes eventos.

Los aspectos clave de los escuchadores abarcan:

Vinculación a eventos


Los listeners establecen conexiones con eventos a través del método on() o addListener() ofrecido por EventEmitter.

Estas funciones se alistan para reaccionar a eventos específicos emitidos por un emisor.

Ejecución de Listeners


Al emitirse un evento, todos los listeners registrados diseñados para ese evento se ejecutan secuencialmente, facilitando que múltiples funciones reaccionen ante la ocurrencia del mismo evento.

Parámetros de escucha


Al emitir un evento, todos los escuchadores registrados diseñados para ese evento se ejecutan secuencialmente, facilitando que múltiples funciones reaccionen ante la ocurrencia del mismo evento.

const EventEmitter = require('events');
const myEmitter = new EventEmitter();
// Listener 1 for 'eventA'
myEmitter.on('eventA', () => {
 console.log('Listener 1 for eventA executed');
});
// Listener 2 for 'eventA'
myEmitter.on('eventA', () => {
 console.log('Listener 2 for eventA executed');
});
// Emitting 'eventA'
myEmitter.emit('eventA');

En este ejemplo, se registran dos escuchadores para el 'eventoA'. Cuando el evento es emitido usando emit(), ambos listeners son ejecutados secuencialmente en el orden en que fueron registrados.

Beneficios de la Arquitectura Dirigida por Eventos en Node.js

Procesamiento asíncrono y IO no bloqueante


Node.js conocido por su naturaleza asíncrona complementa EDA a la perfección. EDA aprovecha esto al permitir el manejo de eventos sin bloqueo.

A medida que ocurren los eventos, Node.js gestiona eficientemente estos eventos concurrentemente sin esperar a que cada operación se complete.

Acoplamiento flexible y modularidad


EDA promueve el acoplamiento flexible entre los distintos componentes de una aplicación. Los componentes se comunican a través de eventos, lo que reduce las dependencias directas entre ellos.

Este acoplamiento laxo permite una mayor modularidad, ya que los componentes pueden funcionar de forma independiente, lo que hace que el sistema sea más fácil de mantener y de ampliar o modificar.

Escalabilidad y capacidad de respuesta


El modelo basado en eventos de Node.js contribuye significativamente a la escalabilidad de las aplicaciones. La capacidad de distribuir eventos entre múltiples oyentes o suscriptores permite una mejor distribución de la carga y utilización de los recursos.

Gestión de errores y resistencia mejoradas


EDA facilita el manejo robusto de errores dentro de las aplicaciones Node.js. Al emitir eventos de error específicos, los componentes pueden comunicar fallos o condiciones excepcionales, permitiendo que otras partes del sistema respondan en consecuencia.

Comunicación en tiempo real y flujo de datos basado en eventos


En escenarios que requieren comunicación o flujo de datos en tiempo real, como aplicaciones de chat o sistemas IoT, EDA en Node.js sobresale.

El enfoque basado en eventos permite una comunicación fluida entre las diferentes partes del sistema en tiempo real.

Flexibilidad y extensibilidad
EDA fomenta una arquitectura flexible que se adapta a futuros cambios y extensiones. Se pueden añadir nuevas funcionalidades o características introduciendo nuevos eventos o escuchadores sin interrumpir los componentes existentes.

Ejemplos
Aplicación de chat en tiempo real


Imagina construir una aplicación de chat en tiempo real usando Node.js y Socket, donde múltiples usuarios puedan intercambiar mensajes instantáneamente.

He aquí una demostración simplificada.

const http = require('http');
const express = require('express');
const socketIO = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

// Event handler for WebSocket connections
io.on('connection', (socket) => {
  // Event handler for incoming messages
  socket.on('message', (message) => {
    // Broadcasting the received message to all connected clients except the sender
    socket.broadcast.emit('message', message);
  });
});

server.listen(8080, () => {
  console.log('Server running on port 8080');
});

En este ejemplo, el servidor SocketIO (una instancia de SocketIO Server) espera conexiones. Cuando un cliente se conecta, se emite un evento.

Posteriormente, el servidor escucha los mensajes entrantes de los clientes, emitiendo el evento 'message'.

Monitorización del Sistema de Archivos Basada en Eventos


Considera un escenario en el que necesitas monitorizar un directorio en busca de cambios en los archivos usando Node.js.

const fs = require('fs');
const EventEmitter = require('events');
class FileWatcher extends EventEmitter {
  watchDir(directory) {
    fs.watch(directory, (eventType, filename) => {
      if (eventType === 'change') {
        this.emit('fileChanged', filename);
      }
    });
  }
}

En este ejemplo, se crea una instancia de FileWatcher, que extiende EventEmitter. Vigila un directorio especificado en busca de cambios en los archivos usando el método fs.watch() de Node.js.

Cuando se produce un evento 'change' en el directorio, el vigilante emite un evento 'fileChanged'. Se configura un escuchador de eventos para manejar este evento registrando el nombre del archivo que ha sido cambiado.

Gestión de peticiones HTTP con Express.js


Vamos a ampliar el ejemplo del servidor HTTP utilizando Express.js para gestionar las peticiones entrantes.

const express = require('express');
const app = express();
// Event handler for GET request to the home route
app.get('/', (req, res) => {
  res.send('Welcome to the home page!');
});
// Event handler for GET request to other routes
app.get('*', (req, res) => {
  res.status(404).send('Page not found!');
});
// Start the server
const server = app.listen(3000, () => {
  console.log('Server running on port 3000');
});
// Event listener for server start event
server.on('listening', () => {
  console.log('Server started!');
});const wss = new WebSocket.Server({ port: 8080 });

En este ejemplo, Express.js, que utiliza patrones basados en eventos, se utiliza para definir rutas y gestionar las peticiones HTTP entrantes.

Cuando se realiza una petición GET a la ruta home ('/') express emite un evento 'request'. De forma similar para otras rutas, se emite un evento 'request'.

Conclusión


La Arquitectura Dirigida por Eventos (EDA) en Node.js ofrece a los desarrolladores un sinfín de ventajas, permitiendo la creación de aplicaciones altamente performantes, escalables y responsivas.

Mediante la utilización de procesamiento asíncrono, acoplamiento flexible, escalabilidad y comunicación en tiempo real, EDA refuerza la resistencia, adaptabilidad y capacidad de la arquitectura para gestionar eficientemente tareas complejas.

Fuente

Plataforma de cursos gratis sobre programación