前面我們講到了Spring在進行事務邏輯織入的時候，無論是事務開始，提交或者回滾，都會觸發相應的事務事件。本文首先會使用例項進行講解Spring事務事件是如何使用的，然後會講解這種使用方式的實現原理。

1. 示例

對於事務事件，Spring提供了一個註解@TransactionEventListener，將這個註解標註在某個方法上，那麼就將這個方法宣告為了一個事務事件處理器，而具體的事件型別則是由TransactionalEventListener.phase屬性進行定義的。如下是TransactionalEventListener的宣告：

```

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@EventListenerpublic @interface TransactionalEventListener {

    // 指定當前標註方法處理事務的型別 TransactionPhasephase()defaultTransactionPhase.AFTER_COMMIT;

    // 用於指定當前方法如果沒有事務，是否執行相應的事務事件監聽器 booleanfallbackExecution()defaultfalse;

    // 與classes屬性一樣，指定了當前事件傳入的引數型別，指定了這個引數之後就可以在監聽方法上    // 直接什麼一個這個引數了 @AliasFor(annotation = EventListener.class, attribute = "classes")

Class<?>[] value() default {};

    // 作用於value屬性一樣，用於指定當前監聽方法的引數型別 @AliasFor(annotation = EventListener.class, attribute = "classes")

Class<?>[] classes() default {};

    // 這個屬性使用Spring Expression Language對目標類和方法進行匹配，對於不匹配的方法將會過濾掉 Stringcondition()default"";

}

```

關於這裡的classes屬性需要說明一下，如果指定了classes屬性，那麼當前監聽方法的引數型別就可以直接使用所釋出的事件的引數型別，如果沒有指定，那麼這裡監聽的引數型別可以使用兩種：ApplicationEvent和PayloadApplicationEvent。對於ApplicationEvent型別的引數，可以透過其getSource()方法獲取釋出的事件引數，只不過其返回值是一個Object型別的，如果想獲取具體的型別還需要進行強轉；對於PayloadApplicationEvent型別，其可以指定一個泛型引數，該泛型引數必須與釋出的事件的引數型別一致，這樣就可以透過其getPayload()方法獲取事務事件釋出的資料了。關於上述屬性中的TransactionPhase，其可以取如下幾個型別的值：

```

public enum TransactionPhase {

    // 指定目標方法在事務commit之前執行 BEFORE_COMMIT,

    // 指定目標方法在事務commit之後執行 AFTER_COMMIT,

    // 指定目標方法在事務rollback之後執行 AFTER_ROLLBACK,

    // 指定目標方法在事務完成時執行，這裡的完成是指無論事務是成功提交還是事務回滾了 AFTER_COMPLETION

}

```

這裡我們假設資料庫有一個user表，對應的有一個UserService和User的model，用於往該表中插入資料，並且插入動作時使用註解標註目標方法。如下是這幾個類的宣告：

```

public classUser{

  private long id;

  private String name;

  private int age;

  // getter and setter...}

```

```

@Service@Transactionalpublic classUserServiceImplimplementsUserService{

  @Autowired  private JdbcTemplate jdbcTemplate;

  @Autowired  private ApplicationEventPublisher publisher;

  @Override  publicvoidinsert(User user){

    jdbcTemplate.update("insert into user (id, name, age) value (?, ?, ?)",

        user.getId(), user.getName(), user.getAge());

    publisher.publishEvent(user);

  }

}

```

上述程式碼中有一點需要注意的是，對於需要監控事務事件的方法，在目標方法執行的時候需要使用ApplicationEventPublisher釋出相應的事件訊息。如下是對上述訊息進行監控的程式：

```

@Componentpublic classUserTransactionEventListener{

  @TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)

  publicvoidbeforeCommit(PayloadApplicationEvent<User> event){

    System.out.println("before commit, id: " + event.getPayload().getId());

  }

  @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)

  publicvoidafterCommit(PayloadApplicationEvent<User> event){

    System.out.println("after commit, id: " + event.getPayload().getId());

  }

  @TransactionalEventListener(phase = TransactionPhase.AFTER_COMPLETION)

  publicvoidafterCompletion(PayloadApplicationEvent<User> event){

    System.out.println("after completion, id: " + event.getPayload().getId());

  }

  @TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)

  publicvoidafterRollback(PayloadApplicationEvent<User> event){

    System.out.println("after rollback, id: " + event.getPayload().getId());

  }

}

```

這裡對於事件的監控，只需要在監聽方法上新增@TransactionalEventListener註解即可。這裡需要注意的一個問題，在實際使用過程中，對於監聽的事務事件，需要使用其他的引數進行事件的過濾，因為這裡的監聽還是會監聽所有事件引數為User型別的事務，而無論其是哪個位置發出來的。如果需要對事件進行過濾，這裡可以封裝一個UserEvent物件，其內儲存一個類似EventType的屬性和一個User物件，這樣在釋出訊息的時候就可以指定EventType屬性，而在監聽訊息的時候判斷當前方法監聽的事件物件的EventType是否為目標type，如果是，則對其進行處理，否則直接略過。下面是上述程式的xml檔案配置和驅動程式：

```

public classTransactionApp{

  @Test  publicvoidtestTransaction(){

    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

    UserService userService = context.getBean(UserService.class);

    User user = getUser();

    userService.insert(user);

  }

  privateUsergetUser(){

    int id = new Random()

      .nextInt(1000000);

    User user = new User();

    user.setId(id);

    user.setName("Mary");

    user.setAge(27);

    return user;

  }

}

```

執行上述程式，其執行結果如下：

```

before commit, id: 935052

after commit, id: 935052

after completion, id: 935052

```

 可以看到，這裡確實成功監聽了目標程式的相關事務行為。

2. 實現原理

關於事務的實現原理，這裡其實是比較簡單的，在前面的文章中，我們講解到，Spring對事務監控的處理邏輯在TransactionSynchronization中，如下是該介面的宣告：

```

public interfaceTransactionSynchronizationextendsFlushable{

    // 在當前事務掛起時執行 defaultvoidsuspend(){

}

    // 在當前事務重新載入時執行 defaultvoidresume(){

}

    // 在當前資料重新整理到資料庫時執行 defaultvoidflush(){

}

    // 在當前事務commit之前執行 defaultvoidbeforeCommit(booleanreadOnly){

}

    // 在當前事務completion之前執行 defaultvoidbeforeCompletion(){

}

    // 在當前事務commit之後實質性 defaultvoidafterCommit(){

}

    // 在當前事務completion之後執行 defaultvoidafterCompletion(intstatus){

}

}

```

很明顯，這裡的TransactionSynchronization介面只是抽象了一些行為，用於事務事件發生時觸發，這些行為在Spring事務中提供了內在支援，即在相應的事務事件時，其會獲取當前所有註冊的TransactionSynchronization物件，然後呼叫其相應的方法。那麼這裡TransactionSynchronization物件的註冊點對於我們瞭解事務事件觸發有至關重要的作用了。這裡我們首先回到事務標籤的解析處，在前面講解事務標籤解析時，我們講到Spring會註冊一個TransactionalEventListenerFactory型別的bean到Spring容器中，這裡關於標籤的解析讀者可以閱讀本人前面的文章。這裡註冊的TransactionalEventListenerFactory實現了EventListenerFactory介面，這個介面的主要作用是先判斷目標方法是否是某個監聽器的型別，然後為目標方法生成一個監聽器，其會在某個bean初始化之後由Spring呼叫其方法用於生成監聽器。如下是該類的實現：

```

public classTransactionalEventListenerFactoryimplementsEventListenerFactory,Ordered{

    // 指定當前監聽器的順序    private int order = 50;

    publicvoidsetOrder(intorder){

        this.order = order;

    }

    @Override    publicintgetOrder(){

        return this.order;

    }

    // 指定目標方法是否是所支援的監聽器的型別，這裡的判斷邏輯就是如果目標方法上包含有    // TransactionalEventListener註解，則說明其是一個事務事件監聽器    @Override    publicbooleansupportsMethod(Method method){

        return (AnnotationUtils.findAnnotation(method, TransactionalEventListener.class) != null);

    }

    // 為目標方法生成一個事務事件監聽器，這裡ApplicationListenerMethodTransactionalAdapter實現了    // ApplicationEvent介面    @Override    public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {

        return new ApplicationListenerMethodTransactionalAdapter(beanName, type, method);

    }

}

```

這裡關於事務事件監聽的邏輯其實已經比較清楚了。ApplicationListenerMethodTransactionalAdapter本質上是實現了ApplicationListener介面的，也就是說，其是Spring的一個事件監聽器，這也就是為什麼進行事務處理時需要使用ApplicationEventPublisher.publish()方法釋出一下當前事務的事件。

ApplicationListenerMethodTransactionalAdapter在監聽到釋出的事件之後會生成一個TransactionSynchronization物件，並且將該物件註冊到當前事務邏輯中，如下是監聽事務事件的處理邏輯：

```

@OverridepublicvoidonApplicationEvent(ApplicationEvent event){

    // 如果當前TransactionManager已經配置開啟事務事件監聽，    // 此時才會註冊TransactionSynchronization物件    if (TransactionSynchronizationManager.isSynchronizationActive()) {

        // 透過當前事務事件釋出的引數，建立一個TransactionSynchronization物件        TransactionSynchronization transactionSynchronization =

            createTransactionSynchronization(event);

        // 註冊TransactionSynchronization物件到TransactionManager中        TransactionSynchronizationManager

            .registerSynchronization(transactionSynchronization);

    } else if (this.annotation.fallbackExecution()) {

        // 如果當前TransactionManager沒有開啟事務事件處理，但是當前事務監聽方法中配置了        // fallbackExecution屬性為true，說明其需要對當前事務事件進行監聽，無論其是否有事務        if (this.annotation.phase() == TransactionPhase.AFTER_ROLLBACK

            && logger.isWarnEnabled()) {

            logger.warn("Processing "

                        + event + " as a fallback execution on AFTER_ROLLBACK phase");

        }

        processEvent(event);

    } else {

        // 走到這裡說明當前是不需要事務事件處理的，因而直接略過        if (logger.isDebugEnabled()) {

            logger.debug("No transaction is active - skipping " + event);

        }

    }

}

```

這裡需要說明的是，上述annotation屬性就是在事務監聽方法上解析的TransactionalEventListener註解中配置的屬性。可以看到，對於事務事件的處理，這裡建立了一個TransactionSynchronization物件，其實主要的處理邏輯就是在返回的這個物件中，而createTransactionSynchronization()方法內部只是建立了一個TransactionSynchronizationEventAdapter物件就返回了。這裡我們直接看該物件的原始碼：

```

private static classTransactionSynchronizationEventAdapterextendsTransactionSynchronizationAdapter{

    private final ApplicationListenerMethodAdapter listener;

    private final ApplicationEvent event;

    private final TransactionPhase phase;

    publicTransactionSynchronizationEventAdapter(ApplicationListenerMethodAdapter

        listener, ApplicationEvent event, TransactionPhase phase){

        this.listener = listener;

        this.event = event;

        this.phase = phase;

    }

    @Override    publicintgetOrder(){

        return this.listener.getOrder();

    }

    // 在目標方法配置的phase屬性為BEFORE_COMMIT時，處理before commit事件    publicvoidbeforeCommit(booleanreadOnly){

        if (this.phase == TransactionPhase.BEFORE_COMMIT) {

            processEvent();

        }

    }

    // 這裡對於after completion事件的處理，雖然分為了三個if分支，但是實際上都是執行的processEvent()    // 方法，因為after completion事件是事務事件中一定會執行的，因而這裡對於commit，    // rollback和completion事件都在當前方法中處理也是沒問題的    publicvoidafterCompletion(intstatus){

        if (this.phase == TransactionPhase.AFTER_COMMIT && status == STATUS_COMMITTED) {

            processEvent();

        } else if (this.phase == TransactionPhase.AFTER_ROLLBACK

                   && status == STATUS_ROLLED_BACK) {

            processEvent();

        } else if (this.phase == TransactionPhase.AFTER_COMPLETION) {

            processEvent();

        }

    }

    // 執行事務事件    protectedvoidprocessEvent(){

        this.listener.processEvent(this.event);

    }

}

```

可以看到，對於事務事件的處理，最終都是委託給了ApplicationListenerMethodAdapter.processEvent()方法進行的。如下是該方法的原始碼：

```

publicvoidprocessEvent(ApplicationEvent event){

    // 處理事務事件的相關引數，這裡主要是判斷TransactionalEventListener註解中是否配置了value    // 或classes屬性，如果配置了，則將方法引數轉換為該指定型別傳給監聽的方法；如果沒有配置，則判斷    // 目標方法是ApplicationEvent型別還是PayloadApplicationEvent型別，是則轉換為該型別傳入    Object[] args = resolveArguments(event);

    // 這裡主要是獲取TransactionalEventListener註解中的condition屬性，然後透過    // Spring expression language將其與目標類和方法進行匹配    if (shouldHandle(event, args)) {

        // 透過處理得到的引數藉助於反射呼叫事務監聽方法        Object result = doInvoke(args);

        if (result != null) {

            // 對方法的返回值進行處理            handleResult(result);

        } else {

            logger.trace("No result object given - no result to handle");

        }

    }

}// 處理事務監聽方法的引數protected Object[] resolveArguments(ApplicationEvent event) {

    // 獲取釋出事務事件時傳入的引數型別    ResolvableType declaredEventType = getResolvableType(event);

    if (declaredEventType == null) {

        return null;

    }

    // 如果事務監聽方法的引數個數為0，則直接返回    if (this.method.getParameterCount() == 0) {

        return new Object[0];

    }

    // 如果事務監聽方法的引數不為ApplicationEvent或PayloadApplicationEvent，則直接將釋出事務    // 事件時傳入的引數當做事務監聽方法的引數傳入。從這裡可以看出，如果事務監聽方法的引數不是    // ApplicationEvent或PayloadApplicationEvent型別，那麼其引數必須只能有一個，並且這個    // 引數必須與釋出事務事件時傳入的引數一致    Class<?> eventClass = declaredEventType.getRawClass();

    if ((eventClass == null || !ApplicationEvent.class.isAssignableFrom(eventClass)) &&

        event instanceof PayloadApplicationEvent) {

        return new Object[] {((PayloadApplicationEvent) event).getPayload()};

    } else {

        // 如果引數型別為ApplicationEvent或PayloadApplicationEvent，則直接將其傳入事務事件方法        return new Object[] {event};

    }

}// 判斷事務事件方法方法是否需要進行事務事件處理privatebooleanshouldHandle(ApplicationEvent event, @Nullable Object[] args){

    if (args == null) {

        return false;

    }

    String condition = getCondition();

    if (StringUtils.hasText(condition)) {

        Assert.notNull(this.evaluator, "EventExpressionEvaluator must no be null");

        EvaluationContext evaluationContext = this.evaluator.createEvaluationContext(

            event, this.targetClass, this.method, args, this.applicationContext);

        return this.evaluator.condition(condition, this.methodKey, evaluationContext);

    }

    return true;

}// 對事務事件方法的返回值進行處理，這裡的處理方式主要是將其作為一個事件繼續釋出出去，這樣就可以在// 一個統一的位置對事務事件的返回值進行處理protectedvoidhandleResult(Object result){

    // 如果返回值是陣列型別，則對陣列元素一個一個進行釋出    if (result.getClass().isArray()) {

        Object[] events = ObjectUtils.toObjectArray(result);

        for (Object event : events) {

            publishEvent(event);

        }

    } else if (result instanceof Collection<?>) {

        // 如果返回值是集合型別，則對集合進行遍歷，並且釋出集合中的每個元素        Collection<?> events = (Collection<?>) result;

        for (Object event : events) {

            publishEvent(event);

        }

    } else {

        // 如果返回值是一個物件，則直接將其進行釋出        publishEvent(result);

    }

}

```

對於事務事件的處理，總結而言，就是為每個事務事件監聽方法建立了一個TransactionSynchronizationEventAdapter物件，透過該物件在釋出事務事件的時候，會在當前執行緒中註冊該物件，這樣就可以保證每個執行緒每個監聽器中只會對應一個TransactionSynchronizationEventAdapter物件。在Spring進行事務事件的時候會呼叫該物件對應的監聽方法，從而達到對事務事件進行監聽的目的。

在此我向大家推薦一個架構學習交流群。交流學習群號：478030634 裡面會分享一些資深架構師錄製的影片錄影：有Spring，MyBatis，Netty原始碼分析，高併發、高效能、分散式、微服務架構的原理，JVM效能最佳化、分散式架構等這些成為架構師必備的知識體系。還能領取免費的學習資源，目前受益良多

3. 小結

本文首先對事務事件監聽程式的使用方式進行了講解，然後在原始碼層面講解了Spring事務監聽器是如何實現的。在Spring事務監聽器使用過程中，需要注意的是要對當前接收到的事件型別進行判斷，因為不同的事務可能會發布同樣的訊息物件過來。

作者：AI喬治
連結：