文档章节

Spring事务事件监控

爱宝贝丶
 爱宝贝丶
发布于 09/06 19:26
字数 3460
阅读 2473
收藏 102

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

1. 示例

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

@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,其可以取如下几个类型的值:

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...
}
@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发布相应的事件消息。如下是对上述消息进行监控的程序:

@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进行事务事件的时候会调用该对象对应的监听方法,从而达到对事务事件进行监听的目的。

3. 小结

       本文首先对事务事件监听程序的使用方式进行了讲解,然后在源码层面讲解了Spring事务监听器是如何实现的。在Spring事务监听器使用过程中,需要注意的是要对当前接收到的事件类型进行判断,因为不同的事务可能会发布同样的消息对象过来。

© 著作权归作者所有

共有 人打赏支持
爱宝贝丶
粉丝 137
博文 77
码字总数 258388
作品 0
武汉
程序员
加载中

评论(4)

X_H
X_H
能提供源码更好了
李尼成
孟定镇
法球特效
不明嚼栗
MGL_TECH
MGL_TECH
记录,马克
这些优秀的 Spring Cloud 开源软件,你知道几个?

Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发,如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等,都可以用...

技术小能手
08/30
0
0
Struts2+Spring+Hibernate3集成

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/hxdeng/article/details/52278238 1. 加入Struts2,Hibernate3.3,Spring3.3 和数据库驱动包 注意:当有包重复...

降龙十八腿
2016/08/22
0
0
Spring事务用法示例与实现原理

关于事务,简单来说,就是为了保证数据完整性而存在的一种工具,其主要有四大特性:原子性,一致性,隔离性和持久性。对于Spring事务,其最终还是在数据库层面实现的,而Spring只是以一种比较...

爱宝贝丶
08/28
0
0
JavaMelody监控spring、struts

  Struts监控 Struts的监控相对来说要简单多了,只要按照下面的步骤,肯定是没有问题的。   第一步,导入必要的jar包,需要的jar包前面已经提到过了。   一个是javamelody.jar,另一个...

glen_xu
2015/07/23
0
0
简化SSM搭建详细分析配置

一直使用SSH2 和 spring boot,最近换工作,使用新框架SpringMVC,带着SSH2的思路学习SpringMVC还是挺容易的,下面分享一下SSM的搭建 总体来说搭建SSM分五步 一:创建maven工程 这里是创建m...

红尾巴的猪
2017/11/10
0
0

没有更多内容

加载失败,请刷新页面

加载更多

web打印控件 LODOP的详细api

web打印控件 LODOP的详细api

wangxujun59
21分钟前
1
0
从一次小哥哥与小姐姐的转账开始, 浅谈分布式事务从理论到实践

分布式事务是个业界难题,在看分布式事务方案之前,先从单机数据库事务开始看起。 什么是事务 事务(Transaction)是数据库系统中一系列操作的一个逻辑单元,所有操作要么全部成功要么全部失...

中间件小哥
24分钟前
5
0
荣登Github日榜!微信最新开源MMKV

MMKV 开源当日即登Github Trending日榜,三日后荣登周榜。MMKV 在腾讯内部开源半年,得到公司内部团队的广泛应用和一致好评。 MMKV 是基于 mmap 内存映射的移动端通用 key-value 组件,底层序...

腾讯开源
33分钟前
2
0
前端取色工具:jcpicker

http://annystudio.com/software/colorpicker/#jcp-download

轻量级赤影
35分钟前
1
0
Swift - 将图片保存到相册

import Photos func loadImage(image:UIImage) { UIImageWriteToSavedPhotosAlbum(image, self, #selector(saveImage(image:didFinishSavingWithError:contextInfo:)), ni......

west_zll
41分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部