Come gestire 2 metodi DAO in un'unica transazione?

In un'intervista qualcuno mi ha chiesto: come possiamo gestire 2 metodi transazionali / dao in una singola transazione. Funzionalità desiderate:

1. Se qualcuno di loro fallisce, dobbiamo ripristinare entrambi i metodi.
2. Entrambi i metodi possono essere chiamati separatamente collegati con una singola transazione.
3. La gestione dovrebbe essere a livello DAO, non a livello di servizio.

Penso: la domanda riguarda la gestione delle transazioni di primavera.

Innanzitutto, la gestione delle transazioni dovrebbe essere eseguita a livello di servizio, non a livello DAO in quanto ciò creerebbe un sacco di sovraccarico di prestazioni (per gestire il livello di isolamento e la propagazione delle transazioni appropriati in ciascun metodo diverso). Inoltre, l'ambito di un'unità di lavoro viene dal livello di servizio anziché dal livello di accesso ai dati: immagina di eseguire un processo aziendale che deve gestire 2 o più DAO.

C'è molta discussione in Internet che punta in quella direzione come qui , qui e qui .

Ad ogni modo, dato che si tratta di un'intervista, accettiamo la domanda così com'è. Dal mio punto di vista, @Transactionaluseresti l' annotazione (o la configurazione XML) in entrambi i metodi e con una propagazione delle transazioni con REQUIREDvalore. In questo modo, quando viene invocato uno di questi metodi e se non esiste alcuna transazione precedente, verrà creata una nuova transazione:

@Transactional
class MyDAO {

   @Transactional(propagation = REQUIRED)
   public void foo() {
   }

   @Transactional(propagation = REQUIRED)
   public void bar() {
   }

}

Ignorando la molla e le strutture nella mia risposta ..... solo l'idea di base dell'uso dei parametri di funzione. Sono sicuro che il concetto potrebbe applicarsi all'interno di [inserire il framework qui].

Dovresti gestire il commit / rollback al di fuori dei 2 metodi DAO. I 2 metodi dovrebbero prendere la transazione / connessione come input.

codice psuedo:

bool method1(Tran t) { /* stuff */}
bool method2(Tran t) { /* stuff */ }

callingMethod() {
     Tran t = null;
     try {
         t = new Conn().open().startTran();
         if(method1(t) && method2(t))
             t.commit();
         else
             t.rollBaack();
     }
     catch(ex) {  t.rollBack();  }
     finally {  t.closeConn();  }
}

È possibile che due metodi funzionino in modo indipendente anche nello stesso momento in cui potrebbero essere eseguiti in una stessa transazione, quindi è necessario utilizzare Propagation-Required. Se la transazione deve essere eseguita nella stessa transazione, utilizzerà la prima transazione altrimenti verrà creata una nuova transazione se invocata in modo indipendente. Correggimi se sbaglio.