closure-dicontainer
Dependency Injection Container for Google Closure Library
- concise api (resolve A as B with C by D)
- automatic types registration
- resolving based on strong types parsed from annotations
- run-time configuration
- advanced mode compilation friendly
Getting Started
This is standalone Node.js module. For Gulp, use gulp-closure-dicontainer.
var diContainer = require('closure-dicontainer');
var src = diContainer(fs.readFileSync(depsPath, {
encoding: 'utf8'
}), {
baseJsDir: 'bower_components/closure-library/closure/goog',
name: 'app.DiContainer',
resolve: ['App']
});
fs.writeFileSync('build/dicontainer.js', src);Options
options.name
Type: String
Default value: 'app.DiContainer'
Generated DI container name.
options.resolve
Type: Array.<string>
Default value: ['App']
Array of types to be resolved.
options.baseJsDir
Type: String
Default value: 'bower_components/closure-library/closure/goog'
Optional
Usage Example
How to use DI container in your app.
/**
@fileoverview App main method.
*/
goog.provide('app.main');
goog.require('app.DiContainer');
app.main = function() {
var container = new app.DiContainer;
container.configure({
// Inject run-time value when App is going to be instantiated.
resolve: App,
"with": {
// This is parameter name.
element: document.body
}
}, {
// Resolve something with something else.
resolve: este.storage.Storage,
as: este.storage.Local
}, {
// Custom factory when new keyword is not enough.
resolve: foo.ui.Lightbox,
by: function(lightbox) {
return lightbox.setSomething();
}
}, {
// Resolve interface by something real.
resolve: foo.IFoo,
by: function() {
return new foo.Foo;
}
});
var app = container.resolveApp();
app.start();
};
goog.exportSymbol('app.main', app.main);Container Configuration
There is a pattern: Resolve A as B with C by D.
A is type to be resolved. B is optional type to be returned. C is optional object for run-time configuration, where key is argument name and value is runtime value. D is optional factory method.
Enjoy in action in Este.js.
So how does it really work?
It's simple. DI container loads deps.js file. Then it needs to know where resolving should start, aka which type should be resolved. For instance: foo.App. DI container then parse foo.App constructor, and create factories for all passed types. Then it do the same thing with all passed instances. The result is JavaScript file containing all these goog.require's and factories for required types. Default life style is singleton (the good one, because instance does not control own life cycle).
After DI container file creation, deps.js must be updated, which is task for dev stack. Everything will be available in Este.js soon.