请演示springbooot+mybatis+mysql+Redis实现订单在指定时间内没有完成支付自动取消订单的功能

好的，我可以为您演示如何使用Spring Boot、MyBatis、MySQL和Redis实现订单在指定时间内没有完成支付自动取消订单的功能。

首先，我们需要定义订单实体类，包含订单号、订单状态、创建时间、过期时间等属性。

public class Order {
    private Long id;
    private String orderNo;
    private Integer status;
    private Date createTime;
    private Date expireTime;
    // 省略getter和setter方法
}

然后我们需要在MySQL数据库中创建订单表，用于存储订单信息。

CREATE TABLE `order` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `order_no` varchar(32) NOT NULL,
  `status` int(11) NOT NULL,
  `create_time` datetime NOT NULL,
  `expire_time` datetime NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

接着，我们需要使用MyBatis来实现订单表的增删改查操作，以及定时任务更新订单状态的操作。这些操作可以通过Mapper接口和Mapper.xml文件来实现。在Mapper.xml文件中，我们可以使用MySQL的定时任务机制，定期执行更新操作，将过期的订单状态改为已取消。

<!-- OrderMapper.xml -->
<mapper namespace="com.example.demo.mapper.OrderMapper">
    <insert id="insertOrder" parameterType="Order">
        insert into `order` (order_no, status, create_time, expire_time)
        values (#{orderNo}, #{status}, #{createTime}, #{expireTime})
    </insert>

    <update id="cancelOrder" parameterType="Order">
        update `order` set status = #{status} where id = #{id}
    </update>

    <select id="getOrderById" parameterType="Long" resultType="Order">
        select * from `order` where id = #{id}
    </select>

    <update id="updateExpiredOrderStatus">
        update `order` set status = #{status} where status = #{oldStatus} and expire_time <= #{now}
    </update>
</mapper>

在定时任务中，我们需要使用MyBatis的update方法来更新过期的订单状态。

@Service
public class OrderService {
    private final OrderMapper orderMapper;

    public OrderService(OrderMapper orderMapper) {
        this.orderMapper = orderMapper;
    }

    @Scheduled(cron = "0 */1 * * * ?") // 每分钟执行一次
    public void updateExpiredOrderStatus() {
        Order order = new Order();
        order.setStatus(OrderStatusEnum.CANCELED.getValue());
        order.setOldStatus(OrderStatusEnum.UNPAID.getValue());
        order.setNow(new Date());
        orderMapper.updateExpiredOrderStatus(order);
    }
}

然后，我们需要使用Redis来实现订单状态的缓存。在订单创建时，将订单信息存储到Redis中，并设置过期时间为订单的过期时间。当用户支付成功后，将Redis中的订单状态改为已支付。如果订单未支付并且过期时间已到，则将Redis中的订单状态改为已取消，并通过MyBatis更新订单状态。

@Configuration
public class RedisConfig {
    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.database}")
    private int database;

    @Bean
    public JedisPool jedisPool() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(100);
        jedisPoolConfig.setMaxIdle(20);
        jedisPoolConfig.setMinIdle(10);
        jedisPoolConfig.setMaxWaitMillis(10000);
        return new JedisPool(jedisPoolConfig, host, port, timeout, password, database);
    }
}

@Service
public class OrderService {
    private final OrderMapper orderMapper;
    private final JedisPool jedisPool;

    public OrderService(OrderMapper orderMapper, JedisPool jedisPool) {
        this.orderMapper = orderMapper;
        this.jedisPool = jedisPool;
    }

    public Order createOrder(Order order) {
        orderMapper.insertOrder(order);
        String key = "order:" + order.getId();
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.set(key, String.valueOf(OrderStatusEnum.UNPAID.getValue()), "NX", "EX", order.getExpireTime().getTime() / 1000);
        }
        return order;
    }

    public void payOrder(Long orderId) {
        String key = "order:" + orderId;
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.set(key, String.valueOf(OrderStatusEnum.PAID.getValue()));
        }
    }
}

最后，我们需要使用Spring的定时任务来定期检查Redis中的订单状态，并对过期的订单进行处理。具体实现可以通过在Spring Boot应用程序中添加一个Scheduled注解方法来实现。

@Service
public class OrderService {
    private final OrderMapper orderMapper;
    private final JedisPool jedisPool;

    public OrderService(OrderMapper orderMapper, JedisPool jedisPool) {
        this.orderMapper = orderMapper;
        this.jedisPool = jedisPool;
    }

    @Scheduled(cron = "0 */1 * * * ?") // 每分钟执行一次
    public void checkExpiredOrder() {
        try (Jedis jedis = jedisPool.getResource()) {
            Set<String> keys = jedis.keys("order:*");
            if (keys != null && !keys.isEmpty()) {
                for (String key : keys) {
                    String value = jedis.get(key);
                    if (value != null) {
                        Long orderId = Long.parseLong(key.split(":")[1]);
                        Order order = orderMapper.getOrderById(orderId);
                        if (order != null && order.getStatus() == OrderStatusEnum.UNPAID.getValue()) {
                            if (new Date().after(order.getExpireTime())) {
                                order.setStatus(OrderStatusEnum.CANCELED.getValue());
                                orderMapper.cancelOrder(order);
                                jedis.del(key);
                            }
                        } else {
                            jedis.del(key);
                        }
                    }
                }
            }
        }
    }
}

以上就是使用Spring Boot、MyBatis、MySQL和Redis实现订单在指定时间内没有完成支付自动取消订单的详细演示。