Package org.springframework.beans.factory.support

# Class RootBeanDefinition

java.lang.Object
org.springframework.core.AttributeAccessorSupport
org.springframework.beans.BeanMetadataAttributeAccessor
org.springframework.beans.factory.support.AbstractBeanDefinition
org.springframework.beans.factory.support.RootBeanDefinition

All Implemented Interfaces:
  `Serializable`, `Cloneable`, `BeanMetadataElement`, `BeanDefinition`, `org.springframework.core.AttributeAccessor`

public class RootBeanDefinition extends AbstractBeanDefinition
A root bean definition represents the merged bean definition at runtime that backs a specific bean in a Spring BeanFactory. It might have been created from multiple original bean definitions that inherit from each other, for example, `GenericBeanDefinitions` from XML declarations. A root bean definition is essentially the 'unified' bean definition view at runtime.

Root bean definitions may also be used for registering individual bean definitions in the configuration phase. This is particularly applicable for programmatic definitions derived from factory methods (for example, `@Bean` methods) and instance suppliers (for example, lambda expressions) which come with extra type metadata (see `setTargetType(ResolvableType)`/`setResolvedFactoryMethod(Method)`).

Note: The preferred choice for bean definitions derived from declarative sources (for example, XML definitions) is the flexible `GenericBeanDefinition` variant. GenericBeanDefinition comes with the advantage that it allows for dynamically defining parent dependencies, not 'hard-coding' the role as a root bean definition, even supporting parent relationship changes in the bean post-processor phase.

Author:
  Rod Johnson, Juergen Hoeller, Sam Brannen
See Also:
  - `GenericBeanDefinition`
  - `ChildBeanDefinition`
  - Serialized Form

## Field Summary

### Fields inherited from class org.springframework.beans.factory.support.AbstractBeanDefinition

`AUTOWIRE_AUTODETECT, AUTOWIRE_BY_NAME, AUTOWIRE_BY_TYPE, AUTOWIRE_CONSTRUCTOR, AUTOWIRE_NO, DEPENDENCY_CHECK_ALL, DEPENDENCY_CHECK_NONE, DEPENDENCY_CHECK_OBJECTS, DEPENDENCY_CHECK_SIMPLE, INFER_METHOD, ORDER_ATTRIBUTE, PREFERRED_CONSTRUCTORS_ATTRIBUTE, SCOPE_DEFAULT`

### Fields inherited from interface org.springframework.beans.factory.config.BeanDefinition

`ROLE_APPLICATION, ROLE_INFRASTRUCTURE, ROLE_SUPPORT, SCOPE_PROTOTYPE, SCOPE_SINGLETON`

## Constructor Summary

Constructors
Constructor
Description
`RootBeanDefinition()`
Create a new RootBeanDefinition, to be configured through its bean properties and configuration methods.
`RootBeanDefinition(Class<?> beanClass)`
Create a new RootBeanDefinition for a singleton.
`RootBeanDefinition(Class<?> beanClass, int autowireMode, boolean dependencyCheck)`
Create a new RootBeanDefinition for a singleton, using the given autowire mode.
`RootBeanDefinition(Class<?> beanClass, ConstructorArgumentValues cargs, MutablePropertyValues pvs)`
Create a new RootBeanDefinition for a singleton, providing constructor arguments and property values.
`RootBeanDefinition(Class<T> beanClass, String scope, Supplier<T> instanceSupplier)`
Create a new RootBeanDefinition for a scoped bean, constructing each instance through calling the given supplier (possibly a lambda or method reference).
`RootBeanDefinition(Class<T> beanClass, Supplier<T> instanceSupplier)`
Create a new RootBeanDefinition for a singleton bean, constructing each instance through calling the given supplier (possibly a lambda or method reference).
`RootBeanDefinition(String beanClassName)`
Create a new RootBeanDefinition for a singleton, providing constructor arguments and property values.
`RootBeanDefinition(String beanClassName, ConstructorArgumentValues cargs, MutablePropertyValues pvs)`
Create a new RootBeanDefinition for a singleton, providing constructor arguments and property values.
`RootBeanDefinition(RootBeanDefinition original)`
Create a new RootBeanDefinition as deep copy of the given bean definition.
`RootBeanDefinition(org.springframework.core.ResolvableType beanType)`
Deprecated.
as of 6.0.11, in favor of an extra `setTargetType(ResolvableType)` call

## Method Summary

Modifier and Type
Method
Description
`RootBeanDefinition`
`cloneBeanDefinition()`
Clone this bean definition.
`boolean`
`equals(Object other)`
`BeanDefinitionHolder`
`getDecoratedDefinition()`
Return the target definition that is being decorated by this bean definition, if any.
`Set<Member>`
`getExternallyManagedConfigMembers()`
Get all externally managed configuration methods and fields (as an immutable Set).
`Set<String>`
`getExternallyManagedDestroyMethods()`
Get all externally managed destruction methods (as an immutable Set).
`Set<String>`
`getExternallyManagedInitMethods()`
Get all externally managed initialization methods (as an immutable Set).
`String`
`getParentName()`
Return the name of the parent definition of this bean definition, if any.
`Constructor<?>[]`
`getPreferredConstructors()`
Determine preferred constructors to use for default construction, if any.
`AnnotatedElement`
`getQualifiedElement()`
Return the `AnnotatedElement` defining qualifiers, if any.
`org.springframework.core.ResolvableType`
`getResolvableType()`
Return a `ResolvableType` for this bean definition, either from runtime-cached type information or from configuration-time `setTargetType(ResolvableType)` or `AbstractBeanDefinition.setBeanClass(Class)`, also considering resolved factory method definitions.
`Method`
`getResolvedFactoryMethod()`
Return the resolved factory method as a Java Method object, if available.
`Class<?>`
`getTargetType()`
Return the target type of this bean definition, if known (either specified in advance or resolved on first instantiation).
`boolean`
`isExternallyManagedConfigMember(Member configMember)`
Determine if the given method or field is an externally managed configuration member.
`boolean`
`isExternallyManagedDestroyMethod(String destroyMethod)`
Determine if the given method name indicates an externally managed destruction method.
`boolean`
`isExternallyManagedInitMethod(String initMethod)`
Determine if the given method name indicates an externally managed initialization method.
`boolean`
`isFactoryMethod(Method candidate)`
Check whether the given candidate qualifies as a factory method.
`void`
`markAsPostProcessed()`
Mark this bean definition as post-processed, i.e.
`void`
`registerExternallyManagedConfigMember(Member configMember)`
Register an externally managed configuration method or field.
`void`
`registerExternallyManagedDestroyMethod(String destroyMethod)`
Register an externally managed configuration destruction method — for example, a method annotated with JSR-250's `jakarta.annotation.PreDestroy` annotation.
`void`
`registerExternallyManagedInitMethod(String initMethod)`
Register an externally managed configuration initialization method — for example, a method annotated with JSR-250's `javax.annotation.PostConstruct` or Jakarta's `jakarta.annotation.PostConstruct` annotation.
`void`
`resolveDestroyMethodIfNecessary()`
Resolve the inferred destroy method if necessary.
`void`
`setDecoratedDefinition(BeanDefinitionHolder decoratedDefinition)`
Register a target definition that is being decorated by this bean definition.
`void`
`setNonUniqueFactoryMethodName(String name)`
Specify a factory method name that refers to an overloaded method.
`void`
`setParentName(String parentName)`
Set the name of the parent definition of this bean definition, if any.
`void`
`setQualifiedElement(AnnotatedElement qualifiedElement)`
Specify the `AnnotatedElement` defining qualifiers, to be used instead of the target class or factory method.
`void`
`setResolvedFactoryMethod(Method method)`
Set a resolved Java Method for the factory method on this bean definition.
`void`
`setTargetType(Class<?> targetType)`
Specify the target type of this bean definition, if known in advance.
`void`
`setTargetType(org.springframework.core.ResolvableType targetType)`
Specify a generics-containing target type of this bean definition, if known in advance.
`void`
`setUniqueFactoryMethodName(String name)`
Specify a factory method name that refers to a non-overloaded method.
`String`
`toString()`

### Methods inherited from class org.springframework.beans.factory.support.AbstractBeanDefinition

`addQualifier, applyDefaults, clone, copyQualifiersFrom, getAutowireMode, getBeanClass, getBeanClassName, getConstructorArgumentValues, getDependencyCheck, getDependsOn, getDescription, getDestroyMethodName, getDestroyMethodNames, getFactoryBeanName, getFactoryMethodName, getInitMethodName, getInitMethodNames, getInstanceSupplier, getLazyInit, getMethodOverrides, getOriginatingBeanDefinition, getPropertyValues, getQualifier, getQualifiers, getResolvedAutowireMode, getResource, getResourceDescription, getRole, getScope, hasBeanClass, hasConstructorArgumentValues, hashCode, hasMethodOverrides, hasPropertyValues, hasQualifier, isAbstract, isAutowireCandidate, isBackgroundInit, isDefaultCandidate, isEnforceDestroyMethod, isEnforceInitMethod, isFallback, isLazyInit, isLenientConstructorResolution, isNonPublicAccessAllowed, isPrimary, isPrototype, isSingleton, isSynthetic, overrideFrom, prepareMethodOverride, prepareMethodOverrides, resolveBeanClass, setAbstract, setAutowireCandidate, setAutowireMode, setBackgroundInit, setBeanClass, setBeanClassName, setConstructorArgumentValues, setDefaultCandidate, setDependencyCheck, setDependsOn, setDescription, setDestroyMethodName, setDestroyMethodNames, setEnforceDestroyMethod, setEnforceInitMethod, setFactoryBeanName, setFactoryMethodName, setFallback, setInitMethodName, setInitMethodNames, setInstanceSupplier, setLazyInit, setLenientConstructorResolution, setMethodOverrides, setNonPublicAccessAllowed, setOriginatingBeanDefinition, setPrimary, setPropertyValues, setResource, setResourceDescription, setRole, setScope, setSynthetic, validate`

### Methods inherited from class org.springframework.beans.BeanMetadataAttributeAccessor

`addMetadataAttribute, getAttribute, getMetadataAttribute, getSource, removeAttribute, setAttribute, setSource`

### Methods inherited from class org.springframework.core.AttributeAccessorSupport

`attributeNames, computeAttribute, copyAttributesFrom, hasAttribute`

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

`finalize, getClass, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface org.springframework.core.AttributeAccessor

`attributeNames, computeAttribute, getAttribute, hasAttribute, removeAttribute, setAttribute`

### Methods inherited from interface org.springframework.beans.BeanMetadataElement

`getSource`

## Constructor Details

### RootBeanDefinition

public RootBeanDefinition()
Create a new RootBeanDefinition, to be configured through its bean properties and configuration methods.

See Also:
  - `AbstractBeanDefinition.setBeanClass(java.lang.Class<?>)`
  - `AbstractBeanDefinition.setScope(java.lang.String)`
  - `AbstractBeanDefinition.setConstructorArgumentValues(org.springframework.beans.factory.config.ConstructorArgumentValues)`
  - `AbstractBeanDefinition.setPropertyValues(org.springframework.beans.MutablePropertyValues)`

### RootBeanDefinition

public RootBeanDefinition(@Nullable Class<?> beanClass)
Create a new RootBeanDefinition for a singleton.

Parameters:
  `beanClass` - the class of the bean to instantiate
See Also:
  - `AbstractBeanDefinition.setBeanClass(java.lang.Class<?>)`

### RootBeanDefinition

@Deprecated(since="6.0.11") public RootBeanDefinition(@Nullable org.springframework.core.ResolvableType beanType)
Deprecated.
as of 6.0.11, in favor of an extra `setTargetType(ResolvableType)` call
Create a new RootBeanDefinition for a singleton.

Parameters:
  `beanType` - the type of bean to instantiate
Since:
  6.0
See Also:
  - `setTargetType(ResolvableType)`

### RootBeanDefinition

public RootBeanDefinition(@Nullable Class<T> beanClass, @Nullable Supplier<T> instanceSupplier)
Create a new RootBeanDefinition for a singleton bean, constructing each instance through calling the given supplier (possibly a lambda or method reference).

Parameters:
  `beanClass` - the class of the bean to instantiate
  `instanceSupplier` - the supplier to construct a bean instance, as an alternative to a declaratively specified factory method
Since:
  5.0
See Also:
  - `AbstractBeanDefinition.setInstanceSupplier(java.util.function.Supplier<?>)`

### RootBeanDefinition

public RootBeanDefinition(@Nullable Class<T> beanClass, String scope, @Nullable Supplier<T> instanceSupplier)
Create a new RootBeanDefinition for a scoped bean, constructing each instance through calling the given supplier (possibly a lambda or method reference).

Parameters:
  `beanClass` - the class of the bean to instantiate
  `scope` - the name of the corresponding scope
  `instanceSupplier` - the supplier to construct a bean instance, as an alternative to a declaratively specified factory method
Since:
  5.0
See Also:
  - `AbstractBeanDefinition.setInstanceSupplier(java.util.function.Supplier<?>)`

### RootBeanDefinition

public RootBeanDefinition(@Nullable Class<?> beanClass, int autowireMode, boolean dependencyCheck)
Create a new RootBeanDefinition for a singleton, using the given autowire mode.

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 objects (not applicable to autowiring a constructor, thus ignored there)

### RootBeanDefinition

public RootBeanDefinition(@Nullable Class<?> beanClass, @Nullable ConstructorArgumentValues cargs, @Nullable MutablePropertyValues pvs)
Create a new RootBeanDefinition for a singleton, providing constructor arguments and property values.

Parameters:
  `beanClass` - the class of the bean to instantiate
  `cargs` - the constructor argument values to apply
  `pvs` - the property values to apply

### RootBeanDefinition

public RootBeanDefinition(String beanClassName)
Create a new RootBeanDefinition for a singleton, providing constructor arguments and property values.

Takes a bean class name to avoid eager loading of the bean class.

Parameters:
  `beanClassName` - the name of the class to instantiate

### RootBeanDefinition

public RootBeanDefinition(String beanClassName, ConstructorArgumentValues cargs, MutablePropertyValues pvs)
Create a new RootBeanDefinition for a singleton, providing constructor arguments and property values.

Takes a bean class name to avoid eager loading of the bean class.

Parameters:
  `beanClassName` - the name of the class to instantiate
  `cargs` - the constructor argument values to apply
  `pvs` - the property values to apply

### RootBeanDefinition

public RootBeanDefinition(RootBeanDefinition original)
Create a new RootBeanDefinition as deep copy of the given bean definition.

Parameters:
  `original` - the original bean definition to copy from

## Method Details

### getParentName

@Nullable public String getParentName()
Description copied from interface: `BeanDefinition`
Return the name of the parent definition of this bean definition, if any.

### setParentName

public void setParentName(@Nullable String parentName)
Description copied from interface: `BeanDefinition`
Set the name of the parent definition of this bean definition, if any.

### setDecoratedDefinition

public void setDecoratedDefinition(@Nullable BeanDefinitionHolder decoratedDefinition)
Register a target definition that is being decorated by this bean definition.

### getDecoratedDefinition

@Nullable public BeanDefinitionHolder getDecoratedDefinition()
Return the target definition that is being decorated by this bean definition, if any.

### setQualifiedElement

public void setQualifiedElement(@Nullable AnnotatedElement qualifiedElement)
Specify the `AnnotatedElement` defining qualifiers, to be used instead of the target class or factory method.

Since:
  4.3.3
See Also:
  - `setTargetType(ResolvableType)`
  - `getResolvedFactoryMethod()`

### getQualifiedElement

@Nullable public AnnotatedElement getQualifiedElement()
Return the `AnnotatedElement` defining qualifiers, if any. Otherwise, the factory method and target class will be checked.

Since:
  4.3.3

### setTargetType

public void setTargetType(@Nullable org.springframework.core.ResolvableType targetType)
Specify a generics-containing target type of this bean definition, if known in advance.

Since:
  4.3.3

### setTargetType

public void setTargetType(@Nullable Class<?> targetType)
Specify the target type of this bean definition, if known in advance.

Since:
  3.2.2

### getTargetType

@Nullable public Class<?> getTargetType()
Return the target type of this bean definition, if known (either specified in advance or resolved on first instantiation).

Since:
  3.2.2

### getResolvableType

public org.springframework.core.ResolvableType getResolvableType()
Return a `ResolvableType` for this bean definition, either from runtime-cached type information or from configuration-time `setTargetType(ResolvableType)` or `AbstractBeanDefinition.setBeanClass(Class)`, also considering resolved factory method definitions.

Specified by:
  `getResolvableType` in interface `BeanDefinition`
Overrides:
  `getResolvableType` in class `AbstractBeanDefinition`
Returns:
  the resolvable type (potentially `ResolvableType.NONE`)
Since:
  5.1
See Also:
  - `setTargetType(ResolvableType)`
  - `AbstractBeanDefinition.setBeanClass(Class)`
  - `setResolvedFactoryMethod(Method)`

### getPreferredConstructors

@Nullable public Constructor<?>[] getPreferredConstructors()
Determine preferred constructors to use for default construction, if any. Constructor arguments will be autowired if necessary.

As of 6.1, the default implementation of this method takes the `AbstractBeanDefinition.PREFERRED_CONSTRUCTORS_ATTRIBUTE` attribute into account. Subclasses are encouraged to preserve this through a `super` call, either before or after their own preferred constructor determination.

Returns:
  one or more preferred constructors, or `null` if none (in which case the regular no-arg default constructor will be called)
Since:
  5.1

### setUniqueFactoryMethodName

public void setUniqueFactoryMethodName(String name)
Specify a factory method name that refers to a non-overloaded method.

### setNonUniqueFactoryMethodName

public void setNonUniqueFactoryMethodName(String name)
Specify a factory method name that refers to an overloaded method.

Since:
  5.2

### isFactoryMethod

public boolean isFactoryMethod(Method candidate)
Check whether the given candidate qualifies as a factory method.

### setResolvedFactoryMethod

public void setResolvedFactoryMethod(@Nullable Method method)
Set a resolved Java Method for the factory method on this bean definition.

Parameters:
  `method` - the resolved factory method, or `null` to reset it
Since:
  5.2

### getResolvedFactoryMethod

@Nullable public Method getResolvedFactoryMethod()
Return the resolved factory method as a Java Method object, if available.

Returns:
  the factory method, or `null` if not found or not resolved yet

### markAsPostProcessed

public void markAsPostProcessed()
Mark this bean definition as post-processed, i.e. processed by `MergedBeanDefinitionPostProcessor`.

Since:
  6.0

### registerExternallyManagedConfigMember

public void registerExternallyManagedConfigMember(Member configMember)
Register an externally managed configuration method or field.

### isExternallyManagedConfigMember

public boolean isExternallyManagedConfigMember(Member configMember)
Determine if the given method or field is an externally managed configuration member.

### getExternallyManagedConfigMembers

public Set<Member> getExternallyManagedConfigMembers()
Get all externally managed configuration methods and fields (as an immutable Set).

Since:
  5.3.11

### registerExternallyManagedInitMethod

public void registerExternallyManagedInitMethod(String initMethod)
Register an externally managed configuration initialization method — for example, a method annotated with JSR-250's `javax.annotation.PostConstruct` or Jakarta's `jakarta.annotation.PostConstruct` annotation.

The supplied `initMethod` may be a simple method name or a qualified method name for package-private and `private` methods. A qualified name is necessary for package-private and `private` methods in order to disambiguate between multiple such methods with the same name within a type hierarchy.

### isExternallyManagedInitMethod

public boolean isExternallyManagedInitMethod(String initMethod)
Determine if the given method name indicates an externally managed initialization method.

See `registerExternallyManagedInitMethod(java.lang.String)` for details regarding the format for the supplied `initMethod`.

### getExternallyManagedInitMethods

public Set<String> getExternallyManagedInitMethods()
Get all externally managed initialization methods (as an immutable Set).

See `registerExternallyManagedInitMethod(java.lang.String)` for details regarding the format for the initialization methods in the returned set.

Since:
  5.3.11

### resolveDestroyMethodIfNecessary

public void resolveDestroyMethodIfNecessary()
Resolve the inferred destroy method if necessary.

Since:
  6.0

### registerExternallyManagedDestroyMethod

public void registerExternallyManagedDestroyMethod(String destroyMethod)
Register an externally managed configuration destruction method — for example, a method annotated with JSR-250's `jakarta.annotation.PreDestroy` annotation.

The supplied `destroyMethod` may be the simple method name for non-private methods or the qualified method name for `private` methods. A qualified name is necessary for `private` methods in order to disambiguate between multiple private methods with the same name within a class hierarchy.

### isExternallyManagedDestroyMethod

public boolean isExternallyManagedDestroyMethod(String destroyMethod)
Determine if the given method name indicates an externally managed destruction method.

See `registerExternallyManagedDestroyMethod(java.lang.String)` for details regarding the format for the supplied `destroyMethod`.

### getExternallyManagedDestroyMethods

public Set<String> getExternallyManagedDestroyMethods()
Get all externally managed destruction methods (as an immutable Set).

See `registerExternallyManagedDestroyMethod(java.lang.String)` for details regarding the format for the destruction methods in the returned set.

Since:
  5.3.11

### cloneBeanDefinition

public RootBeanDefinition cloneBeanDefinition()
Description copied from class: `AbstractBeanDefinition`
Clone this bean definition. To be implemented by concrete subclasses.

Specified by:
  `cloneBeanDefinition` in class `AbstractBeanDefinition`
Returns:
  the cloned bean definition object

### equals

public boolean equals(@Nullable Object other)

Overrides:
  `equals` in class `AbstractBeanDefinition`

### toString

public String toString()

Overrides:
  `toString` in class `AbstractBeanDefinition`