Comment pouvons-nous partager les données entre les différentes étapes d'un Travail de Spring Batch?

l'emploi référentiel est utilisé indirectement pour le passage des données entre les étapes (Jean-Philippe est juste que la meilleure façon de le faire est de mettre les données dans le StepExecutionContext puis utilisez le avec beaucoup de détails nommé ExecutionContextPromotionListener pour promouvoir l'exécution de l'étape contexte clés de la JobExecutionContext.

Il est utile de noter qu'il existe un écouteur pour la promotion de JobParameter clés d'un StepExecutionContext ainsi (encore plus avec beaucoup de détails nommé JobParameterExecutionContextCopyListener); vous trouverez ces beaucoup si des étapes de travail ne sont pas complètement indépendants l'un de l'autre.

Sinon, vous êtes de gauche le passage des données entre les étapes à l'aide encore plus à des systèmes élaborés, comme des files d'attente JMS, ou (à dieu ne plaise) codée en dur emplacements des fichiers.

Quant à la taille des données qui est transmis dans le contexte, je dirais aussi que vous garder les petits (mais je n'ai pas tout les détails sur le

Je dirais que vous avez 3 options:

1. Utilisation StepContext et de le promouvoir à JobContext et vous y avez accès à partir de chaque étape, vous devez comme indiqué obéir à la limite de la taille
2. Créer @JobScope de haricots et ajouter des données à cet haricot, @Autowire elle en cas de besoin et de l'utiliser (inconvénient est que c'est en mémoire de la structure et si échec du travail de perte de données, mlgh causer des problèmes avec la possibilité de redémarrage)
3. Nous avons eu de plus grands ensembles de données nécessaires pour être traitées à travers les étapes (lire chaque ligne dans le format csv et écrire DB, lire à partir de DB, d'agréger et de les envoyer à l'API) nous avons donc décidé de modéliser les données dans une nouvelle table dans la même DB comme spring batch méta tables, garder ids dans JobContext et l'accès en cas de besoin et supprimer cette table temporaire lorsque le travail se termine avec succès.

Voici ce que j'ai fait pour enregistrer un objet qui est accessible à travers les étapes.

1. Créé un écouteur pour la définition de l'objet dans le contexte du poste

@Component("myJobListener")
public class MyJobListener implements JobExecutionListener {

    public void beforeJob(JobExecution jobExecution) {

        String myValue = someService.getValue();
        jobExecution.getExecutionContext().putString("MY_VALUE", myValue);
    }
}

1. Défini l'auditeur dans le contexte du poste

<listeners>
         <listener ref="myJobListener"/>
</listeners>

1. Consommé la valeur de l'étape à l'aide de BeforeStep annotation

@BeforeStep
public void initializeValues(StepExecution stepExecution) {

String value = stepExecution.getJobExecution().getExecutionContext().getString("MY_VALUE");

}

Utiliser `ExecutionContextPromotionListener .

public class YourItemWriter implements ItemWriter<Object> {
private StepExecution stepExecution;
public void write(List<? extends Object> items) throws Exception {
//Some Business Logic

//put your data into stepexecution context
ExecutionContext stepContext = this.stepExecution.getExecutionContext();
stepContext.put("someKey", someObject);
}
@BeforeStep
public void saveStepExecution(Final StepExecution stepExecution) {
this.stepExecution = stepExecution;
}
}

Maintenant, vous devez ajouter promotionListener à votre travail

@Bean
public Step step1() {
        return stepBuilder
        .get("step1")<Company,Company>  chunk(10)
        .reader(reader()).processor(processor()).writer(writer())
        .listener(promotionListener()).build();
    }

@Bean
public ExecutionContextPromotionListener promotionListener() {
    ExecutionContextPromotionListener listener = new ExecutionContextPromotionListener();
    listener.setKeys(new String[] {"someKey"});
    listener.setStrict(true);
    return listener;
}

Maintenant, dans step2 récupérer vos données à partir d'emploi ExecutionContext

public class RetrievingItemWriter implements ItemWriter<Object> {
private Object someObject;
public void write(List<? extends Object> items) throws Exception {
//...
}
@BeforeStep
public void retrieveInterstepData(StepExecution stepExecution) {
JobExecution jobExecution = stepExecution.getJobExecution();
ExecutionContext jobContext = jobExecution.getExecutionContext();
this.someObject = jobContext.get("someKey");
}
}

Si vous travaillez avec tasklets, puis utilisez suivantes pour obtenir ou mettre ExecutionContext

List<YourObject> yourObjects = (List<YourObject>) chunkContent.getStepContext().getJobExecutionContext().get("someKey");

Que Nenad Bozic a dit dans sa 3ème option, l'utilisation de tables temporaires pour partager les données entre les étapes, à l'aide de contexte à part le fait aussi la même chose, il écrit au tableau et les charges de retour dans la prochaine étape, mais si vous ecrire dans des tables temporaires, vous pouvez nettoyer à la fin de l'emploi.