Spring Transaction Annotationen - Execute on Success

Question

Ich verwende Spring-Anwendungsereignisse innerhalb meiner Service-Schicht, um das breitere System zu benachrichtigen, wenn bestimmte Ereignisse auftreten. Das Problem, das ich habe, ist, dass die Ereignisse in einem transaktionalen Kontext ausgelöst werden (ich verwende Spring @Transactional Annotation). Die Gefahr besteht darin, dass ich ein Ereignis auslöst und dann die Transaktion beim Commit fehlschlägt (dies kann beispielsweise bei Verwendung von Hibernate passieren). In diesem Szenario gehen die Ereignis-Listener von einem Zustand aus, der nach der Ausführung zurückgesetzt wird. Die Gefahr besteht hier darin, dass ich beispielsweise eine E-Mail gesendet habe, um die Registrierung eines Nutzers auf einer Website zu bestätigen, obwohl sein Benutzerkonto tatsächlich nicht erstellt wurde.

Gibt es eine Möglichkeit, unter Beibehaltung der Verwendung von Anmerkungen, irgendwo ein Ereignis zu markieren, das nach der Transaktion ausgelöst werden soll? Es scheint irgendwie analog zu SwingUtilities.invokeLater(Runnable runnable) bei GUI-Programmierung in Java Swing. Ich möchte sagen, führen Sie dieses Bit des Codes später aus, sobald die aktuelle Transaktion erfolgreich festgeschrieben wird.

Irgendwelche Ideen?

Danke,

Andrew

Answer 1

Der richtige Weg, um Ihr Problem mit der Bestätigung E-Mail zu lösen, ist wahrscheinlich eine verteilte Transaktionen mit einer JMS-Ressource in ihnen die Teilnahme zu verwenden.

jedoch als eine schnelle und unsaubere Lösung, können Sie versuchen, einen Wrapper um einen PlatformTransactionManager zu schaffen, die Runnable s ausgeführt wird nach erfolgreicher begehen in einigen ThreadLocal Speicher registriert (und entfernen Sie sie aus ThreadLocal nach Rollback). Eigentlich AbstractPlatformTransactionManager haben genau diese Art von Logik mit TransactionSynchronization s, aber es ist zu tief in seine Implementierungsdetails vergraben.

Answer 2

Sie können TransactionSynchronizationManager verwenden, ohne den PlatformTransactionManager zu hacken.

Hinweis: TransactionAware ist eine Markierungsschnittstelle, die angibt, dass ein ApplicationListener ein Ereignis empfangen möchte, nachdem die Transaktion erfolgreich übergeben wurde.

public class TransactionAwareApplicationEventMulticaster extends SimpleApplicationEventMulticaster { 

    @Override 
    public void multicastEvent(ApplicationEvent event) { 
     for (ApplicationListener listener : getApplicationListeners(event)) { 
      if ((listener instanceof TransactionAware) && TransactionSynchronizationManager.isSynchronizationActive()) { 
       TransactionSynchronizationManager.registerSynchronization(
        new EventTransactionSynchronization(listener, event)); 
      } 
      else { 
       notifyEvent(listener, event); 
      } 
     } 
    } 

    void notifyEvent(final ApplicationListener listener, final ApplicationEvent event) { 
      Executor executor = getTaskExecutor(); 
      if (executor != null) { 
       executor.execute(new Runnable() { 
        public void run() { 
         listener.onApplicationEvent(event); 
        } 
       }); 
      } 
      else { 
       listener.onApplicationEvent(event); 
      } 
    } 

    class EventTransactionSynchronization extends TransactionSynchronizationAdapter { 
     private final ApplicationListener listener; 
     private final ApplicationEvent event; 

     EventTransactionSynchronization(ApplicationListener listener, ApplicationEvent event) { 
      this.listener = listener; 
      this.event = event; 
     } 

     @Override 
     public void afterCompletion(int status) { 
      if ((phase == TransactionPhase.AFTER_SUCCESS) 
        && (status == TransactionSynchronization.STATUS_COMMITTED)) { 
       notifyEvent(listener, event); 
      } 
     } 
    } 
} 

Answer 3

Dies funktioniert für mich:

TransactionSynchronizationManager.registerSynchronization(
    new TransactionSynchronizationAdapter() { 
     @Override 
     public void afterCommit() { 
      // things to do when commited 
     } 
     // other methods to override are available too 
    });