registra dinámicamente el detector de transacciones con spring?

Question

Tengo una aplicación de marco de resorte en la que me gustaría agregar un oyente de transacción a una transacción que está actualmente en progreso. La motivación es activar una acción posterior a la confirmación que notifique a los sistemas posteriores. Estoy usando @Transactional para ajustar una transacción en torno a algún método de servicio, que es donde quiero crear/registrar el oyente de transacción posterior. Quiero hacer algo como "me gusta" lo siguiente.

public class MyService { 
@Transaction 
public void doIt() { 
    modifyObjects(); 

    // something like this 
    getTransactionManager().registerPostCommitAction(new 
    TransactionSynchronizationAdapter() { 
    public void afterCommit() { 
     notifyDownstream(); 
    } 
    }); 
} 
} 

Spring tiene una interfaz TransactionSynchronization y clase de adaptador que parece exactamente lo que quiero; sin embargo, no está claro cómo registrar uno dinámicamente con la transacción actual o con el administrador de transacciones. Prefiero no subclasificar JtaTransactionManager si puedo evitarlo.

Q: Alguien ha hecho esto antes.

Q: ¿Cuál es la forma más sencilla de registrar mi adaptador?

Answer 1

podría utilizar un aspecto aspect to match métodos transaccionales en su servicio para lograr esto:

@Aspect 
public class AfterReturningExample { 

    @AfterReturning("execution(* com.mypackage.MyService.*(..))") 
    public void afterReturning() { 
    // ... 
    } 

} 

Answer 2

En realidad no fue tan duro como pensaba; spring tiene una clase de ayudante estática que coloca las cosas 'correctas' en el contexto del hilo.

TransactionSynchronizationManager.registerSynchronization(
    new TransactionSynchronizationAdapter() { 
     @Override 
     public void afterCommit() { 
      s_logger.info("TRANSACTION COMPLETE!!!"); 
     } 
    } 
); 

Answer 3

Aquí es una solución más completa que hice para un problema similar que con el deseo de mis mensajes enviados después de las transacciones se confirman (Podría haber usado RabbitMQ TX, sino que son más bien lento).

public class MessageBusUtils { 
    public static Optional<MessageBusResourceHolder> getTransactionalResourceHolder(TxMessageBus messageBus) { 

     if (! TransactionSynchronizationManager.isActualTransactionActive()) { 
      return Optional.absent(); 
     } 

     MessageBusResourceHolder o = (MessageBusResourceHolder) TransactionSynchronizationManager.getResource(messageBus); 
     if (o != null) return Optional.of(o); 

     o = new MessageBusResourceHolder(); 
     TransactionSynchronizationManager.bindResource(messageBus, o); 
     o.setSynchronizedWithTransaction(true); 
     if (TransactionSynchronizationManager.isSynchronizationActive()) { 
      TransactionSynchronizationManager.registerSynchronization(new MessageBusResourceSynchronization(o, messageBus)); 
     } 
     return Optional.of(o); 

    } 

    private static class MessageBusResourceSynchronization extends ResourceHolderSynchronization<MessageBusResourceHolder, TxMessageBus> { 
     private final TxMessageBus messageBus; 
     private final MessageBusResourceHolder holder; 

     public MessageBusResourceSynchronization(MessageBusResourceHolder resourceHolder, TxMessageBus resourceKey) { 
      super(resourceHolder, resourceKey); 
      this.messageBus = resourceKey; 
      this.holder = resourceHolder; 
     } 


     @Override 
     protected void cleanupResource(MessageBusResourceHolder resourceHolder, TxMessageBus resourceKey, 
       boolean committed) { 
      resourceHolder.getPendingMessages().clear(); 
     } 

     @Override 
     public void afterCompletion(int status) { 
      if (status == TransactionSynchronization.STATUS_COMMITTED) { 
       for (Object o : holder.getPendingMessages()) { 
        messageBus.post(o, false); 
       } 
      } 
      else { 
       holder.getPendingMessages().clear(); 
      } 
      super.afterCompletion(status); 
     } 


    } 
} 

public class MessageBusResourceHolder extends ResourceHolderSupport { 

    private List<Object> pendingMessages = Lists.newArrayList(); 

    public void addMessage(Object message) { 
     pendingMessages.add(message); 
    } 


    protected List<Object> getPendingMessages() { 
     return pendingMessages; 
    } 

} 

En su clase en la que realmente envía el mensaje que va a hacer

@Override 
public void postAfterCommit(Object o) { 
    Optional<MessageBusResourceHolder> holder = MessageBusTxUtils.getTransactionalResourceHolder(this); 
    if (holder.isPresent()) { 
     holder.get().addMessage(o); 
    } 
    else { 
     post(o, false); 
    } 
} 

Lo siento por las largas muestras de codificación interminables pero es de esperar que mostrar a alguien cómo hacer algo después de una confirmación.

Answer 4

Tiene sentido anular el administrador de transacciones en los métodos de compromiso y retrotracción, llamando al super.commit() desde el principio.