GrepCode: org.springframework.beans.factory.config.ConfigurableListableBeanFactory (.java) - Interface

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

3.1.1.RELEASE
3.0.6.RELEASE
3.0.5.RELEASE
3.0.4.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.5
2.5.4
2.5.3
2.5.2
2.5.1
1.2.1
/
org.springframework.beans.factory.config.ConfigurableListableBeanFactory
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.config;
18
 
19
 import org.springframework.beans.BeansException;
20
 import org.springframework.beans.factory.ListableBeanFactory;
21
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;

 Configuration interface to be implemented by most listable bean factories.
 In addition to ConfigurableBeanFactory, it provides facilities to
 analyze and modify bean definitions, and to pre-instantiate singletons.

 This subinterface of org.springframework.beans.factory.BeanFactory
 is not meant to be used in normal application code: Stick to
 org.springframework.beans.factory.BeanFactory or
 org.springframework.beans.factory.ListableBeanFactory for typical
 use cases. This interface is just meant to allow for framework-internal
 plug'n'play even when needing access to bean factory configuration methods.

 
 Author(s):Juergen Hoeller Since:03.11.2003 See also:org.springframework.context.support.AbstractApplicationContext#getBeanFactory()
38
 
39
 public interface ConfigurableListableBeanFactory
40
 		extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {

	
 Ignore the given dependency type for autowiring:
 for example, String. Default is none.
 
 Parameters:type the dependency type to ignore
46
 
47
 	void ignoreDependencyType(Class type);

	
 Ignore the given dependency interface for autowiring.
 This will typically be used by application contexts to register
 dependencies that are resolved in other ways, like BeanFactory through
 BeanFactoryAware or ApplicationContext through ApplicationContextAware.
 
By default, only the BeanFactoryAware interface is ignored.
 For further types to ignore, invoke this method for each type.
 
 Parameters:ifc the dependency interface to ignore See also:org.springframework.beans.factory.BeanFactoryAwareorg.springframework.context.ApplicationContextAware
59
 
60
 	void ignoreDependencyInterface(Class ifc);

	
 Register a special dependency type with corresponding autowired value.
 This is intended for factory/context references that are supposed
 to be autowirable but are not defined as beans in the factory:
 e.g. a dependency of type ApplicationContext resolved to the
 ApplicationContext instance that the bean is living in.
 
Note: There are no such default types registered in a plain BeanFactory,
 not even for the BeanFactory interface itself.
 
 Parameters:dependencyType the dependency type to register. This will typically
 be a base interface such as BeanFactory, with extensions of it resolved
 as well if declared as an autowiring dependency (e.g. ListableBeanFactory),
 as long as the given value actually implements the extended interface.autowiredValue the corresponding autowired value. This may also be an
 implementation of the org.springframework.beans.factory.ObjectFactory
 interface, which allows for lazy resolution of the actual target value.
77
 
78
 	void registerResolvableDependency(Class dependencyType, Object autowiredValue);

	
 Determine whether the specified bean qualifies as an autowire candidate,
 to be injected into other beans which declare a dependency of matching type.
 This method checks ancestor factories as well.
 
 Parameters:beanName the name of the bean to checkdescriptor the descriptor of the dependency to resolve Returns:whether the bean should be considered as autowire candidate Throws:org.springframework.beans.factory.NoSuchBeanDefinitionException if there is no bean with the given name
88
 
89
 	boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
90
 			throws NoSuchBeanDefinitionException;

	
 Return the registered BeanDefinition for the specified bean, allowing access
 to its property values and constructor argument value (which can be
 modified during bean factory post-processing).
 A returned BeanDefinition object should not be a copy but the original
 definition object as registered in the factory. This means that it should
 be castable to a more specific implementation type, if necessary.
 
NOTE: This method does not consider ancestor factories.
 It is only meant for accessing local bean definitions of this factory.
 
 Parameters:beanName the name of the bean Returns:the registered BeanDefinition Throws:org.springframework.beans.factory.NoSuchBeanDefinitionException if there is no bean with the given name
 defined in this factory
105
106
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	
 Freeze all bean definitions, signalling that the registered bean definitions
 will not be modified or post-processed any further.
 This allows the factory to aggressively cache bean definition metadata.
 
112
113
	void freezeConfiguration();

	
 Return whether this factory's bean definitions are frozen,
 i.e. are not supposed to be modified or post-processed any further.
 
 Returns:true if the factory's configuration is considered frozen
119
120
	boolean isConfigurationFrozen();

	
 Ensure that all non-lazy-init singletons are instantiated, also considering
 FactoryBeans.
 Typically invoked at the end of factory setup, if desired.
 
 Throws:org.springframework.beans.BeansException if one of the singleton beans could not be created.
 Note: This may have left the factory with some beans already initialized!
 Call ConfigurableBeanFactory.destroySingletons() for full cleanup in this case. See also:ConfigurableBeanFactory.destroySingletons()
130
131
	void preInstantiateSingletons() throws BeansException;
132
133
}