org.springframework.beans.factory.config.ServiceLocatorFactoryBean Maven / Gradle / Ivy
/*
* Copyright 2002-2017 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
*
* https://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.config;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Properties;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.FatalBeanException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;
/**
* A {@link FactoryBean} implementation that takes an interface which must have one or more
* methods with the signatures {@code MyType xxx()} or {@code MyType xxx(MyIdType id)}
* (typically, {@code MyService getService()} or {@code MyService getService(String id)})
* and creates a dynamic proxy which implements that interface, delegating to an
* underlying {@link org.springframework.beans.factory.BeanFactory}.
*
* Such service locators permit the decoupling of calling code from
* the {@link 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 {@code 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
* {@link 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
* {@link 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
* {@code toString}. The resulting String can be used as bean name as-is,
* provided that corresponding beans are defined in the bean factory.
* Alternatively, {@linkplain #setServiceMappings(java.util.Properties) 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 dependent on any Spring APIs.
*
*
package a.b.c;
*
*public interface ServiceFactory {
*
* public MyService getService();
*}
*
* A sample config in an XML-based
* {@link 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 {@code 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 dependent on any Spring APIs.
*
*
package a.b.c;
*
*public interface ServiceFactory {
*
* public MyService getService (String serviceName);
*}
*
* A sample config in an XML-based
* {@link 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 {@code 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 {@link ObjectFactoryCreatingFactoryBean} for an alternate approach.
*
* @author Colin Sampaleanu
* @author Juergen Hoeller
* @since 1.1.4
* @see #setServiceLocatorInterface
* @see #setServiceMappings
* @see ObjectFactoryCreatingFactoryBean
*/
public class ServiceLocatorFactoryBean implements FactoryBean