Spring Batch: Un lecteur de plusieurs processeurs et des écrivains

Dans Spring batch j'ai besoin de passer les articles lus par un ItemReader à deux processeurs différents et écrivain. Ce que je suis en train de réaliser, c'est que...

 +---> ItemProcessor#1 ---> ItemWriter#1 
| 
ItemReader ---> item ---+ 
| 
+---> ItemProcessor#2 ---> ItemWriter#2

Cela est nécessaire parce que les articles écrits par ItemWriter#1 devraient être traitées d'une manière complètement différente par rapport à celles écrites par ItemWriter#2.
En outre, ItemReader lit élément à partir d'une base de données et les requêtes qu'il exécute sont donc de calcul coûteux que l'exécution de la même requête à deux reprises doivent être jetés.

Tout soupçon sur la manière de réaliser un tel ensemble ? Ou, au moins, sont logiquement équivalentes ?

OriginalL'auteur danidemi | 2013-09-25

  1. 9

    Cette solution est valable si votre article devrait être traitée par le processeur #1 et le processeur #2

    Vous devez créer un processeur #0 avec cette signature:

    class Processor0<Item, CompositeResultBean>

    où CompositeResultBean est un bean défini comme

    class CompositeResultBean {
  Processor1ResultBean result1;
  Processor2ResultBean result2;
}

    Dans votre Processeur #0 à seulement déléguer les tâches aux processeurs #1 et #2 et mettre le résultat dans CompositeResultBean

    CompositeResultBean Processor0.process(Item item) {
  final CompositeResultBean r = new CompositeResultBean();
  r.setResult1(processor1.process(item));
  r.setResult2(processor2.process(item));
  return r;
}

    Votre propre écrivain est un CompositeItemWriter que délégué à l'écrivain CompositeResultBean.result1 ou CompositeResultBean.result2 (regardez PropertyExtractingDelegatingItemwriter, peut-être peut aider)

    Malheureusement, les exigences de l'est, en effet, que le même élément doit être traité par les DEUX processeurs. Juste pour vous donner un peu plus de contexte, le lecteur lit un enregistrement à partir de db, alors le processeur#1 doit mapper les noms de champ à d'autres noms de champ et écrivain#1 écrit la mappé élément dans une autre base de données. Processeur#2, à partir du même élément d'origine, doit s'exécuter complètement différent de l'élaboration puis d'écrire l'article dans un système d'héritage.
    Ok, j'ai une solution pour ce problème. juste attendre pour le modifier
    Je serais curieux de vous voir solution. Pourriez-vous avoir le temps de le mettre à jour ici?
    Regarde ma vieille édition, devrait être la bonne solution...

    OriginalL'auteur Luca Basso Ricci

  2. 2

    J'ai suivi Luca la suggestion d'utiliser PropertyExtractingDelegatingItemWriter comme écrivain et j'ai été capable de travailler avec deux entités différentes en une seule étape.

    Tout d'abord ce que j'ai fait a été de définir un DTO qui stocke les deux entités/résultats du processeur

    public class DatabaseEntry {
    private AccessLogEntry accessLogEntry;
    private BlockedIp blockedIp;

    public AccessLogEntry getAccessLogEntry() {
        return accessLogEntry;
    }

    public void setAccessLogEntry(AccessLogEntry accessLogEntry) {
        this.accessLogEntry = accessLogEntry;
    }

    public BlockedIp getBlockedIp() {
        return blockedIp;
    }

    public void setBlockedIp(BlockedIp blockedIp) {
        this.blockedIp = blockedIp;
    }
}

    Puis j'ai passé cette DTO pour l'écrivain, un PropertyExtractingDelegatingItemWriter classe où j'définir deux méthodes personnalisées pour écrire les entités dans la base de données, voir mon écrivain code ci-dessous:

    @Configuration
public class LogWriter extends LogAbstract {
@Autowired
private DataSource dataSource;
@Bean()
public PropertyExtractingDelegatingItemWriter<DatabaseEntry> itemWriterAccessLogEntry() {
PropertyExtractingDelegatingItemWriter<DatabaseEntry> propertyExtractingDelegatingItemWriter = new PropertyExtractingDelegatingItemWriter<DatabaseEntry>();
propertyExtractingDelegatingItemWriter.setFieldsUsedAsTargetMethodArguments(new String[]{"accessLogEntry", "blockedIp"});
propertyExtractingDelegatingItemWriter.setTargetObject(this);
propertyExtractingDelegatingItemWriter.setTargetMethod("saveTransaction");
return propertyExtractingDelegatingItemWriter;
}
public void saveTransaction(AccessLogEntry accessLogEntry, BlockedIp blockedIp) throws SQLException {
writeAccessLogTable(accessLogEntry);
if (blockedIp != null) {
writeBlockedIp(blockedIp);
}
}
private void writeBlockedIp(BlockedIp entry) throws SQLException {
PreparedStatement statement = dataSource.getConnection().prepareStatement("INSERT INTO blocked_ips (ip,threshold,startDate,endDate,comment) VALUES (?,?,?,?,?)");
statement.setString(1, entry.getIp());
statement.setInt(2, threshold);
statement.setTimestamp(3, Timestamp.valueOf(startDate));
statement.setTimestamp(4, Timestamp.valueOf(endDate));
statement.setString(5, entry.getComment());
statement.execute();
}
private void writeAccessLogTable(AccessLogEntry entry) throws SQLException {
PreparedStatement statement = dataSource.getConnection().prepareStatement("INSERT INTO log_entries (date,ip,request,status,userAgent) VALUES (?,?,?,?,?)");
statement.setTimestamp(1, Timestamp.valueOf(entry.getDate()));
statement.setString(2, entry.getIp());
statement.setString(3, entry.getRequest());
statement.setString(4, entry.getStatus());
statement.setString(5, entry.getUserAgent());
statement.execute();
}
}

    Avec cette approche, vous pouvez obtenir le voulait le premier comportement à partir d'un seul lecteur pour le traitement de plusieurs entités et de les enregistrer en une seule étape.

    OriginalL'auteur Juan Pablo G

  3. 2

    Vous pouvez utiliser un CompositeItemProcessor et CompositeItemWriter

    De ne pas ressembler exactement à votre schéma, il sera séquentielle, mais il va faire le travail.

    Je ne pense pas assez. Je vais juste finir avec un "complexe" du processeur, mais en fin de compte il n'y aura qu'un traité élément passé à un seul ItemWriter! Au lieu de cela j'ai besoin de la ItemWriter#1 à écrire un article qui n'est pas celui qui sera écrit par ItemWriter#2! Une exigence est que les deux ItemWriters agir sur les différents éléments! Gardez à l'esprit qu'en ressort-lot vous avez une étape qui est ternaire: un ItemReader, un ItemProcessor, un ItemWriter.
    Merci pour la mention de ces composants. Ils ont résolu mon problème

    OriginalL'auteur Sebastien Lorber

  4. 0

    Il existe une autre solution si vous avez une quantité raisonnable d'objets (comme des moins de 1 Go) : vous pouvez mettre en cache le résultat de vos sélectionner dans une collection enveloppé dans un Printemps bean.

    Alors u peut juste lire la collecte deux fois, sans frais.

    Oui, cela pourrait être fait, en effet. Mais qu'advient-il si le premier écrivain échoue lors de l'écriture d'un article ? Si je suis votre idée correctement, je pense que le deuxième écrivain n'aurez pas l'occasion d'écrire un article. Est-ce exact ?
    mmm non, les écrivains ne sont pas de transmettre les données les uns des autres, ils ont lu la même chose dans la mémoire de la collecte de l'intérieur d'un printemps singleton bean.

    OriginalL'auteur Tristan

  5. -1

    c'est la solution que j'ai trouvé.

    Donc, l'idée est de coder une nouvelle de l'Écrivain qui "contient" les deux une ItemProcessor et un ItemWriter. Juste pour vous donner une idée, nous l'avons appelé PreprocessoWriter, et c'est le code de base.

    private ItemWriter<O> writer;
private ItemProcessor<I, O> processor;
@Override
public void write(List<? extends I> items) throws Exception {
List<O> toWrite = new ArrayList<O>();
for (I item : items) {
toWrite.add(processor.process(item));
}
writer.write(toWrite);
}

    Il y a beaucoup de choses laissées de côté. Gestion de ItemStream, par exemple. Mais dans notre scénario en particulier, c'était assez.

    De sorte que vous pouvez combiner plusieurs PreprocessorWriter avec CompositeWriter.

    Mélanger le processeur et l'écrivain est une mauvaise idée: c'composants ont créé séparément pour rendre le processus et l'écriture de deux préoccupations distinctes
    Je suis d'accord avec vous sur le concept général. Cependant, comme vous l'avez sûrement lu dans la question d'origine, le problème était de lire des articles une fois, et de processus / écrire de deux manières complètement différentes. Donc, pouvez-vous s'il vous plaît partager la façon dont vous permettrait de résoudre le problème particulier de la question ?
    Vérifier ma réponse pour que. Le traitement est réalisé à l'aide d'un composite de processeur en prenant un seul élément en entrée et une coutume de haricot (CompositeResultBean) en tenant le résultat de plusieurs traitement. Écrit par délégation: CompositeResultBean à l'entrée et appeler le bon délégué de l'écrivain pour CompositeResultBean.result1 et CompositeResultBean.result2. Lu une fois, le processus d'écriture/séparés ItemProcessor/ItemWriter à l'aide de la composition et de la délégation. Tout se fait sans problème concepts

    OriginalL'auteur danidemi