11.Spring IOC集成将bean与状态机关联起来。
CREATE TABLE `tb_order` ( `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID', `order_code` varchar(128) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '订单编码', `status` smallint(3) DEFAULT NULL COMMENT '订单状态', `name` varchar(64) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '订单名称', `price` decimal(12,2) DEFAULT NULL COMMENT '价格', `delete_flag` tinyint(2) NOT NULL DEFAULT '0' COMMENT '删除标记,0未删除 1已删除', `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间', `update_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '更新时间', `create_user_code` varchar(32) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '创建人', `update_user_code` varchar(32) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '更新人', `version` int(11) NOT NULL DEFAULT '0' COMMENT '版本号', `remark` varchar(64) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '备注', PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单表'; /*Data for the table `tb_order` */ insert into `tb_order`(`id`,`order_code`,`status`,`name`,`price`,`delete_flag`,`create_time`,`update_time`,`create_user_code`,`update_user_code`,`version`,`remark`) values (2,'A111',1,'A','22.00',0,'2022-10-15 16:14:11','2022-10-02 21:29:14','zhangsan','zhangsan',0,NULL), (3,'A111',1,'订单A','22.00',0,'2022-10-02 21:53:13','2022-10-02 21:29:14','zhangsan','zhangsan',0,NULL), (4,'A111',1,'订单A','22.00',0,'2022-10-02 21:53:13','2022-10-02 21:29:14','zhangsan','zhangsan',0,NULL), (5,'A111',1,'订单A','22.00',0,'2022-10-03 09:08:30','2022-10-02 21:29:14','zhangsan','zhangsan',0,NULL);1)引入依赖
<!-- redis持久化状态机 --> <dependency> <groupId>org.springframework.statemachine</groupId> <artifactId>spring-statemachine-redis</artifactId> <version>1.2.9.RELEASE</version> </dependency> <!--状态机--> <dependency> <groupId>org.springframework.statemachine</groupId> <artifactId>spring-statemachine-starter</artifactId> <version>2.0.1.RELEASE</version> </dependency>2)定义状态机状态和事件
/** * 堆代码 duidaima.com */ public enum OrderStatus { // 待支付,待发货,待收货,已完成 WAIT_PAYMENT(1, "待支付"), WAIT_DELIVER(2, "待发货"), WAIT_RECEIVE(3, "待收货"), FINISH(4, "已完成"); private Integer key; private String desc; OrderStatus(Integer key, String desc) { this.key = key; this.desc = desc; } public Integer getKey() { return key; } public String getDesc() { return desc; } public static OrderStatus getByKey(Integer key) { for (OrderStatus e : values()) { if (e.getKey().equals(key)) { return e; } } throw new RuntimeException("enum not exists."); } }事件:
/** * 堆代码 duidaima.com */ public enum OrderStatusChangeEvent { // 支付,发货,确认收货 PAYED, DELIVERY, RECEIVED; }3)定义状态机规则和配置状态机
@Configuration @EnableStateMachine(name = "orderStateMachine") public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderStatus, OrderStatusChangeEvent> { /** * 配置状态 * * @param states * @throws Exception */ public void configure(StateMachineStateConfigurer<OrderStatus, OrderStatusChangeEvent> states) throws Exception { states .withStates() .initial(OrderStatus.WAIT_PAYMENT) .states(EnumSet.allOf(OrderStatus.class)); } /** * 配置状态转换事件关系 * * @param transitions * @throws Exception */ public void configure(StateMachineTransitionConfigurer<OrderStatus, OrderStatusChangeEvent> transitions) throws Exception { transitions //支付事件:待支付-》待发货 .withExternal().source(OrderStatus.WAIT_PAYMENT).target(OrderStatus.WAIT_DELIVER).event(OrderStatusChangeEvent.PAYED) .and() //发货事件:待发货-》待收货 .withExternal().source(OrderStatus.WAIT_DELIVER).target(OrderStatus.WAIT_RECEIVE).event(OrderStatusChangeEvent.DELIVERY) .and() //收货事件:待收货-》已完成 .withExternal().source(OrderStatus.WAIT_RECEIVE).target(OrderStatus.FINISH).event(OrderStatusChangeEvent.RECEIVED); } }配置持久化:
/** * 堆代码 duidaima.com */ @Configuration @Slf4j public class Persist<E, S> { /** * 持久化到内存map中 * * @return */ @Bean(name = "stateMachineMemPersister") public static StateMachinePersister getPersister() { return new DefaultStateMachinePersister(new StateMachinePersist() { @Override public void write(StateMachineContext context, Object contextObj) throws Exception { log.info("持久化状态机,context:{},contextObj:{}", JSON.toJSONString(context), JSON.toJSONString(contextObj)); map.put(contextObj, context); } @Override public StateMachineContext read(Object contextObj) throws Exception { log.info("获取状态机,contextObj:{}", JSON.toJSONString(contextObj)); StateMachineContext stateMachineContext = (StateMachineContext) map.get(contextObj); log.info("获取状态机结果,stateMachineContext:{}", JSON.toJSONString(stateMachineContext)); return stateMachineContext; } private Map map = new HashMap(); }); } @Resource private RedisConnectionFactory redisConnectionFactory; /** * 持久化到redis中,在分布式系统中使用 * * @return */ @Bean(name = "stateMachineRedisPersister") public RedisStateMachinePersister<E, S> getRedisPersister() { RedisStateMachineContextRepository<E, S> repository = new RedisStateMachineContextRepository<>(redisConnectionFactory); RepositoryStateMachinePersist p = new RepositoryStateMachinePersist<>(repository); return new RedisStateMachinePersister<>(p); } }4)业务系统
/** */ @RestController @RequestMapping("/order") public class OrderController { @Resource private OrderService orderService; /** * 根据id查询订单 * * @return */ @RequestMapping("/getById") public Order getById(@RequestParam("id") Long id) { //根据id查询订单 Order order = orderService.getById(id); return order; } /** * 创建订单 * * @return */ @RequestMapping("/create") public String create(@RequestBody Order order) { //创建订单 orderService.create(order); return "sucess"; } /** * 对订单进行支付 * * @param id * @return */ @RequestMapping("/pay") public String pay(@RequestParam("id") Long id) { //对订单进行支付 orderService.pay(id); return "success"; } /** * 对订单进行发货 * * @param id * @return */ @RequestMapping("/deliver") public String deliver(@RequestParam("id") Long id) { //对订单进行确认收货 orderService.deliver(id); return "success"; } /** * 对订单进行确认收货 * * @param id * @return */ @RequestMapping("/receive") public String receive(@RequestParam("id") Long id) { //对订单进行确认收货 orderService.receive(id); return "success"; } }servie:
/** */ @Service("orderService") @Slf4j public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService { @Resource private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine; @Resource private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineMemPersister; @Resource private OrderMapper orderMapper; /** * 创建订单 * * @param order * @return */ public Order create(Order order) { order.setStatus(OrderStatus.WAIT_PAYMENT.getKey()); orderMapper.insert(order); return order; } /** * 对订单进行支付 * * @param id * @return */ public Order pay(Long id) { Order order = orderMapper.selectById(id); log.info("线程名称:{},尝试支付,订单号:{}" ,Thread.currentThread().getName() , id); if (!sendEvent(OrderStatusChangeEvent.PAYED, order)) { log.error("线程名称:{},支付失败, 状态异常,订单信息:{}", Thread.currentThread().getName(), order); throw new RuntimeException("支付失败, 订单状态异常"); } return order; } /** * 对订单进行发货 * * @param id * @return */ public Order deliver(Long id) { Order order = orderMapper.selectById(id); log.info("线程名称:{},尝试发货,订单号:{}" ,Thread.currentThread().getName() , id); if (!sendEvent(OrderStatusChangeEvent.DELIVERY, order)) { log.error("线程名称:{},发货失败, 状态异常,订单信息:{}", Thread.currentThread().getName(), order); throw new RuntimeException("发货失败, 订单状态异常"); } return order; } /** * 对订单进行确认收货 * * @param id * @return */ public Order receive(Long id) { Order order = orderMapper.selectById(id); log.info("线程名称:{},尝试收货,订单号:{}" ,Thread.currentThread().getName() , id); if (!sendEvent(OrderStatusChangeEvent.RECEIVED, order)) { log.error("线程名称:{},收货失败, 状态异常,订单信息:{}", Thread.currentThread().getName(), order); throw new RuntimeException("收货失败, 订单状态异常"); } return order; } /** * 发送订单状态转换事件 * synchronized修饰保证这个方法是线程安全的 * * @param changeEvent * @param order * @return */ private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) { boolean result = false; try { //启动状态机 orderStateMachine.start(); //尝试恢复状态机状态 stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId())); Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build(); result = orderStateMachine.sendEvent(message); //持久化状态机状态 stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId())); } catch (Exception e) { log.error("订单操作失败:{}", e); } finally { orderStateMachine.stop(); } return result; } }监听状态的变化:
/** */ @Component("orderStateListener") @WithStateMachine(name = "orderStateMachine") @Slf4j public class OrderStateListenerImpl { @Resource private OrderMapper orderMapper; @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER") public void payTransition(Message<OrderStatusChangeEvent> message) { Order order = (Order) message.getHeaders().get("order"); log.info("支付,状态机反馈信息:{}", message.getHeaders().toString()); //更新订单 order.setStatus(OrderStatus.WAIT_DELIVER.getKey()); orderMapper.updateById(order); //TODO 其他业务 } @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE") public void deliverTransition(Message<OrderStatusChangeEvent> message) { Order order = (Order) message.getHeaders().get("order"); log.info("发货,状态机反馈信息:{}", message.getHeaders().toString()); //更新订单 order.setStatus(OrderStatus.WAIT_RECEIVE.getKey()); orderMapper.updateById(order); //TODO 其他业务 } @OnTransition(source = "WAIT_RECEIVE", target = "FINISH") public void receiveTransition(Message<OrderStatusChangeEvent> message) { Order order = (Order) message.getHeaders().get("order"); log.info("确认收货,状态机反馈信息:{}", message.getHeaders().toString()); //更新订单 order.setStatus(OrderStatus.FINISH.getKey()); orderMapper.updateById(order); //TODO 其他业务 } }3.3 测试验证
/** */ @Resource private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineMemPersister; /** * 发送订单状态转换事件 * synchronized修饰保证这个方法是线程安全的 * * @param changeEvent * @param order * @return */ private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) { boolean result = false; try { //启动状态机 orderStateMachine.start(); //尝试恢复状态机状态 stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId())); Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build(); result = orderStateMachine.sendEvent(message); //持久化状态机状态 stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId())); } catch (Exception e) { log.error("订单操作失败:{}", e); } finally { orderStateMachine.stop(); } return result; }redis持久化
<!-- redis持久化状态机 --> <dependency> <groupId>org.springframework.statemachine</groupId> <artifactId>spring-statemachine-redis</artifactId> <version>1.2.9.RELEASE</version> </dependency>配置yaml:
spring: redis: database: 0 host: localhost jedis: pool: max-active: 8 max-idle: 8 max-wait: '' min-idle: 0 password: '' port: 6379 timeout: 0使用redis持久化类持久化:
/** */ @Resource private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineRedisPersister; /** * 发送订单状态转换事件 * synchronized修饰保证这个方法是线程安全的 * * @param changeEvent * @param order * @return */ private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) { boolean result = false; try { //启动状态机 orderStateMachine.start(); //尝试恢复状态机状态 stateMachineRedisPersister.restore(orderStateMachine, String.valueOf(order.getId())); Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build(); result = orderStateMachine.sendEvent(message); //持久化状态机状态 stateMachineRedisPersister.persist(orderStateMachine, String.valueOf(order.getId())); } catch (Exception e) { log.error("订单操作失败:{}", e); } finally { orderStateMachine.stop(); } return result; }3.4 状态机存在的问题
@Resource private OrderMapper orderMapper; @Resource private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine; @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER") @Transactional(rollbackFor = Exception.class) public void payTransition(Message<OrderStatusChangeEvent> message) { Order order = (Order) message.getHeaders().get("order"); log.info("支付,状态机反馈信息:{}", message.getHeaders().toString()); try { //更新订单 order.setStatus(OrderStatus.WAIT_DELIVER.getKey()); orderMapper.updateById(order); //TODO 其他业务 //模拟异常 if(Objects.equals(order.getName(),"A")){ throw new RuntimeException("执行业务异常"); } } catch (Exception e) { //如果出现异常,记录异常信息,抛出异常信息进行回滚 log.error("payTransition 出现异常:{}",e); throw e; } }监听事件抛出异常,在发送事件中无法感知:
private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) { boolean result = false; try { //启动状态机 orderStateMachine.start(); //尝试恢复状态机状态 stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId())); Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build(); //事件执行异常了,依然返回true,无法感知异常 result = orderStateMachine.sendEvent(message); if(result){ //持久化状态机状态,如果根据true持久化,则会出现问题 stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId())); } } catch (Exception e) { log.error("订单操作失败:{}", e); } finally { orderStateMachine.stop(); } return result; }调试发现:发送事件和监听事件是一个线程,发送事件的结果是在监听操作执行完之后才返回
监听线程:
解决方案:自己保存异常到数据库或者内存中,进行判断,也可以通过接口:org.springframework.statemachine.StateMachine##getExtendedState
public interface ExtendedState { Map<Object, Object> getVariables(); <T> T get(Object var1, Class<T> var2); void setExtendedStateChangeListener(ExtendedState.ExtendedStateChangeListener var1); public interface ExtendedStateChangeListener { void changed(Object var1, Object var2); } } org.springframework.statemachine.support.DefaultExtendedState##getVariables private final Map<Object, Object> variables; public DefaultExtendedState() { this.variables = new ObservableMap(new ConcurrentHashMap(), new DefaultExtendedState.LocalMapChangeListener()); } public Map<Object, Object> getVariables() { return this.variables; }改造监听状态:把业务的执行结果进行保存,1成功,0失败
@Resource private OrderMapper orderMapper; @Resource private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine; @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER") @Transactional(rollbackFor = Exception.class) public void payTransition(Message<OrderStatusChangeEvent> message) { Order order = (Order) message.getHeaders().get("order"); log.info("支付,状态机反馈信息:{}", message.getHeaders().toString()); try { //更新订单 order.setStatus(OrderStatus.WAIT_DELIVER.getKey()); orderMapper.updateById(order); //TODO 其他业务 //模拟异常 if(Objects.equals(order.getName(),"A")){ throw new RuntimeException("执行业务异常"); } //成功 则为1 orderStateMachine.getExtendedState().getVariables().put(CommonConstants.payTransition+order.getId(),1); } catch (Exception e) { //如果出现异常,则进行回滚 log.error("payTransition 出现异常:{}",e); //将异常信息变量信息中,失败则为0 orderStateMachine.getExtendedState().getVariables().put(CommonConstants.payTransition+order.getId(), 0); throw e; } }发送事件改造:如果获取到业务执行异常,则返回失败,不进行状态机持久化 com.zengqingfa.springboot.state.demo.service.impl.OrderServiceImpl##sendEvent
@Resource private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine; @Resource private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineMemPersister; /** * 发送订单状态转换事件 * synchronized修饰保证这个方法是线程安全的 * * @param changeEvent * @param order * @return */ private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order){ boolean result = false; try { //启动状态机 orderStateMachine.start(); //尝试恢复状态机状态 stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId())); Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build(); result = orderStateMachine.sendEvent(message); if(!result){ return false; } //获取到监听的结果信息 Integer o = (Integer) orderStateMachine.getExtendedState().getVariables().get(CommonConstants.payTransition + order.getId()); //操作完成之后,删除本次对应的key信息 orderStateMachine.getExtendedState().getVariables().remove(CommonConstants.payTransition+order.getId()); //如果事务执行成功,则持久化状态机 if(Objects.equals(1,Integer.valueOf(o))){ //持久化状态机状态 stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId())); }else { //订单执行业务异常 return false; } } catch (Exception e) { log.error("订单操作失败:{}", e); } finally { orderStateMachine.stop(); } return result; }代码优化
//获取到监听的结果信息 Integer o = (Integer) orderStateMachine.getExtendedState().getVariables().get(CommonConstants.payTransition + order.getId());监听设置状态的代码有重复代码,需要进行优化,可使用aop
try { //TODO 其他业务 //成功 则为1 orderStateMachine.getExtendedState().getVariables().put(CommonConstants.payTransition+order.getId(),1); } catch (Exception e) { //如果出现异常,则进行回滚 log.error("payTransition 出现异常:{}",e); //将异常信息变量信息中,失败则为0 orderStateMachine.getExtendedState().getVariables().put(CommonConstants.payTransition+order.getId(), 0); throw e; }常量类:
public interface CommonConstants { String orderHeader="order"; String payTransition="payTransition"; String deliverTransition="deliverTransition"; String receiveTransition="receiveTransition"; }支付发送事件:com.zengqingfa.springboot.state.demo.service.impl.OrderServiceImpl##pay
@Resource private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine; @Resource private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineMemPersister; @Resource private OrderMapper orderMapper; /** * 对订单进行支付 * * @param id * @return */ public Order pay(Long id) { Order order = orderMapper.selectById(id); log.info("线程名称:{},尝试支付,订单号:{}" ,Thread.currentThread().getName() , id); if (!sendEvent(OrderStatusChangeEvent.PAYED, order,CommonConstants.payTransition)) { log.error("线程名称:{},支付失败, 状态异常,订单信息:{}", Thread.currentThread().getName(), order); throw new RuntimeException("支付失败, 订单状态异常"); } return order; } /** * 发送订单状态转换事件 * synchronized修饰保证这个方法是线程安全的 * * @param changeEvent * @param order * @return */ private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order,String key){ boolean result = false; try { //启动状态机 orderStateMachine.start(); //尝试恢复状态机状态 stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId())); Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build(); result = orderStateMachine.sendEvent(message); if(!result){ return false; } //获取到监听的结果信息 Integer o = (Integer) orderStateMachine.getExtendedState().getVariables().get(key + order.getId()); //操作完成之后,删除本次对应的key信息 orderStateMachine.getExtendedState().getVariables().remove(key+order.getId()); //如果事务执行成功,则持久化状态机 if(Objects.equals(1,Integer.valueOf(o))){ //持久化状态机状态 stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId())); }else { //订单执行业务异常 return false; } } catch (Exception e) { log.error("订单操作失败:{}", e); } finally { orderStateMachine.stop(); } return result; }使用aop对监听事件切面,把业务执行结果封装到状态机的变量中,注解:
@Retention(RetentionPolicy.RUNTIME) public @interface LogResult { /** *执行的业务key * * @return String */ String key(); }切面:
@Component @Aspect @Slf4j public class LogResultAspect { //拦截 LogHistory注解 @Pointcut("@annotation(com.zengqingfa.springboot.state.demo.aop.annotation.LogResult)") private void logResultPointCut() { //logResultPointCut 日志注解切点 } @Resource private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine; @Around("logResultPointCut()") public Object logResultAround(ProceedingJoinPoint pjp) throws Throwable { //获取参数 Object[] args = pjp.getArgs(); log.info("参数args:{}", args); Message message = (Message) args[0]; Order order = (Order) message.getHeaders().get("order"); //获取方法 Method method = ((MethodSignature) pjp.getSignature()).getMethod(); // 获取LogHistory注解 LogResult logResult = method.getAnnotation(LogResult.class); String key = logResult.key(); Object returnVal = null; try { //执行方法 returnVal = pjp.proceed(); //如果业务执行正常,则保存信息 //成功 则为1 orderStateMachine.getExtendedState().getVariables().put(key + order.getId(), 1); } catch (Throwable e) { log.error("e:{}", e.getMessage()); //如果业务执行异常,则保存信息 //将异常信息变量信息中,失败则为0 orderStateMachine.getExtendedState().getVariables().put(key + order.getId(), 0); throw e; } return returnVal; } }监听类使用注解:
@Component("orderStateListener") @WithStateMachine(name = "orderStateMachine") @Slf4j public class OrderStateListenerImpl { @Resource private OrderMapper orderMapper; @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER") @Transactional(rollbackFor = Exception.class) @LogResult(key = CommonConstants.payTransition) public void payTransition(Message<OrderStatusChangeEvent> message) { Order order = (Order) message.getHeaders().get("order"); log.info("支付,状态机反馈信息:{}", message.getHeaders().toString()); //更新订单 order.setStatus(OrderStatus.WAIT_DELIVER.getKey()); orderMapper.updateById(order); //TODO 其他业务 //模拟异常 if (Objects.equals(order.getName(), "A")) { throw new RuntimeException("执行业务异常"); } } @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE") @LogResult(key = CommonConstants.deliverTransition) public void deliverTransition(Message<OrderStatusChangeEvent> message) { Order order = (Order) message.getHeaders().get("order"); log.info("发货,状态机反馈信息:{}", message.getHeaders().toString()); //更新订单 order.setStatus(OrderStatus.WAIT_RECEIVE.getKey()); orderMapper.updateById(order); //TODO 其他业务 } @OnTransition(source = "WAIT_RECEIVE", target = "FINISH") @LogResult(key = CommonConstants.receiveTransition) public void receiveTransition(Message<OrderStatusChangeEvent> message) { Order order = (Order) message.getHeaders().get("order"); log.info("确认收货,状态机反馈信息:{}", message.getHeaders().toString()); //更新订单 order.setStatus(OrderStatus.FINISH.getKey()); orderMapper.updateById(order); //TODO 其他业务 } }