/*
* Copyright 2002-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.beans.factory.support;
import java.lang.reflect.Member;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConstructorArgumentValues;
/**
* A root bean definition represents the merged bean definition that backs
* a specific bean in a Spring BeanFactory at runtime. It might have been created
* from multiple original bean definitions that inherit from each other,
* typically registered as {@link GenericBeanDefinition GenericBeanDefinitions}.
* A root bean definition is essentially the 'unified' bean definition view at runtime.
*
* <p>Root bean definitions may also be used for registering individual bean definitions
* in the configuration phase. However, since Spring 2.5, the preferred way to register
* bean definitions programmatically is the {@link GenericBeanDefinition} class.
* GenericBeanDefinition has the advantage that it allows to dynamically define
* parent dependencies, not 'hard-coding' the role as a root bean definition.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @see GenericBeanDefinition
* @see ChildBeanDefinition
*/
public class RootBeanDefinition extends AbstractBeanDefinition {
private final Set externallyManagedConfigMembers = Collections.synchronizedSet(new HashSet());
private final Set externallyManagedInitMethods = Collections.synchronizedSet(new HashSet());
private final Set externallyManagedDestroyMethods = Collections.synchronizedSet(new HashSet());
/** Package-visible field for caching the resolved constructor or factory method */
volatile Object resolvedConstructorOrFactoryMethod;
/** Package-visible field for caching fully resolved constructor arguments */
volatile Object[] resolvedConstructorArguments;
/** Package-visible field for caching partly prepared constructor arguments */
volatile Object[] preparedConstructorArguments;
/** Package-visible field that marks the constructor arguments as resolved */
volatile boolean constructorArgumentsResolved = false;
/** Package-visible field that indicates a before-instantiation post-processor having kicked in */
volatile Boolean beforeInstantiationResolved;
/** Package-visible field that indicates MergedBeanDefinitionPostProcessor having been applied */
boolean postProcessed = false;
final Object postProcessingLock = new Object();
/**
* Create a new RootBeanDefinition, to be configured through its bean
* properties and configuration methods.
* @see #setBeanClass
* @see #setBeanClassName
* @see #setScope
* @see #setAutowireMode
* @see #setDependencyCheck
* @see #setConstructorArgumentValues
* @see #setPropertyValues
*/
public RootBeanDefinition() {
super();
}
/**
* Create a new RootBeanDefinition for a singleton.
* @param beanClass the class of the bean to instantiate
*/
public RootBeanDefinition(Class beanClass) {
super();
setBeanClass(beanClass);
}
/**
* Create a new RootBeanDefinition with the given singleton status.
* @param beanClass the class of the bean to instantiate
* @param singleton the singleton status of the bean
* @deprecated since Spring 2.5, in favor of {@link #setScope}
*/
public RootBeanDefinition(Class beanClass, boolean singleton) {
super();
setBeanClass(beanClass);
setSingleton(singleton);
}
/**
* Create a new RootBeanDefinition for a singleton,
* using the given autowire mode.
* @param beanClass the class of the bean to instantiate
* @param autowireMode by name or type, using the constants in this interface
*/
public RootBeanDefinition(Class beanClass, int autowireMode) {
super();
setBeanClass(beanClass);
setAutowireMode(autowireMode);
}
/**
* Create a new RootBeanDefinition for a singleton,
* using the given autowire mode.
* @param beanClass the class of the bean to instantiate
* @param autowireMode by name or type, using the constants in this interface
* @param dependencyCheck whether to perform a dependency check for objects
* (not applicable to autowiring a constructor, thus ignored there)
*/
public RootBeanDefinition(Class beanClass, int autowireMode, boolean dependencyCheck) {
super();
setBeanClass(beanClass);
setAutowireMode(autowireMode);
if (dependencyCheck && getResolvedAutowireMode() != AUTOWIRE_CONSTRUCTOR) {
setDependencyCheck(RootBeanDefinition.DEPENDENCY_CHECK_OBJECTS);
}
}
/**
* Create a new RootBeanDefinition for a singleton,
* providing property values.
* @param beanClass the class of the bean to instantiate
* @param pvs the property values to apply
*/
public RootBeanDefinition(Class beanClass, MutablePropertyValues pvs) {
super(null, pvs);
setBeanClass(beanClass);
}
/**
* Create a new RootBeanDefinition with the given singleton status,
* providing property values.
* @param beanClass the class of the bean to instantiate
* @param pvs the property values to apply
* @param singleton the singleton status of the bean
* @deprecated since Spring 2.5, in favor of {@link #setScope}
*/
public RootBeanDefinition(Class beanClass, MutablePropertyValues pvs, boolean singleton) {
super(null, pvs);
setBeanClass(beanClass);
setSingleton(singleton);
}
/**
* Create a new RootBeanDefinition for a singleton,
* providing constructor arguments and property values.
* @param beanClass the class of the bean to instantiate
* @param cargs the constructor argument values to apply
* @param pvs the property values to apply
*/
public RootBeanDefinition(Class beanClass, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
super(cargs, pvs);
setBeanClass(beanClass);
}
/**
* Create a new RootBeanDefinition for a singleton,
* providing constructor arguments and property values.
* <p>Takes a bean class name to avoid eager loading of the bean class.
* @param beanClassName the name of the class to instantiate
* @param cargs the constructor argument values to apply
* @param pvs the property values to apply
*/
public RootBeanDefinition(String beanClassName, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
super(cargs, pvs);
setBeanClassName(beanClassName);
}
/**
* Create a new RootBeanDefinition as deep copy of the given
* bean definition.
* @param original the original bean definition to copy from
*/
public RootBeanDefinition(RootBeanDefinition original) {
super((BeanDefinition) original);
}
/**
* Create a new RootBeanDefinition as deep copy of the given
* bean definition.
* @param original the original bean definition to copy from
*/
RootBeanDefinition(BeanDefinition original) {
super(original);
}
public String getParentName() {
return null;
}
public void setParentName(String parentName) {
if (parentName != null) {
throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference");
}
}
public void registerExternallyManagedConfigMember(Member configMember) {
this.externallyManagedConfigMembers.add(configMember);
}
public boolean isExternallyManagedConfigMember(Member configMember) {
return this.externallyManagedConfigMembers.contains(configMember);
}
public void registerExternallyManagedInitMethod(String initMethod) {
this.externallyManagedInitMethods.add(initMethod);
}
public boolean isExternallyManagedInitMethod(String initMethod) {
return this.externallyManagedInitMethods.contains(initMethod);
}
public void registerExternallyManagedDestroyMethod(String destroyMethod) {
this.externallyManagedDestroyMethods.add(destroyMethod);
}
public boolean isExternallyManagedDestroyMethod(String destroyMethod) {
return this.externallyManagedDestroyMethods.contains(destroyMethod);
}
public AbstractBeanDefinition cloneBeanDefinition() {
return new RootBeanDefinition(this);
}
public boolean equals(Object other) {
return (this == other || (other instanceof RootBeanDefinition && super.equals(other)));
}
public String toString() {
return "Root bean: " + super.toString();
}
}