Merge pull request #106 from dsyer/BATCH-1948

* BATCH-1948:
  BATCH-1948: Formatting and javadoc fixes
  BATCH-1948: Add @StepScope and associated tests

spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/AbstractBatchConfiguration.java

@@ -37,8 +37,7 @@ import org.springframework.util.Assert;
 
 /**
  * Base {@code Configuration} class providing common structure for enabling and using Spring Batch. Customization is
- * available by implementing the {@link BatchConfigurer} interface.
- * {@link BatchConfigurer}.
+ * available by implementing the {@link BatchConfigurer} interface. {@link BatchConfigurer}.
  * 
  * @author Dave Syer
  * @since 2.2
@@ -48,9 +47,6 @@ import org.springframework.util.Assert;
 @Import(StepScopeConfiguration.class)
 public abstract class AbstractBatchConfiguration implements ImportAware {
 
-	@Autowired
-	private StepScope stepScope;
-
 	@Autowired
 	private ApplicationContext context;
 
@@ -89,13 +85,10 @@ public abstract class AbstractBatchConfiguration implements ImportAware {
 				EnableBatchProcessing.class.getName(), false));
 		Assert.notNull(enabled,
 				"@EnableBatchProcessing is not present on importing class " + importMetadata.getClassName());
-		if (enabled.getBoolean("proxyTargetClass")) {
-			stepScope.setProxyTargetClass(true);
-		}
 	}
 
 	protected BatchConfigurer getConfigurer(Collection<BatchConfigurer> configurers) throws Exception {
-		if (this.configurer!=null) {
+		if (this.configurer != null) {
 			return this.configurer;
 		}
 		if (configurers == null || configurers.isEmpty()) {
@@ -134,6 +127,7 @@ class StepScopeConfiguration {
 
 	@Bean
 	public StepScope stepScope() {
+		stepScope.setAutoProxy(false);
 		return stepScope;
 	}
 

spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/EnableBatchProcessing.java

@@ -21,13 +21,11 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import javax.sql.DataSource;
-
+import org.springframework.batch.core.configuration.JobRegistry;
 import org.springframework.batch.core.configuration.support.ApplicationContextFactory;
 import org.springframework.batch.core.configuration.support.AutomaticJobRegistrar;
 import org.springframework.batch.core.launch.JobLauncher;
 import org.springframework.batch.core.repository.JobRepository;
-import org.springframework.batch.core.scope.StepScope;
 import org.springframework.context.annotation.Import;
 import org.springframework.transaction.PlatformTransactionManager;
 
@@ -35,61 +33,61 @@ import org.springframework.transaction.PlatformTransactionManager;
  * <p>
  * Enable Spring Batch features and provide a base configuration for setting up batch jobs in an &#064;Configuration
  * class, roughly equivalent to using the {@code <batch:*>} XML namespace.
- * 
+ *
  * <pre class="code">
  * &#064;Configuration
  * &#064;EnableBatchProcessing
  * &#064;Import(DataSourceCnfiguration.class)
  * public class AppConfig {
- * 
+ *
  * 	&#064;Autowired
  * 	private JobBuilderFactory jobs;
- * 
+ *
  * 	&#064;Bean
  * 	public Job job() {
  * 		return jobs.get(&quot;myJob&quot;).start(step1()).next(step2()).build();
  * 	}
- * 
+ *
  * 	&#064;Bean
  *    protected Step step1() {
  *       ...
  *    }
- * 
+ *
  * 	&#064;Bean
  *    protected Step step2() {
  *     ...
  *    }
  * }
  * </pre>
- * 
+ *
  * The user has to provide a {@link DataSource} as a bean in the context, or else implement {@link BatchConfigurer} in
  * the configuration class itself, e.g.
- * 
+ *
  * <pre class="code">
  * &#064;Configuration
  * &#064;EnableBatchProcessing
  * public class AppConfig extends DefaultBatchConfigurer {
- * 
+ *
  *    &#064;Bean
  *    public Job job() {
  *       ...
  *    }
- * 
+ *
  *    &#064;Override
  *    protected JobRepository createJobRepository() {
  *       ...
  *    }
- *  
+ *
  *  ...
- *  
+ *
  * }
  * </pre>
- * 
+ *
  * Note that only one of your configuration classes needs to have the <code>&#064;EnableBatchProcessing</code>
  * annotation. Once you have an <code>&#064;EnableBatchProcessing</code> class in your configuration you will have an
  * instance of {@link StepScope} so your beans inside steps can have <code>&#064;Scope("step")</code>. You will also be
  * able to <code>&#064;Autowired</code> some useful stuff into your context:
- * 
+ *
  * <ul>
  * <li>a {@link JobRepository} (bean name "jobRepository")</li>
  * <li>a {@link JobLauncher} (bean name "jobLauncher")</li>
@@ -100,43 +98,43 @@ import org.springframework.transaction.PlatformTransactionManager;
  * <li>a {@link StepBuilderFactory} (bean name "stepBuilders") as a convenience to prevent you from having to inject the
  * job repository and transaction manager into every step</li>
  * </ul>
- * 
+ *
  * If the configuration is specified as <code>modular=true</code> then the context will also contain an
  * {@link AutomaticJobRegistrar}. The job registrar is useful for modularizing your configuration if there are multiple
  * jobs. It works by creating separate child application contexts containing job configurations and registering those
  * jobs. The jobs can then create steps and other dependent components without needing to worry about bean definition
  * name clashes. Beans of type {@link ApplicationContextFactory} will be registered automatically with the job
  * registrar. Example:
- * 
+ *
  * <pre class="code">
  * &#064;Configuration
  * &#064;EnableBatchProcessing(modular=true)
  * public class AppConfig {
- * 
+ *
  *    &#064;Bean
  *    public ApplicationContextFactory someJobs() {
  *       return new GenericApplicationContextFactory(SomeJobConfiguration.class);
  *    }
- * 
+ *
  *    &#064;Bean
  *    public ApplicationContextFactory moreJobs() {
  *       return new GenericApplicationContextFactory(MoreJobConfiguration.class);
  *    }
- *  
+ *
  *  ...
- *  
+ *
  * }
  * </pre>
- * 
+ *
  * Note that a modular parent context in general should <em>not</em> itself contain &#64;Bean definitions for job,
  * especially if a {@link BatchConfigurer} is provided, because cyclic configuration dependencies are otherwise likely
  * to develop.
- * 
+ *
  * </p>
- * 
+ *
  * <p>
  * For reference, the first example above can be compared to the following Spring XML configuration:
- * 
+ *
  * <pre class="code">
  * {@code
  * <batch>
@@ -152,9 +150,9 @@ import org.springframework.transaction.PlatformTransactionManager;
  * </batch>
  * }
  * </pre>
- * 
+ *
  * @author Dave Syer
- * 
+ *
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
@@ -162,12 +160,6 @@ import org.springframework.transaction.PlatformTransactionManager;
 @Import(BatchConfigurationSelector.class)
 public @interface EnableBatchProcessing {
 
-	/**
-	 * Indicate whether beans in <code>scope="step"</code> should use subclass-based (CGLIB) proxies are to be created
-	 * as opposed to standard Java interface-based proxies. The default is {@code false}.
-	 */
-	boolean proxyTargetClass() default false;
-
 	/**
 	 * Indicate whether the configuration is going to be modularized into multiple application contexts. If true then
 	 * you should not create any &#64;Bean Job definitions in this context, but rather supply them in separate (child)

spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/StepScope.java

@@ -0,0 +1,47 @@
+package org.springframework.batch.core.configuration.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import org.springframework.context.annotation.Scope;
+import org.springframework.context.annotation.ScopedProxyMode;
+
+/**
+ * <p>
+ * Convenient annotation for step scoped beans that defaults the proxy mode, so that it doesn't have to be specified
+ * explicitly on every bean definition. Use this on any &#64;Bean that needs to inject &#64;Values from the step
+ * context, and any bean that needs to share a lifecycle with a step execution (e.g. an ItemStream). E.g.
+ * </p>
+ *
+ * <pre class="code">
+ * &#064;Bean
+ * &#064;StepScope
+ * protected Callable&lt;String&gt; value(@Value(&quot;#{stepExecution.stepName}&quot;)
+ * final String value) {
+ * 	return new SimpleCallable(value);
+ * }
+ * </pre>
+ *
+ * <p>Marking a &#64;Bean as &#64;StepScope is equivalent to marking it as <code>&#64;Scope(value="step", proxyMode=INTERFACES)</code></p>
+ *
+ * @author Dave Syer
+ *
+ * @Since 2.2
+ *
+ */
+@Scope(value = "step")
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface StepScope {
+
+	/**
+	 * Set the proxy mode to use (defaults to INTERFACES).
+	 *
+	 * @see Scope#proxyMode()
+	 *
+	 * @return the proxy mode to use
+	 */
+	ScopedProxyMode proxyMode() default ScopedProxyMode.INTERFACES;
+
+}

spring-batch-core/src/test/java/org/springframework/batch/core/configuration/annotation/StepScopeConfigurationTests.java

@@ -0,0 +1,184 @@
+/*
+ * 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.
+ * 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.configuration.annotation;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.Callable;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.springframework.batch.core.StepExecution;
+import org.springframework.batch.core.scope.context.StepSynchronizationManager;
+import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.ScopedProxyMode;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+/**
+ * @author Dave Syer
+ *
+ */
+public class StepScopeConfigurationTests {
+
+	private ConfigurableApplicationContext context;
+
+	private StepExecution stepExecution;
+
+	@Rule
+	public ExpectedException expected = ExpectedException.none();
+
+	@Test
+	public void testXmlStepScopeWithProxyTargetClass() throws Exception {
+		context = new ClassPathXmlApplicationContext(
+				"org/springframework/batch/core/configuration/annotation/StepScopeConfigurationTestsProxyTargetClass-context.xml");
+		SimpleHolder value = context.getBean(SimpleHolder.class);
+		assertEquals("STEP", value.call());
+	}
+
+	@Test
+	public void testXmlStepScopeWithInterface() throws Exception {
+		context = new ClassPathXmlApplicationContext(
+				"org/springframework/batch/core/configuration/annotation/StepScopeConfigurationTestsInterface-context.xml");
+		@SuppressWarnings("unchecked")
+		Callable<String> value = context.getBean(Callable.class);
+		assertEquals("STEP", value.call());
+	}
+
+	@Test
+	public void testStepScopeWithProxyTargetClass() throws Exception {
+		init(StepScopeConfigurationRequiringProxyTargetClass.class);
+		SimpleHolder value = context.getBean(SimpleHolder.class);
+		assertEquals("STEP", value.call());
+	}
+
+	@Test
+	public void testIntentionallyBlowUpOnMissingContextWithProxyTargetClass() throws Exception {
+		init(StepScopeConfigurationRequiringProxyTargetClass.class);
+		StepSynchronizationManager.release();
+		expected.expect(BeanCreationException.class);
+		expected.expectMessage("step scope");
+		SimpleHolder value = context.getBean(SimpleHolder.class);
+		assertEquals("STEP", value.call());
+	}
+
+	@Test
+	public void testStepScopeWithInterface() throws Exception {
+		init(StepScopeConfigurationWithInterface.class);
+		@SuppressWarnings("unchecked")
+		Callable<String> value = context.getBean(Callable.class);
+		assertEquals("STEP", value.call());
+	}
+
+	@Test
+	public void testIntentionallyBlowUpOnMissingContextWithInterface() throws Exception {
+		init(StepScopeConfigurationWithInterface.class);
+		StepSynchronizationManager.release();
+		expected.expect(BeanCreationException.class);
+		expected.expectMessage("step scope");
+		@SuppressWarnings("unchecked")
+		Callable<String> value = context.getBean(Callable.class);
+		assertEquals("STEP", value.call());
+	}
+
+	public void init(Class<?>... config) throws Exception {
+		Class<?>[] configs = new Class<?>[config.length + 1];
+		System.arraycopy(config, 0, configs, 1, config.length);
+		configs[0] = DataSourceConfiguration.class;
+		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+		context.register(configs);
+		context.refresh();
+		this.context = context;
+	}
+
+	@Before
+	public void setup() {
+		stepExecution = new StepExecution("STEP", null);
+		StepSynchronizationManager.register(stepExecution);
+	}
+
+	@After
+	public void close() {
+		StepSynchronizationManager.release();
+		if (context != null) {
+			context.close();
+		}
+	}
+
+	public static class SimpleCallable implements Callable<String> {
+		private final String value;
+
+		private SimpleCallable(String value) {
+			this.value = value;
+		}
+
+		@Override
+		public String call() throws Exception {
+			return value;
+		}
+	}
+
+	public static class SimpleHolder {
+		private final String value;
+
+		protected SimpleHolder() {
+			value = "<WRONG>";
+		}
+
+		public SimpleHolder(String value) {
+			this.value = value;
+		}
+
+		public String call() throws Exception {
+			return value;
+		}
+	}
+
+	@Configuration
+	@EnableBatchProcessing
+	public static class StepScopeConfigurationRequiringProxyTargetClass {
+
+		@Bean
+		@StepScope(proxyMode = ScopedProxyMode.TARGET_CLASS)
+		protected SimpleHolder value(@Value("#{stepExecution.stepName}")
+		final String value) {
+			return new SimpleHolder(value);
+		}
+
+	}
+
+	@Configuration
+	@EnableBatchProcessing
+	public static class StepScopeConfigurationWithInterface {
+
+		@Bean
+		@StepScope
+		protected Callable<String> value(@Value("#{stepExecution.stepName}")
+		final String value) {
+			return new SimpleCallable(value);
+		}
+
+	}
+
+}

spring-batch-core/src/test/resources/org/springframework/batch/core/configuration/annotation/StepScopeConfigurationTestsInterface-context.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
+
+	<bean class="org.springframework.batch.core.scope.StepScope" />
+
+	<bean class="org.springframework.batch.core.configuration.annotation.StepScopeConfigurationTests.SimpleCallable"
+		scope="step">
+		<constructor-arg value="#{stepExecution.stepName}" />
+	</bean>
+
+</beans>

spring-batch-core/src/test/resources/org/springframework/batch/core/configuration/annotation/StepScopeConfigurationTestsProxyTargetClass-context.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
+
+	<bean class="org.springframework.batch.core.scope.StepScope">
+		<property name="proxyTargetClass" value="true" />
+	</bean>
+
+	<bean class="org.springframework.batch.core.configuration.annotation.StepScopeConfigurationTests.SimpleHolder" scope="step">
+		<constructor-arg value="#{stepExecution.stepName}" />
+	</bean>
+
+</beans>