GrepCode: org.springframework.beans.factory.support.RootBeanDefinition (.java) - Class

Maven-Central
/
org.springframework / spring-beans
/
2.5.1

3.1.1.RELEASE
2.5.6
2.5.6.SEC02
2.5.6.SEC01
2.5.5
2.5.4
2.5.3
2.5.2
2.5.1
2.5
2.0-m4
1.2.7
1.2.6
1.2.5
1.2.3
1.2.2
1.2.1
/
org.springframework.beans.factory.support.RootBeanDefinition
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
  /*
2
   * Copyright 2002-2007 the original author or authors.
3
   *
4
   * Licensed under the Apache License, Version 2.0 (the "License");
5
   * you may not use this file except in compliance with the License.
6
   * You may obtain a copy of the License at
7
   *
8
   *      http://www.apache.org/licenses/LICENSE-2.0
9
   *
10
  * Unless required by applicable law or agreed to in writing, software
11
  * distributed under the License is distributed on an "AS IS" BASIS,
12
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
  * See the License for the specific language governing permissions and
14
  * limitations under the License.
15
  */
16
 
17
 package org.springframework.beans.factory.support;
18
 
19
 import java.lang.reflect.Member;
20
 import java.util.Collections;
21
 import java.util.HashSet;
22
 import java.util.Set;
23
 
24
 import org.springframework.beans.MutablePropertyValues;
25
 import org.springframework.beans.factory.config.BeanDefinition;
26
 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 GenericBeanDefinitions.
 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. However, since Spring 2.5, the preferred way to register
 bean definitions programmatically is the 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(s):Rod JohnsonJuergen Hoeller See also:GenericBeanDefinitionChildBeanDefinition
45
 
46
 public class RootBeanDefinition extends AbstractBeanDefinition {
47
 
48
 	private final Set externallyManagedConfigMembers = Collections.synchronizedSet(new HashSet());
49
 
50
 	private final Set externallyManagedInitMethods = Collections.synchronizedSet(new HashSet());
51
 
52
 	private final Set externallyManagedDestroyMethods = Collections.synchronizedSet(new HashSet());

	
Package-visible field for caching the resolved constructor or factory method
54
 
55
 	volatile Object resolvedConstructorOrFactoryMethod;

	
Package-visible field for caching fully resolved constructor arguments
57
 
58
 	volatile Object[] resolvedConstructorArguments;

	
Package-visible field for caching partly prepared constructor arguments
60
 
61
 	volatile Object[] preparedConstructorArguments;

	
Package-visible field that marks the constructor arguments as resolved
63
 
64
 	volatile boolean constructorArgumentsResolved = false;

	
Package-visible field that indicates a before-instantiation post-processor having kicked in
66
 
67
 	volatile Boolean beforeInstantiationResolved;

	
Package-visible field that indicates MergedBeanDefinitionPostProcessor having been applied
69
 
70
 	volatile boolean postProcessed = false;


	
 Create a new RootBeanDefinition, to be configured through its bean
 properties and configuration methods.
 
 See also:AbstractBeanDefinition.setBeanClass(java.lang.Class)AbstractBeanDefinition.setBeanClassName(java.lang.String)AbstractBeanDefinition.setSingleton(boolean)AbstractBeanDefinition.setAutowireMode(int)AbstractBeanDefinition.setDependencyCheck(int)AbstractBeanDefinition.setConstructorArgumentValues(org.springframework.beans.factory.config.ConstructorArgumentValues)AbstractBeanDefinition.setPropertyValues(org.springframework.beans.MutablePropertyValues)
83
 
84
 	public RootBeanDefinition() {
85
 		super();
86
 	}

	
 Create a new RootBeanDefinition for a singleton.
 
 Parameters:beanClass the class of the bean to instantiate
91
 
92
 	public RootBeanDefinition(Class beanClass) {
93
 		super();
94
 		setBeanClass(beanClass);
95
 	}

	
 Create a new RootBeanDefinition with the given singleton status.
 
 Parameters:beanClass the class of the bean to instantiatesingleton the singleton status of the bean
101
102
	public RootBeanDefinition(Class beanClass, boolean singleton) {
103
		super();
104
		setBeanClass(beanClass);
105
		setSingleton(singleton);
106
	}

	
 Create a new RootBeanDefinition for a singleton,
 using the given autowire mode.
 
 Parameters:beanClass the class of the bean to instantiateautowireMode by name or type, using the constants in this interface
113
114
	public RootBeanDefinition(Class beanClass, int autowireMode) {
115
		super();
116
		setBeanClass(beanClass);
117
		setAutowireMode(autowireMode);
118
	}

	
 Create a new RootBeanDefinition for a singleton,
 using the given autowire mode.
 
 Parameters:beanClass the class of the bean to instantiateautowireMode by name or type, using the constants in this interfacedependencyCheck whether to perform a dependency check for objects
 (not applicable to autowiring a constructor, thus ignored there)
127
128
	public RootBeanDefinition(Class beanClass, int autowireMode, boolean dependencyCheck) {
129
		super();
130
		setBeanClass(beanClass);
131
		setAutowireMode(autowireMode);
132
		if (dependencyCheck && getResolvedAutowireMode() != AUTOWIRE_CONSTRUCTOR) {
133
			setDependencyCheck(RootBeanDefinition.DEPENDENCY_CHECK_OBJECTS);
134
		}
135
	}

	
 Create a new RootBeanDefinition for a singleton,
 providing property values.
 
 Parameters:beanClass the class of the bean to instantiatepvs the property values to apply
142
143
	public RootBeanDefinition(Class beanClass, MutablePropertyValues pvs) {
144
		super(null, pvs);
145
		setBeanClass(beanClass);
146
	}

	
 Create a new RootBeanDefinition with the given singleton status,
 providing property values.
 
 Parameters:beanClass the class of the bean to instantiatepvs the property values to applysingleton the singleton status of the bean
154
155
	public RootBeanDefinition(Class beanClass, MutablePropertyValues pvs, boolean singleton) {
156
		super(null, pvs);
157
		setBeanClass(beanClass);
158
		setSingleton(singleton);
159
	}

	
 Create a new RootBeanDefinition for a singleton,
 providing constructor arguments and property values.
 
 Parameters:beanClass the class of the bean to instantiatecargs the constructor argument values to applypvs the property values to apply
167
168
	public RootBeanDefinition(Class beanClass, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
169
		super(cargs, pvs);
170
		setBeanClass(beanClass);
171
	}

	
 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 instantiatecargs the constructor argument values to applypvs the property values to apply
180
181
	public RootBeanDefinition(String beanClassName, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
182
		super(cargs, pvs);
183
		setBeanClassName(beanClassName);
184
	}

	
 Create a new RootBeanDefinition as deep copy of the given
 bean definition.
 
 Parameters:original the original bean definition to copy from
190
191
	public RootBeanDefinition(RootBeanDefinition original) {
192
		super((BeanDefinition) original);
193
	}

	
 Create a new RootBeanDefinition as deep copy of the given
 bean definition.
 
 Parameters:original the original bean definition to copy from
199
200
	RootBeanDefinition(BeanDefinition original) {
201
		super(original);
202
	}
203
204
205
	public String getParentName() {
206
		return null;
207
	}
208
209
	public void setParentName(String parentName) {
210
		if (parentName != null) {
211
			throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference");
212
		}
213
	}
214
215
216
	public void registerExternallyManagedConfigMember(Member configMember) {
217
		this.externallyManagedConfigMembers.add(configMember);
218
	}
219
220
	public boolean isExternallyManagedConfigMember(Member configMember) {
221
		return this.externallyManagedConfigMembers.contains(configMember);
222
	}
223
224
	public void registerExternallyManagedInitMethod(String initMethod) {
225
		this.externallyManagedInitMethods.add(initMethod);
226
	}
227
228
	public boolean isExternallyManagedInitMethod(String initMethod) {
229
		return this.externallyManagedInitMethods.contains(initMethod);
230
	}
231
232
	public void registerExternallyManagedDestroyMethod(String destroyMethod) {
233
		this.externallyManagedDestroyMethods.add(destroyMethod);
234
	}
235
236
	public boolean isExternallyManagedDestroyMethod(String destroyMethod) {
237
		return this.externallyManagedDestroyMethods.contains(destroyMethod);
238
	}
239
240
241
	public AbstractBeanDefinition cloneBeanDefinition() {
242
		return new RootBeanDefinition(this);
243
	}
244
245
	public boolean equals(Object other) {
246
		return (this == other || (other instanceof RootBeanDefinition && super.equals(other)));
247
	}
248
249
	public String toString() {
250
		return "Root bean: " + super.toString();
251
	}
252
253
}