springboot 支付订单超时自动处理

今天遇到的场景如标题:

  支付订单超时自动处理 (待支付订单的有效期三分钟)。 

想到的解决方法

1. 定时器
2.redis 【Redis 事件通知(keyspace & keyevent notification)】

(https://blog.csdn.net/qijiqiguai/article/details/78229111))这里有介绍

3.rabbitmq 延时队列

主要给大家分别讲下 方案2 和 方案3

方案2 :
找到机器上redis配置文件conf/redis.conf,新增一行 notify-keyspace-events Ex

配置文件修改完成后重新启动redis服务。

(如果配置文件修改后未生效,进入redis-cli命令行界面,使用非持久化配置 CONFIG set notify-keyspace-events Ex)

代码如下所示: 例子可以直接跑通。 直接在 TopicMessageListener onMessage 方法下 打断点 即可看到到期redis 值 进入断点中 。
https://github.com/KingestCode/redisnotify.git

方案三:RabbitMQ 延迟消息实现

  1. 前提已经安装了rabbitmq
    2)安装延时插件 http://www.rabbitmq.com/community-plugins.html

千万记住,一定选好版本号,由于我使用的是RabbitMQ 3.7.4,因此对应的rabbitmq_delayed_message_exchange插件也必须选择3.7.x的。

下载完插件后,将其放置到RabbitMQ安装目录下的plugins目录下,并使用如下命令启动这个插件:

./rabbitmq-plugins enable rabbitmq_delayed_message_exchange

集成RabbitMQ


        org.springframework.boot
        spring-boot-starter-amqp

在 application.yml加入 rabbitmq 的配置

spring.rabbitmq.host=127.0.0.1
server:
  port: 8081
redis:
  hostname: localhost
  port: 6379
spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-confirms: true
    publisher-returns: true
    template:
      mandatory: true
    connection-timeout: 15000

RabbitMqConfig


@Configuration
@ConfigurationProperties(prefix = "spring.rabbitmq")
public class RabbitMqConfig {
    private String host;
    private int port;
    private String userName;
    private String password;

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(host,port);
        cachingConnectionFactory.setUsername(userName);
        cachingConnectionFactory.setPassword(password);
        cachingConnectionFactory.setVirtualHost("/");
        cachingConnectionFactory.setPublisherConfirms(true);
        return cachingConnectionFactory;
    }

    @Bean
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory());
        return rabbitTemplate;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}

QueueConfig


@Configuration
public class QueueConfig {
    @Bean
    public CustomExchange delayExchange() {
        Map args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        return new CustomExchange("test_exchange", "x-delayed-message",true, false,args);
    }

    @Bean
    public Queue queue() {
        Queue queue = new Queue("test_queue_1", true);
        return queue;
    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(delayExchange()).with("test_queue_1").noargs();
    }

}

消息发送:MessageServiceImpl


@Service
public class MessageServiceImpl {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMsg(String queueName,String msg) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("消息发送时间:"+sdf.format(new Date()));
        rabbitTemplate.convertAndSend("test_exchange", queueName, msg, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setHeader("x-delay",3000);
                return message;
            }
        });
    }
}

消息接受:MessageReceiver

@Component
public class MessageReceiver {

    @RabbitListener(queues = "test_queue_1")
    public void receive(String msg) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("消息接收时间:"+sdf.format(new Date()));
        System.out.println("接收到的消息:"+msg);
    }
}

测试类: RabbitmqApplicationTests

@RunWith(SpringRunner.class)
@SpringBootTest(classes = UserApplication.class)
public class RabbitmqApplicationTests {
    @Autowired
    private MessageServiceImpl messageService;

    @Test
    public void send() {
        messageService.sendMsg("test_queue_1","hello i am delay msg");
    }

}

运行完后,可以看到如下信息:
消息发送时间:2018-05-03 12:44:53
3秒钟后,Spring Boot控制台会输出:
消息接收时间:2018-05-03 12:44:56
接收到的消息:hello i am delay msg

最后讲下 定时任务以及redis 和 rabbitmq 之间的区别:
其实用定时任务,确实有点问题,原本业务系统希望10分钟后,如果订单未支付,就马上取消订单,并释放商品库存。但是一旦数据量大的话,就会加长获取未支付订单数据的时间,部分订单就做不到10分钟后取消了,可能是15分钟,20分钟之类的。这样的话,库存就无法及时得到释放,也就会影响成单数。而利用延迟消息,则理论上是可以做到按照设定的时间,进行订单取消操作的。

目前网上关于使用RabbitMQ实现延迟消息的文章,大多都是讲如何利用RabbitMQ的死信队列来实现,实现方案看起来都很繁琐复杂,并且还是使用原始的RabbitMQ Client API来实现的,更加显得啰嗦。

Spring Boot 已经对RabbitMQ Client API进行了包装,使用起来简洁很多,下面详细介绍一下如何利用rabbitmq_delayed_message_exchange 插件和Spring Boot来实现延迟消息。

redis 和 rabbitmq 的方式会保证数据的准确性

如果需要rabbitmq 相关代码 请留言 。。。

你可能感兴趣的:(springboot 支付订单超时自动处理)