setAllowCircularReferences

Set whether to allow circular references between beans - and automatically
try to resolve them.

Note that circular reference resolution means that one of the involved beans
will receive a reference to another bean that is not fully initialized yet.
This can lead to subtle and not-so-subtle side effects on initialization;
it does work fine for many scenarios, though.

Default is "true". Turn this off to throw an exception when encountering
a circular reference, disallowing them completely.

NOTE: It is generally recommended to not rely on circular references
between your beans. Refactor your application logic to have the two beans
involved delegate to a third bean that encapsulates their common logic.

setAllowRawInjectionDespiteWrapping

Set whether to allow the raw injection of a bean instance into some other
bean's property, despite the injected bean eventually getting wrapped
(for example, through AOP auto-proxying).

This will only be used as a last resort in case of a circular reference
that cannot be resolved otherwise: essentially, preferring a raw instance
getting injected over a failure of the entire bean wiring process.

Default is "false", as of Spring 2.0. Turn this on to allow for non-wrapped
raw beans injected into some of your references, which was Spring 1.2's
(arguably unclean) default behavior.

NOTE: It is generally recommended to not rely on circular references
between your beans, in particular with auto-proxying involved.

ignoreDependencyInterface

This will typically be used by application contexts to register
dependencies that are resolved in other ways, like BeanFactory through
BeanFactoryAware or ApplicationContext through ApplicationContextAware.

By default, only the BeanFactoryAware interface is ignored.
For further types to ignore, invoke this method for each type.

copyConfigurationFrom

Should include all standard configuration settings as well as
BeanPostProcessors, Scopes, and factory-specific internal settings.
Should not include any metadata of actual bean definitions,
such as BeanDefinition objects and bean name aliases.

Note: This is intended for creating a fresh instance, populating annotated
fields and methods as well as applying all standard bean initialiation callbacks.
It does not> imply traditional by-name or by-type autowiring of properties;
use AutowireCapableBeanFactory.createBean(Class, int, boolean) for that purposes.

autowire

Instantiate a new bean instance of the given class with the specified autowire
strategy. All constants defined in this interface are supported here.
Can also be invoked with AUTOWIRE_NO in order to just apply
before-instantiation callbacks (e.g. for annotation-driven injection).

autowireBeanProperties

Autowire the bean properties of the given bean instance by name or type.
Can also be invoked with AUTOWIRE_NO in order to just apply
after-instantiation callbacks (e.g. for annotation-driven injection).

applyBeanPropertyValues

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.

This implementation is simplistic in that it is not able to
handle factory methods and InstantiationAwareBeanPostProcessors.
It only predicts the bean type correctly for a standard bean.
To be overridden in subclasses, applying more sophisticated type detection.

getTypeForFactoryBean

This implementation attempts to query the FactoryBean's generic parameter metadata
if present to determine the object type. If not present, i.e. the FactoryBean is
declared as a raw type, checks the FactoryBean's getObjectType method
on a plain instance of the FactoryBean, without bean properties applied yet.
If this doesn't return a type yet, a full creation of the FactoryBean is
used as fallback (through delegation to the superclass's implementation).

The shortcut check for a FactoryBean is only applied in case of a singleton
FactoryBean. If the FactoryBean instance itself is not kept as singleton,
it will be fully created to check the type of its exposed object.

instantiateUsingFactoryMethod

Instantiate the bean using a named factory method. The method may be static, if the
mbd parameter specifies a class, rather than a factoryBean, or an instance variable
on a factory object itself configured using Dependency Injection.

autowireByType

This is like PicoContainer default, in which there must be exactly one bean
of the property type in the bean factory. This makes bean factories simple to
configure for small namespaces, but doesn't work as well as standard Spring
behavior for bigger applications.

Parameters:

beanName - the name of the bean to autowire by type

mbd - the merged bean definition to update through autowiring

bw - BeanWrapper from which we can obtain information about the bean

pvs - the PropertyValues to register wired objects with

unsatisfiedNonSimpleProperties

Return an array of non-simple bean properties that are unsatisfied.
These are probably unsatisfied references to other beans in the
factory. Does not include simple properties like primitives or Strings.

invokeInitMethods

Give a bean a chance to react now all its properties are set,
and a chance to know about its owning bean factory (this object).
This means checking whether the bean implements InitializingBean or defines
a custom init method, and invoking the necessary callback(s) if it does.

Parameters:

beanName - the bean name in the factory (for debugging purposes)

bean - the new bean instance we may need to initialize

mbd - the merged bean definition that the bean was created with
(can also be null, if given an existing bean instance)