Ai-je besoin d'injection de dépendance dans NodeJS, ou la façon de traiter avec ...?

En bref, vous n'avez pas besoin d'un conteneur d'injection de dépendance ou d'un service de localisation comme vous le feriez en C#/Java. Depuis Node.js, exploite la module pattern, il n'est pas nécessaire d'effectuer constructeur ou des biens de l'injection. Bien que vous le pouvez encore.

La grande chose à propos de JS, c'est que vous pouvez modifier à peu près tout pour obtenir ce que vous voulez. C'est pratique quand il s'agit de tester.

Voici mon très boiteux exemple artificiel.

MyClass.js:

var fs = require('fs');

MyClass.prototype.errorFileExists = function(dir) {
    var dirsOrFiles = fs.readdirSync(dir);
    for (var d in dirsOrFiles) {
        if (d === 'error.txt') return true;
    }
    return false;
};

MyClass.test.js:

describe('MyClass', function(){
    it('should return an error if error.txt is found in the directory', function(done){
        var mc = new MyClass();
        assert(mc.errorFileExists('/tmp/mydir')); //true
    });
});

Avis comment MyClass dépend de la fs module? Comme @ShatyemShekhar mentionné, vous pouvez le faire en effet, le constructeur ou bien à l'injection dans d'autres langues. Mais il n'est pas nécessaire en Javascript.

Dans ce cas, vous pouvez faire deux choses.

Vous pouvez talon la fs.readdirSync méthode ou vous pouvez revenir un tout autre module lorsque vous appelez require.

Méthode 1:

var oldmethod = fs.readdirSync;
fs.readdirSync = function(dir) { 
    return ['somefile.txt', 'error.txt', 'anotherfile.txt']; 
};

*** PERFORM TEST ***
*** RESTORE METHOD AFTER TEST ****
fs.readddirSync = oldmethod;

Méthode 2:

var oldrequire = require
require = function(module) {
    if (module === 'fs') {
        return {
            readdirSync: function(dir) { 
                return ['somefile.txt', 'error.txt', 'anotherfile.txt']; 
            };
        };
    } else
        return oldrequire(module);

}

La clé est de tirer parti de la puissance de Node.js et Javascript. Remarque, je suis un CoffeeScript gars, mon JS syntaxe est peut-être incorrect quelque part. Aussi, je ne dis pas que c'est la meilleure façon, mais c'est une façon. Javascript gourous pourriez être en mesure de carillon avec d'autres solutions.

Mise à jour:

Cela devrait répondre à votre question spécifique concernant les connexions de base de données. J'aimerais créer un module séparé pour votre pour encapsuler votre connexion de base de données logique. Quelque chose comme ceci:

MyDbConnection.js: (assurez-vous de choisir un meilleur nom)

var db = require('whichever_db_vendor_i_use');

module.exports.fetchConnection() = function() {
    //logic to test connection

    //do I want to connection pool?

    //do I need only one connection throughout the lifecyle of my application?

    return db.createConnection(port, host, databasename); //<--- values typically from a config file    
}

Puis, un module qui a besoin d'une connexion de base de données seraient alors il suffit d'inclure votre MyDbConnection module.

SuperCoolWebApp.js:

var dbCon = require('./lib/mydbconnection'); //wherever the file is stored

//now do something with the connection
var connection = dbCon.fetchConnection(); //mydbconnection.js is responsible for pooling, reusing, whatever your app use case is

//come TEST time of SuperCoolWebApp, you can set the require or return whatever you want, or, like I said, use an actual connection to a TEST database. 

Ne suivez pas cet exemple verbatim. C'est un piètre exemple pour essayer de communiquer que vous tirer parti de l' module modèle pour la gestion de vos dépendances. Espérons que cela aide un peu plus.

Je sais que ce fil est assez vieux à ce point, mais j'ai pensé carillon avec mes pensées sur ce. Le TL;DR est qu'en raison de la non typé, de la nature dynamique de JavaScript, vous pouvez effectivement faire beaucoup de chose sans avoir recours à l'injection de dépendance (DI) au motif ou à l'aide d'un DI-cadre. Cependant, comme une application devient plus grand et plus complexe, DI peut certainement aider à la maintenabilité du code.

DI en C#

De comprendre pourquoi DI n'est pas que les grandes d'un besoin en JavaScript, il est utile de regarder un langage fortement typé comme le C#. (Mes excuses à ceux qui ne connaissent pas le C#, mais il devrait être assez facile à suivre.) Disons que nous avons une application qui décrit une voiture et son klaxon. Vous serait de définir deux classes:

class Horn
{
    public void Honk()
    {
        Console.WriteLine("beep!");
    }
}

class Car
{
    private Horn horn;

    public Car()
    {
        this.horn = new Horn();
    }

    public void HonkHorn()
    {
        this.horn.Honk();
    }
}

class Program
{
    static void Main()
    {
        var car = new Car();
        car.HonkHorn();
    }
}

Il y a quelques problèmes d'écrire le code de cette façon.

1. La Car classe est étroitement associée à la mise en œuvre de la corne dans la Horn classe. Si nous voulons changer le type de pavillon utilisé par la voiture, nous devons modifier la Car classe même si son utilisation de la corne ne change pas. Cela fait de test difficile car on ne peut pas tester le Car classe dans l'isolement de sa dépendance, la Horn classe.
2. La Car classe est responsable du cycle de vie de la Horn classe. Dans un exemple simple comme cela, il n'est pas un gros problème, mais dans les applications réelles dépendances dépendances, qui ont des dépendances, etc. Le Car classe devrait être responsable de la création de l'ensemble de l'arborescence de ses dépendances. Ce n'est pas seulement compliqué et répétitif, mais il viole la "responsabilité unique" de la classe. Il devrait se concentrer sur la voiture, pas la création d'instances.
3. Il n'y a aucun moyen de réutiliser le même cas de dépendance. Encore une fois, ce n'est pas important dans cette application jouet, mais envisager une connexion de base de données. En règle générale, vous avez une seule instance qui est partagé au sein de votre application.

Maintenant, laissez-nous refactoriser cette utilisation d'une injection de dépendance modèle.

interface IHorn
{
    void Honk();
}

class Horn : IHorn
{
    public void Honk()
    {
        Console.WriteLine("beep!");
    }
}

class Car
{
    private IHorn horn;

    public Car(IHorn horn)
    {
        this.horn = horn;
    }

    public void HonkHorn()
    {
        this.horn.Honk();
    }
}

class Program
{
    static void Main()
    {
        var horn = new Horn();
        var car = new Car(horn);
        car.HonkHorn();
    }
}

Nous avons fait deux choses importantes ici. Tout d'abord, nous avons mis en place une interface de notre Horn classe implémente. Cela nous permet de code de la Car classe de l'interface au lieu de la mise en oeuvre particulière. Maintenant, le code pourrait prendre ce qui implémente IHorn. Deuxièmement, nous avons pris la corne de l'instanciation de Car et de le transmettre à la place. Cela résout les problèmes ci-dessus et laisse à la fonction principale de l'application pour gérer des instances et de leurs cycles de vie.

Ce que cela signifie, c'est que pourrait introduire un nouveau type de klaxon de la voiture à utiliser, sans toucher à la Car classe:

class FrenchHorn : IHorn
{
    public void Honk()
    {
        Console.WriteLine("le beep!");
    }
}

Le principal pourrait juste injecter une instance de la FrenchHorn classe à la place. Également, cela simplifie considérablement les tests. Vous pouvez créer un MockHorn classe d'injecter dans la Car constructeur pour s'assurer que vous testez juste le Car classe dans l'isolement.

L'exemple ci-dessus montre le manuel de l'injection de dépendance. Généralement, DI est fait avec un cadre (par exemple, L'unité ou Ninject dans le C# du monde). Ces cadres ne tous les de la dépendance de câblage pour vous par la marche de votre graphe de dépendance et la création d'instances que nécessaire.

La Norme Node.js Façon

Examinons maintenant le même exemple dans Node.js. Nous serions probablement briser notre code en 3 modules:

//horn.js
module.exports = {
    honk: function () {
        console.log("beep!");
    }
};

//car.js
var horn = require("./horn");
module.exports = {
    honkHorn: function () {
        horn.honk();
    }
};

//index.js
var car = require("./car");
car.honkHorn();

Parce que JavaScript est non typé, nous n'avons pas tout à fait le même couplage étroit que nous avions avant. Il n'est pas nécessaire pour les interfaces (et qui n'existe pas) comme les car module va juste tenter d'appeler le honk méthode sur ce que l' horn module exportations.

En outre, en raison du Nœud require caches tout, les modules sont essentiellement des singletons stockées dans un conteneur. Tout autre module qui effectue un require sur le horn module obtiendrez exactement la même instance. Cela rend le partage de singleton objets comme des connexions de base de données très facile.

Maintenant, il est toujours la question que l' car module est responsable de l'extraction de sa propre dépendance horn. Si vous voulais la voiture à utiliser un autre module pour sa corne, vous auriez à changer le require instruction dans le car module. Ce n'est pas une chose commune à faire, mais il cause des problèmes avec les tests.

La manière habituelle les gens à gérer les tests de problème avec proxyquire. En raison de la nature dynamique de JavaScript, proxyquire intercepte les appels à exiger et retours tous les stubs/se moque de vous fournir à la place.

var proxyquire = require('proxyquire');
var hornStub = {
    honk: function () {
        console.log("test beep!");
    }
};

var car = proxyquire('./car', { './horn': hornStub });

//Now make test assertions on car...

C'est plus que suffisant pour la plupart des applications. Si cela fonctionne pour votre application, puis aller avec elle. Cependant, dans mon expérience, que les applications deviennent plus gros et plus complexes, le maintien de code comme cela devient plus difficile.

DI en JavaScript

Node.js est très flexible. Si vous n'êtes pas satisfait avec la méthode ci-dessus, vous pouvez écrire vos modules à l'aide de l'injection de dépendance modèle. Dans ce modèle, chaque module exporte une fonction de fabrication (ou d'un constructeur de la classe).

//horn.js
module.exports = function () {
    return {
        honk: function () {
            console.log("beep!");
        }
    };
};

//car.js
module.exports = function (horn) {
    return {
        honkHorn: function () {
            horn.honk();
        }
    };
};

//index.js
var horn = require("./horn")();
var car = require("./car")(horn);
car.honkHorn();

Ce qui est très analogue à la méthode C# plus tôt dans la index.js module est responsable par exemple de cycle de vie et de câblage. Le test unitaire est très simple, comme vous pouvez juste passer dans les mocks/stubs pour les fonctions. Encore une fois, si c'est assez bon pour votre demande d'aller avec elle.

Bolus DI Cadre

À la différence de C#, il n'existe pas de standard établi DI cadres pour vous aider dans votre gestion de la dépendance. Il y a un certain nombre de cadres dans le mécanisme national de prévention de registre, mais aucun n'a une adoption généralisée. Beaucoup de ces options ont été cités déjà dans les autres réponses.

Je n'étais pas particulièrement heureux avec toutes les options disponibles, j'ai donc écrit mon propre appelé bolus. Bolus est conçu pour fonctionner avec le code écrit dans la DI de style ci-dessus et essaie d'être très SEC et très simple. En utilisant exactement les mêmes car.js et horn.js modules ci-dessus, vous pouvez réécrire la index.js module avec bolus comme:

//index.js
var Injector = require("bolus");
var injector = new Injector();
injector.registerPath("**/*.js");

var car = injector.resolve("car");
car.honkHorn();

L'idée de base est que vous créez un injecteur. Vous vous inscrivez tous vos modules dans l'injecteur. Ensuite il vous suffit de résoudre ce dont vous avez besoin. Bolus vont marcher sur le graphe de dépendance et de créer et d'injecter les dépendances nécessaires. Vous n'enregistrez pas beaucoup dans un jouet exemple comme ça, mais dans les grandes applications complexes sur des arbres de dépendance de l'économie est énorme.

Bolus prend en charge un tas de fonctionnalités intéressantes comme des dépendances optionnelles et de tester des variables globales, mais il y a deux avantages principaux que j'ai vu par rapport à la norme Node.js approche. Tout d'abord, si vous avez beaucoup d'applications similaires, vous pouvez créer un privé mnp module pour votre base qui crée un injecteur et les registres des objets utiles sur elle. Alors vos apps pouvez ajouter, remplacer, et de résoudre, au besoin, comme la façon dont AngularJS est injecteur fonctionne. Deuxièmement, vous pouvez utiliser bolus de gérer les diverses situations de dépendances. Par exemple, vous pourriez utiliser un middleware pour créer un enfant de l'injecteur par demande, enregistrer l'id utilisateur, id de session, enregistreur, etc. sur l'injecteur ainsi que tous les modules en fonction de ceux-ci. Ensuite résoudre ce dont vous avez besoin pour traiter les requêtes. Cela vous donne les instances de vos modules par demande et évite d'avoir à passer l'enregistreur, etc. le long de chaque module à l'appel de la fonction.

J'ai construit L'électrolyte pour cet effet. L'autre injection de dépendance des solutions à l'extérieur, il y avait trop envahissante à mon goût, et de jouer avec le mondial require est un grief donné de la mine.

Électrolyte embrasse modules, en particulier ceux que l'exportation d'un "setup" de la fonction comme vous le voyez dans Connect/Express middleware. Essentiellement, ces types de modules sont juste des usines pour certains, objet de leur retour.

Par exemple, un module qui crée une connexion de base de données:

var mysql = require('mysql');

exports = module.exports = function(settings) {
  var connection = mysql.createConnection({
    host: settings.dbHost,
    port: settings.dbPort
  });

  connection.connect(function(err) {
    if (err) { throw err; }
  });

  return connection;
}

exports['@singleton'] = true;
exports['@require'] = [ 'settings' ];

Ce que vous voyez au fond sont annotations, un bit supplémentaire de métadonnées que l'Électrolyte utilise pour instancier et injecter des dépendances, automatiquement le câblage de votre application à l'ensemble des composants.

Pour créer une connexion de base de données:

var db = electrolyte.create('database');

Électrolyte transitivement traverse la @require'd dépendances, et l'injecte des instances comme arguments de la fonction exportée.

La clé, c'est que ce mini-invasive. Ce module est totalement fonctionnelle, indépendante de l'Électrolyte lui-même. Cela signifie que vos tests unitaires pouvez tester juste le module de test, en passant dans la maquette des objets sans avoir besoin de dépendances supplémentaires à rewire internes.

Lors de l'exécution de la demande complète, l'Électrolyte étapes de l'inter-module de niveau, le câblage des choses ensemble, sans la nécessité pour les variables globales, les singletons ou excessive de la plomberie.

J'ai récemment vérifié ce fil de discussion pour la même raison que l'OP - la plupart des libs que j'ai rencontré temporairement la réécriture de la directive require. J'ai eu des degrés de succès avec cette méthode, et j'ai donc fini par utiliser l'approche suivante.

Dans le contexte d'une demande expresse - je wrap app.js dans un bootstrap.js fichier:

var path = require('path');
var myapp = require('./app.js');

var loader = require('./server/services/loader.js');

//give the loader the root directory
//and an object mapping module names 
//to paths relative to that root
loader.init(path.normalize(__dirname), require('./server/config/loader.js')); 

myapp.start();

L'objet de la carte réussi à le chargeur ressemble à ceci:

//live loader config
module.exports = {
    'dataBaseService': '/lib/dataBaseService.js'
}

//test loader config
module.exports = {
    'dataBaseService': '/mocks/dataBaseService.js'
    'otherService' : {other: 'service'} //takes objects too...
};

Alors, plutôt que l'appel direct d'exiger...

var myDatabaseService = loader.load('dataBaseService');

Si aucun alias n'est situé dans le chargeur - alors, il va juste valeur par défaut à la régularité de l'exiger.
Ceci a deux avantages: je peux échanger dans n'importe quelle version de la classe, et il supprime la nécessité
pour utiliser un chemin relatif noms tout au long de l'application (donc Si j'ai besoin d'un custom lib ci-dessous
ou au-dessus de l'actuel fichier, je n'ai pas besoin de traverser, et nécessitent la mise en cache sera le module contre la même clé). Il me permet également de spécifier les objets fantaisie à n'importe quel point dans l'application, plutôt que dans l'immédiat suite de tests.

J'ai tout juste de publier un petit module npm pour plus de commodité:

https://npmjs.org/package/nodejs-simple-loader

Pour ES6 j'ai développé ce conteneur
https://github.com/zazoomauro/node-dependency-injection

import {ContainerBuilder} from 'node-dependency-injection'

let container = new ContainerBuilder()
container.register('mailer', 'Mailer')

Ensuite, vous pouvez définir, par exemple, le choix de transport du conteneur:

import {ContainerBuilder} from 'node-dependency-injection'

let container = new ContainerBuilder()
container
  .register('mailer', 'Mailer')
  .addArgument('sendmail')

Cette classe est maintenant beaucoup plus souple que vous avez séparé le choix de transport de la mise en œuvre et dans le récipient.

Maintenant que le service mailer est dans le conteneur que vous pouvez injecter en tant que dépendance d'autres classes. Si vous avez un NewsletterManager classe comme ceci:

class NewsletterManager {
    construct (mailer, fs) {
        this._mailer = mailer
        this._fs = fs
    }
}

export default NewsletterManager

Lors de la définition de la newsletter_manager a service, le service mailer n'existe pas encore. Utilisation de la classe de Référence à dire le récipient pour injecter le service mailer lorsqu'il initialise le gestionnaire de newsletter:

import {ContainerBuilder, Reference, PackageReference} from 'node-dependency-injection'
import Mailer from './Mailer'
import NewsletterManager from './NewsletterManager'

let container = new ContainerBuilder()

container
  .register('mailer', Mailer)
  .addArgument('sendmail')

container
  .register('newsletter_manager', NewsletterManager)
  .addArgument(new Reference('mailer'))
  .addArgument(new PackageReference('fs-extra'))

Vous pouvez également configurer le conteneur avec des fichiers de configuration comme Yaml, Json ou JS fichiers

Le conteneur de service peut être compilé pour plusieurs raisons. Ces raisons comprennent la vérification de tout les problèmes potentiels tels que les références circulaires et de faire le conteneur plus efficace.

container.compile()

Je pense que nous avons encore besoin de l'Injection de Dépendance dans Nodejs parce qu'il desserre les dépendances entre les services et de faire une demande de plus en plus clairement.

Inspiré par Spring Framework, j'ai aussi implémenter mon propre module de soutien de l'injection de dépendances dans Nodejs. Mon module est également capable de détecter la code changes et auto reload les services sans redémarrer votre application.

Visiter mon projet: Buncha - conteneur IoC

Merci!

Ont un coup d'oeil à dips (Un simple mais puissant de l'injection de dépendances et de l'entité (fichier) cadre de gestion pour Node.js)

https://github.com/devcrust/node-dips

J'ai récemment créé une bibliothèque appelée circuitbox qui vous permet d'utiliser l'injection de dépendance avec node.js. Il n'vrai injection de dépendance contre de nombreux de la dépendance de la recherche basée sur les bibliothèques que j'ai vu. Circuitbox soutient également la création asynchrone et les routines d'initialisation. Ci-dessous est un exemple:

Assumer le code suivant dans un fichier appelé consoleMessagePrinter.js

'use strict';

//Our console message printer
//deps is injected by circuitbox with the dependencies
function ConsoleMessagePrinter(deps) {
  return {
    print: function () {
      console.log(deps.messageSource.message());
    }
  };
}

module.exports = ConsoleMessagePrinter;

Supposons que celui-ci est dans le fichier main.js

'use strict';

//our simple message source
//deps is injected by circuitbox with the dependencies
var simpleMessageSource = function (deps) {
  return {
    message: function () {
      return deps.message;
    }
  };
};

//require circuitbox
var circuitbox = require('../lib');

//create a circuitbox
circuitbox.create({
  modules: [
    function (registry) {
      //the message to be used
      registry.for('message').use('This is the message');

      //define the message source
      registry.for('messageSource').use(simpleMessageSource)
        .dependsOn('message');

      //define the message printer - does a module.require internally
      registry.for('messagePrinter').requires('./consoleMessagePrinter')
        .dependsOn('messageSource');
    }
  ]
}).done(function (cbx) {

  //get the message printer and print a message
  cbx.get('messagePrinter').done(function (printer) {
    printer.print();
  }, function (err) {
    console.log('Could not recieve a printer');
    return;
  });

}, function (err) {
  console.log('Could not create circuitbox');
});

Circuitbox vous permet de définir vos composants et de déclarer les dépendances entre les modules. Une fois initialisé, il vous permet de récupérer un composant. Circuitbox injecte automatiquement tous les éléments le composant cible implique et donne à vous pour utiliser.

Le projet est en version alpha. Vos commentaires, idées et commentaires sont les bienvenus.

Espère que cela aide!

Il devrait être flexible et simple comme ceci:

var MyClass1 = function () {}
var MyClass2 = function (myService1) {
    //myService1.should.be.instanceof(MyClass1); 
}


container.register('myService1', MyClass1);
container.register('myService2', MyClass2, ['myService1']);

J'ai écrit l'article sur l'Injection de Dépendance dans node.js.

• Gestion de vos services —node.js l'injection de dépendance
• La documentation du paquet ici

J'espère que cela peut vous aider avec ceci.

J'ai développé une bibliothèque qui gère l'injection de dépendance avec une manière simple, ce qui diminue le code réutilisable. Chaque module est défini par un nom unique et une fonction de contrôleur. Les paramètres du contrôleur reflète le module de dépendances.

Lire plus sur KlarkJS

Bref exemple:

KlarkModule(module, 'myModuleName1', function($nodeModule1, myModuleName2) {
    return {
        log: function() { console.log('Hello from module myModuleName1') }
    };
});

• myModuleName1 est le nom du module.
• $nodeModule1 est une bibliothèque externe de node_module. Le nom correspond à node-module1. Le préfixe $ indique que c'est un module externe.
• myModuleName2 est le nom d'un module interne.
• La valeur de retour du contrôleur est utilisé à partir d'autres modules internes, lorsqu'ils définissent le paramètre myModuleName1.

J'ai travaillé avec .Net, PHP et Java pour le temps long donc je voulais avoir une pratique de l'Injection de Dépendances dans NodeJS trop. Les gens, a déclaré le haut-DI dans NodeJS est assez comme nous pouvons l'obtenir avec le Module. Mais il ne me satisfont pas bien. Je voulais garder un Module de pas plus d'une Classe. En outre, je voulais que le DI d'avoir un support complet pour le Module de gestion du cycle de vie (singleton module, transitoire module etc.) mais avec le Noeud module, j'ai eu à écrire du code manuel, très souvent. Enfin, je voulais faire de l'Unité de Test plus facile. C'est pourquoi j'ai créé une Injection de Dépendance pour moi.

Si vous êtes à la recherche d'un DI, lui donner un essai. Il peut être trouvé ici: https://github.com/robo-creative/nodejs-robo-container. Il est entièrement documenté. Il aborde également certains des problèmes communs à la DI et de la façon de les résoudre en POO façon. Espérons que cela aide.