Spring事务事件监控

时间  2019-12-05
标签 spring 事务 事件 监控 栏目 Spring 繁體版
原文   原文链接

前面咱们讲到了Spring在进行事务逻辑织入的时候，不管是事务开始，提交或者回滚，都会触发相应的事务事件。本文首先会使用实例进行讲解Spring事务事件是如何使用的，而后会讲解这种使用方式的实现原理。mysql

1.示例

对于事务事件，Spring提供了一个注解@TransactionEventListener，将这个注解标注在某个方法上，那么就将这个方法声明为了一个事务事件处理器，而具体的事件类型则是由TransactionalEventListener.phase属性进行定义的。以下是TransactionalEventListener的声明：spring

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

// 指定当前标注方法处理事务的类型
TransactionPhase phase() default TransactionPhase.AFTER_COMMIT;

// 用于指定当前方法若是没有事务，是否执行相应的事务事件监听器
boolean fallbackExecution() default false;

// 与classes属性同样，指定了当前事件传入的参数类型，指定了这个参数以后就能够在监听方法上
// 直接什么一个这个参数了
@AliasFor(annotation = EventListener.class, attribute = "classes")
Class<?>[] value() default {};

// 做用于value属性同样，用于指定当前监听方法的参数类型
@AliasFor(annotation = EventListener.class, attribute = "classes")
Class<?>[] classes() default {};

// 这个属性使用Spring Expression Language对目标类和方法进行匹配，对于不匹配的方法将会过滤掉
String condition() default "";

}

关于这里的classes属性须要说明一下，若是指定了classes属性，那么当前监听方法的参数类型就能够直接使用所发布的事件的参数类型，若是没有指定，那么这里监听的参数类型可使用两种：ApplicationEvent和PayloadApplicationEvent。对于ApplicationEvent类型的参数，能够经过其getSource()方法获取发布的事件参数，只不过其返回值是一个Object类型的，若是想获取具体的类型还须要进行强转；对于PayloadApplicationEvent类型，其能够指定一个泛型参数，该泛型参数必须与发布的事件的参数类型一致，这样就能够经过其getPayload()方法获取事务事件发布的数据了。关于上述属性中的TransactionPhase，其能够取以下几个类型的值：sql

public enum TransactionPhase {
   // 指定目标方法在事务commit以前执行
   BEFORE_COMMIT,

   // 指定目标方法在事务commit以后执行
    AFTER_COMMIT,

    // 指定目标方法在事务rollback以后执行
    AFTER_ROLLBACK,

   // 指定目标方法在事务完成时执行，这里的完成是指不管事务是成功提交仍是事务回滚了
   AFTER_COMPLETION
  }

这里咱们假设数据库有一个user表，对应的有一个UserService和User的model，用于往该表中插入数据，而且插入动做时使用注解标注目标方法。以下是这几个类的声明：数据库

public class User {
private long id;
private String name;
private int age;

// getter and setter...
}

.express

@Service
@Transactional
public class UserServiceImpl implements UserService {
@Autowired
private JdbcTemplate jdbcTemplate;

 @Autowired
 private ApplicationEventPublisher publisher;

@Override
public void insert(User user) {
jdbcTemplate.update("insert into user (id, name, age) value (?, ?, ?)", 
    user.getId(), user.getName(), user.getAge());
publisher.publishEvent(user);
}
}

上述代码中有一点须要注意的是，对于须要监控事务事件的方法，在目标方法执行的时候须要使用ApplicationEventPublisher发布相应的事件消息。以下是对上述消息进行监控的程序：apache

@Component
public class UserTransactionEventListener {

@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
public void beforeCommit(PayloadApplicationEvent<User> event) {
System.out.println("before commit, id: " + event.getPayload().getId());
}

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void afterCommit(PayloadApplicationEvent<User> event) {
System.out.println("after commit, id: " + event.getPayload().getId());
}

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMPLETION)
public void afterCompletion(PayloadApplicationEvent<User> event) {
System.out.println("after completion, id: " + event.getPayload().getId());
}

@TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)
public void afterRollback(PayloadApplicationEvent<User> event) {
System.out.println("after rollback, id: " + event.getPayload().getId());
}
}

这里对于事件的监控，只须要在监听方法上添加@TransactionalEventListener注解便可。这里须要注意的一个问题，在实际使用过程当中，对于监听的事务事件，须要使用其余的参数进行事件的过滤，由于这里的监听仍是会监听全部事件参数为User类型的事务，而不管其是哪一个位置发出来的。若是须要对事件进行过滤，这里能够封装一个UserEvent对象，其内保存一个相似EventType的属性和一个User对象，这样在发布消息的时候就能够指定EventType属性，而在监听消息的时候判断当前方法监听的事件对象的EventType是否为目标type，若是是，则对其进行处理，不然直接略过。下面是上述程序的xml文件配置和驱动程序：数组

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="url" value="jdbc:mysql://localhost/test?useUnicode=true"/>
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="username" value="******"/>
<property name="password" value="******"/>
</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>

<bean id="transactionManager" 
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

<context:component-scan base-package="com.transaction"/>
<tx:annotation-driven/>

.性能优化

public class TransactionApp {
@Test
public void testTransaction() {
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean(UserService.class);
User user = getUser();
userService.insert(user);
}

private User getUser() {
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 interface TransactionSynchronization extends Flushable {

// 在当前事务挂起时执行
default void suspend() {
}

// 在当前事务从新加载时执行
default void resume() {
}

// 在当前数据刷新到数据库时执行
default void flush() {
}

// 在当前事务commit以前执行
default void beforeCommit(boolean readOnly) {
}

// 在当前事务completion以前执行
default void beforeCompletion() {
}

// 在当前事务commit以后实质性
default void afterCommit() {
}

// 在当前事务completion以后执行
default void afterCompletion(int status) {
}
}

很明显，这里的TransactionSynchronization接口只是抽象了一些行为，用于事务事件发生时触发，这些行为在Spring事务中提供了内在支持，即在相应的事务事件时，其会获取当前全部注册的TransactionSynchronization对象，而后调用其相应的方法。那么这里TransactionSynchronization对象的注册点对于咱们了解事务事件触发有相当重要的做用了。这里咱们首先回到事务标签的解析处，在前面讲解事务标签解析时，咱们讲到Spring会注册一个TransactionalEventListenerFactory类型的bean到Spring容器中，这里关于标签的解析读者能够阅读本人前面的文章Spring事务用法示例与实现原理。这里注册的TransactionalEventListenerFactory实现了EventListenerFactory接口，这个接口的主要做用是先判断目标方法是不是某个监听器的类型，而后为目标方法生成一个监听器，其会在某个bean初始化以后由Spring调用其方法用于生成监听器。以下是该类的实现：

public class TransactionalEventListenerFactory implements EventListenerFactory, Ordered {

// 指定当前监听器的顺序
private int order = 50;

public void setOrder(int order) {
    this.order = order;
}

@Override
public int getOrder() {
    return this.order;
}


// 指定目标方法是不是所支持的监听器的类型，这里的判断逻辑就是若是目标方法上包含有
// TransactionalEventListener注解，则说明其是一个事务事件监听器
@Override
public boolean supportsMethod(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对象，而且将该对象注册到当前事务逻辑中，以下是监听事务事件的处理逻辑：

@Override
 public void onApplicationEvent(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 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;
}

@Override
public int getOrder() {
    return this.listener.getOrder();
}

// 在目标方法配置的phase属性为BEFORE_COMMIT时，处理before commit事件
public void beforeCommit(boolean readOnly) {
    if (this.phase == TransactionPhase.BEFORE_COMMIT) {
        processEvent();
    }
}

// 这里对于after completion事件的处理，虽然分为了三个if分支，可是实际上都是执行的processEvent()
// 方法，由于after completion事件是事务事件中必定会执行的，于是这里对于commit，
// rollback和completion事件都在当前方法中处理也是没问题的
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);
}
}

能够看到，对于事务事件的处理，最终都是委托给了ApplicationListenerMethodAdapter.processEvent()方法进行的。以下是该方法的源码：

public void processEvent(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};
}
 }

 // 判断事务事件方法方法是否须要进行事务事件处理
private boolean shouldHandle(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;
 }

 // 对事务事件方法的返回值进行处理，这里的处理方式主要是将其做为一个事件继续发布出去，这样就能够在
// 一个统一的位置对事务事件的返回值进行处理
protected void handleResult(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事务监听器使用过程当中，须要注意的是要对当前接收到的事件类型进行判断，由于不一样的事务可能会发布一样的消息对象过来。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程