Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.beans.factory.config
Interface AutowireCapableBeanFactory

All Superinterfaces:
  BeanFactory

All Known Subinterfaces:
  ConfigurableListableBeanFactory

All Known Implementing Classes:
  AbstractAutowireCapableBeanFactory, DefaultListableBeanFactory, XmlBeanFactory

    public interface AutowireCapableBeanFactory

extends BeanFactory

Extension of the `BeanFactory` interface to be implemented by bean factories that are capable of autowiring, provided that they want to expose this functionality for existing bean instances.

This subinterface of BeanFactory is not meant to be used in normal application code: stick to `BeanFactory` or `ListableBeanFactory` for typical use cases.

Integration code for other frameworks can leverage this interface to wire and populate existing bean instances that Spring does not control the lifecycle of. This is particularly useful for WebWork Actions and Tapestry Page objects, for example.

Note that this interface is not implemented by `ApplicationContext` facades, as it is hardly ever used by application code. That said, it is available from an application context too, accessible through ApplicationContext's `ApplicationContext.getAutowireCapableBeanFactory()` method.

You may also implement the `BeanFactoryAware` interface, which exposes the internal BeanFactory even when running in an ApplicationContext, to get access to an AutowireCapableBeanFactory: simply cast the passed-in BeanFactory to AutowireCapableBeanFactory.

Since:
  04.12.2003
Author:
  Juergen Hoeller
See Also:
  `BeanFactoryAware`, `ConfigurableListableBeanFactory`, `ApplicationContext.getAutowireCapableBeanFactory()`

Field Summary
`static int` | `AUTOWIRE_AUTODETECT` Constant that indicates determining an appropriate autowire strategy through introspection of the bean class.
`static int` | `AUTOWIRE_BY_NAME` Constant that indicates autowiring bean properties by name.
`static int` | `AUTOWIRE_BY_TYPE` Constant that indicates autowiring bean properties by type.
`static int` | `AUTOWIRE_CONSTRUCTOR` Constant that indicates autowiring a constructor.
`static int` | `AUTOWIRE_NO` Constant that indicates no autowiring at all (other than callbacks such as BeanFactoryAware).

Fields inherited from interface org.springframework.beans.factory.BeanFactory
`FACTORY_BEAN_PREFIX`

Method Summary
`Object` | `applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)` Apply `BeanPostProcessors` to the given existing bean instance, invoking their `postProcessAfterInitialization` methods.
`Object` | `applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)` Apply `BeanPostProcessors` to the given existing bean instance, invoking their `postProcessBeforeInitialization` methods.
`void` | `applyBeanPropertyValues(Object existingBean, String beanName)` Apply the property values of the bean definition with the given name to the given bean instance.
`Object` | `autowire(Class beanClass, int autowireMode, boolean dependencyCheck)` Instantiate a new bean instance of the given class with the specified autowire strategy.
`void` | `autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)` Autowire the bean properties of the given bean instance by name or type.
`Object` | `configureBean(Object existingBean, String beanName)` Configure the given bean instance: autowiring bean properties, applying bean property values, applying factory callbacks such as `setBeanName` and `setBeanFactory`, and also applying all bean post processors.
`Object` | `createBean(Class beanClass, int autowireMode, boolean dependencyCheck)` Fully create a new bean instance of the given class with the specified autowire strategy.
`Object` | `initializeBean(Object existingBean, String beanName)` Initialize the given bean instance, applying factory callbacks such as `setBeanName` and `setBeanFactory`, also applying all bean post processors.

Methods inherited from interface org.springframework.beans.factory.BeanFactory
`containsBean, getAliases, getBean, getBean, getType, isPrototype, isSingleton, isTypeMatch`

Field Detail

### AUTOWIRE_NO

    static final int AUTOWIRE_NO

  Constant that indicates no autowiring at all (other than callbacks such as BeanFactoryAware).

  See Also:
    `createBean(java.lang.Class, int, boolean)`, `autowire(java.lang.Class, int, boolean)`, `autowireBeanProperties(java.lang.Object, int, boolean)`, Constant Field Values

### AUTOWIRE_BY_NAME

    static final int AUTOWIRE_BY_NAME

  Constant that indicates autowiring bean properties by name.

  See Also:
    `createBean(java.lang.Class, int, boolean)`, `autowire(java.lang.Class, int, boolean)`, `autowireBeanProperties(java.lang.Object, int, boolean)`, Constant Field Values

### AUTOWIRE_BY_TYPE

    static final int AUTOWIRE_BY_TYPE

  Constant that indicates autowiring bean properties by type.

  See Also:
    `createBean(java.lang.Class, int, boolean)`, `autowire(java.lang.Class, int, boolean)`, `autowireBeanProperties(java.lang.Object, int, boolean)`, Constant Field Values

### AUTOWIRE_CONSTRUCTOR

    static final int AUTOWIRE_CONSTRUCTOR

  Constant that indicates autowiring a constructor.

  See Also:
    `createBean(java.lang.Class, int, boolean)`, `autowire(java.lang.Class, int, boolean)`, Constant Field Values

### AUTOWIRE_AUTODETECT

    static final int AUTOWIRE_AUTODETECT

  Constant that indicates determining an appropriate autowire strategy through introspection of the bean class.

  See Also:
    `createBean(java.lang.Class, int, boolean)`, `autowire(java.lang.Class, int, boolean)`, Constant Field Values

Method Detail

### createBean

    Object createBean(Class beanClass,
                      int autowireMode,
                      boolean dependencyCheck)
                      throws BeansException

  Fully create a new bean instance of the given class with the specified autowire strategy. All constants defined in this interface are supported here.

  Performs full initialization of the bean, including all applicable `BeanPostProcessors`.

  Parameters:
    `beanClass` - the class of the bean to create
    `autowireMode` - by name or type, using the constants in this interface
    `dependencyCheck` - whether to perform a dependency check for objects (not applicable to autowiring a constructor, thus ignored there)
  Returns:
    the new bean instance
  Throws:
    `BeansException` - if instantiation or wiring failed
  See Also:
    `AUTOWIRE_NO`, `AUTOWIRE_BY_NAME`, `AUTOWIRE_BY_TYPE`, `AUTOWIRE_CONSTRUCTOR`, `AUTOWIRE_AUTODETECT`

### autowire

    Object autowire(Class beanClass,
                    int autowireMode,
                    boolean dependencyCheck)
                    throws BeansException

  Instantiate a new bean instance of the given class with the specified autowire strategy. All constants defined in this interface are supported here.

  Does not apply any `BeanPostProcessors` or perform any further initialization of the bean. This interface offers distinct, fine-grained operations for those purposes, for example `initializeBean(java.lang.Object, java.lang.String)`.

  Parameters:
    `beanClass` - the class of the bean to instantiate
    `autowireMode` - by name or type, using the constants in this interface
    `dependencyCheck` - whether to perform a dependency check for object references in the bean instance (not applicable to autowiring a constructor, thus ignored there)
  Returns:
    the new bean instance
  Throws:
    `BeansException` - if instantiation or wiring failed
  See Also:
    `AUTOWIRE_NO`, `AUTOWIRE_BY_NAME`, `AUTOWIRE_BY_TYPE`, `AUTOWIRE_CONSTRUCTOR`, `AUTOWIRE_AUTODETECT`, `initializeBean(java.lang.Object, java.lang.String)`, `applyBeanPostProcessorsBeforeInitialization(java.lang.Object, java.lang.String)`, `applyBeanPostProcessorsAfterInitialization(java.lang.Object, java.lang.String)`

### autowireBeanProperties

    void autowireBeanProperties(Object existingBean,
                                int autowireMode,
                                boolean dependencyCheck)
                                throws BeansException

  Autowire the bean properties of the given bean instance by name or type.

  Parameters:
    `existingBean` - the existing bean instance
    `autowireMode` - by name or type, using the constants in this interface
    `dependencyCheck` - whether to perform a dependency check for object references in the bean instance
  Throws:
    `BeansException` - if wiring failed
  See Also:
    `AUTOWIRE_BY_NAME`, `AUTOWIRE_BY_TYPE`

### applyBeanPropertyValues

    void applyBeanPropertyValues(Object existingBean,
                                 String beanName)
                                 throws BeansException

  Apply the property values of the bean definition with the given name to the given bean instance. The bean definition can either define a fully self-contained bean, reusing its property values, or just property values meant to be used for existing bean instances.

  Note: This method does not autowire bean properties; it just applies explicitly defined property values. Use the `autowireBeanProperties(java.lang.Object, int, boolean)` method to autowire an existing bean instance.

  Parameters:
    `existingBean` - the existing bean instance
    `beanName` - the name of the bean definition in the bean factory (a bean definition of that name has to be available)
  Throws:
    `NoSuchBeanDefinitionException` - if there is no bean with the given name
    `BeansException` - if applying the property values failed
  See Also:
    `autowireBeanProperties(java.lang.Object, int, boolean)`

### configureBean

    Object configureBean(Object existingBean,
                         String beanName)
                         throws BeansException

  Configure the given bean instance: autowiring bean properties, applying bean property values, applying factory callbacks such as `setBeanName` and `setBeanFactory`, and also applying all bean post processors.

  This is effectively a superset of what `initializeBean` provides, fully applying the configuration specified by the corresponding bean definition.

  Parameters:
    `existingBean` - the existing bean instance
    `beanName` - the name of the bean, to be passed to it if necessary (a bean definition of that name has to be available)
  Returns:
    the bean instance to use, either the original or a wrapped one
  Throws:
    `NoSuchBeanDefinitionException` - if there is no bean with the given name
    `BeansException` - if the initialization failed
  See Also:
    `initializeBean(java.lang.Object, java.lang.String)`

### initializeBean

    Object initializeBean(Object existingBean,
                          String beanName)
                          throws BeansException

  Initialize the given bean instance, applying factory callbacks such as `setBeanName` and `setBeanFactory`, also applying all bean post processors.

  Note that no bean definition of the given name has to exist in the bean factory. The passed-in bean name will simply be used for callbacks but not checked against the registered bean definitions.

  Parameters:
    `existingBean` - the existing bean instance
    `beanName` - the name of the bean, to be passed to it if necessary (only passed to `BeanPostProcessors`)
  Returns:
    the bean instance to use, either the original or a wrapped one
  Throws:
    `BeansException` - if the initialization failed

### applyBeanPostProcessorsBeforeInitialization

    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean,
                                                       String beanName)
                                                       throws BeansException

  Apply `BeanPostProcessors` to the given existing bean instance, invoking their `postProcessBeforeInitialization` methods. The returned bean instance may be a wrapper around the original.

  Parameters:
    `existingBean` - the new bean instance
    `beanName` - the name of the bean
  Returns:
    the bean instance to use, either the original or a wrapped one
  Throws:
    `BeansException` - if any post-processing failed
  See Also:
    `BeanPostProcessor.postProcessBeforeInitialization(java.lang.Object, java.lang.String)`

### applyBeanPostProcessorsAfterInitialization

    Object applyBeanPostProcessorsAfterInitialization(Object existingBean,
                                                      String beanName)
                                                      throws BeansException

  Apply `BeanPostProcessors` to the given existing bean instance, invoking their `postProcessAfterInitialization` methods. The returned bean instance may be a wrapper around the original.

  Parameters:
    `existingBean` - the new bean instance
    `beanName` - the name of the bean
  Returns:
    the bean instance to use, either the original or a wrapped one
  Throws:
    `BeansException` - if any post-processing failed
  See Also:
    `BeanPostProcessor.postProcessAfterInitialization(java.lang.Object, java.lang.String)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002-2007 The Spring Framework.