redis实现延迟任务

1.为什么redis中使用两种数据类型，list和zset？

2.在添加zset数据的时候，为什么需要预加载？

3.延迟任务服务实现

3.1 搭建heima-leadnews-schedule模块

leadnews-schedule是一个通用的服务，单独创建模块来管理任何类型的延迟任务

①：导入资料文件夹下的heima-leadnews-schedule模块到heima-leadnews-service下，如下图所示：

 ②：添加bootstrap.yml

server:
  port: 51701
spring:
  application:
    name: leadnews-schedule
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.200.130:8848
      config:
        server-addr: 192.168.200.130:8848
        file-extension: yml

③：在nacos中添加对应配置，并添加数据库及mybatis-plus的配置

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/leadnews_schedule?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: root
# 设置Mapper接口所对应的XML文件位置，如果你在Mapper接口中有自定义方法，需要进行该配置
mybatis-plus:
  mapper-locations: classpath*:mapper
@Data
@TableName("taskinfo")
public class Taskinfo implements Serializable {

    private static final long serialVersionUID = 1L;

    
    @TableId(type = IdType.ID_WORKER)
    private Long taskId;

    
    @TableField("execute_time")
    private Date executeTime;

    
    @TableField("parameters")
    private byte[] parameters;

    
    @TableField("priority")
    private Integer priority;

    
    @TableField("task_type")
    private Integer taskType;


}

taskinfo_logs 任务日志表

实体类

package com.heima.model.schedule.pojos;

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;


@Data
@TableName("taskinfo_logs")
public class TaskinfoLogs implements Serializable {

    private static final long serialVersionUID = 1L;

    
    @TableId(type = IdType.ID_WORKER)
    private Long taskId;

    
    @TableField("execute_time")
    private Date executeTime;

    
    @TableField("parameters")
    private byte[] parameters;

    
    @TableField("priority")
    private Integer priority;

    
    @TableField("task_type")
    private Integer taskType;

    
    @Version
    private Integer version;

    
    @TableField("status")
    private Integer status;


}

乐观锁支持

@Bean
public MybatisPlusInterceptor optimisticLockerInterceptor(){
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
    return interceptor;
}

5.安装redis

①拉取镜像

docker pull redis

② 创建容器

docker run -d --name redis --restart=always -p 6379:6379 redis --requirepass "leadnews"

6.项目集成redis

① 在项目导入redis相关依赖，已经完成

    org.springframework.boot
    spring-boot-starter-data-redis



    org.apache.commons
    commons-pool2

② 在heima-leadnews-schedule中集成redis,添加以下nacos配置，链接上redis

spring:
  redis:
    host: 192.168.200.130
    password: leadnews
    port: 6379

③ 拷贝资料文件夹下的类：CacheService到heima-leadnews-common模块下，并添加自动配置

package com.heima.schedule.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.StringRedisConnection;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
public class CacheService extends CachingConfigurerSupport {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public StringRedisTemplate getstringRedisTemplate() {
        return this.stringRedisTemplate;
    }

    

    
    public void delete(String key) {
        stringRedisTemplate.delete(key);
    }

    
    public void delete(Collection keys) {
        stringRedisTemplate.delete(keys);
    }

    
    public byte[] dump(String key) {
        return stringRedisTemplate.dump(key);
    }

    
    public Boolean exists(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    
    public Boolean expire(String key, long timeout, TimeUnit unit) {
        return stringRedisTemplate.expire(key, timeout, unit);
    }

    
    public Boolean expireAt(String key, Date date) {
        return stringRedisTemplate.expireAt(key, date);
    }

    
    public Set keys(String pattern) {
        return stringRedisTemplate.keys(pattern);
    }

    
    public Boolean move(String key, int dbIndex) {
        return stringRedisTemplate.move(key, dbIndex);
    }

    
    public Boolean persist(String key) {
        return stringRedisTemplate.persist(key);
    }

    
    public Long getExpire(String key, TimeUnit unit) {
        return stringRedisTemplate.getExpire(key, unit);
    }

    
    public Long getExpire(String key) {
        return stringRedisTemplate.getExpire(key);
    }

    
    public String randomKey() {
        return stringRedisTemplate.randomKey();
    }

    
    public void rename(String oldKey, String newKey) {
        stringRedisTemplate.rename(oldKey, newKey);
    }

    
    public Boolean renameIfAbsent(String oldKey, String newKey) {
        return stringRedisTemplate.renameIfAbsent(oldKey, newKey);
    }

    
    public DataType type(String key) {
        return stringRedisTemplate.type(key);
    }

    

    
    public void set(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    
    public String get(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    
    public String getRange(String key, long start, long end) {
        return stringRedisTemplate.opsForValue().get(key, start, end);
    }

    
    public String getAndSet(String key, String value) {
        return stringRedisTemplate.opsForValue().getAndSet(key, value);
    }

    
    public Boolean getBit(String key, long offset) {
        return stringRedisTemplate.opsForValue().getBit(key, offset);
    }

    
    public List multiGet(Collection keys) {
        return stringRedisTemplate.opsForValue().multiGet(keys);
    }

    
    public boolean setBit(String key, long offset, boolean value) {
        return stringRedisTemplate.opsForValue().setBit(key, offset, value);
    }

    
    public void setEx(String key, String value, long timeout, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    
    public boolean setIfAbsent(String key, String value) {
        return stringRedisTemplate.opsForValue().setIfAbsent(key, value);
    }

    
    public void setRange(String key, String value, long offset) {
        stringRedisTemplate.opsForValue().set(key, value, offset);
    }

    
    public Long size(String key) {
        return stringRedisTemplate.opsForValue().size(key);
    }

    
    public void multiSet(Map maps) {
        stringRedisTemplate.opsForValue().multiSet(maps);
    }

    
    public boolean multiSetIfAbsent(Map maps) {
        return stringRedisTemplate.opsForValue().multiSetIfAbsent(maps);
    }

    
    public Long incrBy(String key, long increment) {
        return stringRedisTemplate.opsForValue().increment(key, increment);
    }

    
    public Double incrByFloat(String key, double increment) {
        return stringRedisTemplate.opsForValue().increment(key, increment);
    }

    
    public Integer append(String key, String value) {
        return stringRedisTemplate.opsForValue().append(key, value);
    }

    

    
    public Object hGet(String key, String field) {
        return stringRedisTemplate.opsForHash().get(key, field);
    }

    
    public Map hGetAll(String key) {
        return stringRedisTemplate.opsForHash().entries(key);
    }

    
    public List