class VehiculeProcessor implements ItemProcessor<Vehicule, Vehicule> {
  @Override
  Vehicule process(Vehicule item) throws Exception {
    if(item.getModele() == null){
      //Retourner null permet de filtrer le résultat et de ne pas l'envoyer à l'ItemWriter
      return null;
    }
    item.setMarque(item.getMarque() != null ? item.getMarque().toUpperCase() : "N/A";
    item.setDenomination(item.getMarque() + " " + item.getModele());
    return item;
  }
}

//Interface fournie par Spring Batch
public interface StepExecutionListener extends StepListener {
    void beforeStep(StepExecution stepExecution);
    ExitStatus afterStep(StepExecution stepExecution);
}

public class VehiculeStepListener implements StepExecutionListener {
  @Override
  public void beforeStep(StepExecution sExec) throws Exception {
    //Avant l'exécution de la Step
  }

  @Override
  public ExitStatus afterStep(StepExecution sExec) throws Exception {
    //Une fois la Step exécutée
  }
}

Il est aussi possible d'utiliser le annotations @BeforeStep et @AfterStep sur des méthodes implémentées dans un Reader/Processor/Writer ou une Tasklet

public class VehiculeTasklet implements Tasklet {
  @BeforeStep
  public void beforeStep(StepExecution sExec) throws Exception {
    //Avant l'exécution de la Step
  }

  @AfterStep
  public ExitStatus afterStep(StepExecution sExec) throws Exception {
    //Une fois la Step exécutée
  }
}

//Interface fournie par Spring Batch
public interface ChunkListener extends StepListener {
    void beforeChunk();
    void afterChunk();
}

public class VehiculeChunkListener implements ChunkListener {
  @Override
  public void beforeChunk() throws Exception {
    //Avant l'exécution du Chunk
  }

  @Override
  public void afterChunk() throws Exception {
    //Une fois le chunk terminé
  }
}

Il est aussi possible d'utiliser le annotations @BeforeChunk et @AfterChunk sur des méthodes implémentées dans un Reader/Writer.

public class VehiculeItemReader implements ItemReader<Vehicule> {
  Vehicule read() {...}

  @BeforeChunk
  public void beforeChunk() throws Exception {
    //Avant l'exécution du chunk
  }

  @AfterChunk
  public void afterChunk() throws Exception {
    //Une fois le chunk terminé
  }
}

//Interfaces fournies par Spring Batch
public interface ItemReadListener<T> extends StepListener {
    void beforeRead();
    void afterRead(T item);
    void onReadError(Exception ex);
}
public interface ItemProcessListener<T, S> extends StepListener {
    void beforeProcess(T item);
    void afterProcess(T item, S result);
    void onProcessError(T item, Exception ex);
}
public interface ItemWriteListener<S> extends StepListener {
    void beforeWrite(List<? extends S> items);
    void afterWrite(List<? extends S> items);
    void onWriteError(Exception ex, List<? extends S> items);
}

Il est aussi possible d'utiliser le annotations @Before*, @After*, @On*Error sur des méthodes implémentées dans un Reader/Processor/Writer.

public class VIP implements ItemProcessor<Vehicule, Vehicule> {
  Vehicule process(Vehicule v) {...}
  @BeforeProcess
  public void beforeProcess(Vehicule item) throws Exception {
    //Avant le traitement de l'élément
  }
  @AfterProcess
  public void afterProcess(Vehicule v, Vehicule r) throws Exception {
    //Une fois l'élément traité
  }
  @OnProcessError
  public void onProcessError(Exception ex) throws Exception {
    //Lors d'une exception levée lors du traitement
  }
}

//Interfaces fournies par Spring Batch
public interface SkipListener<T, S> extends StepListener {
    void onSkipInRead(Throwable ex);
    void onSkipInProcess(T item, Throwable ex);
    void onSkipInWrite(S item, Throwable ex);
}

public class VSL implements SkipListener<Vehicule, Vehicule> {
    @Override
    public void onSkipInRead(Throwable ex) {
    }
    @Override
    public void onSkipInProcess(Vehicule v, Throwable ex) {
    }
    @Override
    public void onSkipInWrite(Vehicule v, Throwable ex) {
    }
}

Il est aussi possible d'utiliser le annotations @OnSkipInRead, @OnSkipInProcess, @OnSkipInWrite sur des méthodes implémentées dans un Reader/Processor/Writer.

public class VIP implements ItemProcessor<Vehicule, Vehicule> {
  Vehicule process(Vehicule v) {...}

  @OnSkipInProcess
  public void onSkipInProcess(Vehicule v, Throwable ex) {
    //Si une exception configurée pour ignorer l'élément
    //est levée, cette méthode est exécutée avec en paramètre
    //l'élément qui a posé problème et l'exception qui a été levée.
  }
}