springboot +java延时任务(Delayed)

问题场景:
订单超时自动取消,类似淘宝或者美团等购买商品时,在用户没有按照规定时间付款时,订单会在指定时间取消。

解决办法:
1.定时任务:该方案通常是在小型项目中使用,即通过一个线程定时的去扫描数据库,通过订单时间来判断是否有超时的订单,然后进行update或delete等操作(quartz来实现
2.基于RabbitMQ实现,借助于RabbitMQ的延迟队列TTL和死信队列。
3.JDK的延迟队列
该方案是利用JDK自带的DelayQueue来实现,这是一个无界阻塞队列,该队列只有在延迟期满的时候才能从中获取元素,放入DelayQueue中的对象,是必须实现Delayed接口的。
其中Poll():获取并移除队列的超时元素,没有则返回空
take():获取并移除队列的超时元素,如果没有则wait当前线程,直到有元素满足超时条件,返回结果
4.redis缓存
思路一利用redis的zset,zset是一个有序集合,每一个元素(member)都关联了一个score,通过score排序来取集合中的值
添加元素:ZADD key score member [[score member] [score member] …]
按顺序查询元素:ZRANGE key start stop [WITHSCORES]
查询元素score:ZSCORE key member
移除元素:ZREM key member [member …]
以上都是可以解决此场景。
今天重点说一下java延时队列(Delayed)
话不多说,直接上代码
1.controller层
注意:使用 @Autowired进行使用

public class OrderController extends BaseController {

    private final ITOrderService iTOrderService;

    @Autowired
    private DelayQueueManagers delayQueueManager;
/**
     * 新增订单管理
     */
    @ApiOperation(value="新增订单")
//    @PreAuthorize("@ss.hasPermi('manage:order:add')" )
    @Log(title = "订单管理" , businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody TOrder tOrder) throws ParseException {
        Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(DateUtils.getTime());
        tOrder.setFinshtime(date);
        tOrder.setCreatetime(date);
        tOrder.setPaytime(date);
        tOrder.setUpdatetime(date);
        delayQueueManager.put(new DelayTask(new TaskBase(tOrder.getOid().toString()),1000*60*1));//新增任务
        return toAjax(iTOrderService.save(tOrder) ? 1 : 0);
    }

2.定义延迟队列管理类DelayQueueManagers
注意:必须加@Component,注入到spring

package com.nft.shop.test;
import com.nft.manage.service.ITOrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Executors;

@Component
@Slf4j
public class DelayQueueManagers implements CommandLineRunner {

    private final DelayQueue<DelayTask> delayQueue = new DelayQueue<>();

    @Autowired
    private ITOrderService iTOrderService;

    /**
     * 加入到延时队列中
     * @param task
     */
    public void put(DelayTask task) {
        log.error("加入延时任务:{}", task);
        delayQueue.put(task);
    }
    /**
     * 取消延时任务
     * @param task
     * @return
     */
    public boolean remove(DelayTask task) {
        log.error("取消延时任务:{}", task);
        return delayQueue.remove(task);
    }
    /**
     * 取消延时任务
     * @param taskid
     * @return
     */
    public boolean remove(String taskid) {
        return remove(new DelayTask(new TaskBase(taskid), 0));
    }
    @Override
    public void run(String... args) throws Exception {
        log.info("初始化延时队列");
        Executors.newSingleThreadExecutor().execute(new Thread(this::excuteThread));
    }
    /**
     * 延时任务执行线程
     */
    private void excuteThread() {
        while (true) {
            try {
                DelayTask task = delayQueue.take();
                processTask(task);
            } catch (InterruptedException e) {
                break;
            }
        }
    }
    /**
     * 内部执行延时任务
     * @param task
     */
    private void processTask(DelayTask task) {
        log.error("执行延时任务:{}-{}", task,task.getData().getIdentifier());
        List<Map> list = iTOrderService.queryOrderTimerStatus();
        if (!CollectionUtils.isEmpty(list)) {
            for (int i = 0; i < list.size(); i++) {
                iTOrderService.updateOrderTimerStatus((Integer) list.get(i).get("oId"));
            }
        }
    }
}

3.taskBase

package com.nft.shop.test;

public class TaskBase {
    private String identifier;

    public TaskBase(String identifier) {
        this.identifier = identifier;
    }

    public String getIdentifier() {
        return identifier;
    }

    public void setIdentifier(String identifier) {
        this.identifier = identifier;
    }

}

4.DelayTask

package com.nft.shop.test;
import com.nft.common.utils.DateUtils;

import java.util.Date;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
public class DelayTask implements Delayed {

    final private TaskBase data;

    final private long expire;

    /**
     * 构造延时任务
     *
     * @param data   业务数据
     * @param expire 任务延时时间(ms)
     */
    public DelayTask(TaskBase data, long expire) {
        super();
        this.data = data;
        this.expire = expire + System.currentTimeMillis();
    }

    public TaskBase getData() {
        return data;
    }

    public long getExpire() {
        return expire;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof DelayTask) {
            return this.data.getIdentifier().equals(((DelayTask) obj).getData().getIdentifier());
        }
        return false;
    }

    @Override
    public String toString() {
        return "{" + "data:" + data.toString() + "," + "延时时间:" + DateUtils.getTimestampToTime(expire,DateUtils.YYYY_MM_DD_HH_MM_SS) + "}";
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(this.expire - System.currentTimeMillis(), unit);
    }

    @Override
    public int compareTo(Delayed o) {
        long delta = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
        return (int) delta;
    }
}

其中用了格式化日期

public class DateUtils extends org.apache.commons.lang3.time.DateUtils
{

  public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";


  public static String getTimestampToTime(Long timeStamp,final String ts){
      SimpleDateFormat sdf=new SimpleDateFormat(ts);
      return sdf.format(new Date(Long.parseLong(String.valueOf(timeStamp))));
  }
  }
  • 0
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot 整合 RabbitMQ 延时队列是一种常见场景,主要用于处理那些需要延迟执行的任务。在Spring Boot中,你可以使用`RabbitmqTemplate`和`AmqpAdmin`来集成RabbitMQ,并利用`delayed-message-exchange`和`x-delayed-message-routing-key`特性实现延时队列。 以下是基本步骤: 1. **配置RabbitMQ**: 首先,在Spring Boot的配置文件中(如application.yml)添加RabbitMQ的相关配置,包括连接地址、交换器、队列等。 ```yaml spring: rabbit: host: localhost port: 5672 username: guest password: guest virtual-host: / ``` 2. **声明延时队列**: 使用`AmqpAdmin`创建一个延时队列,它需要一个特殊的交换器(通常是`x-delayed-message`类型)。 ```java @Autowired private AmqpAdmin admin; public void configureQueue(String queueName) { ExchangeOptions exchangeOptions = new ExchangeOptions() .type(ExchangeTypes.X_DELAYED_MESSAGE) .durable(true); admin.declareExchange("delayed_queue", exchangeOptions); Map<String, Object> bindingArgs = new HashMap<>(); bindingArgs.put("x-delayed-type", "direct"); admin.declareQueue(queueName, true, true, bindingArgs); } ``` 3. **发送延时消息**: 在发送消息时,指定`x-delay`属性为延迟时间(单位通常为毫秒),并使用`x-delayed-message-routing-key`作为路由键。 ```java RabbitTemplate rabbitTemplate = new RabbitTemplate(rabbitConnectionFactory); Map<String, Object> messageProperties = new HashMap<>(); messageProperties.put(RabbitMQMessageHeaders.DELIVERY_MODE, DeliveryMode.PERSISTENT); messageProperties.put(RabbitMQMessageHeaders.EXPIRE_TIME, System.currentTimeMillis() + (delayInMilliseconds * 1000)); // delayInMilliseconds是你希望的延迟时间 rabbitTemplate.convertAndSend("delayed_queue", "your.routing.key", "your.message", messageProperties); ``` 4. **消费延时消息**: 使用普通的消费者或者延时消费者(`@RabbitListener`或自定义`MessageListenerContainer`)来消费队列中的消息。对于延时消费,你可以监听特定的路由键,或者使用`@RabbitListener`的`container`参数指定一个带有延时策略的`ConcurrentMessageListenerContainer`。 ```java @Component public class DelayedConsumer { @RabbitListener(queues = "your.queue.name", containerFactory = "delayedListenerContainer") public void consume(String message) { // 处理消息 } @Bean(name = "delayedListenerContainer") public ConcurrentMessageListenerContainer delayedListenerContainer() { ConcurrentMessageListenerContainer container = new ConcurrentMessageListenerContainer(rabbitConnectionFactory); container.setDeadLetterExchange("dead_letter_exchange"); return container; } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值