org.springframework.beans.factory.ListableBeanFactory Maven / Gradle / Ivy
/*
* Copyright 2002-2006 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;
import java.util.Map;
import org.springframework.beans.BeansException;
/**
* Extension of the BeanFactory interface to be implemented by bean factories
* that can enumerate all their bean instances, rather than attempting bean lookup
* by name one by one as requested by clients. BeanFactory implementations that
* preload all their beans (for example, DOM-based XML factories) may implement
* this interface. This interface is discussed in "Expert One-on-One J2EE Design
* and Development", by Rod Johnson.
*
* If this is a HierarchicalBeanFactory, the return values will not take
* any BeanFactory hierarchy into account, but will relate only to the beans defined
* in the current factory. Use the BeanFactoryUtils helper class to consider beans
* in ancestor factories too.
*
*
The methods in this interface will just respect bean definitions of this factory.
* They will ignore any singleton beans that have been registered by other means like
* ConfigurableBeanFactory's registerSingleton method, with the exception
* of getBeanNamesOfType and getBeansOfType which will check
* such manually registered singletons too. Of course, BeanFactory's getBean
* does allow transparent access to such special beans as well. However, in typical
* scenarios, all beans will be defined by external bean definitions anyway, so most
* applications don't need to worry about this differentation.
*
*
With the exception of getBeanDefinitionCount and
* containsBeanDefinition, the methods in this interface are
* not designed for frequent invocation. Implementations may be slow.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @since 16 April 2001
* @see HierarchicalBeanFactory
* @see BeanFactoryUtils
* @see org.springframework.beans.factory.config.ConfigurableBeanFactory#registerSingleton
*/
public interface ListableBeanFactory extends BeanFactory {
/**
* Check if this bean factory contains a bean definition with the given name.
*
Does not consider any hierarchy this factory may participate in,
* and ignores any singleton beans that have been registered by
* other means than bean definitions.
* @param beanName the name of the bean to look for
* @return if this bean factory contains a bean definition with the given name
* @see #containsBean
*/
boolean containsBeanDefinition(String beanName);
/**
* Return the number of beans defined in the factory.
*
Does not consider any hierarchy this factory may participate in,
* and ignores any singleton beans that have been registered by
* other means than bean definitions.
* @return the number of beans defined in the factory
*/
int getBeanDefinitionCount();
/**
* Return the names of all beans defined in this factory.
*
Does not consider any hierarchy this factory may participate in,
* and ignores any singleton beans that have been registered by
* other means than bean definitions.
* @return the names of all beans defined in this factory,
* or an empty array if none defined
*/
String[] getBeanDefinitionNames();
/**
* Return the names of beans matching the given type (including subclasses),
* judging from either bean definitions or the value of getObjectType
* in the case of FactoryBeans.
*
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.
*
Does not consider any hierarchy this factory may participate in.
* Use BeanFactoryUtils' beanNamesForTypeIncludingAncestors
* to include beans in ancestor factories too.
*
Note: Does not ignore singleton beans that have been registered
* by other means than bean definitions.
*
This version of getBeanNamesForType matches all kinds of beans, be it
* singletons, prototypes, or FactoryBeans. In most implementations, the
* result will be the same as for getBeanNamesOfType(type, true, true).
*
Bean names returned by this method should always return bean names in the
* order of definition in the backend configuration, as far as possible.
* @param type the class or interface to match, or null for all bean names
* @return the names of beans (or objects created by FactoryBeans) matching
* the given object type (including subclasses), or an empty array if none
* @see FactoryBean#getObjectType
* @see BeanFactoryUtils#beanNamesForTypeIncludingAncestors(ListableBeanFactory, Class)
*/
String[] getBeanNamesForType(Class type);
/**
* Return the names of beans matching the given type (including subclasses),
* judging from either bean definitions or the value of getObjectType
* in the case of FactoryBeans.
*
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).
$ *
Does not consider any hierarchy this factory may participate in.
* Use BeanFactoryUtils' beanNamesForTypeIncludingAncestors
* to include beans in ancestor factories too.
*
Note: Does not ignore singleton beans that have been registered
* by other means than bean definitions.
*
Bean names returned by this method should always return bean names in the
* order of definition in the backend configuration, as far as possible.
* @param type the class or interface to match, or null for all bean names
* @param includePrototypes whether to include prototype beans too
* or just singletons (also applies to FactoryBeans)
* @param 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.
* @return the names of beans (or objects created by FactoryBeans) matching
* the given object type (including subclasses), or an empty array if none
* @see FactoryBean#getObjectType
* @see BeanFactoryUtils#beanNamesForTypeIncludingAncestors(ListableBeanFactory, Class, boolean, boolean)
*/
String[] getBeanNamesForType(Class type, boolean includePrototypes, boolean allowEagerInit);
/**
* Return the bean instances that match the given object type (including
* subclasses), judging from either bean definitions or the value of
* getObjectType in the case of FactoryBeans.
*
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.
*
Does not consider any hierarchy this factory may participate in.
* Use BeanFactoryUtils' beansOfTypeIncludingAncestors
* to include beans in ancestor factories too.
*
Note: Does not ignore singleton beans that have been registered
* by other means than bean definitions.
*
This version of getBeansOfType matches all kinds of beans, be it
* singletons, prototypes, or FactoryBeans. In most implementations, the
* result will be the same as for getBeansOfType(type, true, true).
*
The Map returned by this method should always return bean names and
* corresponding bean instances in the order of definition in the
* backend configuration, as far as possible. This will usually mean that
* either JDK 1.4 or Commons Collections needs to be available.
* @param type the class or interface to match, or null for all concrete beans
* @return a Map with the matching beans, containing the bean names as
* keys and the corresponding bean instances as values
* @throws BeansException if a bean could not be created
* @since 1.1.2
* @see FactoryBean#getObjectType
* @see BeanFactoryUtils#beansOfTypeIncludingAncestors(ListableBeanFactory, Class)
*/
Map getBeansOfType(Class type) throws BeansException;
/**
* Return the bean instances that match the given object type (including
* subclasses), judging from either bean definitions or the value of
* getObjectType in the case of FactoryBeans.
*
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).
*
Does not consider any hierarchy this factory may participate in.
* Use BeanFactoryUtils' beansOfTypeIncludingAncestors
* to include beans in ancestor factories too.
*
Note: Does not ignore singleton beans that have been registered
* by other means than bean definitions.
*
The Map returned by this method should always return bean names and
* corresponding bean instances in the order of definition in the
* backend configuration, as far as possible. This will usually mean that
* either JDK 1.4 or Commons Collections needs to be available.
* @param type the class or interface to match, or null for all concrete beans
* @param includePrototypes whether to include prototype beans too
* or just singletons (also applies to FactoryBeans)
* @param 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.
* @return a Map with the matching beans, containing the bean names as
* keys and the corresponding bean instances as values
* @throws BeansException if a bean could not be created
* @see FactoryBean#getObjectType
* @see BeanFactoryUtils#beansOfTypeIncludingAncestors(ListableBeanFactory, Class, boolean, boolean)
*/
Map getBeansOfType(Class type, boolean includePrototypes, boolean allowEagerInit)
throws BeansException;
}