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

Maven-Central
/
org.springframework / spring-beans
/
2.5.6.SEC01

3.1.1.RELEASE
3.0.3.RELEASE
3.0.2.RELEASE
3.0.1.RELEASE
3.0.0.RELEASE
2.5.6
2.5.6.SEC03
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
1.2.7
1.2.1
/
org.springframework.beans.factory.BeanFactoryUtils
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
  /*
2
   * Copyright 2002-2008 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;
18
 
19
 import java.util.ArrayList;
20
 import java.util.Arrays;
21
 import java.util.Iterator;
22
 import java.util.LinkedHashMap;
23
 import java.util.List;
24
 import java.util.Map;
25
 
26
 import org.springframework.beans.BeansException;
27
 import org.springframework.util.Assert;
28
 import org.springframework.util.StringUtils;

 Convenience methods operating on bean factories, in particular
 on the ListableBeanFactory interface.

 Returns bean counts, bean names or bean instances,
 taking into account the nesting hierarchy of a bean factory
 (which the methods defined on the ListableBeanFactory interface don't,
 in contrast to the methods defined on the BeanFactory interface).

 
 Author(s):Rod JohnsonJuergen Hoeller Since:04.07.2003
42
 
43
 public abstract class BeanFactoryUtils {

	
 Separator for generated bean names. If a class name or parent name is not
 unique, "#1", "#2" etc will be appended, until the name becomes unique.
 
48
 
49
 	public static final String GENERATED_BEAN_NAME_SEPARATOR = "#";


	
 Return whether the given name is a factory dereference
 (beginning with the factory dereference prefix).
 
 Parameters:name the name of the bean Returns:whether the given name is a factory dereference See also:BeanFactory.FACTORY_BEAN_PREFIX
58
 
59
 	public static boolean isFactoryDereference(String name) {
60
 		return (name != null && name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
61
 	}

	
 Return the actual bean name, stripping out the factory dereference
 prefix (if any, also stripping repeated factory prefixes if found).
 
 Parameters:name the name of the bean Returns:the transformed name See also:BeanFactory.FACTORY_BEAN_PREFIX
69
 
70
 	public static String transformedBeanName(String name) {
71
 		Assert.notNull(name, "'name' must not be null");
72
 		String beanName = name;
73
 		while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
74
 			beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
75
 		}
76
 		return beanName;
77
 	}

	
 Return whether the given name is a bean name which has been generated
 by the default naming strategy (containing a "#..." part).
 
 Parameters:name the name of the bean Returns:whether the given name is a generated bean name See also:GENERATED_BEAN_NAME_SEPARATORorg.springframework.beans.factory.support.BeanDefinitionReaderUtils.generateBeanName(org.springframework.beans.factory.config.BeanDefinition,org.springframework.beans.factory.support.BeanDefinitionRegistry)org.springframework.beans.factory.support.DefaultBeanNameGenerator
87
 
88
 	public static boolean isGeneratedBeanName(String name) {
89
 		return (name != null && name.indexOf(GENERATED_BEAN_NAME_SEPARATOR) != -1);
90
 	}

	
 Extract the "raw" bean name from the given (potentially generated) bean name,
 excluding any "#..." suffixes which might have been added for uniqueness.
 
 Parameters:name the potentially generated bean name Returns:the raw bean name See also:GENERATED_BEAN_NAME_SEPARATOR
98
 
99
 	public static String originalBeanName(String name) {
100
		Assert.notNull(name, "'name' must not be null");
101
		int separatorIndex = name.indexOf(GENERATED_BEAN_NAME_SEPARATOR);
102
		return (separatorIndex != -1 ? name.substring(0, separatorIndex) : name);
103
	}


	
 Count all beans in any hierarchy in which this factory participates.
 Includes counts of ancestor bean factories.
 Beans that are "overridden" (specified in a descendant factory
 with the same name) are only counted once.
 
 Parameters:lbf the bean factory Returns:count of beans including those defined in ancestor factories
113
114
	public static int countBeansIncludingAncestors(ListableBeanFactory lbf) {
115
		return beanNamesIncludingAncestors(lbf).length;
116
	}
	
	
 Return all bean names in the factory, including ancestor factories.
 
 Parameters:lbf the bean factory Returns:the array of matching bean names, or an empty array if none See also:beanNamesForTypeIncludingAncestors(org.springframework.beans.factory.ListableBeanFactory,java.lang.Class)
123
124
	public static String[] beanNamesIncludingAncestors(ListableBeanFactory lbf) {
125
		return beanNamesForTypeIncludingAncestors(lbf, Object.class);
126
	}


	
 Get all bean names for the given type, including those defined in ancestor
 factories. Will return unique names in case of overridden bean definitions.
 Does consider objects created by FactoryBeans, which means that FactoryBeans
 will get initialized. If the object created by the FactoryBean doesn't match,
 the raw FactoryBean itself will be matched against the type.
 
This version of beanNamesForTypeIncludingAncestors automatically
 includes prototypes and FactoryBeans.
 
 Parameters:lbf the bean factorytype the type that beans must match Returns:the array of matching bean names, or an empty array if none
140
141
	public static String[] beanNamesForTypeIncludingAncestors(ListableBeanFactory lbf, Class type) {
142
		Assert.notNull(lbf, "ListableBeanFactory must not be null");
143
		String[] result = lbf.getBeanNamesForType(type);
144
		if (lbf instanceof HierarchicalBeanFactory) {
145
			HierarchicalBeanFactory hbf = (HierarchicalBeanFactory) lbf;
146
			if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
147
				String[] parentResult = beanNamesForTypeIncludingAncestors(
148
						(ListableBeanFactory) hbf.getParentBeanFactory(), type);
149
				List resultList = new ArrayList();
150
				resultList.addAll(Arrays.asList(result));
151
				for (int i = 0; i < parentResult.length; i++) {
152
					String beanName = parentResult[i];
153
					if (!resultList.contains(beanName) && !hbf.containsLocalBean(beanName)) {
154
						resultList.add(beanName);
155
					}
156
				}
157
				result = StringUtils.toStringArray(resultList);
158
			}
159
		}
160
		return result;
161
	}

	
 Get all bean names for the given type, including those defined in ancestor
 factories. Will return unique names in case of overridden bean definitions.
 Does consider objects created by FactoryBeans if the "allowEagerInit"
 flag is set, which means that FactoryBeans will get initialized. If the
 object created by the FactoryBean doesn't match, the raw FactoryBean itself
 will be matched against the type. If "allowEagerInit" is not set,
 only raw FactoryBeans will be checked (which doesn't require initialization
 of each FactoryBean).
 
 Parameters:lbf the bean factoryincludeNonSingletons whether to include prototype or scoped beans too
 or just singletons (also applies to FactoryBeans)allowEagerInit whether to initialize lazy-init singletons and
 objects created by FactoryBeans (or by factory methods with a
 "factory-bean" reference) for the type check. Note that FactoryBeans need to be
 eagerly initialized to determine their type: So be aware that passing in "true"
 for this flag will initialize FactoryBeans and "factory-bean" references.type the type that beans must match Returns:the array of matching bean names, or an empty array if none
182
183
	public static String[] beanNamesForTypeIncludingAncestors(
184
			ListableBeanFactory lbf, Class type, boolean includeNonSingletons, boolean allowEagerInit) {
185
186
		Assert.notNull(lbf, "ListableBeanFactory must not be null");
187
		String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
188
		if (lbf instanceof HierarchicalBeanFactory) {
189
			HierarchicalBeanFactory hbf = (HierarchicalBeanFactory) lbf;
190
			if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
191
				String[] parentResult = beanNamesForTypeIncludingAncestors(
192
						(ListableBeanFactory) hbf.getParentBeanFactory(), type, includeNonSingletons, allowEagerInit);
193
				List resultList = new ArrayList();
194
				resultList.addAll(Arrays.asList(result));
195
				for (int i = 0; i < parentResult.length; i++) {
196
					String beanName = parentResult[i];
197
					if (!resultList.contains(beanName) && !hbf.containsLocalBean(beanName)) {
198
						resultList.add(beanName);
199
					}
200
				}
201
				result = StringUtils.toStringArray(resultList);
202
			}
203
		}
204
		return result;
205
	}

	
 Return all beans of the given type or subtypes, also picking up beans defined in
 ancestor bean factories if the current bean factory is a HierarchicalBeanFactory.
 The returned Map will only contain beans of this type.
 Does consider objects created by FactoryBeans, which means that FactoryBeans
 will get initialized. If the object created by the FactoryBean doesn't match,
 the raw FactoryBean itself will be matched against the type.
 
 Parameters:lbf the bean factorytype type of bean to match Returns:the Map of matching bean instances, or an empty Map if none Throws:org.springframework.beans.BeansException if a bean could not be created
218
219
	public static Map beansOfTypeIncludingAncestors(ListableBeanFactory lbf, Class type)
220
	    throws BeansException {
221
222
		Assert.notNull(lbf, "ListableBeanFactory must not be null");
223
		Map result = new LinkedHashMap(4);
224
		result.putAll(lbf.getBeansOfType(type));
225
		if (lbf instanceof HierarchicalBeanFactory) {
226
			HierarchicalBeanFactory hbf = (HierarchicalBeanFactory) lbf;
227
			if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
228
				Map parentResult = beansOfTypeIncludingAncestors(
229
						(ListableBeanFactory) hbf.getParentBeanFactory(), type);
230
				for (Iterator it = parentResult.entrySet().iterator(); it.hasNext();) {
231
					Map.Entry entry = (Map.Entry) it.next();
232
					String beanName = (String) entry.getKey();
233
					if (!result.containsKey(beanName) && !hbf.containsLocalBean(beanName)) {
234
						result.put(beanName, entry.getValue());
235
					}
236
				}
237
			}
238
		}
239
		return result;
240
	}

	
 Return all beans of the given type or subtypes, also picking up beans defined in
 ancestor bean factories if the current bean factory is a HierarchicalBeanFactory.
 The returned Map will only contain beans of this type.
 Does consider objects created by FactoryBeans if the "allowEagerInit"
 flag is set, which means that FactoryBeans will get initialized. If the
 object created by the FactoryBean doesn't match, the raw FactoryBean itself
 will be matched against the type. If "allowEagerInit" is not set,
 only raw FactoryBeans will be checked (which doesn't require initialization
 of each FactoryBean).
 
 Parameters:lbf the bean factorytype type of bean to matchincludeNonSingletons whether to include prototype or scoped beans too
 or just singletons (also applies to FactoryBeans)allowEagerInit whether to initialize lazy-init singletons and
 objects created by FactoryBeans (or by factory methods with a
 "factory-bean" reference) for the type check. Note that FactoryBeans need to be
 eagerly initialized to determine their type: So be aware that passing in "true"
 for this flag will initialize FactoryBeans and "factory-bean" references. Returns:the Map of matching bean instances, or an empty Map if none Throws:org.springframework.beans.BeansException if a bean could not be created
263
264
	public static Map beansOfTypeIncludingAncestors(
265
			ListableBeanFactory lbf, Class type, boolean includeNonSingletons, boolean allowEagerInit)
266
	    throws BeansException {
267
268
		Assert.notNull(lbf, "ListableBeanFactory must not be null");
269
		Map result = new LinkedHashMap(4);
270
		result.putAll(lbf.getBeansOfType(type, includeNonSingletons, allowEagerInit));
271
		if (lbf instanceof HierarchicalBeanFactory) {
272
			HierarchicalBeanFactory hbf = (HierarchicalBeanFactory) lbf;
273
			if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
274
				Map parentResult = beansOfTypeIncludingAncestors(
275
						(ListableBeanFactory) hbf.getParentBeanFactory(), type, includeNonSingletons, allowEagerInit);
276
				for (Iterator it = parentResult.entrySet().iterator(); it.hasNext();) {
277
					Map.Entry entry = (Map.Entry) it.next();
278
					String beanName = (String) entry.getKey();
279
					if (!result.containsKey(beanName) && !hbf.containsLocalBean(beanName)) {
280
						result.put(beanName, entry.getValue());
281
					}
282
				}
283
			}
284
		}
285
		return result;
286
	}


	
 Return a single bean of the given type or subtypes, also picking up beans
 defined in ancestor bean factories if the current bean factory is a
 HierarchicalBeanFactory. Useful convenience method when we expect a
 single bean and don't care about the bean name.
 Does consider objects created by FactoryBeans, which means that FactoryBeans
 will get initialized. If the object created by the FactoryBean doesn't match,
 the raw FactoryBean itself will be matched against the type.
 
This version of beanOfTypeIncludingAncestors automatically includes
 prototypes and FactoryBeans.
 
 Parameters:lbf the bean factorytype type of bean to match Returns:the matching bean instance Throws:NoSuchBeanDefinitionException
 if 0 or more than 1 beans of the given type were foundorg.springframework.beans.BeansException if the bean could not be created
305
306
	public static Object beanOfTypeIncludingAncestors(ListableBeanFactory lbf, Class type)
307
			throws BeansException {
308
309
		Map beansOfType = beansOfTypeIncludingAncestors(lbf, type);
310
		if (beansOfType.size() == 1) {
311
			return beansOfType.values().iterator().next();
312
		}
313
		else {
314
			throw new NoSuchBeanDefinitionException(type, "expected single bean but found " + beansOfType.size());
315
		}
316
	}

	
 Return a single bean of the given type or subtypes, also picking up beans
 defined in ancestor bean factories if the current bean factory is a
 HierarchicalBeanFactory. Useful convenience method when we expect a
 single bean and don't care about the bean name.
 Does consider objects created by FactoryBeans if the "allowEagerInit"
 flag is set, which means that FactoryBeans will get initialized. If the
 object created by the FactoryBean doesn't match, the raw FactoryBean itself
 will be matched against the type. If "allowEagerInit" is not set,
 only raw FactoryBeans will be checked (which doesn't require initialization
 of each FactoryBean).
 
 Parameters:lbf the bean factorytype type of bean to matchincludeNonSingletons whether to include prototype or scoped beans too
 or just singletons (also applies to FactoryBeans)allowEagerInit whether to initialize lazy-init singletons and
 objects created by FactoryBeans (or by factory methods with a
 "factory-bean" reference) for the type check. Note that FactoryBeans need to be
 eagerly initialized to determine their type: So be aware that passing in "true"
 for this flag will initialize FactoryBeans and "factory-bean" references. Returns:the matching bean instance Throws:NoSuchBeanDefinitionException
 if 0 or more than 1 beans of the given type were foundorg.springframework.beans.BeansException if the bean could not be created
342
343
	public static Object beanOfTypeIncludingAncestors(
344
			ListableBeanFactory lbf, Class type, boolean includeNonSingletons, boolean allowEagerInit)
345
	    throws BeansException {
346
347
		Map beansOfType = beansOfTypeIncludingAncestors(lbf, type, includeNonSingletons, allowEagerInit);
348
		if (beansOfType.size() == 1) {
349
			return beansOfType.values().iterator().next();
350
		}
351
		else {
352
			throw new NoSuchBeanDefinitionException(type, "expected single bean but found " + beansOfType.size());
353
		}
354
	}

	
 Return a single bean of the given type or subtypes, not looking in ancestor
 factories. Useful convenience method when we expect a single bean and
 don't care about the bean name.
 Does consider objects created by FactoryBeans, which means that FactoryBeans
 will get initialized. If the object created by the FactoryBean doesn't match,
 the raw FactoryBean itself will be matched against the type.
 
This version of beanOfType automatically includes
 prototypes and FactoryBeans.
 
 Parameters:lbf the bean factorytype type of bean to match Returns:the matching bean instance Throws:NoSuchBeanDefinitionException
 if 0 or more than 1 beans of the given type were foundorg.springframework.beans.BeansException if the bean could not be created
371
372
	public static Object beanOfType(ListableBeanFactory lbf, Class type) throws BeansException {
373
		Assert.notNull(lbf, "ListableBeanFactory must not be null");
374
		Map beansOfType = lbf.getBeansOfType(type);
375
		if (beansOfType.size() == 1) {
376
			return beansOfType.values().iterator().next();
377
		}
378
		else {
379
			throw new NoSuchBeanDefinitionException(type, "expected single bean but found " + beansOfType.size());
380
		}
381
	}

	
 Return a single bean of the given type or subtypes, not looking in ancestor
 factories. Useful convenience method when we expect a single bean and
 don't care about the bean name.
 Does consider objects created by FactoryBeans if the "allowEagerInit"
 flag is set, which means that FactoryBeans will get initialized. If the
 object created by the FactoryBean doesn't match, the raw FactoryBean itself
 will be matched against the type. If "allowEagerInit" is not set,
 only raw FactoryBeans will be checked (which doesn't require initialization
 of each FactoryBean).
 
 Parameters:lbf the bean factorytype type of bean to matchincludeNonSingletons whether to include prototype or scoped beans too
 or just singletons (also applies to FactoryBeans)allowEagerInit whether to initialize lazy-init singletons and
 objects created by FactoryBeans (or by factory methods with a
 "factory-bean" reference) for the type check. Note that FactoryBeans need to be
 eagerly initialized to determine their type: So be aware that passing in "true"
 for this flag will initialize FactoryBeans and "factory-bean" references. Returns:the matching bean instance Throws:NoSuchBeanDefinitionException
 if 0 or more than 1 beans of the given type were foundorg.springframework.beans.BeansException if the bean could not be created
406
407
	public static Object beanOfType(
408
			ListableBeanFactory lbf, Class type, boolean includeNonSingletons, boolean allowEagerInit)
409
	    throws BeansException {
410
411
		Assert.notNull(lbf, "ListableBeanFactory must not be null");
412
		Map beansOfType = lbf.getBeansOfType(type, includeNonSingletons, allowEagerInit);
413
		if (beansOfType.size() == 1) {
414
			return beansOfType.values().iterator().next();
415
		}
416
		else {
417
			throw new NoSuchBeanDefinitionException(type, "expected single bean but found " + beansOfType.size());
418
		}
419
	}
420
421
}