java.lang.Object
   org.springframework.beans.factory.config.ServiceLocatorFactoryBean

All Implemented Interfaces:
    BeanFactoryAware, InitializingBean, FactoryBean

Such service locators permit the decoupling of calling code from the org.springframework.beans.factory.BeanFactory API, by using an appropriate custom locator interface. They will typically be used for prototype beans, i.e. for factory methods that are supposed to return a new instance for each call. The client receives a reference to the service locator via setter or constructor injection, to be able to invoke the locator's factory methods on demand. For singleton beans, direct setter or constructor injection of the target bean is preferable.

On invocation of the no-arg factory method, or the single-arg factory method with a String id of null or empty String, if exactly one bean in the factory matches the return type of the factory method, that bean is returned, otherwise a org.springframework.beans.factory.NoSuchBeanDefinitionException is thrown.

On invocation of the single-arg factory method with a non-null (and non-empty) argument, the proxy returns the result of a org.springframework.beans.factory.BeanFactory#getBean(String) call, using a stringified version of the passed-in id as bean name.

A factory method argument will usually be a String, but can also be an int or a custom enumeration type, for example, stringified via toString. The resulting String can be used as bean name as-is, provided that corresponding beans are defined in the bean factory. Alternatively, a custom mapping between service ids and bean names can be defined.

By way of an example, consider the following service locator interface. Note that this interface is not dependant on any Spring APIs.

package a.b.c;

public interface ServiceFactory {

public MyService getService ();
}

A sample config in an XML-based org.springframework.beans.factory.BeanFactory might look as follows:

<beans>

<!-- Prototype bean since we have state -->
<bean id="myService" class="a.b.c.MyService" singleton="false"/>

<!-- will lookup the above 'myService' bean by *TYPE* -->
<bean id="myServiceFactory"
class="org.springframework.beans.factory.config.ServiceLocatorFactoryBean">
<property name="serviceLocatorInterface" value="a.b.c.ServiceFactory"/>
</bean>

<bean id="clientBean" class="a.b.c.MyClientBean">
<property name="myServiceFactory" ref="myServiceFactory"/>
</bean>

</beans>

The attendant MyClientBean class implementation might then look something like this:

package a.b.c;

public class MyClientBean {

private ServiceFactory myServiceFactory;

// actual implementation provided by the Spring container
public void setServiceFactory(ServiceFactory myServiceFactory) {
this.myServiceFactory = myServiceFactory;
}

public void someBusinessMethod() {
// get a 'fresh', brand new MyService instance
MyService service = this.myServiceFactory.getService();
// use the service object to effect the business logic...
}
}

By way of an example that looks up a bean by name, consider the following service locator interface. Again, note that this interface is not dependant on any Spring APIs.

package a.b.c;

public interface ServiceFactory {

public MyService getService (String serviceName);
}

A sample config in an XML-based org.springframework.beans.factory.BeanFactory might look as follows:

<beans>

<!-- Prototype beans since we have state (both extend MyService) -->
<bean id="specialService" class="a.b.c.SpecialService" singleton="false"/>
<bean id="anotherService" class="a.b.c.AnotherService" singleton="false"/>

<bean id="myServiceFactory"
class="org.springframework.beans.factory.config.ServiceLocatorFactoryBean">
<property name="serviceLocatorInterface" value="a.b.c.ServiceFactory"/>
</bean>

<bean id="clientBean" class="a.b.c.MyClientBean">
<property name="myServiceFactory" ref="myServiceFactory"/>
</bean>

</beans>

The attendant MyClientBean class implementation might then look something like this:

package a.b.c;

public class MyClientBean {

private ServiceFactory myServiceFactory;

// actual implementation provided by the Spring container
public void setServiceFactory(ServiceFactory myServiceFactory) {
this.myServiceFactory = myServiceFactory;
}

public void someBusinessMethod() {
// get a 'fresh', brand new MyService instance
MyService service = this.myServiceFactory.getService("specialService");
// use the service object to effect the business logic...
}

public void anotherBusinessMethod() {
// get a 'fresh', brand new MyService instance
MyService service = this.myServiceFactory.getService("anotherService");
// use the service object to effect the business logic...
}
}

See ObjectFactoryCreatingFactoryBean for an alternate approach.

Also see:

setServiceLocatorInterface
setServiceMappings
ObjectFactoryCreatingFactoryBean
author: Colin - Sampaleanu

author: Juergen - Hoeller

since: 1.1.4 -

 public  void afterPropertiesSet() 
{
		if (this.serviceLocatorInterface == null) {
			throw new IllegalArgumentException("Property 'serviceLocatorInterface' is required");
		}
		// Create service locator proxy.
		this.proxy = Proxy.newProxyInstance(
				this.serviceLocatorInterface.getClassLoader(),
				new Class[] {this.serviceLocatorInterface},
				new ServiceLocatorInvocationHandler());
}

 protected Exception createServiceLocatorException(Constructor exceptionConstructor,
    BeansException cause) 
{
		Class[] paramTypes = exceptionConstructor.getParameterTypes();
		Object[] args = new Object[paramTypes.length];
		for (int i = 0; i <  paramTypes.length; i++) {
			if (paramTypes[i].equals(String.class)) {
				args[i] = cause.getMessage();
			}
			else if (paramTypes[i].isInstance(cause)) {
				args[i] = cause;
			}
		}
		return (Exception) BeanUtils.instantiateClass(exceptionConstructor, args);
}

 protected Constructor determineServiceLocatorExceptionConstructor(Class exceptionClass) 
{
		try {
			return exceptionClass.getConstructor(new Class[] {String.class, Throwable.class});
		}
		catch (NoSuchMethodException ex) {
			try {
				return exceptionClass.getConstructor(new Class[] {Throwable.class});
			}
			catch (NoSuchMethodException ex2) {
				try {
					return exceptionClass.getConstructor(new Class[] {String.class});
				}
				catch (NoSuchMethodException ex3) {
					throw new IllegalArgumentException(
							"Service locator exception [" + exceptionClass.getName() +
							"] neither has a (String, Throwable) constructor nor a (String) constructor");
				}
			}
		}
}

 public Object getObject() 
{
		return this.proxy;
}

 public Class getObjectType() 
{
		return this.serviceLocatorInterface;
}

 public boolean isSingleton() 
{
		return true;
}

 public  void setBeanFactory(BeanFactory beanFactory) throws BeansException 
{
		if (!(beanFactory instanceof ListableBeanFactory)) {
			throw new FatalBeanException(
					"ServiceLocatorFactoryBean needs to run in a BeanFactory that is a ListableBeanFactory");
		}
		this.beanFactory = (ListableBeanFactory) beanFactory;
}

 public  void setServiceLocatorExceptionClass(Class serviceLocatorExceptionClass) 
{
		if (serviceLocatorExceptionClass != null && !Exception.class.isAssignableFrom(serviceLocatorExceptionClass)) {
			throw new IllegalArgumentException(
					"serviceLocatorException [" + serviceLocatorExceptionClass.getName() + "] is not a subclass of Exception");
		}
		this.serviceLocatorExceptionConstructor =
				determineServiceLocatorExceptionConstructor(serviceLocatorExceptionClass);
}

 public  void setServiceLocatorInterface(Class interfaceType) 
{
		this.serviceLocatorInterface = interfaceType;
}

 public  void setServiceMappings(Properties serviceMappings) 
{
		this.serviceMappings = serviceMappings;
}