Node.js - Modulo di dominio

Node.js domainil modulo viene utilizzato per intercettare l'errore non gestito. Questi errori non gestiti possono essere intercettati utilizzando l'associazione interna o l'associazione esterna. Se gli errori non vengono gestiti affatto, si bloccherà semplicemente l'applicazione Node.

• Internal Binding - L'emettitore di errori sta eseguendo il suo codice all'interno del metodo di esecuzione di un dominio.

• External Binding - L'emettitore di errori viene aggiunto esplicitamente a un dominio utilizzando il suo metodo di aggiunta.

Questo modulo può essere importato utilizzando la seguente sintassi.

var domain = require("domain")

La classe di dominio del modulo di dominio viene utilizzata per fornire funzionalità di errori di instradamento ed eccezioni non rilevate all'oggetto Dominio attivo. È una classe figlia di EventEmitter. Per gestire gli errori che rileva, ascolta il suo evento di errore. Viene creato utilizzando la seguente sintassi:

var domain = require("domain");
var child = domain.create();

Metodi

Sr.No.	Metodo e descrizione
1	domain.run(function) Eseguire la funzione fornita nel contesto del dominio, associando implicitamente tutti gli emettitori di eventi, i timer e le richieste di basso livello creati in quel contesto. Questo è il modo più semplice per utilizzare un dominio.
2	domain.add(emitter) Aggiunge esplicitamente un emettitore al dominio. Se un gestore di eventi chiamato dall'emettitore genera un errore, o se l'emettitore emette un evento di errore, verrà indirizzato all'evento di errore del dominio, proprio come con l'associazione implicita.
3	domain.remove(emitter) L'opposto di domain.add (emitter). Rimuove la gestione del dominio dall'emettitore specificato.
4	domain.bind(callback) La funzione restituita sarà un wrapper attorno alla funzione di callback fornita. Quando viene chiamata la funzione restituita, tutti gli errori generati verranno indirizzati all'evento di errore del dominio.
5	domain.intercept(callback) Questo metodo è quasi identico a domain.bind (callback). Tuttavia, oltre a rilevare gli errori generati, intercetterà anche gli oggetti Error inviati come primo argomento della funzione.
6	domain.enter() Il metodo enter è il plumbing utilizzato dai metodi run, bind e intercept per impostare il dominio attivo. Imposta domain.active e process.domain sul dominio e inserisce implicitamente il dominio nello stack di dominio gestito dal modulo di dominio (vedere domain.exit () per i dettagli sullo stack di dominio). La chiamata a enter delimita l'inizio di una catena di chiamate asincrone e operazioni di I / O associate a un dominio.
7	domain.exit() Il metodo di uscita esce dal dominio corrente, estraendolo dallo stack del dominio. Ogni volta che l'esecuzione passa al contesto di una catena diversa di chiamate asincrone, è importante assicurarsi che il dominio corrente sia uscito. La chiamata all'uscita delimita la fine o un'interruzione della catena di chiamate asincrone e operazioni di I / O associate a un dominio.
8	domain.dispose() Una volta chiamato dispose, il dominio non verrà più utilizzato dai callback associati al dominio tramite run, bind o intercept e viene emesso un evento dispose

Proprietà

S.No.	Proprietà e descrizione
1	domain.members Un array di timer ed emettitori di eventi che sono stati aggiunti esplicitamente al dominio.

Esempio

Crea un file js denominato main.js con il codice seguente:

var EventEmitter = require("events").EventEmitter;
var domain = require("domain");

var emitter1 = new EventEmitter();

// Create a domain
var domain1 = domain.create();

domain1.on('error', function(err) {
   console.log("domain1 handled this error ("+err.message+")");
});

// Explicit binding 
domain1.add(emitter1);

emitter1.on('error',function(err) {
   console.log("listener handled this error ("+err.message+")");
});

emitter1.emit('error',new Error('To be handled by listener'));
emitter1.removeAllListeners('error');
emitter1.emit('error',new Error('To be handled by domain1'));

var domain2 = domain.create();

domain2.on('error', function(err) {
   console.log("domain2 handled this error ("+err.message+")");
});

// Implicit binding
domain2.run(function() {
   var emitter2 = new EventEmitter();
   emitter2.emit('error',new Error('To be handled by domain2'));   
});

domain1.remove(emitter1);
emitter1.emit('error', new Error('Converted to exception. System will crash!'));

Ora esegui main.js per vedere il risultato -

$ node main.js

Verifica l'output.

listener handled this error (To be handled by listener)
domain1 handled this error (To be handled by domain1)
domain2 handled this error (To be handled by domain2)

events.js:72 throw er; // Unhandled 'error' event
         ^
Error: Converted to exception. System will crash!
   at Object. (/web/com/1427722220_30772/main.js:40:24)
   at Module._compile (module.js:456:26)
   at Object.Module._extensions..js (module.js:474:10)
   at Module.load (module.js:356:32)
   at Function.Module._load (module.js:312:12)
   at Function.Module.runMain (module.js:497:10)
   at startup (node.js:119:16)
   at node.js:906:3