Package org.picocontainer.injectors

# Class FactoryInjector<T>

java.lang.Object
org.picocontainer.injectors.FactoryInjector<T>

All Implemented Interfaces:
  `ComponentAdapter<T>`, `Injector<T>`

public abstract class FactoryInjector<T> extends Object implements Injector<T>

An Injector which provides an custom instance in a factory style

Author:
  Paul Hammant

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static class`
`FactoryInjector.CantWorkItOut`

## Nested classes/interfaces inherited from interface org.picocontainer.ComponentAdapter

`ComponentAdapter.NOTHING`

## Constructor Summary

Constructors
Constructor
Description
`FactoryInjector()`
`FactoryInjector(Class<T> key)`

## Method Summary

Modifier and Type
Method
Description
`void`
`accept(PicoVisitor visitor)`
Accepts a visitor for this ComponentAdapter.
`boolean`
`componentHasLifecycle()`
`Object`
`decorateComponentInstance(PicoContainer container, Type into, T instance)`
A preexiting component instance can be injected into after instantiation
`void`
`dispose(PicoContainer container)`
`<U extends ComponentAdapter>
U`
`findAdapterOfType(Class<U> adapterType)`
Locates a component adapter of type componentAdapterType in the ComponentAdapter chain.
`static Class<?>`
`getClass(Type type)`
`Class<? extends T>`
`getComponentImplementation()`
Retrieve the class of the component.
`T`
`getComponentInstance(PicoContainer container)`
Retrieve the component instance.
`abstract T`
`getComponentInstance(PicoContainer container, Type into)`
Retrieve the component instance.
`Object`
`getComponentKey()`
Retrieve the key associated with the component.
`ComponentAdapter<T>`
`getDelegate()`
Component adapters may be nested in a chain, and this method is used to grab the next ComponentAdapter in the chain.
`String`
`getDescriptor()`
Get a string key descriptor of the component adapter for use in toString()
`static <T> List<Class<?>>`
`getTypeArguments(Class<FactoryInjector> class1, Class<? extends Object> class2)`
Get the actual type arguments a child class has used to extend a generic base class.
`void`
`start(PicoContainer container)`
`void`
`stop(PicoContainer container)`
`void`
`verify(PicoContainer container)`
Verify that all dependencies for this adapter can be satisfied.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### FactoryInjector

public FactoryInjector() throws PicoCompositionException

Throws:
  `PicoCompositionException`

### FactoryInjector

public FactoryInjector(Class<T> key)

## Method Details

### getClass

public static Class<?> getClass(Type type)

### getTypeArguments

public static <T> List<Class<?>> getTypeArguments(Class<FactoryInjector> class1, Class<? extends Object> class2)
Get the actual type arguments a child class has used to extend a generic base class.

Parameters:
  `class1` - the base class
  `class2` - the child class
Returns:
  a list of the raw classes for the actual type arguments.

### getComponentKey

public Object getComponentKey()
Description copied from interface: `ComponentAdapter`
Retrieve the key associated with the component.

Specified by:
  `getComponentKey` in interface `ComponentAdapter<T>`
Returns:
  the component's key. Should either be a class type (normally an interface) or an identifier that is unique (within the scope of the current PicoContainer).

### getComponentImplementation

public Class<? extends T> getComponentImplementation()
Description copied from interface: `ComponentAdapter`
Retrieve the class of the component.

Specified by:
  `getComponentImplementation` in interface `ComponentAdapter<T>`
Returns:
  the component's implementation class. Should normally be a concrete class (ie, a class that can be instantiated).

### accept

public void accept(PicoVisitor visitor)
Description copied from interface: `ComponentAdapter`
Accepts a visitor for this ComponentAdapter. The method is normally called by visiting a `PicoContainer`, that cascades the visitor also down to all its ComponentAdapter instances.

Specified by:
  `accept` in interface `ComponentAdapter<T>`
Parameters:
  `visitor` - the visitor.

### getDelegate

public ComponentAdapter<T> getDelegate()
Description copied from interface: `ComponentAdapter`
Component adapters may be nested in a chain, and this method is used to grab the next ComponentAdapter in the chain.

Specified by:
  `getDelegate` in interface `ComponentAdapter<T>`
Returns:
  the next component adapter in line or null if there is no delegate ComponentAdapter.

### findAdapterOfType

public <U extends ComponentAdapter> U findAdapterOfType(Class<U> adapterType)
Description copied from interface: `ComponentAdapter`
Locates a component adapter of type componentAdapterType in the ComponentAdapter chain. Will return null if there is no adapter of the given type.

Specified by:
  `findAdapterOfType` in interface `ComponentAdapter<T>`
Type Parameters:
  `U` - the type of ComponentAdapter being located.
Parameters:
  `adapterType` - the class of the adapter type being located. Never null.
Returns:
  the appropriate component adapter of type U. May return null if the component adapter type is not returned.

### getComponentInstance

public T getComponentInstance(PicoContainer container)
Description copied from interface: `ComponentAdapter`
Retrieve the component instance. This method will usually create a new instance each time it is called, but that is not required. For example, `Cached` will always return the same instance.

Specified by:
  `getComponentInstance` in interface `ComponentAdapter<T>`
Parameters:
  `container` - the `PicoContainer`, that is used to resolve any possible dependencies of the instance.
Returns:
  the component instance.

### getComponentInstance

public abstract T getComponentInstance(PicoContainer container, Type into)
Description copied from interface: `ComponentAdapter`
Retrieve the component instance. This method will usually create a new instance each time it is called, but that is not required. For example, `Cached` will always return the same instance.

Specified by:
  `getComponentInstance` in interface `ComponentAdapter<T>`
Parameters:
  `container` - the `PicoContainer`, that is used to resolve any possible dependencies of the instance.
  `into` - the class that is about to be injected into. Use ComponentAdapter.NOTHING.class if this is not important to you.
Returns:
  the component instance.

### decorateComponentInstance

public Object decorateComponentInstance(PicoContainer container, Type into, T instance)
Description copied from interface: `Injector`
A preexiting component instance can be injected into after instantiation

Specified by:
  `decorateComponentInstance` in interface `Injector<T>`
Parameters:
  `container` - the container that can provide injectable dependencies
  `into` -
  `instance` - the instance to
Returns:

### verify

public void verify(PicoContainer container)
Description copied from interface: `ComponentAdapter`
Verify that all dependencies for this adapter can be satisfied. Normally, the adapter should verify this by checking that the associated PicoContainer contains all the needed dependencies.

Specified by:
  `verify` in interface `ComponentAdapter<T>`
Parameters:
  `container` - the `PicoContainer`, that is used to resolve any possible dependencies of the instance.

### getDescriptor

public String getDescriptor()
Description copied from interface: `ComponentAdapter`
Get a string key descriptor of the component adapter for use in toString()

Specified by:
  `getDescriptor` in interface `ComponentAdapter<T>`
Returns:
  the descriptor

### start

public void start(PicoContainer container)

### stop

public void stop(PicoContainer container)

### dispose

public void dispose(PicoContainer container)

### componentHasLifecycle

public boolean componentHasLifecycle()