ObjectFactoryCreatingFactoryBean creates a serializable ObjectFactory reference; added ProviderCreatingFactoryBean, exposing a serializable JSR-330 Provider reference (SPR-6998)

org.springframework.beans/src/main/java/org/springframework/beans/factory/config/ObjectFactoryCreatingFactoryBean.java

@@ -16,7 +16,10 @@
 
 package org.springframework.beans.factory.config;
 
+import java.io.Serializable;
+
 import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.util.Assert;
 
@@ -41,7 +44,7 @@ import org.springframework.util.Assert;
  * <pre class="code">&lt;beans&gt;
  *
  *   &lt;!-- Prototype bean since we have state --&gt;
- *   &lt;bean id="myService" class="a.b.c.MyService" singleton="false"/&gt;
+ *   &lt;bean id="myService" class="a.b.c.MyService" scope="prototype"/&gt;
  *
  *   &lt;bean id="myServiceFactory"
  *       class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean"&gt;
@@ -63,9 +66,9 @@ import org.springframework.util.Assert;
  *
  * public class MyClientBean {
  *
- *   private ObjectFactory myServiceFactory;
+ *   private ObjectFactory&lt;MyService&gt; myServiceFactory;
  *
- *   public void setMyServiceFactory(ObjectFactory myServiceFactory) {
+ *   public void setMyServiceFactory(ObjectFactory&lt;MyService&gt; myServiceFactory) {
  *     this.myServiceFactory = myServiceFactory;
  *   }
  *
@@ -98,13 +101,10 @@ public class ObjectFactoryCreatingFactoryBean extends AbstractFactoryBean<Object
 
 	/**
 	 * Set the name of the target bean.
-	 * <p>The target does not <i>have</> to be a prototype bean, but realisticially
-	 * always will be (because if the target bean were a singleton, then said
-	 * singleton bean could simply be injected straight into the dependent object,
-	 * thus obviating the need for the extra level of indirection afforded by
-	 * the approach encapsulated by this class). Please note that no exception
-	 * will be thrown if the supplied <code>targetBeanName</code> does not
-	 * reference a prototype bean.
+	 * <p>The target does not <i>have</> to be a non-singleton bean, but realisticially
+	 * always will be (because if the target bean were a singleton, then said singleton
+	 * bean could simply be injected straight into the dependent object, thus obviating
+	 * the need for the extra level of indirection afforded by this factory approach).
 	 */
 	public void setTargetBeanName(String targetBeanName) {
 		this.targetBeanName = targetBeanName;
@@ -124,21 +124,27 @@ public class ObjectFactoryCreatingFactoryBean extends AbstractFactoryBean<Object
 
 	@Override
 	protected ObjectFactory createInstance() {
-		return new ObjectFactory() {
-			public Object getObject() throws BeansException {
-				return getTargetBean(targetBeanName);
-			}
-		};
+		return new TargetBeanObjectFactory(getBeanFactory(), this.targetBeanName);
 	}
 
+
 	/**
-	 * Template method for obtaining a target bean instance.
-	 * Called by the exposed ObjectFactory's <code>getObject()</code> method.
-	 * @param targetBeanName the name of the target bean
-	 * @return the target bean instance
+	 * Independent inner class - for serialization purposes.
 	 */
-	protected Object getTargetBean(String targetBeanName) {
-		return getBeanFactory().getBean(targetBeanName);
+	private static class TargetBeanObjectFactory implements ObjectFactory, Serializable {
+
+		private final BeanFactory beanFactory;
+
+		private final String targetBeanName;
+
+		public TargetBeanObjectFactory(BeanFactory beanFactory, String targetBeanName) {
+			this.beanFactory = beanFactory;
+			this.targetBeanName = targetBeanName;
+		}
+
+		public Object getObject() throws BeansException {
+			return this.beanFactory.getBean(this.targetBeanName);
+		}
 	}
 
 }

org.springframework.beans/src/main/java/org/springframework/beans/factory/config/ProviderCreatingFactoryBean.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2002-2010 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.config;
+
+import java.io.Serializable;
+import javax.inject.Provider;
+
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.util.Assert;
+
+/**
+ * A {@link org.springframework.beans.factory.FactoryBean} implementation that
+ * returns a value which is a JSR-330 {@link javax.inject.Provider} that in turn
+ * returns a bean sourced from a {@link org.springframework.beans.factory.BeanFactory}.
+ *
+ * <p>This is basically a JSR-330 compliant variant of Spring's good old
+ * {@link ObjectFactoryCreatingFactoryBean}. It can be used for traditional
+ * external dependency injection configuration that targets a property or
+ * constructor argument of type <code>javax.inject.Provider</code>, as an
+ * alternative to JSR-330's <code>@Inject</code> annotation-driven approach.
+ *
+ * @author Juergen Hoeller
+ * @since 3.0.2
+ * @see javax.inject.Provider
+ * @see ObjectFactoryCreatingFactoryBean
+ */
+public class ProviderCreatingFactoryBean extends AbstractFactoryBean<Provider> {
+
+	private String targetBeanName;
+
+
+	/**
+	 * Set the name of the target bean.
+	 * <p>The target does not <i>have</> to be a non-singleton bean, but realisticially
+	 * always will be (because if the target bean were a singleton, then said singleton
+	 * bean could simply be injected straight into the dependent object, thus obviating
+	 * the need for the extra level of indirection afforded by this factory approach).
+	 */
+	public void setTargetBeanName(String targetBeanName) {
+		this.targetBeanName = targetBeanName;
+	}
+
+	@Override
+	public void afterPropertiesSet() throws Exception {
+		Assert.hasText(this.targetBeanName, "Property 'targetBeanName' is required");
+		super.afterPropertiesSet();
+	}
+
+
+	@Override
+	public Class getObjectType() {
+		return Provider.class;
+	}
+
+	@Override
+	protected Provider createInstance() {
+		return new TargetBeanProvider(getBeanFactory(), this.targetBeanName);
+	}
+
+
+	/**
+	 * Independent inner class - for serialization purposes.
+	 */
+	private static class TargetBeanProvider implements Provider, Serializable {
+
+		private final BeanFactory beanFactory;
+
+		private final String targetBeanName;
+
+		public TargetBeanProvider(BeanFactory beanFactory, String targetBeanName) {
+			this.beanFactory = beanFactory;
+			this.targetBeanName = targetBeanName;
+		}
+
+		public Object get() throws BeansException {
+			return this.beanFactory.getBean(this.targetBeanName);
+		}
+	}
+
+}