Container

Implements: IConfigurable interface, IReferenceable interface, IUnreferenceable interface, IOpenable interface

Description

The Container class allows you to create an inversion of control (IoC) container that creates components and manages their lifecycle.

Important points

• The container is driven by configuration, which is usually stored in a JSON or YAML file.
• The configuration contains a list of components identified by their type or locator, followed by their configuration.
• On start, a container performs the following actions:
  • Creates components using their types or calls registered factories to create them using their locators.
  • Configures components that implement IConfigurable interface and passes them their configuration parameters.
  • Sets references to components that implement IReferenceable interface and passes them references of all components in the container.
  • Opens components that implement IOpenable interface.
• On stop, a container reverses the orden of its actions:
  • Closes components that implement IClosable interface
  • Unsets references in components that implement IUnreferenceable interface
  • Destroys components in the container.

Configuration parameters

• name: context (container or process) name
• description: human-readable description of the context
• properties: section of additional descriptive properties
  • …

Constructors

Creates a new instance of the container.

public Container(String name, String description)

• name: String - (optional) container’s name (accessible via ContextInfo)
• description: String - (optional) container’s description (accessible via ContextInfo)

Fields

Instance methods

addFactory

Adds a factory to the container. The factory is used to create components
added to the container by their locators (descriptors).

public void addFactory(IFactory factory)

• factory: IFactory - component factory to be added.

close

Closes the component and frees used resources.

public void close(IContext context) throws ApplicationException

• context: IContext - (optional) a context to trace execution through call chain.

configure

Configures the component by passing its configuration parameters.

public void configure(ConfigParams config) throws ConfigException

• config: ConfigParams - configuration parameters to be set.

getConfig

Gets the container’s configuration.

public ContainerConfig getConfig()

• returns: ContainerConfig - container’s configuration.

setConfig

Sets the container’s configuration.

public void setConfig(ContainerConfig value)

• value: ContainerConfig - container’s configuration.

isOpen

Checks if the component is open.

public boolean isOpen()

• returns: boolean - True if the component is open and false otherwise.

open

Opens the component.

public void open(IContext context) throws ApplicationException

• context: IContext - (optional) a context to trace execution through call chain.

readConfigFromFile

Reads the container’s configuration from a JSON or YAML file and parameterizes it with the given values.

public void readConfigFromFile(IContext context, String path, ConfigParams parameters) throws ApplicationException

• context: IContext - (optional) a context to trace execution through call chain.
• path: String - path to the configuration file
• parameters: ConfigParams - configuration parameters or null to skip parameterization.

setReferences

Sets references to dependent components.

public void setReferences(IReferences references) throws ReferenceException, ConfigException

• references: IReferences - references to locate the component dependencies.

unsetReferences

Unsets (clears) previously set references to dependent components.

public void unsetReferences()

Examples

======= config.yaml ========
- descriptor: mygroup:mycomponent1:default:default:1.0
param1: 123
param2: ABC
- type: mycomponent2,mypackage
param1: 321
param2: XYZ
============================

{
  Container container = new Container();
  container.addFactory(new MyComponentFactory());
 
  ConfigParams parameters = ConfigParams.fromValue(process.env);
  container.readConfigFromFile("123", "./config/config.yml", parameters);
 
  container.open("123");
  System.out.println("Container is opened");
  ...
  container.close("123");
  System.out.println("Container is closed");
  }

See also

• IConfigurable interface

• IReferenceable interface

• IUnreferenceable interface

• IOpenable interface