BATCH-1701: Implementation of JobScope

* Updated Job and Step scopes to use common class introduced by jpraet
* Updated Job and Step Synchronization Managers to use common class
 introduced by jpraet
* Updated JobScope related code to not be concerned with Spring 2.5
 (which is what batch was on when the PR was opened).

Author: mminella

spring-batch-core/src/main/java/org/springframework/batch/core/job/AbstractJob.java

@@ -335,9 +335,9 @@ public final void execute(JobExecution execution) {
 				if (execution.getStatus().isLessThanOrEqualTo(BatchStatus.STOPPED)
 						&& execution.getStepExecutions().isEmpty()) {
 					ExitStatus exitStatus = execution.getExitStatus();
-					execution
-					.setExitStatus(exitStatus.and(ExitStatus.NOOP
-							.addExitDescription("All steps already completed or no steps configured for this job.")));
+					ExitStatus newExitStatus =
+							ExitStatus.NOOP.addExitDescription("All steps already completed or no steps configured for this job.");
+					execution.setExitStatus(exitStatus.and(newExitStatus));
 				}
 
 				execution.setEndTime(new Date());

spring-batch-core/src/main/java/org/springframework/batch/core/scope/BatchScopeSupport.java

@@ -0,0 +1,226 @@
+/*
+ * Copyright 2013 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.batch.core.scope;
+
+import org.springframework.aop.scope.ScopedProxyUtils;
+import org.springframework.batch.core.scope.context.StepContext;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.BeanDefinitionHolder;
+import org.springframework.beans.factory.config.BeanDefinitionVisitor;
+import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.config.Scope;
+import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.core.Ordered;
+import org.springframework.util.Assert;
+import org.springframework.util.StringValueResolver;
+
+/**
+ * ScopeSupport.
+ *
+ * @author Michael Minella
+ * @since 3.0
+ */
+public abstract class BatchScopeSupport implements Scope, BeanFactoryPostProcessor, Ordered {
+
+	private boolean autoProxy = true;
+
+	private boolean proxyTargetClass = false;
+
+	private String name;
+
+	private int order = Ordered.LOWEST_PRECEDENCE;
+
+	/**
+	 * @param order the order value to set priority of callback execution for
+	 * the {@link BeanFactoryPostProcessor} part of this scope bean.
+	 */
+	public void setOrder(int order) {
+		this.order = order;
+	}
+
+	@Override
+	public int getOrder() {
+		return order;
+	}
+
+	public String getName() {
+		return this.name;
+	}
+
+	/**
+	 * Public setter for the name property. This can then be used as a bean
+	 * definition attribute, e.g. scope="job".
+	 *
+	 * @param name the name to set for this scope.
+	 */
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	/**
+	 * Flag to indicate that proxies should use dynamic subclassing. This allows
+	 * classes with no interface to be proxied. Defaults to false.
+	 *
+	 * @param proxyTargetClass set to true to have proxies created using dynamic
+	 * subclasses
+	 */
+	public void setProxyTargetClass(boolean proxyTargetClass) {
+		this.proxyTargetClass = proxyTargetClass;
+	}
+
+	/**
+	 * Flag to indicate that bean definitions need not be auto proxied. This gives control back to the declarer of the
+	 * bean definition (e.g. in an @Configuration class).
+	 *
+	 * @param autoProxy the flag value to set (default true)
+	 */
+	public void setAutoProxy(boolean autoProxy) {
+		this.autoProxy = autoProxy;
+	}
+
+	public abstract String getTargetNamePrefix();
+
+	/**
+	 * Register this scope with the enclosing BeanFactory.
+	 *
+	 * @see BeanFactoryPostProcessor#postProcessBeanFactory(ConfigurableListableBeanFactory)
+	 *
+	 * @param beanFactory the BeanFactory to register with
+	 * @throws BeansException if there is a problem.
+	 */
+	@Override
+	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
+
+		beanFactory.registerScope(name, this);
+
+		if(!autoProxy) {
+			return;
+		}
+
+		Assert.state(beanFactory instanceof BeanDefinitionRegistry,
+				"BeanFactory was not a BeanDefinitionRegistry, so JobScope cannot be used.");
+		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
+
+		for (String beanName : beanFactory.getBeanDefinitionNames()) {
+			if (!beanName.startsWith(getTargetNamePrefix())) {
+				BeanDefinition definition = beanFactory.getBeanDefinition(beanName);
+				// Replace this or any of its inner beans with scoped proxy if it
+				// has this scope
+				boolean scoped = name.equals(definition.getScope());
+				Scopifier scopifier = new Scopifier(registry, name, proxyTargetClass, scoped);
+				scopifier.visitBeanDefinition(definition);
+
+				if (scoped && !definition.isAbstract()) {
+					createScopedProxy(beanName, definition, registry, proxyTargetClass);
+				}
+			}
+		}
+
+	}
+
+	/**
+	 * Wrap a target bean definition in a proxy that defers initialization until
+	 * after the {@link StepContext} is available. Amounts to adding
+	 * <aop-auto-proxy/> to a step scoped bean.
+	 *
+	 * @param beanName the bean name to replace
+	 * @param definition the bean definition to replace
+	 * @param registry the enclosing {@link BeanDefinitionRegistry}
+	 * @param proxyTargetClass true if we need to force use of dynamic
+	 * subclasses
+	 * @return a {@link BeanDefinitionHolder} for the new representation of the
+	 * target. Caller should register it if needed to be visible at top level in
+	 * bean factory.
+	 */
+	protected static BeanDefinitionHolder createScopedProxy(String beanName, BeanDefinition definition,
+			BeanDefinitionRegistry registry, boolean proxyTargetClass) {
+
+		BeanDefinitionHolder proxyHolder;
+
+		proxyHolder = ScopedProxyUtils.createScopedProxy(new BeanDefinitionHolder(definition, beanName), registry,
+				proxyTargetClass);
+
+		registry.registerBeanDefinition(beanName, proxyHolder.getBeanDefinition());
+
+		return proxyHolder;
+
+	}
+
+	/**
+	 * Helper class to scan a bean definition hierarchy and force the use of
+	 * auto-proxy for step scoped beans.
+	 *
+	 * @author Dave Syer
+	 *
+	 */
+	protected static class Scopifier extends BeanDefinitionVisitor {
+
+		private final boolean proxyTargetClass;
+
+		private final BeanDefinitionRegistry registry;
+
+		private final String scope;
+
+		private final boolean scoped;
+
+		public Scopifier(BeanDefinitionRegistry registry, String scope, boolean proxyTargetClass, boolean scoped) {
+			super(new StringValueResolver() {
+				@Override
+				public String resolveStringValue(String value) {
+					return value;
+				}
+			});
+			this.registry = registry;
+			this.proxyTargetClass = proxyTargetClass;
+			this.scope = scope;
+			this.scoped = scoped;
+		}
+
+		@Override
+		protected Object resolveValue(Object value) {
+
+			BeanDefinition definition = null;
+			String beanName = null;
+			if (value instanceof BeanDefinition) {
+				definition = (BeanDefinition) value;
+				beanName = BeanDefinitionReaderUtils.generateBeanName(definition, registry);
+			}
+			else if (value instanceof BeanDefinitionHolder) {
+				BeanDefinitionHolder holder = (BeanDefinitionHolder) value;
+				definition = holder.getBeanDefinition();
+				beanName = holder.getBeanName();
+			}
+
+			if (definition != null) {
+				boolean nestedScoped = scope.equals(definition.getScope());
+				boolean scopeChangeRequiresProxy = !scoped && nestedScoped;
+				if (scopeChangeRequiresProxy) {
+					// Exit here so that nested inner bean definitions are not
+					// analysed
+					return createScopedProxy(beanName, definition, registry, proxyTargetClass);
+				}
+			}
+
+			// Nested inner bean definitions are recursively analysed here
+			value = super.resolveValue(value);
+			return value;
+
+		}
+	}
+}

spring-batch-core/src/main/java/org/springframework/batch/core/scope/JobScope.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2006-2007 the original author or authors.
+ * Copyright 2006-2013 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.
@@ -19,8 +19,6 @@
 import org.apache.commons.logging.LogFactory;
 import org.springframework.batch.core.scope.context.JobContext;
 import org.springframework.batch.core.scope.context.JobSynchronizationManager;
-import org.springframework.batch.core.scope.util.ContextFactory;
-import org.springframework.batch.core.scope.util.JobContextFactory;
 import org.springframework.beans.BeanWrapper;
 import org.springframework.beans.BeanWrapperImpl;
 import org.springframework.beans.factory.ObjectFactory;
@@ -32,31 +30,34 @@
  * job. All objects in this scope are <aop:scoped-proxy/> (no need to
  * decorate the bean definitions).<br/>
  * <br/>
- * 
+ *
  * In addition, support is provided for late binding of references accessible
  * from the {@link JobContext} using #{..} placeholders. Using this feature,
  * bean properties can be pulled from the job or job execution context and the
  * job parameters. E.g.
- * 
+ *
  * <pre>
  * &lt;bean id=&quot;...&quot; class=&quot;...&quot; scope=&quot;job&quot;&gt;
  * 	&lt;property name=&quot;name&quot; value=&quot;#{jobParameters[input]}&quot; /&gt;
  * &lt;/bean&gt;
- * 
+ *
  * &lt;bean id=&quot;...&quot; class=&quot;...&quot; scope=&quot;job&quot;&gt;
  * 	&lt;property name=&quot;name&quot; value=&quot;#{jobExecutionContext['input.stem']}.txt&quot; /&gt;
  * &lt;/bean&gt;
  * </pre>
- * 
+ *
  * The {@link JobContext} is referenced using standard bean property paths (as
  * per {@link BeanWrapper}). The examples above all show the use of the Map
  * accessors provided as a convenience for job attributes.
- * 
+ *
  * @author Dave Syer
  * @author Jimmy Praet (create JobScope based on {@link StepScope})
- * @since 2.0
+ * @author Michael Minella
+ * @since 3.0
  */
-public class JobScope extends ScopeSupport {
+public class JobScope extends BatchScopeSupport {
+
+	private static final String TARGET_NAME_PREFIX = "jobScopedTarget.";
 
 	private Log logger = LogFactory.getLog(getClass());
 
@@ -67,20 +68,15 @@ public class JobScope extends ScopeSupport {
 	 */
 	public static final String ID_KEY = "JOB_IDENTIFIER";
 
-	/**
-	 * The ContextFactory.
-	 */
-	private static final ContextFactory CONTEXT_FACTORY = new JobContextFactory();
-
 	public JobScope() {
-		super("job", CONTEXT_FACTORY);
+		super();
+		setName("job");
 	}
 
 	/**
-	 * If Spring 3.0 is available, this will be used to resolve expressions in
-	 * job-scoped beans. This method is part of the Scope SPI in Spring 3.0,
-	 * but should just be ignored by earlier versions of Spring.
+	 * This will be used to resolve expressions in job-scoped beans.
 	 */
+	@Override
 	public Object resolveContextualObject(String key) {
 		JobContext context = getContext();
 		// TODO: support for attributes as well maybe (setters not exposed yet
@@ -91,8 +87,9 @@ public Object resolveContextualObject(String key) {
 	/**
 	 * @see Scope#get(String, ObjectFactory)
 	 */
+	@SuppressWarnings("rawtypes")
+	@Override
 	public Object get(String name, ObjectFactory objectFactory) {
-
 		JobContext context = getContext();
 		Object scopedObject = context.getAttribute(name);
 
@@ -118,6 +115,7 @@ public Object get(String name, ObjectFactory objectFactory) {
 	/**
 	 * @see Scope#getConversationId()
 	 */
+	@Override
 	public String getConversationId() {
 		JobContext context = getContext();
 		return context.getId();
@@ -126,6 +124,7 @@ public String getConversationId() {
 	/**
 	 * @see Scope#registerDestructionCallback(String, Runnable)
 	 */
+	@Override
 	public void registerDestructionCallback(String name, Runnable callback) {
 		JobContext context = getContext();
 		logger.debug(String.format("Registered destruction callback in scope=%s, name=%s", this.getName(), name));
@@ -135,6 +134,7 @@ public void registerDestructionCallback(String name, Runnable callback) {
 	/**
 	 * @see Scope#remove(String)
 	 */
+	@Override
 	public Object remove(String name) {
 		JobContext context = getContext();
 		logger.debug(String.format("Removing from scope=%s, name=%s", this.getName(), name));
@@ -144,7 +144,7 @@ public Object remove(String name) {
 	/**
 	 * Get an attribute accessor in the form of a {@link JobContext} that can
 	 * be used to store scoped bean instances.
-	 * 
+	 *
 	 * @return the current job context which we can use as a scope storage
 	 *         medium
 	 */
@@ -156,4 +156,8 @@ private JobContext getContext() {
 		return context;
 	}
 
-}
+	@Override
+	public String getTargetNamePrefix() {
+		return TARGET_NAME_PREFIX;
+	}
+}