1.面试官提问：你说你在项目中使用springsecurity + jwt 实现了登录功能，能简单讲一下怎么实现的吗？

2.使用RabbitMQ实现订单超时取消功能

redis实现的劣势

1. 订单状态定义

   首先，我们需要定义订单的不同状态。在这个示例中，我们可以定义以下订单状态：

   WAITING_FOR_PAYMENT：待支付状态，表示用户已下单但尚未完成支付。

   PAID：支付成功状态，表示用户已成功完成支付。

   CANCELLED：已取消状态，表示订单已被取消。

2. 发送订单消息到队列

   当用户下单时，我们需要将订单信息发送到RabbitMQ队列中。在发送订单消息时，我们需要设置消息的TTL为30分钟，以便在30分钟后触发超时取消订单的逻辑。

java

@Component
public class OrderProducer {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    public void sendOrderMessage(String orderId) {
        OrderMessage orderMessage = new OrderMessage();
        orderMessage.setOrderId(orderId);
        orderMessage.setStatus(OrderStatus.WAITING_FOR_PAYMENT);
        rabbitTemplate.convertAndSend("order.exchange", "order.routingKey", orderMessage, message -> {
            message.getMessageProperties().setExpiration("1800000"); // 设置消息的TTL为30分钟
            return message;
        });
    }
}

3. 创建订单状态转换的消费者

   创建一个消费者，监听DLX所指定的交换机，并根据订单状态的不同进行相应的处理。在这个示例中，我们将根据订单状态执行不同的逻辑，如果订单在30分钟内未支付，则执行取消订单的操作。

java

@Component
public class OrderConsumer {
    @RabbitListener(queues = "order.dead-letter.queue")
    public void processExpiredOrder(OrderMessage orderMessage) {
        if (orderMessage.getStatus() == OrderStatus.WAITING_FOR_PAYMENT) {
            // 30分钟后未支付，取消订单
            cancelOrder(orderMessage.getOrderId());
        }
    }
    private void cancelOrder(String orderId) {
        // 执行取消订单的逻辑
        System.out.println("Canceling order: " + orderId);
        // 更新订单状态为已取消
        // orderService.cancelOrder(orderId);
    }
}

4. 配置RabbitMQ

   在RabbitMQ中，我们需要创建一个交换机、一个队列和一个DLX（死信交换机），并将队列绑定到DLX上。同时，我们也需要设置DLX的路由键，以便将超时的订单消息发送到DLX中。

java

@Configuration
public class RabbitMQConfig {
    @Bean
    public DirectExchange orderExchange() {
        return new DirectExchange("order.exchange");
    }
    @Bean
    public Queue orderQueue() {
        return QueueBuilder.durable("order.queue")
                .withArgument("x-dead-letter-exchange", "order.dead-letter.exchange")
                .withArgument("x-dead-letter-routing-key", "order.dead-letter.routing-key")
                .build();
    }
    @Bean
    public DirectExchange orderDeadLetterExchange() {
        return new DirectExchange("order.dead-letter.exchange");
    }
    @Bean
    public Queue orderDeadLetterQueue() {
        return new Queue("order.dead-letter.queue");
    }
    @Bean
    public Binding bindingOrder() {
        return BindingBuilder.bind(orderQueue())
                .to(orderExchange())
                .with("order.routingKey");
    }
    @Bean
    public Binding bindingOrderDeadLetter() {
        return BindingBuilder.bind(orderDeadLetterQueue())
                .to(orderDeadLetterExchange())
                .with("order.dead-letter.routing-key");
    }
}

在以上配置中，我们定义了一个名为order.exchange的直连交换机，以及一个名为order.queue的队列。我们还定义了一个DLX，名为order.dead-letter.exchange，并将队列order.queue绑定到DLX上。当订单消息在30分钟内未被消费时，将会被发送到DLX中。

3.使用Redis+Lua脚本实现秒杀功能，后期用了Redisson锁进行优化处理。

public class SeckillService {
    private final RedissonClient redissonClient;
    private final String luaScript;
    public SeckillService(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
        // 加载Lua脚本
        this.luaScript = "local count = redis.call('get', KEYS[1])\n" +
                "if tonumber(count) >= tonumber(ARGV[1]) then\n" +
                "    redis.call('decrby', KEYS[1], ARGV[1])\n" +
                "    return 1\n" +
                "else\n" +
                "    return 0\n" +
                "end";
    }
    public boolean seckill(String productId, int quantity) {
        RLock lock = redissonClient.getLock(productId);
        try {
            // 加锁
            lock.lock();
            // 执行Lua脚本
            RScript script = redissonClient.getScript();
            List