org.springframework.beans.factory.access
Class SingletonBeanFactoryLocator

Direct Known Subclasses:

DefaultBeanFactoryLocator

public class SingletonBeanFactoryLocator

implements BeanFactoryLocator

Keyed-singleton implementation of BeanFactoryLocator, which leverages existing Spring constructs. This is normally accessed through LocatorFactory, but may also be used directly.

Please see the warning in BeanFactoryLocator's JavaDoc about appropriate usage of singleton style BeanFactoryLocator implementations. It is the opinion of the Spring team that the use of this class and similar classes is unecessary except (sometimes) for a small amount of glue code. Excessive usage will lead to code that is more tightly coupled, and harder to modify or test.

In this implementation, an ApplicationContext is built up from one or more XML definition files, accessed as resources. The default name of the resource file(s) is 'beanRefFactory.xml', which is used when the instance is obtained with the no-arg getInstance() method. Using getInstance(java.lang.String) will return a singleton instance which will use a name for the resource file(s) which is the specificed selector argument, instead of the default. The purpose of this Application Context is to create and hold a copy of one or more 'real' BeanFactory or Application Context instances, and allow those to be obtained either directly or via an alias. As such, it provides a level of indirection, and allows multiple pieces of code, which are not able to work in a Dependency Injection fashion, to refer to and use the same target BeanFactory/ApplicationContext instance(s), by different names.

Consider an example application scenario:

com.mycompany.myapp.util.applicationContext.xml - ApplicationContext definition file which defines beans for 'util' layer.
com.mycompany.myapp.dataaccess-applicationContext.xml - ApplicationContext definition file which defines beans for 'data access' layer. Depends on the above
com.mycompany.myapp.services.applicationContext.xml - ApplicationContext definition file which defines beans for 'services' layer. Depends on the above

In an ideal scenario, these would be combined to create one ApplicationContext, or created as three hierarchical ApplicationContexts, by one piece of code somewhere at application startup (perhaps a Servlet filter), from which all other code in the application would flow, obtained as beans from the context(s). However when third party code enters into the picture, things can get problematic. If the third party code needs to create user classes, which should normally be obtained from a Spring BeanFactory/ApplicationContext, but can handle only newInstance() style object creation, then some extra work is required to actually access and use object from a BeanFactory/ApplicationContext. One solutions is to make the class created by the third party code be just a stub or proxy, which gets the real object from a BeanFactory/ApplicationContext, and delegates to it. However, it is is not normally workable for the stub to create the BeanFactory on each use, as depending on what is inside it, that can be an expensive operation. Additionally, there is a fairly tight coupling between the stub and the name of the definition resource for the BeanFactory/ApplicationContext. This is where KeyedSingletonBeanFactoryLocator comes in. The stub can obtain a KeyedSingletonBeanFactoryLocator instance, which is effectively a singleton, and ask it for an appropriate BeanFactory. A subsequent invocation (assuming the same classloader is involved) by the stub or another piece of code, will obtain the same instance. The simple aliasing mechanism allows the context to be asked for by a name which is appropriate for (or describes) the user. The deployer can match alias names to actual context names.

Another use of KeyedSingletonBeanFactoryLocator, is to demand-load/use one or more BeanFactories/ApplicationContexts. Because the definiiton can contain one of more BeanFactories/ApplicationContexts, which can be independent or in a hierarchy, if they are set to lazy-initialize, they will only be created when actually requested for use.
Given the above=mentioned three ApplicationContexts, consider the simplest KeyedSingletonBeanFactoryLocator usage scenario, where there is only one single beanRefFactory.xml definition file:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

<bean id="com.mycompany.myapp"
class="org.springframework.context.support.ClassPathXmlApplicationContext">
<constructor-arg>
<list>
<value>com.mycompany.myapp.util.applicationContext.xml</value>
<value>com.mycompany.myapp.dataaccess.applicationContext.xml</value>
<value>com.mycompany.myapp.dataaccess.services.xml</value>
</list>
</constructor-arg>
</bean>

</beans>

BeanFactoryLocator bfl = KeyedSingletonBeanFactoryLocator.getInstance();
BeanFactoryReference bf = bfl.useFactory("com.mycompany.myapp");
// now use some bean from factory 
MyClass zed = bf.getFactory().getBean("mybean");

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

<bean id="com.mycompany.myapp.util" lazy-init="true"
class="org.springframework.context.support.ClassPathXmlApplicationContext">
<constructor-arg>
<value>com.mycompany.myapp.util.applicationContext.xml</value>
</constructor-arg>
</bean>

<!-- child of above -->
<bean id="com.mycompany.myapp.dataaccess" lazy-init="true"
class="org.springframework.context.support.ClassPathXmlApplicationContext">
<constructor-arg>
<value>com.mycompany.myapp.dataaccess.applicationContext.xml</value>
</constructor-arg>
<constructor-arg>
<ref bean="com.mycompany.myapp.util"/>
</constructor-arg>
</bean>

<!-- child of above -->
<bean id="com.mycompany.myapp.services" lazy-init="true"
class="org.springframework.context.support.ClassPathXmlApplicationContext">
<constructor-arg>
<value>com.mycompany.myapp.dataaccess.services.xml</value>
</constructor-arg>
<constructor-arg>
<ref bean="com.mycompany.myapp.dataaccess"/>
</constructor-arg>
</bean>

<!-- define an alias -->
<bean id="com.mycompany.myapp.mypackage"
class="java.lang.String">
<constructor-arg>
<value>com.mycompany.myapp.services</value>
</constructor-arg>
</bean>

</beans>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<bean id="com.mycompany.myapp.util" lazy-init="true"
class="org.springframework.context.support.ClassPathXmlApplicationContext">
<constructor-arg>
<value>com.mycompany.myapp.util.applicationContext.xml</value>
</constructor-arg>
</bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<!-- child of util -->
<bean id="com.mycompany.myapp.dataaccess" lazy-init="true"
class="org.springframework.context.support.ClassPathXmlApplicationContext">
<constructor-arg>
<value>com.mycompany.myapp.dataaccess.applicationContext.xml</value>
</constructor-arg>
<constructor-arg>
<ref bean="com.mycompany.myapp.util"/>
</constructor-arg>
</bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<!-- child of data-access -->
<bean id="com.mycompany.myapp.services" lazy-init="true"
class="org.springframework.context.support.ClassPathXmlApplicationContext">
<constructor-arg>
<value>com.mycompany.myapp.dataaccess.services.xml</value>
</constructor-arg>
<constructor-arg>
<ref bean="com.mycompany.myapp.dataaccess"/>
</constructor-arg>
</bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<!-- define an alias -->
<bean id="com.mycompany.myapp.mypackage"
class="java.lang.String">
<constructor-arg>
<value>com.mycompany.myapp.services</value>
</constructor-arg>
</bean>

</beans>

Author:

colin sampaleanu

Version: $Revision: 1.7 $

See Also: LocatorFactory

public final static String BEANS_REFS_XML_NAME

public static BeanFactoryLocator getInstance()
                                       throws org.springframework.beans.FatalBeanException

Returns an instance which uses the default "beanRefFactory.xml", as the name of the definition file(s). All resources returned by the current thread's context classloader's getResources() method with this name will be combined to create a definition, which is just a BeanFactory.

public static BeanFactoryLocator getInstance(String selector)
                                       throws org.springframework.beans.FatalBeanException

Returns an instance which uses the the specified selector, as the name of the definition file(s). All resources returned by the current thread's context classloader's getResources() method with this name will be combined to create a definition, which is just a a BeanFactory.

Parameters:

selector - the name of the resource(s) which will be read and combine to form the definition for the KeyedSingletonBeanFactoryLocator instance

public BeanFactoryReference useFactory(String factoryKey)
                                 throws org.springframework.beans.FatalBeanException

Association Links

to Class java.lang.String

to Class java.util.Map

to Class java.util.Map

to Class java.util.Map

to Class java.lang.String