Package org.apache.struts2.inject

# Interface Container

All Superinterfaces:
  `Serializable`

All Known Implementing Classes:
  `MockContainer`

public interface Container extends Serializable

Injects dependencies into constructors, methods and fields annotated with `Inject`. Immutable.

When injecting a method or constructor, you can additionally annotate its parameters with `Inject` and specify a dependency name. When a parameter has no annotation, the container uses the name from the method or constructor's `Inject` annotation respectively.

For example:

      class Foo {

        // Inject the int constant named "i".
        @Inject("i") int i;

        // Inject the default implementation of Bar and the String constant
        // named "s".
        @Inject Foo(Bar bar, @Inject("s") String s) {
          ...
        }

        // Inject the default implementation of Baz and the Bob implementation
        // named "foo".
        @Inject void initialize(Baz baz, @Inject("foo") Bob bob) {
          ...
        }

        // Inject the default implementation of Tee.
        @Inject void setTee(Tee tee) {
          ...
        }
      }

To create and inject an instance of `Foo`:

      Container c = ...;
      Foo foo = c.inject(Foo.class);

Author:
  crazybob@google.com (Bob Lee)
See Also:
  - `ContainerBuilder`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final String`
  `DEFAULT_NAME`
  Default dependency name.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `<T> T`
  `getInstance(Class<T> type)`
  Convenience method. Equivalent to `getInstance(type, DEFAULT_NAME)`.
  `<T> T`
  `getInstance(Class<T> type, String name)`
  Gets an instance of the given dependency which was declared in `ContainerBuilder`.
  `Set<String>`
  `getInstanceNames(Class<?> type)`
  Gets a set of all registered names for the given type
  `<T> T`
  `inject(Class<T> implementation)`
  Creates and injects a new instance of type `implementation`.
  `void`
  `inject(Object o)`
  Injects dependencies into the fields and methods of an existing object.
  `void`
  `removeScopeStrategy()`
  Removes the scope strategy for the current thread.
  `void`
  `setScopeStrategy(Scope.Strategy scopeStrategy)`
  Sets the scope strategy for the current thread.

- ## Field Details

  - ### DEFAULT_NAME

    static final String DEFAULT_NAME
    Default dependency name.
    See Also:
      - Constant Field Values

- ## Method Details

  - ### inject

    void inject(Object o)
    Injects dependencies into the fields and methods of an existing object.
    Parameters:
      `o` - object to inject

  - ### inject

    <T> T inject(Class<T> implementation)
    Creates and injects a new instance of type `implementation`.
    Type Parameters:
      `T` - type
    Parameters:
      `implementation` - of dependency
    Returns:
      instance

  - ### getInstance

    <T> T getInstance(Class<T> type, String name)
    Gets an instance of the given dependency which was declared in `ContainerBuilder`.
    Type Parameters:
      `T` - type
    Parameters:
      `type` - of dependency
      `name` - of dependency
    Returns:
      instance

  - ### getInstance

    <T> T getInstance(Class<T> type)
    Convenience method. Equivalent to `getInstance(type, DEFAULT_NAME)`.
    Type Parameters:
      `T` - type
    Parameters:
      `type` - of dependency
    Returns:
      instance

  - ### getInstanceNames

    Set<String> getInstanceNames(Class<?> type)
    Gets a set of all registered names for the given type
    Parameters:
      `type` - The instance type
    Returns:
      A set of registered names or empty set if no instances are registered for that type

  - ### setScopeStrategy

    void setScopeStrategy(Scope.Strategy scopeStrategy)
    Sets the scope strategy for the current thread.
    Parameters:
      `scopeStrategy` - scope strategy

  - ### removeScopeStrategy

    void removeScopeStrategy()
    Removes the scope strategy for the current thread.