基于RabbitMQ，Redis，Redisson，RocketMQ四种技术实现订单延时关闭功能及其相关优缺点介绍（以12306为主题）

目录

1. 延迟关闭订单

1.1 订单延时关闭功能技术选型

1.1.1 定时任务

1.1.2 RabbitMQ

1.1.3 Redis 过期监听

1.1.4 Redisson

1.1.5 RocketMQ

1.2 RocketMQ订单延时关闭发送方实现

1.3 RocketMQ订单延时关闭的消费方实现

1. 延迟关闭订单

用户发起订单后，如果长时间未支付，需要将订单关闭，也就是大家常说的延时关闭订单。12306的PC端的延迟时间是10分钟:

1.1 订单延时关闭功能技术选型

1.1.1 定时任务

通过定时任务是一种常见的订单延迟关闭解决方案。

可以通过调度平台来实现定时任务的执行，具体任务是根据订单创建时间扫描所有到期的订单，并执行关闭订单的操作。

大家常用的定时任务调度平台有以下这些：

  • https://github.com/xuxueli/xxl-job

  • https://github.com/PowerJob/PowerJob

  • https://github.com/apache/shardingsphere-elasticjob

这种方案的优点在于简单易实现，但是，该方案也存在一些问题：

  1. 延迟时间不精确：使用定时任务执行订单关闭逻辑，无法保证订单在十分钟后准确地关闭。如果任务执行器在关闭订单的具体时间点出现问题，可能导致订单关闭的时间延后。

  2. 不适合高并发场景：定时任务执行的频率通常是固定的，无法根据实际订单的情况来灵活调整。在高并发场景下，可能导致大量的定时任务同时执行，造成系统负载过大。

  3. 分库分表问题：拿 12306 来说，订单表按照用户标识和订单号进行了分库分表，那这样的话，和上面说的根据订单创建时间去扫描一批订单进行关闭，自然就行不通。因为根据创建时间查询没有携带分片键，存在读扩散问题。

通常最不推荐的方式是使用定时任务来实现订单关闭。

1.1.2 RabbitMQ

RabbitMQ 是一个功能强大的消息中间件，通过使用 RabbitMQ 的延时消息特性，我们可以轻松实现订单十分钟延时关闭功能。首先，我们需要在 RabbitMQ 服务器上启用延时特性，通常通过安装 rabbitmq_delayed_message_exchange 插件来支持延时消息功能。

接下来，我们创建两个队列：订单队列和死信队列。订单队列用于存储需要延时关闭的订单消息，而死信队列则用于存储延时时间到达后的订单消息。在创建订单队列时，我们要为队列配置延时特性，指定订单消息的延时时间，比如十分钟。这样，当有新的订单需要延时关闭时，我们只需要将订单消息发送到订单队列，并设置消息的延时时间。

在订单队列中设置死信交换机和死信队列，当订单消息的延时时间到达后，消息会自动转发到死信队列，从而触发关闭订单的操作。在死信队列中，我们可以监听消息，并执行关闭订单的逻辑。为了确保消息的可靠性，可以在关闭订单操作前添加适当的幂等性措施，这样即使消息重复处理，也不会对系统产生影响。

通过以上步骤，我们就成功实现了订单的十分钟延时关闭功能。当有新的订单需要延时关闭时，将订单消息发送到订单队列，并设置延时时间。在延时时间到达后，订单消息会自动进入死信队列，从而触发关闭订单的操作。这种方式既简单又可靠，保证了系统的稳定性和可用性。

从整体来说 RabbitMQ 实现延时关闭订单功能是比较合适的，但也存在几个问题：

  1. 延时精度：RabbitMQ 的延时消息特性是基于消息的 TTL（Time-To-Live）来实现的，因此消息的延时时间并不是完全准确的，可能会有一定的误差。在处理订单十分钟延时关闭时，可能会有一些订单的关闭时间略晚于预期时间。

  2. 高并发问题：如果系统中有大量的订单需要延时关闭，而订单关闭操作非常复杂耗时，可能会导致消息队列中的消息堆积。这样就可能导致延时关闭操作无法及时处理，影响订单的实际关闭时间。

  3. 重复消息问题：由于网络原因或其他不可预知的因素，可能会导致消息重复发送到订单队列。如果没有处理好消息的幂等性，可能会导致订单重复关闭的问题，从而造成数据不一致或其他异常情况。

  4. 可靠性问题：RabbitMQ 是一个消息中间件，它是一个独立的系统。如果 RabbitMQ 本身出现故障或宕机，可能会导致订单延时关闭功能失效。因此，在使用 RabbitMQ 实现延时关闭功能时，需要考虑如何保证 RabbitMQ 的高可用性和稳定性。

延时精度和高并发属于一类问题，取决于客户端的消费能力。重复消费问题是所有消息中间件都需要解决，需要通过消息表等幂等解决方案解决。比较难搞定的是可用性问题，RabbitMQ 在可用性方面较弱，部分场景下会存在单点故障问题。

1.1.3 Redis 过期监听

可以借助 Redis 的过期消息监听机制实现延时关闭功能。

首先，在订单创建时，将订单信息存储到 Redis，并设置过期时间为十分钟。同时，在 Redis 中存储一个过期消息监听的键值对，键为订单号，值为待处理订单的标识。

其次，编写一个消息监听器，持续监听 Redis 的过期事件。监听器使用 Redis 的 PSUBSCRIBE 命令订阅过期事件，并在监听到过期事件时触发相应的处理逻辑。

当订单过期时间到达时，Redis 会自动触发过期事件，消息监听器捕获到该事件，并获取到过期的订单号。接着，监听器执行订单关闭的逻辑，如更新订单状态为关闭状态，释放相关资源等，实现订单的十分钟延时关闭功能。

需要注意的是，消息监听器应该是一个长期运行的任务，确保持续监听 Redis 的过期事件。为了保证系统的稳定性和可靠性，可以在实现订单关闭逻辑时添加容错机制，以应对 Redis 可能发生故障或重启的情况。

Redis 过期消息也存在几个问题：

  1. 不够精确：Redis 的过期时间是通过定时器实现的，可能存在一定的误差，导致订单的关闭时间不是精确的十分钟。这对于某些对时间要求较高的场景可能不适用。

  2. Redis 宕机：如果 Redis 宕机或重启，那些已经设置了过期时间但还未过期的订单信息将会丢失，导致这部分订单无法正确关闭。需要考虑如何处理这种异常情况。

  3. 可靠性：依赖 Redis 的过期时间来实现订单关闭功能，需要确保 Redis 的高可用性和稳定性。如果 Redis 发生故障或网络问题，可能导致订单关闭功能失效。

  4. 版本问题：Redis 5.0 之前是不保证延迟消息持久化的，如果客户端消费过程中宕机或者重启，这个消息不会重复投递。5.0 之后推出了 Stream 功能，有了持久化等比较完善的延迟消息功能。

1.1.4 Redisson

通过 Redisson 的 RDelayedQueue 功能可以实现订单十分钟延时关闭的功能。

首先，我们需要创建一个 RDelayedQueue 对象，用于存放需要延时关闭的订单信息。当用户创建订单时，我们将订单信息添加到 RDelayedQueue 中，并设置订单的延时时间为十分钟。

Redisson 提供了监听功能，可以实现对 RDelayedQueue 中订单信息的监听。一旦订单到达设定的延时时间，Redisson 会触发监听事件。在监听到订单的延时事件后，我们可以编写相应的处理逻辑，即关闭对应的订单。

在处理订单关闭时，我们可以根据订单号或订单创建时间等信息，来找到对应的订单进行关闭操作。

不过这种方式也不推荐使用，基本上 Redis 过期监听消息存在的问题，RDelayedQueue 也都会有，因为 RDelayedQueue 本质上也是依赖 Redis 实现。

1.1.5 RocketMQ

在订单生成时，我们将订单关闭消息发送到 RocketMQ，并设置消息的延迟时间为十分钟。RocketMQ 支持设置消息的延迟时间，可以通过设置消息的 delayLevel 来指定延迟级别，每个级别对应一种延迟时间。这样，订单关闭消息将在十分钟后自动被消费者接收到。

需要注意，RocketMQ 5.0 之后已经支持了自定义时间的延迟，而不仅是延迟级别范围内的时间。

为了处理订单关闭消息，我们需要在消费者端创建一个消息监听器。当消息监听器接收到订单关闭消息时，触发订单关闭操作，将订单状态设置为关闭状态。

需要注意的是，RocketMQ 的消息传递机制保证了消息的可靠性传递，因此消息可能会进行多次重试。为了确保订单关闭操作的幂等性，即多次执行不会产生副作用，我们需要在订单关闭逻辑中进行幂等性的处理。

铁路 12306 系统中，使用 RocketMQ 作为延时关闭订单的技术实现，从整体考虑，处理能力以及稳定性相对来说较为合适。

1.2 RocketMQ订单延时关闭发送方实现

在12306中,当订单添加完成之后, 在OrderService方,会延迟10分钟,发送一个关闭订单的消息给到MQ, 而关闭订单的消费方订阅这个消息,进行未及时支付的订单进行取消操作.

1) 我们创建一个延迟关闭订单的事件实体类 DelayCloseOrderEvent

​
package com.fs.fs12306.biz.orderservice.mq.event;
​
import com.fs.fs12306.biz.orderservice.dto.req.TicketOrderItemCreateReqDTO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
​
import java.util.List;
​
/*** 延迟关闭订单事件*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DelayCloseOrderEvent {
​/*** 车次 ID*/private String trainId;
​/*** 出发站点*/private String departure;
​/*** 到达站点*/private String arrival;
​/*** 订单号*/private String orderSn;
​/*** 乘车人购票信息*/private List<TicketOrderItemCreateReqDTO> trainPurchaseTicketResults;
}
​

2) 消息发送事件基础扩充属性实体 BaseSendExtendDTO

​
package com.fs.fs12306.biz.orderservice.mq.produce;
​
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
​
/*** 消息发送事件基础扩充属性实体**/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public final class BaseSendExtendDTO {
​/*** 事件名称*/private String eventName;
​/*** 主题*/private String topic;
​/*** 标签*/private String tag;
​/*** 业务标识*/private String keys;
​/*** 发送消息超时时间*/private Long sentTimeout;
​/*** 延迟消息*/private Integer delayLevel;
}
​

3) 把发送消息封装成一个模版类AbstractCommonSendProduceTemplate,目的是为了提供一个抽象的公共类，方便在项目中发送RocketMQ消息。

​
package com.fs.fs12306.biz.orderservice.mq.produce;
​
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSON;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.messaging.Message;
​
import java.util.Optional;
​
/*** RocketMQ 抽象公共发送消息组件**/
@Slf4j
@RequiredArgsConstructor
public abstract class AbstractCommonSendProduceTemplate<T> {
​private final RocketMQTemplate rocketMQTemplate;
​/*** 构建消息发送事件基础扩充属性实体* @param messageSendEvent 消息发送事件* @return 扩充属性实体*/protected abstract BaseSendExtendDTO buildBaseSendExtendParam(T messageSendEvent);
​/*** 构建消息基本参数，请求头、Keys...** @param messageSendEvent 消息发送事件* @param requestParam     扩充属性实体* @return 消息基本参数*/protected abstract Message<?> buildMessage(T messageSendEvent, BaseSendExtendDTO requestParam);
​/*** 消息事件通用发送** @param messageSendEvent 消息发送事件* @return 消息发送返回结果*/public SendResult sendMessage(T messageSendEvent) {//构建基础扩充属性实体BaseSendExtendDTO baseSendExtendDTO = buildBaseSendExtendParam(messageSendEvent);SendResult sendResult;try {//构建消息的topic和tag,格式: topic:tagStringBuilder destinationBuilder = StrUtil.builder().append(baseSendExtendDTO.getTopic());if (StrUtil.isNotBlank(baseSendExtendDTO.getTag())) {destinationBuilder.append(":").append(baseSendExtendDTO.getTag());}//同步发送消息sendResult = rocketMQTemplate.syncSend(destinationBuilder.toString(),buildMessage(messageSendEvent, baseSendExtendDTO),baseSendExtendDTO.getSentTimeout(),Optional.ofNullable(baseSendExtendDTO.getDelayLevel()).orElse(0));log.info("[{}] 消息发送结果：{}，消息ID：{}，消息Keys：{}", baseSendExtendDTO.getEventName(), sendResult.getSendStatus(), sendResult.getMsgId(), baseSendExtendDTO.getKeys());} catch (Throwable ex) {log.error("[{}] 消息发送失败，消息体：{}", baseSendExtendDTO.getEventName(), JSON.toJSONString(messageSendEvent), ex);throw ex;}return sendResult;}
}
​

AbstractCommonSendProduceTemplate定义了一个抽象的RocketMQ消息发送模板，具体的实现需要子类根据具体需求进行。通过这种方式，可以在不同的场景下复用消息发送的逻辑，提高代码的可维护性和可扩展性。

4) 编写延迟关闭订单生产者 DelayCloseOrderSendProduce

让延迟关闭订单生产者继承AbstractCommonSendProduceTemplate类,复用消息发送的逻辑

package com.fs.fs12306.biz.orderservice.mq.produce;
​
import cn.hutool.core.util.StrUtil;
import com.fs.fs12306.biz.orderservice.common.constant.OrderRocketMQConstant;
import com.fs.fs12306.biz.orderservice.mq.domain.MessageWrapper;
import com.fs.fs12306.biz.orderservice.mq.event.DelayCloseOrderEvent;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.common.message.MessageConst;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;
​
import java.util.UUID;
​
/*** 延迟关闭订单生产者**/
@Slf4j
@Component
public class DelayCloseOrderSendProduce extends AbstractCommonSendProduceTemplate<DelayCloseOrderEvent> {
​private final ConfigurableEnvironment environment;
​public DelayCloseOrderSendProduce(@Autowired RocketMQTemplate rocketMQTemplate, @Autowired ConfigurableEnvironment environment) {super(rocketMQTemplate);this.environment = environment;}
​@Overrideprotected BaseSendExtendDTO buildBaseSendExtendParam(DelayCloseOrderEvent messageSendEvent) {return BaseSendExtendDTO.builder().eventName("延迟关闭订单").keys(messageSendEvent.getOrderSn()).topic(environment.resolvePlaceholders(OrderRocketMQConstant.ORDER_DELAY_CLOSE_TOPIC_KEY)).tag(environment.resolvePlaceholders(OrderRocketMQConstant.ORDER_DELAY_CLOSE_TAG_KEY)).sentTimeout(2000L)// RocketMQ 延迟消息级别 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h.delayLevel(14).build();}
​@Overrideprotected Message<?> buildMessage(DelayCloseOrderEvent messageSendEvent, BaseSendExtendDTO requestParam) {String keys = StrUtil.isEmpty(requestParam.getKeys()) ? UUID.randomUUID().toString() : requestParam.getKeys();return MessageBuilder.withPayload(new MessageWrapper(requestParam.getKeys(), messageSendEvent)).setHeader(MessageConst.PROPERTY_KEYS, keys).setHeader(MessageConst.PROPERTY_TAGS, requestParam.getTag()).build();}
}

对于消息的负载信息,我们进行再次封装: MessageWrapper

​
package com.fs.fs12306.biz.orderservice.mq.domain;
​
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
​
import java.io.Serializable;
import java.util.UUID;
​
/*** 消息体包装器**/
@Data
@Builder
@NoArgsConstructor(force = true)
@AllArgsConstructor
@RequiredArgsConstructor
public final class MessageWrapper<T> implements Serializable {
​private static final long serialVersionUID = 1L;
​/*** 消息发送 Keys*/@NonNullprivate String keys;
​/*** 消息体*/@NonNullprivate T message;
​/*** 唯一标识，用于客户端幂等验证*/private String uuid = UUID.randomUUID().toString();
​/*** 消息发送时间*/private Long timestamp = System.currentTimeMillis();
}
​

在往数据库插入订单相关的数据之后,我们就使用延时关闭订单的生产者延迟发送一个消息,从而实现延时关闭订单的功能

try {// 发送 RocketMQ 延时消息，指定时间后取消订单DelayCloseOrderEvent delayCloseOrderEvent = DelayCloseOrderEvent.builder().trainId(String.valueOf(requestParam.getTrainId())).departure(requestParam.getDeparture()).arrival(requestParam.getArrival()).orderSn(orderSn).trainPurchaseTicketResults(requestParam.getTicketOrderItems()).build();SendResult sendResult = delayCloseOrderSendProduce.sendMessage(delayCloseOrderEvent);if (!Objects.equals(sendResult.getSendStatus(), SendStatus.SEND_OK)) {throw new ServiceException("投递延迟关闭订单消息队列失败");}} catch (Throwable ex) {log.error("延迟关闭订单消息队列发送错误，请求参数：{}", JSON.toJSONString(requestParam), ex);throw ex;}

1.3 RocketMQ订单延时关闭的消费方实现

12306中的关闭订单的消费方是在TicketService实现的.可能会有一个疑问，为什么延迟关闭订单发送端在订单服务，消费延迟关闭订单消息却是在购票服务？

如果消息的消费在订单服务中进行，那么订单服务就需要调用购票服务来进行座位的释放或订单状态的更新。这样就形成了一个远程循环依赖：订单服务依赖于购票服务，同时购票服务又依赖于订单服务。这对于微服务涉及中是需要尽可能避免的。所以，最终将消费延迟关闭消息放在了购票服务。

在ticketService服务中,也定义一个延时关闭订单的事件实体类, 与发送方的延时关闭订单事件的实体类是一样,

​
package com.fs.fs12306.biz.ticketservice.mq.event;
​
import com.fs.fs12306.biz.ticketservice.service.handler.ticket.dto.TrainPurchaseTicketRespDTO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
​
import java.util.List;
​
/*** 延迟关闭订单事件**/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DelayCloseOrderEvent {
​/*** 车次 ID*/private String trainId;
​/*** 出发站点*/private String departure;
​/*** 到达站点*/private String arrival;
​/*** 订单号*/private String orderSn;
​/*** 乘车人购票信息*/private List<TrainPurchaseTicketRespDTO> trainPurchaseTicketResults;
}
​

封装消息体包装器MessageWrapper

​
package com.fs.fs12306.biz.ticketservice.mq.domain;
​
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
​
import java.io.Serializable;
import java.util.UUID;
​
/*** 消息体包装器**/
@Data
@Builder
@NoArgsConstructor(force = true)
@AllArgsConstructor
@RequiredArgsConstructor
public final class MessageWrapper<T> implements Serializable {
​private static final long serialVersionUID = 1L;
​/*** 消息发送 Keys*/@NonNullprivate String keys;
​/*** 消息体*/@NonNullprivate T message;
​/*** 唯一标识，用于客户端幂等验证*/private String uuid = UUID.randomUUID().toString();
​/*** 消息发送时间*/private Long timestamp = System.currentTimeMillis();
}
​

这里有一个可以优化的地方,我们发现DelayCloseOrderEvent,MessageWrapper在OrderService和ticketService重复编写了, 可以把DelayCloseOrderEvent类抽取出来,放到一个公共模块中.

编写延时关闭订单的消费者DelayCloseOrderConsumer

​
package com.fs.fs12306.biz.ticketservice.mq.consumer;
​
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.fs.fs12306.biz.ticketservice.common.constant.TicketRocketMQConstant;
import com.fs.fs12306.biz.ticketservice.dto.domain.RouteDTO;
import com.fs.fs12306.biz.ticketservice.dto.req.CancelTicketOrderReqDTO;
import com.fs.fs12306.biz.ticketservice.mq.domain.MessageWrapper;
import com.fs.fs12306.biz.ticketservice.mq.event.DelayCloseOrderEvent;
import com.fs.fs12306.biz.ticketservice.remote.TicketOrderRemoteService;
import com.fs.fs12306.biz.ticketservice.remote.dto.TicketOrderDetailRespDTO;
import com.fs.fs12306.biz.ticketservice.remote.dto.TicketOrderPassengerDetailRespDTO;
import com.fs.fs12306.biz.ticketservice.service.SeatService;
import com.fs.fs12306.biz.ticketservice.service.TrainStationService;
import com.fs.fs12306.biz.ticketservice.service.handler.ticket.dto.TrainPurchaseTicketRespDTO;
import com.fs.fs12306.biz.ticketservice.service.handler.ticket.tokenbucket.TicketAvailabilityTokenBucket;
import com.fs.fs12306.frameworks.starter.cache.DistributedCache;
import com.fs.fs12306.frameworks.starter.common.util.BeanUtil;
import com.fs.fs12306.frameworks.starter.convention.result.Result;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
​
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
​
import static com.fs.fs12306.biz.ticketservice.common.constant.RedisKeyConstant.TRAIN_STATION_REMAINING_TICKET;
​
/*** 延迟关闭订单消费者**/
@Slf4j
@Component
@RequiredArgsConstructor
@RocketMQMessageListener(topic = TicketRocketMQConstant.ORDER_DELAY_CLOSE_TOPIC_KEY,selectorExpression = TicketRocketMQConstant.ORDER_DELAY_CLOSE_TAG_KEY,consumerGroup = TicketRocketMQConstant.TICKET_DELAY_CLOSE_CG_KEY
)
public final class DelayCloseOrderConsumer implements RocketMQListener<MessageWrapper<DelayCloseOrderEvent>> {
​private final SeatService seatService;private final TicketOrderRemoteService ticketOrderRemoteService;private final TrainStationService trainStationService;private final DistributedCache distributedCache;private final TicketAvailabilityTokenBucket ticketAvailabilityTokenBucket;
​@Value("${ticket.availability.cache-update.type:}")private String ticketAvailabilityCacheUpdateType;
​@Overridepublic void onMessage(MessageWrapper<DelayCloseOrderEvent> delayCloseOrderEventMessageWrapper) {log.info("[延迟关闭订单] 开始消费：{}", JSON.toJSONString(delayCloseOrderEventMessageWrapper));DelayCloseOrderEvent delayCloseOrderEvent = delayCloseOrderEventMessageWrapper.getMessage();String orderSn = delayCloseOrderEvent.getOrderSn();Result<Boolean> closedTickOrder;try {//远程调用OrderService的关闭订单的接口closedTickOrder = ticketOrderRemoteService.closeTickOrder(new CancelTicketOrderReqDTO(orderSn));} catch (Throwable ex) {log.error("[延迟关闭订单] 订单号：{} 远程调用订单服务失败", orderSn, ex);throw ex;}if (closedTickOrder.isSuccess() && !StrUtil.equals(ticketAvailabilityCacheUpdateType, "binlog")) {if (!closedTickOrder.getData()) {log.info("[延迟关闭订单] 订单号：{} 用户已支付订单", orderSn);return;}String trainId = delayCloseOrderEvent.getTrainId();String departure = delayCloseOrderEvent.getDeparture();String arrival = delayCloseOrderEvent.getArrival();List<TrainPurchaseTicketRespDTO> trainPurchaseTicketResults = delayCloseOrderEvent.getTrainPurchaseTicketResults();try {//释放锁定的座位seatService.unlock(trainId, departure, arrival, trainPurchaseTicketResults);} catch (Throwable ex) {log.error("[延迟关闭订单] 订单号：{} 回滚列车DB座位状态失败", orderSn, ex);throw ex;}try {StringRedisTemplate stringRedisTemplate = (StringRedisTemplate) distributedCache.getInstance();Map<Integer, List<TrainPurchaseTicketRespDTO>> seatTypeMap = trainPurchaseTicketResults.stream().collect(Collectors.groupingBy(TrainPurchaseTicketRespDTO::getSeatType));List<RouteDTO> routeDTOList = trainStationService.listTakeoutTrainStationRoute(trainId, departure, arrival);//缓存中的余票加routeDTOList.forEach(each -> {String keySuffix = StrUtil.join("_", trainId, each.getStartStation(), each.getEndStation());seatTypeMap.forEach((seatType, trainPurchaseTicketRespDTOList) -> {stringRedisTemplate.opsForHash().increment(TRAIN_STATION_REMAINING_TICKET + keySuffix, String.valueOf(seatType), trainPurchaseTicketRespDTOList.size());});});TicketOrderDetailRespDTO ticketOrderDetail = BeanUtil.convert(delayCloseOrderEvent, TicketOrderDetailRespDTO.class);ticketOrderDetail.setPassengerDetails(BeanUtil.convert(delayCloseOrderEvent.getTrainPurchaseTicketResults(), TicketOrderPassengerDetailRespDTO.class));ticketAvailabilityTokenBucket.rollbackInBucket(ticketOrderDetail);} catch (Throwable ex) {log.error("[延迟关闭订单] 订单号：{} 回滚列车Cache余票失败", orderSn, ex);throw ex;}}}
}
​

OrderService的feign client接口

​
package com.fs.fs12306.biz.ticketservice.remote;
​
import com.fs.fs12306.biz.ticketservice.dto.req.CancelTicketOrderReqDTO;
import com.fs.fs12306.biz.ticketservice.dto.req.TicketOrderItemQueryReqDTO;
import com.fs.fs12306.biz.ticketservice.remote.dto.TicketOrderCreateRemoteReqDTO;
import com.fs.fs12306.biz.ticketservice.remote.dto.TicketOrderDetailRespDTO;
import com.fs.fs12306.biz.ticketservice.remote.dto.TicketOrderPassengerDetailRespDTO;
import com.fs.fs12306.frameworks.starter.convention.result.Result;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.cloud.openfeign.SpringQueryMap;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
​
/*** 车票订单远程服务调用**/
@FeignClient(value = "fs12306-order-service", url = "${aggregation.remote-url:}")
public interface TicketOrderRemoteService {/*** 创建车票订单** @param requestParam 创建车票订单请求参数* @return 订单号*/@PostMapping("/api/order-service/order/ticket/create")Result<String> createTicketOrder(@RequestBody TicketOrderCreateRemoteReqDTO requestParam);
​/*** 车票订单关闭** @param requestParam 车票订单关闭入参* @return 关闭订单返回结果*/@PostMapping("/api/order-service/order/ticket/close")Result<Boolean> closeTickOrder(@RequestBody CancelTicketOrderReqDTO requestParam);
​/*** 车票订单取消** @param requestParam 车票订单取消入参* @return 订单取消返回结果*/@PostMapping("/api/order-service/order/ticket/cancel")Result<Void> cancelTicketOrder(@RequestBody CancelTicketOrderReqDTO requestParam);
}
​

接下来需要在OrderService服务中,实现对订单关闭的业务实现

​
package com.fs.fs12306.biz.orderservice.controller;
​
import cn.crane4j.annotation.AutoOperate;
import com.fs.fs12306.biz.orderservice.dto.req.*;
import com.fs.fs12306.biz.orderservice.dto.resp.TicketOrderDetailRespDTO;
import com.fs.fs12306.biz.orderservice.dto.resp.TicketOrderDetailSelfRespDTO;
import com.fs.fs12306.biz.orderservice.dto.resp.TicketOrderPassengerDetailRespDTO;
import com.fs.fs12306.biz.orderservice.service.OrderItemService;
import com.fs.fs12306.biz.orderservice.service.OrderService;
import com.fs.fs12306.frameworks.starter.convention.page.PageResponse;
import com.fs.fs12306.frameworks.starter.convention.result.Result;
import com.fs.fs12306.frameworks.starter.web.Results;
import lombok.RequiredArgsConstructor;
​
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
​
import java.util.List;
​
/*** 车票订单接口控制层**/
@RestController
@RequiredArgsConstructor
public class TicketOrderController {
​private final OrderService orderService;private final OrderItemService orderItemService;
​/*** 根据订单号查询车票订单*/@GetMapping("/api/order-service/order/ticket/query")public Result<TicketOrderDetailRespDTO> queryTicketOrderByOrderSn(@RequestParam(value = "orderSn") String orderSn) {return Results.success(orderService.queryTicketOrderByOrderSn(orderSn));}
​/*** 根据子订单记录id查询车票子订单详情*/@GetMapping("/api/order-service/order/item/ticket/query")public Result<List<TicketOrderPassengerDetailRespDTO>> queryTicketItemOrderById(TicketOrderItemQueryReqDTO requestParam) {return Results.success(orderItemService.queryTicketItemOrderById(requestParam));}
​/*** 分页查询车票订单*/@AutoOperate(type = TicketOrderDetailRespDTO.class, on = "data.records")@GetMapping("/api/order-service/order/ticket/page")public Result<PageResponse<TicketOrderDetailRespDTO>> pageTicketOrder(TicketOrderPageQueryReqDTO requestParam) {return Results.success(orderService.pageTicketOrder(requestParam));}
​/*** 分页查询本人车票订单*/@GetMapping("/api/order-service/order/ticket/self/page")public Result<PageResponse<TicketOrderDetailSelfRespDTO>> pageSelfTicketOrder(TicketOrderSelfPageQueryReqDTO requestParam) {return Results.success(orderService.pageSelfTicketOrder(requestParam));}
​/*** 车票订单创建*/@PostMapping("/api/order-service/order/ticket/create")public Result<String> createTicketOrder(@RequestBody TicketOrderCreateReqDTO requestParam) {return Results.success(orderService.createTicketOrder(requestParam));}
​/*** 车票订单关闭*/@PostMapping("/api/order-service/order/ticket/close")public Result<Boolean> closeTickOrder(@RequestBody CancelTicketOrderReqDTO requestParam) {return Results.success(orderService.closeTickOrder(requestParam));}
​/*** 车票订单取消*/@PostMapping("/api/order-service/order/ticket/cancel")public Result<Boolean> cancelTickOrder(@RequestBody CancelTicketOrderReqDTO requestParam) {return Results.success(orderService.cancelTickOrder(requestParam));}
}
​

关闭订单的业务实现:

OrderService接口定义关闭订单的方法:closeTickOrder

/*** 关闭火车票订单** @param requestParam 关闭火车票订单入参*/
boolean closeTickOrder(CancelTicketOrderReqDTO requestParam);
OrderServiceImpl类的具体closeTickOrder方法的实现如下:@Overridepublic boolean closeTickOrder(CancelTicketOrderReqDTO requestParam) {String orderSn = requestParam.getOrderSn();LambdaQueryWrapper<OrderDO> queryWrapper = Wrappers.lambdaQuery(OrderDO.class).eq(OrderDO::getOrderSn, orderSn).select(OrderDO::getStatus);OrderDO orderDO = orderMapper.selectOne(queryWrapper);if (Objects.isNull(orderDO) || orderDO.getStatus() != OrderStatusEnum.PENDING_PAYMENT.getStatus()) {return false;}// 原则上订单关闭和订单取消这两个方法可以复用，为了区分未来考虑到的场景，这里对方法进行拆分但复用逻辑return cancelTickOrder(requestParam);}
​
@Overridepublic boolean cancelTickOrder(CancelTicketOrderReqDTO requestParam) {String orderSn = requestParam.getOrderSn();LambdaQueryWrapper<OrderDO> queryWrapper = Wrappers.lambdaQuery(OrderDO.class).eq(OrderDO::getOrderSn, orderSn);OrderDO orderDO = orderMapper.selectOne(queryWrapper);if (orderDO == null) {throw new ServiceException(OrderCanalErrorCodeEnum.ORDER_CANAL_UNKNOWN_ERROR);} else if (orderDO.getStatus() != OrderStatusEnum.PENDING_PAYMENT.getStatus()) {throw new ServiceException(OrderCanalErrorCodeEnum.ORDER_CANAL_STATUS_ERROR);}RLock lock = redissonClient.getLock(StrBuilder.create("order:canal:order_sn_").append(orderSn).toString());if (!lock.tryLock()) {throw new ClientException(OrderCanalErrorCodeEnum.ORDER_CANAL_REPETITION_ERROR);}try {OrderDO updateOrderDO = new OrderDO();updateOrderDO.setStatus(OrderStatusEnum.CLOSED.getStatus());updateOrderDO.setOrderSn(orderSn);LambdaUpdateWrapper<OrderDO> updateWrapper = Wrappers.lambdaUpdate(OrderDO.class).eq(OrderDO::getOrderSn, orderSn);int updateResult = orderMapper.update(updateOrderDO, updateWrapper);if (updateResult <= 0) {throw new ServiceException(OrderCanalErrorCodeEnum.ORDER_CANAL_ERROR);}OrderItemDO updateOrderItemDO = new OrderItemDO();updateOrderItemDO.setStatus(OrderItemStatusEnum.CLOSED.getStatus());updateOrderItemDO.setOrderSn(orderSn);LambdaUpdateWrapper<OrderItemDO> updateItemWrapper = Wrappers.lambdaUpdate(OrderItemDO.class).eq(OrderItemDO::getOrderSn, orderSn);int updateItemResult = orderItemMapper.update(updateOrderItemDO, updateItemWrapper);if (updateItemResult <= 0) {throw new ServiceException(OrderCanalErrorCodeEnum.ORDER_CANAL_ERROR);}} finally {lock.unlock();}return true;}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/456030.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

2023 ICPC 亚洲澳门赛区赛 D. Graph of Maximum Degree 3

2023 ICPC 亚洲澳门赛区赛 D. Graph of Maximum Degree 3

题目 题解 #include <bits/stdc.h> using namespace std; // #define int long long #define pb push_back #define fi first #define se second #define lson p << 1 #define rson p << 1 | 1 #define ll long long #define pii pair<int, int> #defi…
阅读更多...
Spring--4

Spring--4

SpringWeb 概念 是Spring框架的一个模块&#xff0c;基于Servlet的一个原始Web框架。 SpringWEB 运行流程 描述&#xff1a;前端用户请求发送的后端以后&#xff0c;先经过前端控制器DispatcherServlet(再次之前也可能有过滤器的存在)&#xff0c;经过前端控制器解析后&…
阅读更多...
ASP.NET Core 路由规则 MapControllerRoute、MapDefaultControllerRoute、MapController

ASP.NET Core 路由规则 MapControllerRoute、MapDefaultControllerRoute、MapController

MapControllers 来映射属性路由控制器。 资料
阅读更多...
一起搭WPF架构之LiveCharts.Wpf的简单了解与安装

一起搭WPF架构之LiveCharts.Wpf的简单了解与安装

一起搭WPF架构之LiveCharts.Wpf的简单了解与安装 前言LiveCharts.Wpf介绍LiveCharts.Wpf的安装总结 前言 根据项目需求&#xff0c;我单独留了一个界面用于进行数据分析。数据分析的内容考虑是采用图表的形式将SQLite数据库中存储的数据进行绘制成图&#xff0c;以便数据分析。…
阅读更多...
第三十一篇：TCP协议如何解决丢包的问题，TCP系列六

第三十一篇：TCP协议如何解决丢包的问题，TCP系列六

前面我们说TCP协议是可靠的、基于字节流、面向连接的传输层通信协议&#xff1b; 这里我想换种说法&#xff1a;与其说是TCP协议是可靠的&#xff0c;不如说传输层程序软件实现了TCP协议的规范&#xff08;网络层次模型&#xff0c;每一层都有对应的程序软件&#xff09;&…
阅读更多...
33 类与对象 · 下

33 类与对象 · 下

目录 一、构造函数的深入 &#xff08;一&#xff09;构造函数的其他特点 &#xff08;二&#xff09;使用例 1、Date类与Time类显示写 2、Date类与Time类写一部分 &#xff08;三&#xff09;总结 &#xff08;四&#xff09;初始化顺序小题目 二、类型转化 &#xff…
阅读更多...
【芯片设计】DC综合retiming策略的学习与实践

【芯片设计】DC综合retiming策略的学习与实践

对于DC综合中的retiming策略早有耳闻&#xff0c;但是一直没有比较系统的学习和实验过&#xff0c;正好借着这次交付过程的归纳总结机会&#xff0c;把一些零零散散的收获学习记录下。 记得刚出新手村时和某位大佬聊到过&#xff0c;他说你逻辑里写了在某级计算一个结果&#…
阅读更多...
UE5之5.4 第一人称示例代码阅读2 子弹发射逻辑

UE5之5.4 第一人称示例代码阅读2 子弹发射逻辑

TP_WeaponComponent.h 看看头文件 暴露了attach weapon和fire给蓝图 这两个函数意义一看名字吧&#xff0c;就是捡起来枪的时候执行&#xff0c;一个就是发射子弹的时候执行 #pragma once#include "CoreMinimal.h" #include "Components/SkeletalMeshComponen…
阅读更多...
Appium中的api(二)

Appium中的api(二)

目录 元素定位操作api 1--通过id定位api 2--通过class获取定位元素 3--通过xpath表达式定位元素 4.完整代码 解释 效果 元素定位操作api 1--通过id定位api 注:driver.find_element是获取单个元素 # 通过id获取 mySearchId "com.android.settings:id/search_acti…
阅读更多...
如何对pdf文件进行加密？pdf文件加密全攻略与深度解析（5个方法）

如何对pdf文件进行加密？pdf文件加密全攻略与深度解析（5个方法）

如何对pdf文件进行加密&#xff1f; 只见&#xff0c;在深夜的情报局里&#xff0c;特工小李将一份绝密PDF文件放在保险箱内&#xff0c;以为这样就天衣无缝了。 细细推敲&#xff0c;漏洞百出&#xff1a; 如果钥匙被盗呢&#xff1f;如果被神匠破解出密码呢&#xff1f;如果…
阅读更多...
Halcon基础-瓶盖带角度的OCR批量识别

Halcon基础-瓶盖带角度的OCR批量识别

Halcon基础-OCR识别 1、OCR识别素材2、创建路径文件3、Halcon代码实现4、运行效果5、资源获取 1、OCR识别素材 这里我准备了7张不同角度的OCR图片&#xff0c;如下所示&#xff1a; 2、创建路径文件 按照下图所示创建全部文件夹和文件&#xff1a; 01用来存放OCR识别原图 c…
阅读更多...
Vue中使用el-upload实现文件上传时控制提交按钮状态的最佳实践

Vue中使用el-upload实现文件上传时控制提交按钮状态的最佳实践

在Web应用开发中&#xff0c;文件上传是一个常见的需求。在使用Vue框架和Element UI库时&#xff0c;我们经常使用el-upload组件来处理文件上传。但是&#xff0c;如何在上传过程中控制提交按钮的可用状态&#xff0c;以避免在上传未完成时误触提交操作&#xff0c;是一个值得探…
阅读更多...
解决：如何在opencv中得到与matlab立体标定一样的矫正图？（python版opencv）

解决：如何在opencv中得到与matlab立体标定一样的矫正图？（python版opencv）

目的&#xff1a;采用一样的标定参数&#xff0c;matlab中和opencv中的立体矫正图像是一样的吗&#xff1f;不一样的话怎么让它们一样&#xff1f; 结论&#xff1a;不一样。后文为解决方案。 原因&#xff1a;注意matlab的标定结果在matlab中的用法和在opencv中的用法不一样&a…
阅读更多...
光伏电站折旧率的计算

光伏电站折旧率的计算

折旧率的计算方法 直线法&#xff1a;直线法是最常用的折旧计算方法。它假设光伏设备在使用寿命内每年的折旧额保持不变。计算公式为&#xff1a; 折旧率(资产原值-净残值)预计使用寿命。 其中&#xff0c;资产原值是指光伏设备购置价值或建成投产时的价值&#xff1b;净残值…
阅读更多...
chrome清除https状态

chrome清除https状态

莫名其妙的http跳转到https的url了。 解决办法 浏览器地址栏输入&#xff1a;chrome://net-internals/#hsts 输入你需要删除的域名即可&#xff01;&#xff01;&#xff01;
阅读更多...
AMD平台，5600X+6650XT，虚拟机安装macOS 15 Sequoia 15.0.1 (2024.10)

AMD平台，5600X+6650XT，虚拟机安装macOS 15 Sequoia 15.0.1 (2024.10)

macOS 15 Sequoia终于出正式版了&#xff0c;没有Mac&#xff0c;所以还是虚拟机玩玩&#xff0c;还是属于折腾&#xff0c;安装过程和之前差不多&#xff0c;这次我从外网获得了8核和16核openCore&#xff0c;分享一下。 提前发一下ISO镜像地址和openCore引导磁盘地址 ISO镜…
阅读更多...
《人工智能往事》—— 简而言之，AI 已经包围了我们。AI 就是我们。

《人工智能往事》—— 简而言之，AI 已经包围了我们。AI 就是我们。

《人工智能往事》这本书我挺喜欢的&#xff08;推荐给对计算机和AI史有考古兴趣的同学们&#xff09;。我是几年前读的英文版《This Could Be Important: My Life and Times with the Artificial Intelligentsia Pamela McCorduck》很高兴发现国内推出了译本。 作者帕梅拉麦考…
阅读更多...
一座数智工厂，看见汽车制造的诗与远方

一座数智工厂，看见汽车制造的诗与远方

今天的中国&#xff0c;已经是名副其实的汽车制造与出口大国。 根据国家统计局10月18日发布的数据&#xff0c;今年9月中国新能源汽车产量同比增长48.5%&#xff0c;增速为2023年5月以来新高。1月至9月汽车行业出口交货值同比增长17.1%。中国汽车产业的高速发展&#xff0c;离不…
阅读更多...
学习docker第三弹------Docker镜像以及推送拉取镜像到阿里云公有仓库和私有仓库

学习docker第三弹------Docker镜像以及推送拉取镜像到阿里云公有仓库和私有仓库

docker目录 1 Docker镜像dockers镜像的进一步理解 2 Docker镜像commit操作实例案例内容是ubuntu安装vim 3 将本地镜像推送至阿里云4 将阿里云镜像下载到本地仓库5 后记 1 Docker镜像 镜像&#xff0c;是docker的三件套之一&#xff08;镜像、容器、仓库&#xff09;&#xff0…
阅读更多...
uniapp微信小程序使用vant组件库

uniapp微信小程序使用vant组件库

1. vant组件库(微信小程序版本)官网地址 地址: vant组件库(微信小程序版本) 2. uniapp微信小程序引入 <1>. 去到GitHub中将资源克隆到本地,地址: vant-weapp <2>. 到本地把文件拷贝到我们的uniapp微信小程序项目中 在项目的目录下新建一个文件wxcomponents&#…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023