Generation of S2Container is carried out by the "create" method of S2ApplicationContext class.

require 's2container'
container = Seasar::Container::S2ApplicationContext.instance.create

By using the s2app method which returns S2ApplicationContext instance, S2Container is generable as follows.

require 's2container'
container = s2app.create

The following method is used in order to take out a component from S2Container.

S2Container#get_component(component_key)

The class name or component name of a component is specified as an argument.
When there are two or more components which indicates the class specified in S2Container, Since S2Container cannot judge which component should be returned, it carries out a raise of the exception "TooManyRegistrationRuntimeException". Therefore, please specify the class name it is decided uniquely that a component will be.
It is also the same as when taking out a component by a component name.

As an example, The following classes are defined. A component name is set up by a character string and Symbol by the argument of the s2component method.

module Example
  class IndexAction
    s2component :name => "index"
  end

  class TopAction
    s2component :name => :top
  end

  class ResultAction
    s2component
  end
end

It is as follows, when specifying a component name by a character string and getting a component.

require 's2container'
require 'example'
container = s2app.create
component = container.get_component("index")

It is as follows, when specifying a component by Class and getting a component. The component method is alias of the get_component method.

component = container.component(Example::IndexAction)

It is as follows, when specifying a component by Symbol and getting a component. The get method is alias of the get_component method.

component = container.get(:top)

[] can also be used as a method which gets a component from S2Contaienr.

component = container[Example::ResultAction]

	NOTE
	This Example is located at "example/example01".

Dependency Injection of S2Container is the property injection by automatic binding. Instance variables and accessor methods are treated as a property. Automatic binding solves the dependency between components by the property name and by the class and component name which are specified by the default value of a property.

Let's define following classes. The constructor (initialize method) of Action class defines instance variables. The dependence information on Action and Service component is set up as a default value of an instance variable. Moreover, since the attr_accessor method defines the property "d", the component named "d" will be injected.

module Example
  class Action
    s2comp
    def initialize
      @a = nil
      @b = :di, "x.y.z.service_b"
      @c = :di, ServiceC
      @x_ = nil
      @_x = nil
    end
    attr_reader :a, :b, :c
    attr_accessor :d
  end

  class ServiceA
    s2comp :name => :a
  end

  class ServiceB
    s2comp :name => "service_b", :namespace => "x.y.z"
  end

  class ServiceC
    s2comp
  end

  class ServiceD
    s2comp :name => :d
  end
end

Please create the following executable files. when Action component is taken out from S2Container, Dependent Service component will be injected to the instance variables of the Action component.

require 's2container'
require 'example'

container = s2app.create
component = container[Example::Action]

The instance variable to which the underscore was attached a head or behind the variable name is not bound automatically. How to set up the dependency between components by the default value of a property is shown below.

	NOTE
	This Example is located at "example/example02".

Constructor Block is a block which performs generation processing of a component. Constructor Block is set up when registering a component by the s2component method.

Let's define the following classes.

module Example
  class Action
    def initialize(val)
      @val = val
    end
    attr_accessof :val
  end
end

Please create the following executable files. Constructor Block is passed to the s2component method. The evaluation result of the last of Constructor Block must fulfill the relation of is_a? with a component class.

require 's2container'
require 'example'

s2component(:class => Example::Action) {
  Example::Action.new("abc")
} 

container = s2app.create
component = container[Example::Action]
p component.val          # -> "abc" 

	NOTE
	This Example is located at "example/example03".

Constructor Block is a block which performs destroy processing of a component. When the instance setting of the component is ":singleton", thr destructor block is executed. The destructor block is executed in the destroy method of s2container.

Let's define the following classes.

module Example
  class Action
    def init
      s2logger.debug(self.class){"init method called as constructor."}
    end
    def quit
      s2logger.debug(self.class){"quit method called as destructor."}
    end
  end
end

Please create the following executable files. The component is registered by the s2component method. The destructor block is set to the return value(ComponentInfoDef instance) of the s2component method.

require 's2container'
require 'example'

component_info = s2component(:class => Example::Action) {
  # constructor block
  action = Example::Action.new
  action.init
  next action
}

component_info.destructor {|component|
  # destructor block
  component.quit
}

container = s2app.create
container.init                     # call constructor block
container.destroy                  # call destructor block

In S2Container, a binding type can be specified per component.

It is as follows when specifying a binding type by the s2component method.

class Service
  s2component :autobinding => :auto
end

In S2Container, instance management can be specified per component.

It is as follows when specifying an instance type by the s2component method.

class Service
  s2component :instance => :singleton
end