/**1、验证令牌是否合法【令牌的对比和删除必须保证原子性】**/
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
String orderToken = vo.getOrderToken();
//通过lure脚本原子验证令牌和删除令牌（执行脚本后返回long类型的0或1，0表示令牌验证失败，1表示成功）
//Arrays.asList(USER_ORDER_TOKEN_PREFIX + memberResponseVo.getId())表示存到redis里的值
//   orderToken是页面传过来的令牌（表示当前需要验证的值）
Long result = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class),
        Arrays.asList(USER_ORDER_TOKEN_PREFIX + memberResponseVo.getId()),
        orderToken);
if (result == 0L) {
    //令牌验证失败
} else {
    //令牌验证成功

package com.saodai.saodaimall.order.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
/**
 * RabbitMQ配置类
 * 整体思路
 * 首先生产者发送一个消息给topic交换机order-event-exchange，交换机根据路由键order.create.order路由到延时队列order.delay.queue
 * 然后消息在延时队列里等待指定的时间，当时间过期后还没有被消费就会被当成死信，然后把这个消息通过交换机order-event-exchange识别他的新的
 * 路由键order.release.order路由到新的队列order.release.order.queue
 *
 * 这里只有一个交换机，两个队列，一个队列是用来存放消息的，另外一个队列是用来存放死信的（也就是死了的消息，这里并没有直接处理掉，而是放到这个队列里）
 **/
@Configuration
public class MyRabbitMQConfig {
    /**
     *
     *创建延时队列
     *延时队列是通过参数来设置的
     * arguments.put("x-dead-letter-exchange", "order-event-exchange");前面的固定的前缀，表示这个队列延时后的消息
     * @return
     */ 
    @Bean
    public Queue orderDelayQueue() {
        //用map构造参数
        HashMap<String, Object> arguments = new HashMap<>();
        //指定延时后的消息的交换机（x-dead-letter-exchange是固定的前缀，order-event-exchange是自定义的交换机）
        arguments.put("x-dead-letter-exchange", "order-event-exchange");
        //死信路由（也就是消息如果超时了就会被当作死信，然后通过路由键order.release.order路由到指定的消息队列）
        arguments.put("x-dead-letter-routing-key", "order.release.order");
        //设置消息过期时间
        arguments.put("x-message-ttl", 60000); // 消息过期时间 1分钟
        /*
            Queue(String name,  队列名字
            boolean durable,  是否持久化
            boolean exclusive,  是否排他
            boolean autoDelete, 是否自动删除
            Map<String, Object> arguments) 参数
         */
        Queue queue = new Queue("order.delay.queue", true, false, false, arguments);
        return queue;
    }
    /**
     * 死信队列（也就是到了这个队列的都是要死的消息）
     *
     * @return
     */
    @Bean
    public Queue orderReleaseQueue() {
        Queue queue = new Queue("order.release.order.queue", true, false, false);
        return queue;
    }
    /**
     * TopicExchange
     *创建主题类型的交换机
     * @return
     */
    @Bean
    public Exchange orderEventExchange() {
        /*
         *   String name,
         *   boolean durable,
         *   boolean autoDelete,
         *   Map<String, Object> arguments
         * */
        return new TopicExchange("order-event-exchange", true, false);
    }
    /**
     * 创建交换机和队列的捆绑关系（延时队列捆绑）
     * @return
     */
    @Bean
    public Binding orderCreateBinding() {
        /*
         * String destination, 目的地（队列名或者交换机名字）
         * DestinationType destinationType, 目的地类型（Queue、Exhcange）
         * String exchange,
         * String routingKey,
         * Map<String, Object> arguments
         * */
        return new Binding("order.delay.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.create.order",
                null);
    }
    /**
     * 创建交换机和队列的捆绑关系（死信队列捆绑）
     * @return
     */
    @Bean
    public Binding orderReleaseBinding() {
        return new Binding("order.release.order.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.release.order",
                null);
    }
    /**
     * 订单释放直接和库存释放进行绑定
     * @return
     */
    @Bean
    public Binding orderReleaseOtherBinding() {
        return new Binding("stock.release.stock.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.release.other.#",
                null);
    }
    /**
     * 商品秒杀队列
     * @return
     */
    @Bean
    public Queue orderSecKillOrrderQueue() {
        Queue queue = new Queue("order.seckill.order.queue", true, false, false);
        return queue;
    }
    @Bean
    public Binding orderSecKillOrrderQueueBinding() {
        //String destination, DestinationType destinationType, String exchange, String routingKey,
        //      Map<String, Object> arguments
        Binding binding = new Binding(
                "order.seckill.order.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.seckill.order",
                null);
        return binding;
    }
}
  /**
     *
     *创建延时队列
     * @return
     */ 
    @Bean
    public Queue orderDelayQueue() {
        //用map构造参数
        HashMap<String, Object> arguments = new HashMap<>();
        //指定延时后的消息的交换机（x-dead-letter-exchange是固定的前缀，order-event-exchange是自定义的交换机）
        arguments.put("x-dead-letter-exchange", "order-event-exchange");
        //死信路由（也就是消息如果超时了就会被当作死信，然后通过路由键order.release.order路由到指定的消息队列）
        arguments.put("x-dead-letter-routing-key", "order.release.order");
        //设置消息过期时间
        arguments.put("x-message-ttl", 60000); // 消息过期时间 1分钟
        /*
            Queue(String name,  队列名字
            boolean durable,  是否持久化
            boolean exclusive,  是否排他
            boolean autoDelete, 是否自动删除
            Map<String, Object> arguments) 参数
         */
        Queue queue = new Queue("order.delay.queue", true, false, false, arguments);
        return queue;
    }

package com.saodai.saodaimall.ware.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
/**
 * RabbitMQ配置类（一个交换机，两个队列，两个绑定，跟订单服务的基本一样，详细介绍看订单服务的队列）
 *
 */
@Configuration
public class MyRabbitMQConfig {
    /**
     * 使用JSON序列化机制，进行消息转换
     * @return
     */
    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }
    /**
     * RabbitMQ要第一次连接上发现没有队列或者交换机才会创建，所以如果没有下面的代码运行会发现官网中并没有创建交换机和队列
     * 下面代码就是模拟监听，这样就可以连接上RabbitMQ，然后可以创建交换机和队列
     * 但是后面要注释掉（自动解锁库存时这里也会监听队列导致多一个消费者，所以要注释掉）
     */
//     @RabbitListener(queues = "stock.release.stock.queue")
//     public void handle(Message message) {
//
//     }
    /**
     * 库存服务默认的交换机
     * @return
     */
    @Bean
    public Exchange stockEventExchange() {
        //String name, boolean durable, boolean autoDelete, Map<String, Object> arguments
        TopicExchange topicExchange = new TopicExchange("stock-event-exchange", true, false);
        return topicExchange;
    }
    /**
     * 普通队列
     * @return
     */
    @Bean
    public Queue stockReleaseStockQueue() {
        //String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
        Queue queue = new Queue("stock.release.stock.queue", true, false, false);
        return queue;
    }
    /**
     *  延迟队列
     * @return
     */
    @Bean
    public Queue stockDelay() {
        HashMap<String, Object> arguments = new HashMap<>();
        arguments.put("x-dead-letter-exchange", "stock-event-exchange");
        arguments.put("x-dead-letter-routing-key", "stock.release");
        // 消息过期时间 2分钟
        arguments.put("x-message-ttl", 120000);
        Queue queue = new Queue("stock.delay.queue", true, false, false,arguments);
        return queue;
    }
    /**
     * 交换机与普通队列绑定
     * @return
     */
    @Bean
    public Binding stockLocked() {
        //String destination, DestinationType destinationType, String exchange, String routingKey,
        //      Map<String, Object> arguments
        Binding binding = new Binding("stock.release.stock.queue",
                Binding.DestinationType.QUEUE,
                "stock-event-exchange",
                "stock.release.#",
                null);
        return binding;
    }
    /**
     * 交换机与延迟队列绑定
     * @return
     */
    @Bean
    public Binding stockLockedBinding() {
        return new Binding("stock.delay.queue",
                Binding.DestinationType.QUEUE,
                "stock-event-exchange",
                "stock.locked",
                null);
    }
}

 //交换机（x-dead-letter-exchange是固定的，order-event-exchange是自定义的交换机）
arguments.put("x-dead-letter-exchange", "order-event-exchange");
//死信路由（也就是消息如果超时了就会被当作死信，然后通过路由键order.release.order路由到指定的消息队列）
arguments.put("x-dead-letter-routing-key", "order.release.order");
//设置消息过期时间
arguments.put("x-message-ttl", 60000); // 消息过期时间 1分钟

package com.saodai.common.to;
import lombok.Data;
import java.math.BigDecimal;
import java.util.Date;
/**
*订单类
*/
@Data
public class OrderTo {
    private Long id;
    /**
     * member_id
     */
    private Long memberId;
    /**
     * 订单号
     */
    private String orderSn;
    /**
     * 使用的优惠券
     */
    private Long couponId;
    /**
     * create_time
     */
    private Date createTime;
    /**
     * 用户名
     */
    private String memberUsername;
    /**
     * 订单总额
     */
    private BigDecimal totalAmount;
    /**
     * 应付总额
     */
    private BigDecimal payAmount;
    /**
     * 运费金额
     */
    private BigDecimal freightAmount;
    /**
     * 促销优化金额（促销价、满减、阶梯价）
     */
    private BigDecimal promotionAmount;
    /**
     * 积分抵扣金额
     */
    private BigDecimal integrationAmount;
    /**
     * 优惠券抵扣金额
     */
    private BigDecimal couponAmount;
    /**
     * 后台调整订单使用的折扣金额
     */
    private BigDecimal discountAmount;
    /**
     * 支付方式【1->支付宝；2->微信；3->银联； 4->货到付款；】
     */
    private Integer payType;
    /**
     * 订单来源[0->PC订单；1->app订单]
     */
    private Integer sourceType;
    /**
     * 订单状态【0->待付款；1->待发货；2->已发货；3->已完成；4->已关闭；5->无效订单】
     */
    private Integer status;
    /**
     * 物流公司(配送方式)
     */
    private String deliveryCompany;
    /**
     * 物流单号
     */
    private String deliverySn;
    /**
     * 自动确认时间（天）
     */
    private Integer autoConfirmDay;
    /**
     * 可以获得的积分
     */
    private Integer integration;
    /**
     * 可以获得的成长值
     */
    private Integer growth;
    /**
     * 发票类型[0->不开发票；1->电子发票；2->纸质发票]
     */
    private Integer billType;
    /**
     * 发票抬头
     */
    private String billHeader;
    /**
     * 发票内容
     */
    private String billContent;
    /**
     * 收票人电话
     */
    private String billReceiverPhone;
    /**
     * 收票人邮箱
     */
    private String billReceiverEmail;
    /**
     * 收货人姓名
     */
    private String receiverName;
    /**
     * 收货人电话
     */
    private String receiverPhone;
    /**
     * 收货人邮编
     */
    private String receiverPostCode;
    /**
     * 省份/直辖市
     */
    private String receiverProvince;
    /**
     * 城市
     */
    private String receiverCity;
    /**
     * 区
     */
    private String receiverRegion;
    /**
     * 详细地址
     */
    private String receiverDetailAddress;
    /**
     * 订单备注
     */
    private String note;
    /**
     * 确认收货状态[0->未确认；1->已确认]
     */
    private Integer confirmStatus;
    /**
     * 删除状态【0->未删除；1->已删除】
     */
    private Integer deleteStatus;
    /**
     * 下单时使用的积分
     */
    private Integer useIntegration;
    /**
     * 支付时间
     */
    private Date paymentTime;
    /**
     * 发货时间
     */
    private Date deliveryTime;
    /**
     * 确认收货时间
     */
    private Date receiveTime;
    /**
     * 评价时间
     */
    private Date commentTime;
    /**
     * 修改时间
     */
    private Date modifyTime;
}