Módulo Domain de Node.js
Módulos integrados de Node.jsEl módulo Domain es una herramienta en Node.js para simplificar el manejo de errores en código asíncrono. Te permite agrupar múltiples operaciones asíncronas en un "dominio" y capturar y manejar errores de manera unificada dentro de ese dominio.
En términos simples, Domain es como un "contenedor" de manejo de errores; puedes colocar operaciones asíncronas relacionadas en este contenedor y luego gestionar de manera unificada los errores que puedan generar estas operaciones.
El uso del módulo domain quedó obsoleto (deprecated) en Node.js 14, porque la comunidad de Node.js recomienda utilizar formas más modernas de manejar errores, como async/await o una lógica más completa de escucha y manejo de errores.
¿Por qué se necesita el módulo Domain?
En la programación asíncrona de Node.js, el manejo de errores puede volverse complejo:
- Los errores asíncronos son difíciles de capturar: el try-catch tradicional no puede capturar errores en callbacks asíncronos
- La propagación de errores es difícil: los errores pueden ocurrir en cualquier operación asíncrona, lo que dificulta rastrear su origen
- Problemas de limpieza de recursos: después de que ocurre un error, es necesario asegurarse de liberar los recursos correctamente
El módulo Domain fue diseñado para resolver estos problemas.
Conceptos centrales del módulo Domain
1. Crear un Domain
Ejemplo
const myDomain = domain.create();
2. Ciclo de vida de Domain
- Creación: usar
domain.create() - Entrada: usar
domain.enter()o entrada implícita - Ejecución: ejecutar el código dentro del dominio
- Salida: usar
domain.exit() - Destrucción: se destruye automáticamente cuando no hay referencias
3. Vinculación implícita
Domain puede vincularse implícitamente a los siguientes objetos:
setTimeout/setIntervalCallbacks- Eventos de EventEmitter
- Operaciones de flujo (Stream)
Métodos principales de Domain
1. domain.run(fn)
Ejecuta una función en el contexto del dominio:
Ejemplo
// Las operaciones asíncronas aquí serán capturadas por el domain
setTimeout(() => {
throw new Error('Async error');
}, 100);
});
2. domain.add(emitter)
Agrega explícitamente una instancia de EventEmitter al dominio:
Ejemplo
myDomain.add(server);
3. domain.remove(emitter)
Elimina la instancia de EventEmitter del dominio.
4. domain.bind(callback)
Devuelve una nueva función vinculada al dominio:
Ejemplo
if (err) throw err;
console.log(data);
});
5. domain.intercept(callback)
Similar a bind, pero específicamente para callbacks con error primero:
Ejemplo
console.log(data);
});
Manejo de errores
Domain, a través delerrorevento, maneja los errores capturados:
Ejemplo
console.error('Domain caught error:', err);
// Limpiar recursos
server.close();
});
Ejemplos de aplicación práctica
1. Manejo de errores en servidores HTTP
Ejemplo
const domain = require('domain');
const server = http.createServer((req, res) => {
const d = domain.create();
d.on('error', (err) => {
res.statusCode = 500;
res.end(`Server error: ${err.message}`);
// Evitar que el proceso se bloquee
server.close();
});
d.run(() => {
// Manejar la solicitud
process.nextTick(() => {
// Simular un error asíncrono
if (req.url === '/error') {
throw new Error('Intentional error');
}
res.end('OK');
});
});
});
server.listen(3000);
2. Gestión de conexiones de bases de datos
Ejemplo
const db = require('some-db-library');
function queryDatabase(callback) {
const d = domain.create();
d.on('error', (err) => {
console.error('Database error:', err);
db.releaseConnection();
});
d.run(() => {
db.getConnection((err, connection) => {
if (err) throw err;
connection.query('SELECT * FROM users', (err, results) => {
if (err) throw err;
callback(null, results);
db.releaseConnection();
});
});
});
}
Limitaciones de Domain
- Obsoleto: Node.js oficialmente ha deprecado el módulo domain; se recomienda usar async_hooks u otros métodos
- Fugas de memoria: un uso incorrecto puede provocar fugas de memoria
- Sobrecarga de rendimiento: crear y gestionar domain tiene cierta sobrecarga de rendimiento
Alternativas
Dado que el módulo domain ha quedado obsoleto, se pueden considerar las siguientes alternativas:
- async/await + try-catch: use el manejo asíncrono moderno de JavaScript
- Manejo de errores con Promise: use
.catch()para manejar errores en cadenas de Promise - async_hooks: una API de seguimiento de contexto asíncrono de más bajo nivel proporcionada por Node.js
Métodos y propiedades
| Método/Propiedad | Descripción |
|---|---|
domain.create() | Crea y devuelve una nuevadomaininstancia. |
domain.run(callback) | Ejecuta la función de callback proporcionada dentro del dominio y captura automáticamente los errores dentro de dicha llamada. |
domain.bind(callback) | Crea una nueva función que llama a la función original y captura cualquier error lanzado. |
domain.intercept(callback) | Similar abind(), pero pasa el error como primer argumento a la función de callback. |
domain.add(emitter) | Agrega explícitamente un objeto EventEmitter o Timer para que sus errores sean capturados por el dominio actual. |
domain.remove(emitter) | Elimina del dominio el objeto EventEmitter o Timer especificado. |
domain.on('error', callback) | Escucha el eventoerrordentro del dominio y captura todos los errores no manejados. |
Ejemplo
1. Crear un dominio y usar domain.run() para capturar errores
domain.run() puede colocar operaciones asíncronas en el dominio; si ocurre un error en la operación, este será capturado y manejado por el dominio actual.
Ejemplo
const d = domain.create();
d.on('error', (err) => {
console.log('Error capturado:', err);
});
d.run(() => {
setTimeout(() => {
throw new Error('Error asíncrono');
}, 100);
});
En el ejemplo anterior, el error dentro de setTimeout será capturado por el evento error del dominio d y no provocará que el proceso se bloquee.
2. Usar domain.bind() para capturar errores en callbacks
domain.bind() crea una función envolvente que puede capturar errores de la función de callback en el dominio actual.
Ejemplo
const d = domain.create();
d.on('error', (err) => {
console.log('Error capturado:', err);
});
const asyncFunction = d.bind((callback) => {
setTimeout(() => {
callback(new Error('Error en el callback'));
}, 100);
});
asyncFunction((err) => {
if (err) throw err;
});
Aquí, el error en asyncFunction será capturado y manejado por el domain.
3. Usar domain.add() para agregar eventos explícitamente
Puede usar domain.add() para agregar un EventEmitter específico al dominio, de modo que sus errores también sean capturados por ese dominio.
Ejemplo
const EventEmitter = require('events');
const d = domain.create();
const emitter = new EventEmitter();
d.on('error', (err) => {
console.log('Error de EventEmitter capturado:', err);
});
// Agregar el emitter al dominio
d.add(emitter);
emitter.on('data', () => {
throw new Error('Error en EventEmitter');
});
emitter.emit('data');
Cuando el evento data lanza un error, el domain capturará este error sin causar que el programa se bloquee.
Consideraciones y limitaciones de domain
- Impacto en el rendimiento：
domainPuede tener cierto impacto en el rendimiento, especialmente en escenarios de alta concurrencia, por lo que no se recomienda usarlo con frecuencia. - No se recomienda su uso en proyectos nuevos: desde Node.js 4.0,
domainfue marcado como módulo obsoleto. Para proyectos nuevos, se recomienda usar métodos más modernos de manejo de errores, comoasync/await、try/catchy escucha de eventos, entre otros. - No es adecuado para todos los escenarios：
domainNo puede capturar todos los tipos de errores (como errores de sintaxis); solo es adecuado para manejar errores en tiempo de ejecución en operaciones asíncronas y funciones de callback.
Alternativas
Dado quedomainha quedado obsoleto, se recomienda usar las siguientes formas para manejar errores en operaciones asíncronas:
- Usar
async/awaitytry/catch: para funciones que admiten async/await, puede usartry/catchpara la captura de errores. - Manejo global de errores: puede usar
process.on('uncaughtException')yprocess.on('unhandledRejection')para escuchar excepciones no capturadas y rechazos de Promise no manejados. - Manejo de errores en listeners de eventos: para el evento de cada EventEmitter
erroragregue un listener.
AunquedomainEl módulo proporciona una forma sencilla de capturar errores en operaciones asíncronas, pero debido a sus problemas de rendimiento y fiabilidad, Node.js no lo recomienda oficialmente para nuevos proyectos. Para el manejo de excepciones, se recomienda usar soluciones más modernas comoasync/awaity los listeners de eventos, asegurando que los errores puedan manejarse eficazmente en la aplicación.