Decidere tra Spring Batch Step, Tasklet o Chunks

Question

Ho un requisito semplice in cui, ho bisogno di leggere un elenco di elementi (da DB) e devono elaborare gli elementi e una volta elaborati, deve essere aggiornato in DB .

Sto pensando di utilizzare Chunks batch di primavera con lettore, processore e scrittore. Il mio lettore restituirà un elemento alla volta dalla lista e lo invierà al processore e una volta che l'elaborazione è finita, ritorna a Writer dove aggiorna il DB

Posso essere multithreading in seguito con un certo costo di sincronizzazione in questi metodi .

Qui prevedo alcune preoccupazioni.

1. Numero di elementi da elaborare potrebbe essere più. Può essere in 10.000 o anche più.
2. nel processore è necessario un calcolo logico. quindi elaborando 1 oggetto alla volta. non sono sicuro delle prestazioni anche se è multithread con 10 thread.
3. Writer può aggiornare i risultati nel DB per quell'elemento elaborato. Non sai come fare gli aggiornamenti in batch perché ha sempre solo 1 oggetto elaborato e pronto.

Questo approccio è corretto per questo tipo di caso o qualcosa di meglio può essere fatto? C'è un altro modo per elaborare una serie di elementi a una chiamata di lettore, processore & writer? se è così, ho bisogno di creare un mechnism in cui estrarre diciamo 10 elementi dalla lista e darlo al processore? sembra che lo scrittore aggiorni ogni record così come viene, gli aggiornamenti in batch hanno senso solo se lo scrittore riceve un mucchio di oggetti elaborati. qualche suggerimento?

Si prega di gettare alcune luci su questo design per prestazioni migliori.

Grazie,

Answer 1

Primavera batch è lo strumento perfetto per fare quello che ti serve.

Il passo orientato verso il blocco consente di configurare quanti elementi si desidera leggere/elaborare/scrivere con la proprietà intervallo di commit.

 <batch:step id="step1" next="step2"> 
     <batch:tasklet transaction-manager="transactionManager" start-limit="100"> 
      <batch:chunk reader="myReader" processor="myProcessor" writer="MyWriter" commit-interval="800" /> 
      <batch:listeners> 
       <batch:listener ref="myListener" /> 
      </batch:listeners> 
     </batch:tasklet> 
    </batch:step> 

Lasciate che il vostro lettore chiami un'istruzione SELECT che restituisce 10.000 record. E imposti un intervallo di commit = 500.

MyReader chiamerà il metodo read() 500 volte. Diciamo che in realtà, l'implementazione del lettore potrebbe in effetti rimuovere gli elementi dal resultSet. Per ogni chiamata a read(), chiamerà anche il metodo process() di MyProcessor.

Ma non chiamerà il metodo write() di MyWriter finché non viene raggiunto l'intervallo di commit.

Se si guarda alla definizione del ItemWriter dell'interfaccia:

public interface ItemWriter<T> { 

/** 
* Process the supplied data element. Will not be called with any null items 
* in normal operation. 
* 
* @throws Exception if there are errors. The framework will catch the 
* exception and convert or rethrow it as appropriate. 
*/ 
void write(List<? extends T> items) throws Exception; 

} 

Si vede che riceve la scrittura di un elenco di oggetti. Questo elenco sarà la dimensione dell'intervallo di commit (o meno se viene raggiunta la fine)

E a proposito, 10 000 di record non è nulla. Puoi considerare il multithreading se devi gestire milioni di record. Ma anche allora, solo giocando con il punto debole del valore dell'intervallo di commit sarà probabilmente sufficiente.

Spero che sia utile