{{ "containerServices" | trans() }}
The services container is an entity that can regitrer services and parameters .
its main interest is to have access to these resources from all over the code.
Services Container also manages scopes . The notion of scope is a word recuperated from symfony2 . (deprecated in symfony3) It can not be the right word (scope) in nodefony ! In Nodefony a scope is a clone of container itself that you can change without alter this one
You can see here :
Create Container :
#!/usr/bin/env node
const nodefony = require("nodefony");
// CREATE INSTANCE OF CONTAINER
const globalContainer = new nodefony.Container() ;
// YOU CAN REGISTER INSTANCE HERSELF HAS SERVICES
globalContainer.set("global", globalContainer);
console.log( globalContainer) ;
/*
Container {
protoService: [Function: protoService],
protoParameters: [Function: protoParameters],
id: 'L-uRMqnd-',
scope: {},
services: protoService {},
parameters: protoParameters {}
}
*/
IN NODEFONY FRAMEWORK :
The kernel instanciate a global container who manage all services in application.
The Kernel is declared as a service in global container .
The global container itself is declared as a service by the kernel .
Getter and Setter Service in Container
You can define an entity as service with set method of container (or scope)
It is important to add as a service only instance of class
Example to set as a service :
The container core have set method to register as service
#!/usr/bin/env node
const nodefony = require("nodefony");
// CREATE INSTANCE OF CONTAINER
const globalContainer = new nodefony.Container() ;
// CREATE CLASSS TO ADD
const myClass = class myClass {
constructor() {
this.settings = {
foo: "bar"
};
}
getConfig() {
return this.settings;
}
};
// SET INSTANCE AS SERVICE TO CONTAINER
globalContainer.set("myService", new myClass());
// GET SERVICE
let service = globalContainer.get("myService");
// USE
let config = service.getConfig();
console.log(config)
// { foo: 'bar' }
IN NODEFONY FRAMEWORK :
Nodefony Kernel create an instance of container who registre all services existing in config (Global container).
The injection service read config file service.xml to add services in container
Getter and Setter Parameters in Container
#!/usr/bin/env node
const nodefony = require("nodefony");
// CREATE INSTANCE OF CONTAINER
const globalContainer = new nodefony.Container();
// SET PARAMATERS IN CONTAINER
let myObject = {
foo:"bar",
bar:"foo"
}
globalContainer.setParameters( "config", myObject );
// GET PARAMETERS
let config = globalContainer.getParameters("config");
console.log(config);
//{ foo: 'bar', bar: 'foo' }
// GET PARAMETERS AS TREE
let foo = globalContainer.getParameters("config.foo");
console.log(foo)
// bar
Scope :
The scope of the container is a clever clone that allows you to add services without changing its parent container. Also the scope inherits all the changes of the parent . You can use scope like container (set , get ...) a scope is a container .
Create Scope
#!/usr/bin/env node
const nodefony = require("nodefony");
// CREATE INSTANCE OF CONTAINER
const globalContainer = new nodefony.Container();
// CREATE SCOPE WITH NAME
globalContainer.addScope("request");
// enterScope CLONE ;
let scope = globalContainer.enterScope("request");
// now varaible scope is a clone of globalContainer
console.log( scope ) ;
/*
Scope {
protoService: [Function: protoService],
protoParameters: [Function: protoParameters],
id: '1ojktuxzeD',
scope: { request: { '1ojktuxzeD': [Circular] } },
services: protoService {},
parameters: protoParameters {},
name: 'request',
parent:
Container {
protoService: [Function: protoService],
protoParameters: [Function: protoParameters],
id: 'H4fKie8Dg',
scope: { request: [Object] },
services: protoService {},
parameters: protoParameters {}
}
}
*/
console.log( globalContainer ) ;
/*
Container {
protoService: [Function: protoService],
protoParameters: [Function: protoParameters],
id: 'H4fKie8Dg',
scope: { request: { '1ojktuxzeD': [Scope] } },
services: protoService {},
parameters: protoParameters {}
}
*/
HttpKernel create a scope of kernel container (scope named : request ) and clone container on each request .
Leave Scope
#!/usr/bin/env node
const nodefony = require("nodefony");
// CREATE INSTANCE OF CONTAINER
const globalContainer = new nodefony.Container();
// CREATE SCOPE WITH NAME
globalContainer.addScope("request");
// enterScope CLONE1 ;
let scope1 = globalContainer.enterScope("request");
// enterScope CLONE2
let scope2 = globalContainer.enterScope("request");
console.log( globalContainer )
/*
Container {
protoService: [Function: protoService],
protoParameters: [Function: protoParameters],
id: '3JCOFJ1-S',
scope: { request: { eot34LdiAt: [Scope], DWKw457OzD: [Scope] } },
services: protoService {},
parameters: protoParameters {}
}
*/
// to detach scope1 to container
globalContainer.leaveScope(scope1) ;
console.log( globalContainer )
/*
Container {
protoService: [Function: protoService],
protoParameters: [Function: protoParameters],
id: '3JCOFJ1-S',
scope: { request: { DWKw457OzD: [Scope] } },
services: protoService {},
parameters: protoParameters {}
}
*/
// to detach scope2 to container
globalContainer.leaveScope(scope2) ;
console.log( globalContainer );
/*
Container {
protoService: [Function: protoService],
protoParameters: [Function: protoParameters],
id: '3JCOFJ1-S',
scope: { request: {} },
services: protoService {},
parameters: protoParameters {}
}
*/
// Now you can enterScope (clone) without call addScope method
Remove Scope
#!/usr/bin/env node
const nodefony = require("nodefony");
// CREATE INSTANCE OF CONTAINER
const globalContainer = new nodefony.Container();
// CREATE SCOPE WITH NAME
globalContainer.addScope("request");
// enterScope CLONE1 ;
let scope1 = globalContainer.enterScope("request");
// enterScope CLONE2
let scope2 = globalContainer.enterScope("request");
console.log( globalContainer )
/*
Container {
protoService: [Function: protoService],
protoParameters: [Function: protoParameters],
id: 'cMQEoM6jA',
scope: { request: { CjELdwMbx2: [Scope], xDw3T85Tr4: [Scope] } },
services: protoService {},
parameters: protoParameters {} }
*/
// to remove all scopes to container and delete
globalContainer.removeScope("request");
console.log( globalContainer )
/*
Container {
protoService: [Function: protoService],
protoParameters: [Function: protoParameters],
id: 'cMQEoM6jA',
scope: {},
services: protoService {},
parameters: protoParameters {}
}
*/
// now who must call addScope method to enterScope
Nodefony Framewok Usage :
Get service in controller:
To use service you must pass by Services Container :
Example to use service in action controller :
The controller core have get method to find a service
footerAction (){
// get kernel service
let kernel = this.get("kernel");
const version = kernel.settings.system.version ;
// get translation service
let translateService = this.get("translation");
let langs = translateService.getLangs();
let locale = translateService.getLocale();
...
}
Get Parameters in controller:
Example to get parameters in controller :
The container core have getParamaters method to get paramaters
formAction (){
// get bundle settings ( Paramaters inherits from global container )
this.httpSettings = this.getParameters("bundles.http");
// get FORM DATA ( Paramaters added by scope (request) )
let query = this.getParameters("query");
...
}
IN Controller the container is a scope ( request ) . The method set and setParameters don't alter the Global Container.
This scope have the lifetime of one request .
If you set service or parameters in scope, the container parent is not affected !!!