Spring-batch @BeforeStep ne fonctionne pas avec @StepScope

Je suis à l'aide de Spring Batch version 2.2.4.LIBÉRATION
J'ai essayé d'écrire un exemple simple avec état ItemReader, ItemProcessor et ItemWriter haricots.

public class StatefulItemReader implements ItemReader<String> {

    private List<String> list;

    @BeforeStep
    public void initializeState(StepExecution stepExecution) {
        this.list = new ArrayList<>();
    }

    @AfterStep
    public ExitStatus exploitState(StepExecution stepExecution) {
        System.out.println("******************************");
        System.out.println(" READING RESULTS : " + list.size());

        return stepExecution.getExitStatus();
    }

    @Override
    public String read() throws Exception {
        this.list.add("some stateful reading information");
        if (list.size() < 10) {
            return "value " + list.size();
        }
        return null;
    }
}

Dans mon test d'intégration, je vais déclarer mes haricots dans un intérieur statique java config classe comme celle ci-dessous:

@ContextConfiguration
@RunWith(SpringJUnit4ClassRunner.class)
public class SingletonScopedTest {

    @Configuration
    @EnableBatchProcessing
    static class TestConfig {
        @Autowired
        private JobBuilderFactory jobBuilder;
        @Autowired
        private StepBuilderFactory stepBuilder;

        @Bean
        JobLauncherTestUtils jobLauncherTestUtils() {
            return new JobLauncherTestUtils();
        }

        @Bean
        public DataSource dataSource() {
            EmbeddedDatabaseBuilder embeddedDatabaseBuilder = new EmbeddedDatabaseBuilder();
            return embeddedDatabaseBuilder.addScript("classpath:org/springframework/batch/core/schema-drop-hsqldb.sql")
                    .addScript("classpath:org/springframework/batch/core/schema-hsqldb.sql")
                    .setType(EmbeddedDatabaseType.HSQL)
                    .build();
        }

        @Bean
        public Job jobUnderTest() {
            return jobBuilder.get("job-under-test")
                    .start(stepUnderTest())
                    .build();
        }

        @Bean
        public Step stepUnderTest() {
            return stepBuilder.get("step-under-test")
                    .<String, String>chunk(1)
                    .reader(reader())
                    .processor(processor())
                    .writer(writer())
                    .build();
        }

        @Bean
        public ItemReader<String> reader() {
            return new StatefulItemReader();
        }

        @Bean
        public ItemProcessor<String, String> processor() {
            return new StatefulItemProcessor();
        }

        @Bean
        public ItemWriter<String> writer() {
            return new StatefulItemWriter();
        }
    }

    @Autowired
    JobLauncherTestUtils jobLauncherTestUtils;

    @Test
    public void testStepExecution() {
        JobExecution jobExecution = jobLauncherTestUtils.launchStep("step-under-test");

        assertEquals(ExitStatus.COMPLETED, jobExecution.getExitStatus());
    }
}

Ce test passe.

Mais dès que je définis mon StatefulItemReader comme une étape d'étendue de haricot (ce qui est le mieux pour un stateful lecteur), le "avant l'étape" code n'est plus exécuté.

...
    @Bean
    @StepScope
    public ItemReader<String> reader() {
        return new StatefulItemReader();
    }
...

Et j'ai remarqué le même problème avec le processeur et mon écrivain haricots.

Quel est le problème avec mon code? Est-ce lié à ce problème résolu: https://jira.springsource.org/browse/BATCH-1230

L'ensemble de mon projet Maven avec plusieurs JUnit tests peut être trouvé sur GitHub: https://github.com/galak75/spring-batch-step-scope

Je vous remercie d'avance pour vos réponses.

source d'informationauteur Géraud | 2014-01-20

  1. 29

    Lorsque vous configurez un haricot comme suit:

    @Bean
@StepScope
public MyInterface myBean() {
    return new MyInterfaceImpl();
}

    Vous dites de Printemps pour utiliser le mode proxy ScopedProxyMode.TARGET_CLASS. Cependant, par le retour de la MyInterfaceau lieu de la MyInterfaceImplle mandataire a une visibilité sur les méthodes sur la MyInterface. Cela empêche Spring Batch d'être en mesure de trouver les méthodes sur MyInterfaceImpl qui ont été annotés avec l'auditeur annotations comme @BeforeStep. La façon correcte de le configurer, c'est revenir MyInterfaceImpl sur votre méthode de configuration comme ci-dessous:

    @Bean
@StepScope
public MyInterfaceImpl myBean() {
    return new MyInterfaceImpl();
}

    Nous avons ajouté un message d'avertissement message de log au démarrage qui souligne, que nous attendons pour le annoté méthodes d'écoute, si l'objet est mandaté et la cible est une interface, nous ne serons pas en mesure de trouver des méthodes sur la mise en œuvre de la classe avec des annotations sur eux.