Spring事务监听机制---使用@TransactionalEventListener处理数据库事务提交成功后再执行操作（附：Spring4.2新特性讲解）【享学Spring】（上）

@Slf4j
@Service
public class HelloServiceImpl implements HelloService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;
    @Transactional
    @Override
    public Object hello(Integer id) {
        // 向数据库插入一条记录
        String sql = "insert into user (id,name,age) values (" + id + ",'fsx',21)";
        jdbcTemplate.update(sql);
        // 发布一个自定义的事件~~~
        applicationEventPublisher.publishEvent(new MyAfterTransactionEvent("我是和事务相关的事件，请事务提交后执行我~~~", id));
        return "service hello";
    }
    @Slf4j
    @Component
    private static class MyTransactionListener {
        @Autowired
        private JdbcTemplate jdbcTemplate;
        @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
        private void onHelloEvent(HelloServiceImpl.MyAfterTransactionEvent event) {
            Object source = event.getSource();
            Integer id = event.getId();
            String query = "select count(1) from user where id = " + id;
            Integer count = jdbcTemplate.queryForObject(query, Integer.class);
            // 可以看到 这里的count是1  它肯定是在上面事务提交之后才会执行的
            log.info(source + ":" + count.toString()); //我是和事务相关的事件，请事务提交后执行我~~~:1
        }
    }
    // 定一个事件，继承自ApplicationEvent 
    private static class MyAfterTransactionEvent extends ApplicationEvent {
        private Integer id;
        public MyAfterTransactionEvent(Object source, Integer id) {
            super(source);
            this.id = id;
        }
        public Integer getId() {
            return id;
        }
    }
}

// @since 4.2  显然，注解的方式提供得还是挺晚的，而API的方式第一个版本就已经提供了
// 另外最重要的是，它头上有一个注解：`@EventListener`  so  
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@EventListener //有类似于注解继承的效果
public @interface TransactionalEventListener {
  // 这个注解取值有：BEFORE_COMMIT、AFTER_COMMIT、AFTER_ROLLBACK、AFTER_COMPLETION
  // 各个值都代表什么意思表达什么功能，非常清晰~
  // 需要注意的是：AFTER_COMMIT + AFTER_COMPLETION是可以同时生效的
  // AFTER_ROLLBACK + AFTER_COMPLETION是可以同时生效的
  TransactionPhase phase() default TransactionPhase.AFTER_COMMIT;
  // 若没有事务的时候，对应的event是否已经执行  默认值为false表示  没事务就不执行了
  boolean fallbackExecution() default false;
  // 这里巧妙的用到了@AliasFor的能力，放到了@EventListener身上
  // 注意：一般我建议都需要指定此值，否则默认可以处理所有类型的事件  范围太广了
  @AliasFor(annotation = EventListener.class, attribute = "classes")
  Class<?>[] value() default {};
  @AliasFor(annotation = EventListener.class, attribute = "classes")
  Class<?>[] classes() default {};
  String condition() default "";
}

public class TransactionalEventListenerFactory implements EventListenerFactory, Ordered {
  private int order = 50; // 执行时机还是比较早的~~~（默认的工厂是最低优先级）
  // 显然这个工厂只会生成标注有此注解的handler~~~
  @Override
  public boolean supportsMethod(Method method) {
    return AnnotatedElementUtils.hasAnnotation(method, TransactionalEventListener.class);
  }
  // 这里使用的是ApplicationListenerMethodTransactionalAdapter，而非ApplicationListenerMethodAdapter
  // 虽然ApplicationListenerMethodTransactionalAdapter是它的子类
  @Override
  public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {
    return new ApplicationListenerMethodTransactionalAdapter(beanName, type, method);
  }
}

// @since 4.2
class ApplicationListenerMethodTransactionalAdapter extends ApplicationListenerMethodAdapter {
  private final TransactionalEventListener annotation;
  // 构造函数
  public ApplicationListenerMethodTransactionalAdapter(String beanName, Class<?> targetClass, Method method) {
    // 这一步的初始化交给父类，做了很多事情   强烈建议看看上面推荐的事件/监听的博文
    super(beanName, targetClass, method);
    // 自己个性化的：和事务相关
    TransactionalEventListener ann = AnnotatedElementUtils.findMergedAnnotation(method, TransactionalEventListener.class);
    if (ann == null) {
      throw new IllegalStateException("No TransactionalEventListener annotation found on method: " + method);
    }
    this.annotation = ann;
  }
  @Override
  public void onApplicationEvent(ApplicationEvent event) {
    // 若**存在事务**：毫无疑问 就注册一个同步器进去~~
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
      TransactionSynchronization transactionSynchronization = createTransactionSynchronization(event);
      TransactionSynchronizationManager.registerSynchronization(transactionSynchronization);
    }
    // 若fallbackExecution=true，那就是表示即使没有事务  也会执行handler
    else if (this.annotation.fallbackExecution()) {
      if (this.annotation.phase() == TransactionPhase.AFTER_ROLLBACK && logger.isWarnEnabled()) {
        logger.warn("Processing " + event + " as a fallback execution on AFTER_ROLLBACK phase");
      }
      processEvent(event);
    }
    else {
      // No transactional event execution at all
      // 若没有事务，输出一个debug信息，表示这个监听器没有执行~~~~
      if (logger.isDebugEnabled()) {
        logger.debug("No transaction is active - skipping " + event);
      }
    }
  }
  // TransactionSynchronizationEventAdapter是一个内部类，它是一个TransactionSynchronization同步器
  // 此类实现也比较简单，它的order由listener.getOrder();来决定
  private TransactionSynchronization createTransactionSynchronization(ApplicationEvent event) {
    return new TransactionSynchronizationEventAdapter(this, event, this.annotation.phase());
  }
  private static class TransactionSynchronizationEventAdapter extends TransactionSynchronizationAdapter {
    private final ApplicationListenerMethodAdapter listener;
    private final ApplicationEvent event;
    private final TransactionPhase phase;
    public TransactionSynchronizationEventAdapter(ApplicationListenerMethodAdapter listener,
        ApplicationEvent event, TransactionPhase phase) {
      this.listener = listener;
      this.event = event;
      this.phase = phase;
    }
    // 它的order又监听器本身来决定  
    @Override
    public int getOrder() {
      return this.listener.getOrder();
    }
    // 最终都是委托给了listenner来真正的执行处理  来执行最终处理逻辑（也就是解析classes、condtion、执行方法体等等）
    @Override
    public void beforeCommit(boolean readOnly) {
      if (this.phase == TransactionPhase.BEFORE_COMMIT) {
        processEvent();
      }
    }
    // 此处结合status和phase   判断是否应该执行~~~~
    // 此处小技巧：我们发现TransactionPhase.AFTER_COMMIT也是放在了此处执行的，只是它结合了status进行判断而已~~~
    @Override
    public void afterCompletion(int status) {
      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();
      }
    }
    protected void processEvent() {
      this.listener.processEvent(this.event);
    }
  }
}