Como gerenciar 2 métodos DAO em uma única transação?

Em uma entrevista, alguém me perguntou: como gerenciamos 2 métodos transacionais / dao em uma única transação. Recursos desejados:

1. Se alguém falhar, precisamos reverter os dois métodos.
2. Ambos os métodos podem ser chamados separadamente anexados com uma única transação.
3. O gerenciamento deve estar na camada DAO, não na camada de serviço.

Penso: a questão está relacionada ao gerenciamento de transações da primavera.

Primeiro de tudo, o gerenciamento de transações deve ser feito na camada de serviço, e não na camada DAO, pois isso criaria muita sobrecarga de desempenho (para lidar com o nível de isolamento de transação apropriado e a propagação em cada método diferente). Além disso, o escopo de uma unidade de trabalho vem da camada de serviço, e não da camada de acesso a dados: imagine executar um processo de negócios que precise lidar com 2 ou mais DAOs.

Há muita discussão na Internet que aponta nessa direção, como aqui , aqui e aqui .

De qualquer forma, já que é uma entrevista, vamos aceitar a pergunta como ela é. Do meu ponto de vista, você usaria a @Transactionalanotação (ou a configuração XML) nos dois métodos e com uma propagação de transação com REQUIREDvalor. Dessa forma, quando qualquer um desses métodos for chamado e se nenhuma transação anterior existir, uma nova transação será criada:

@Transactional
class MyDAO {

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

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

}

Ignorando primavera e estruturas na minha resposta ..... apenas a idéia básica de usar parâmetros de função. Tenho certeza de que o conceito pode ser aplicado dentro de [inserir estrutura aqui].

Você precisaria manipular a confirmação / reversão fora dos 2 métodos DAO. Os 2 métodos precisariam tomar a transação / conexão como entrada.

código 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();  }
}

Há uma chance de que dois métodos funcionem independentemente também ao mesmo tempo em que possam ser executados em uma mesma transação. Portanto, precisamos usar Propagation-Required. Se a transação precisar ser executada na mesma transação, ela usará a primeira transação, caso contrário, uma nova transação será criada se invocada de forma independente. Corrija-me se eu estiver errada.