【Springboot+Redis】

Liduomi

已于 2022-04-29 14:53:41 修改

阅读量1.9k

点赞数

分类专栏： Redis 文章标签： redis spring boot java

于 2022-03-18 16:08:07 首次发布

本文链接：https://blog.csdn.net/qq_45866560/article/details/123484310

版权

Redis 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Springboot+Redis

一、 springboot集成redis配置
二、基本方法
三、Redis工具类

一、 springboot集成redis配置

1、在 pom.xml 中配置相关的 jar 依赖

		<dependency>
			<groupId>org.springframework.kafka</groupId>
			<artifactId>spring-kafka</artifactId>
			<version>2.4.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
		</dependency>

在SpringBoot2.x之后，redis依赖的底层实现用lettuce替换掉了jedis
（1） jedis：采用的直连，多个线程操作的话，是不安全的；想要避免不安全，使用jedis pool连接池。更像BIO模式
（2）lettuce：采用netty，实例可以在多个线程中共享，不存在线程不安全的情况；可以减少线程数量。更像NIO模式

2、在 Springboot 核心配置文件 application.properties 中配置

spring:
   redis:
      database: 0       # Redis数据库索引（默认为0）
      host: 127.0.0.1   # Redis服务器地址
      port: 6379        # Redis服务器连接端口
      password:         # Redis服务器连接密码（默认为空）
      timeout: 60s      # 连接超时时间
      lettuce:          # Lettuce 是一个可伸缩线程安全的 Redis 客户端，多个线程可以共享同一个 RedisConnection，它利用优秀 netty NIO 框架来高效地管理多个连接
         pool:
            max-idle: 500    # 连接池中的最大空闲连接
            min-idle: 50     # 连接池中的最小空闲连接
            max-active: -1   # 连接池最大连接数（使用负值表示没有限制）

冒号和参数之间有一个空格

3、配置redis序列化

添加Redisson的配置参数读取类RedisConfig

package com.dbfor.redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;
import java.time.Duration;
/**
 * Redis配置
 */
@Configuration
public class RedisConfig {
    /**
     * redis模板，存储关键字是字符串，值jackson2JsonRedisSerializer是序列化后的值
     *
     * @param
     * @return org.springframework.data.redis.core.RedisTemplate
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        //使用StringRedisSerializer来序列化和反序列化redis的key值
        RedisSerializer redisSerializer = new StringRedisSerializer();
        //key
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(redisSerializer);
        //value
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
    @Bean
    public RedisCacheConfiguration redisCacheConfiguration() {
        return RedisCacheConfiguration.
                defaultCacheConfig().
                entryTtl(Duration.ofDays(1)).			//Key过期时间 1天
                // entryTtl(Duration.ofMinutes(30)).//设置缓存默认过期时间 30分钟
                serializeKeysWith(RedisSerializationContext.SerializationPair.
                fromSerializer(new StringRedisSerializer())).
                serializeValuesWith(RedisSerializationContext.SerializationPair.
                        fromSerializer(new GenericJackson2JsonRedisSerializer()));
    }
}

针对数据的“序列化/反序列化”，提供了多种可选择策略(RedisSerializer)
（1）JdkSerializationRedisSerializer：POJO对象的存取场景，使用JDK本身序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作，最终redis-server中将存储字节序列。是目前最常用的序列化策略。
（2）StringRedisSerializer：Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string，是“new String(bytes, charset)”和“string.getBytes(charset)”的直接封装。是最轻量级和高效的策略。
（3）JacksonJsonRedisSerializer：jackson-json工具提供了javabean与json之间的转换能力，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。因为jackson工具在序列化和反序列化时，需要明确指定Class类型，因此此策略封装起来稍微复杂。

二、基本方法

RedisTemplate的直接方法

使用@Autowired注入RedisTemplate（后面直接使用，就不特殊说明）

@Autowired
private RedisTemplate redisTemplate;

1、删除单个key

//    删除key
public void delete(String key){
    redisTemplate.delete(key);
}

2、删除多个key

//    删除多个key
public void deleteKey (Collection<K> keys){
    redisTemplate.delete(keys);
}

3、指定key的失效时间

//    指定key的失效时间
public void expire(String key,long time){
    redisTemplate.expire(key,time,TimeUnit.MINUTES);
}

4、根据key获取过期时间

//    根据key获取过期时间
public long getExpire(String key){
    Long expire = redisTemplate.getExpire(key);
    return expire;
}

5、判断key是否存在

//    判断key是否存在
public boolean hasKey(String key){
    return redisTemplate.hasKey(key);
}

String类型相关操作

1)、添加缓存（2/3是1的递进值）

//1、通过redisTemplate设置值
redisTemplate.boundValueOps("StringKey").set("StringValue");
redisTemplate.boundValueOps("StringKey").set("StringValue",1, TimeUnit.MINUTES);

//2、通过BoundValueOperations设置值
BoundValueOperations stringKey = redisTemplate.boundValueOps("StringKey");
stringKey.set("StringVaule");
stringKey.set("StringValue",1, TimeUnit.MINUTES);

//3、通过ValueOperations设置值
ValueOperations ops = redisTemplate.opsForValue();
ops.set("StringKey", "StringVaule");
ops.set("StringValue","StringVaule",1, TimeUnit.MINUTES);

2)、设置过期时间(单独设置)

redisTemplate.boundValueOps("StringKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("StringKey",1,TimeUnit.MINUTES);

3)、获取缓存值（2/3是1的递进值）

//1、通过redisTemplate设置值
String str1 = (String) redisTemplate.boundValueOps("StringKey").get();

//2、通过BoundValueOperations获取值
BoundValueOperations stringKey = redisTemplate.boundValueOps("StringKey");
String str2 = (String) stringKey.get();

//3、通过ValueOperations获取值
ValueOperations ops = redisTemplate.opsForValue();
String str3 = (String) ops.get("StringKey");

4)、删除key

Boolean result = redisTemplate.delete("StringKey");

5)、顺序递增

redisTemplate.boundValueOps("StringKey").increment(3L);

6)、顺序递减

redisTemplate.boundValueOps("StringKey").increment(-3L);

Hash类型相关操作

1)、添加缓存（2/3是1的递进值）

//1、通过redisTemplate设置值
redisTemplate.boundHashOps("HashKey").put("SmallKey", "HashVaue");

//2、通过BoundValueOperations设置值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
hashKey.put("SmallKey", "HashVaue");

//3、通过ValueOperations设置值
HashOperations hashOps = redisTemplate.opsForHash();
hashOps.put("HashKey", "SmallKey", "HashVaue");

2)、设置过期时间(单独设置)

redisTemplate.boundValueOps("HashKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("HashKey",1,TimeUnit.MINUTES);

3)、添加一个Map集合

HashMap<String, String> hashMap = new HashMap<>();
redisTemplate.boundHashOps("HashKey").putAll(hashMap );

4)、设置过期时间(单独设置)

redisTemplate.boundValueOps("HashKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("HashKey",1,TimeUnit.MINUTES);

5)、提取所有的小key

//1、通过redisTemplate获取值
Set keys1 = redisTemplate.boundHashOps("HashKey").keys();

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
Set keys2 = hashKey.keys();

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
Set keys3 = hashOps.keys("HashKey");

6)、提取所有的value值

//1、通过redisTemplate获取值
List values1 = redisTemplate.boundHashOps("HashKey").values();

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
List values2 = hashKey.values();

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
List values3 = hashOps.values("HashKey");

7)、根据key提取value值

//1、通过redisTemplate获取
String value1 = (String) redisTemplate.boundHashOps("HashKey").get("SmallKey");

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
String value2 = (String) hashKey.get("SmallKey");

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
String value3 = (String) hashOps.get("HashKey", "SmallKey");

8)、获取所有的键值对集合

//1、通过redisTemplate获取
Map entries = redisTemplate.boundHashOps("HashKey").entries();

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
Map entries1 = hashKey.entries();

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
Map entries2 = hashOps.entries("HashKey");

9)、删除

//删除小key
redisTemplate.boundHashOps("HashKey").delete("SmallKey");
//删除大key
redisTemplate.delete("HashKey");

10)、判断Hash中是否含有该值

Boolean isEmpty = redisTemplate.boundHashOps("HashKey").hasKey("SmallKey");

Set类型相关操作

1)、添加Set缓存(值可以是一个，也可是多个)(2/3是1的递进值）

//1、通过redisTemplate设置值
redisTemplate.boundSetOps("setKey").add("setValue1", "setValue2", "setValue3");

//2、通过BoundValueOperations设置值
BoundSetOperations setKey = redisTemplate.boundSetOps("setKey");
setKey.add("setValue1", "setValue2", "setValue3");

//3、通过ValueOperations设置值
SetOperations setOps = redisTemplate.opsForSet();
setOps.add("setKey", "SetValue1", "setValue2", "setValue3");

2)、设置过期时间(单独设置)

redisTemplate.boundValueOps("setKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("setKey",1,TimeUnit.MINUTES);

3)、根据key获取Set中的所有值

//1、通过redisTemplate获取值
Set set1 = redisTemplate.boundSetOps("setKey").members();

//2、通过BoundValueOperations获取值
BoundSetOperations setKey = redisTemplate.boundSetOps("setKey");
Set set2 = setKey.members();

//3、通过ValueOperations获取值
SetOperations setOps = redisTemplate.opsForSet();
Set set3 = setOps.members("setKey");

4)、根据value从一个set中查询,是否存在

Boolean isEmpty = redisTemplate.boundSetOps("setKey").isMember("setValue2");

5)、获取Set缓存的长度

Long size = redisTemplate.boundSetOps("setKey").size();

6)、移除指定的元素

Long result1 = redisTemplate.boundSetOps("setKey").remove("setValue1");

7)、移除指定的key

Boolean result2 = redisTemplate.delete("setKey");

LIST类型相关操作

1)、添加缓存（2/3是1的递进值）

//1、通过redisTemplate设置值
redisTemplate.boundListOps("listKey").leftPush("listLeftValue1");
redisTemplate.boundListOps("listKey").rightPush("listRightValue2");

//2、通过BoundValueOperations设置值
BoundListOperations listKey = redisTemplate.boundListOps("listKey");
listKey.leftPush("listLeftValue3");
listKey.rightPush("listRightValue4");

//3、通过ValueOperations设置值
ListOperations opsList = redisTemplate.opsForList();
opsList.leftPush("listKey", "listLeftValue5");
opsList.rightPush("listKey", "listRightValue6");

2)、将List放入缓存

ArrayList<String> list = new ArrayList<>();
redisTemplate.boundListOps("listKey").rightPushAll(list);
redisTemplate.boundListOps("listKey").leftPushAll(list);

3)、设置过期时间(单独设置)

redisTemplate.boundValueOps("listKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("listKey",1,TimeUnit.MINUTES);

4)、获取List缓存全部内容（起始索引，结束索引）

List listKey1 = redisTemplate.boundListOps("listKey").range(0, 10);

5)、从左或从右弹出一个元素

String listKey2 = (String) redisTemplate.boundListOps("listKey").leftPop();  //从左侧弹出一个元素
String listKey3 = (String) redisTemplate.boundListOps("listKey").rightPop(); //从右侧弹出一个元素

6)、根据索引查询元素

String listKey4 = (String) redisTemplate.boundListOps("listKey").index(1);

7)、获取List缓存的长度

Long size = redisTemplate.boundListOps("listKey").size();

8)、根据索引修改List中的某条数据(key，索引，值)

redisTemplate.boundListOps("listKey").set(3L,"listLeftValue3");

9)、移除N个值为value(key,移除个数，值)

redisTemplate.boundListOps("listKey").remove(3L,"value");

Zset类型的相关操作

1)、向集合中插入元素，并设置分数

//1、通过redisTemplate设置值
redisTemplate.boundZSetOps("zSetKey").add("zSetVaule", 100D);

//2、通过BoundValueOperations设置值
BoundZSetOperations zSetKey = redisTemplate.boundZSetOps("zSetKey");
zSetKey.add("zSetVaule", 100D);

//3、通过ValueOperations设置值
ZSetOperations zSetOps = redisTemplate.opsForZSet();
zSetOps.add("zSetKey", "zSetVaule", 100D);

2)、向集合中插入多个元素,并设置分数

DefaultTypedTuple<String> p1 = new DefaultTypedTuple<>("zSetVaule1", 2.1D);
DefaultTypedTuple<String> p2 = new DefaultTypedTuple<>("zSetVaule2", 3.3D);
redisTemplate.boundZSetOps("zSetKey").add(new HashSet<>(Arrays.asList(p1,p2)));

3)、按照排名先后(从小到大)打印指定区间内的元素, -1为打印全部

Set<String> range = redisTemplate.boundZSetOps("zSetKey").range(0, -1);

4)、获得指定元素的分数

Double score = redisTemplate.boundZSetOps("zSetKey").score("zSetVaule");

5)、返回集合内的成员个数

Long size = redisTemplate.boundZSetOps("zSetKey").size();

6)、返回集合内指定分数范围的成员个数（Double类型）

Long COUNT = redisTemplate.boundZSetOps("zSetKey").count(0D, 2.2D);

7)、返回集合内元素在指定分数范围内的排名（从小到大）

Set byScore = redisTemplate.boundZSetOps("zSetKey").rangeByScore(0D, 2.2D);

8)、带偏移量和个数，(key，起始分数，最大分数，偏移量，个数)

Set<String> ranking2 = redisTemplate.opsForZSet().rangeByScore("zSetKey", 0D, 2.2D 1, 3);

9)、返回集合内元素的排名，以及分数（从小到大）

Set<TypedTuple<String>> tuples = redisTemplate.boundZSetOps("zSetKey").rangeWithScores(0L, 3L);
  for (TypedTuple<String> tuple : tuples) {
      System.out.println(tuple.getValue() + " : " + tuple.getScore());
  }ss

10)、返回指定成员的排名

//从小到大
Long startRank = redisTemplate.boundZSetOps("zSetKey").rank("zSetVaule");
//从大到小
Long endRank = redisTemplate.boundZSetOps("zSetKey").reverseRank("zSetVaule");

11)、从集合中删除指定元素

redisTemplate.boundZSetOps("zSetKey").remove("zSetVaule");

12)、删除指定索引范围的元素（Long类型）

redisTemplate.boundZSetOps("zSetKey").removeRange(0L,3L);

13)、删除指定分数范围内的元素（Double类型）

redisTemplate.boundZSetOps("zSetKey").removeRangeByScorssse(0D,2.2D);

14)、为指定元素加分（Double类型）

Double score = redisTemplate.boundZSetOps("zSetKey").incrementScore("zSetVaule",1.1D);

三、Redis工具类

package xxx.xxxx;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;

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

/**
 * Redis工具类
 */
@Component
public class RedisUtils {

    @Autowired
    private RedisTemplate redisTemplate;


    /**
     * 获取redis当前时间戳
     */
    public Long currentTimeMillis() {
        String SCRIPT_TIME = "local a=redis.call('TIME'); return (a[1]*1000000+a[2])/1000";
        DefaultRedisScript<Long> script = new DefaultRedisScript<>(SCRIPT_TIME , Long.class);
        return (Long)redisTemplate.execute(script, Collections.EMPTY_LIST);
    }

    /**
     * 获取redis当前时间
     */
    public Date getNowDate(){
        Long timeStamp = this.currentTimeMillis();
        return new Date(timeStamp);
    }

    /**
     * 向频道推送消息
     * @param channel
     * @param value
     */
    public void convertSend(final String channel, Object value) {
        redisTemplate.convertAndSend(channel,value);
    }

    /**
     *
     * @Title: set
     * @Description: 写入缓存
     * @param key
     * @param value
     * @return
     * @return: boolean
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     *
     * @Title: increment
     * @Description: 计数
     * @param key
     * @param value
     * @return
     * @return: boolean
     */
    public long increment(final String key, Long value) {
        long result = 0;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            result = operations.increment(key, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     *
     * @Title: set
     * @Description: 写入缓存设置时效时间
     * @param key
     * @param value
     * @param expireTime
     * @return
     * @return: boolean
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }/**
     *
     * @Title: set
     * @Description: 写入缓存设置时效时间
     * @param key
     * @param value
     * @param expireTime
     * @return
     * @return: boolean
     */
    public boolean set(final String key, Object value, Long expireTime,TimeUnit t) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime,t);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     *
     * @Title: remove
     * @Description: 批量删除对应的value
     * @param keys
     * @return: void
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     *
     * @Title: getKeys
     * @Description: 批量获取对应的key
     * @param key
     * @return: Set<String>
     */
    public Set<String> getKeys(String key){
        Set<String> result = redisTemplate.keys(key+"*");
        return result;
    }

    /**
     *
     * @Title: removePattern
     * @Description: 批量删除key
     * @param pattern
     * @return: void
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }

    /**
     *
     * @Title: remove
     * @Description: 删除对应的value
     * @param key
     * @return: void
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     *
     * @Title: exists
     * @Description: 判断缓存中是否有对应的value
     * @param key
     * @return
     * @return: boolean
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     *
     * @Title: get
     * @Description: 读取
     * @param key
     * @return
     * @return: Object
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     *
     * @Title: SetKeyExpireTime
     * @Description: 设置key的过期时间
     * @param key
     * @param expireTime
     * @return: void
     */
    public void SetKeyExpireTime(String key,Long expireTime ) {
        redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
    }

    /**
     *
     * @Title: hmSet
     * @Description: 哈希添加数据
     * @param key
     * @param hashKey
     * @param value
     * @return: void
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     *
     * @Title: hmSize
     * @Description: 哈希获取key数据大小
     * @param key
     * @return
     * @return: Long
     */
    public Long hmSize(String key) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.size(key);
    }

    /**
     *
     * @Title: hmGet
     * @Description: 哈希获取数据
     * @param key
     * @param hashKey
     * @return
     * @return: Object
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     *
     * @Title: hmGet
     * @Description: 通过key+哈希获取集合
     * @param key
     * @param hashKeys
     * @retur
     * @return: List
     */
    public List hmGet(String key, Collection< Object> hashKeys) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.multiGet(key, hashKeys);
    }

    /**
     *
     * @Title: hmGetHshKeys
     * @Description: 获取hashKey的集合
     * @param key
     * @return
     * @return: Set<Object>
     */
    public Set<Object> hmGetHshKeys(String key) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return 	hash.keys(key);
    }

    /**
     *
     * @Title: hmDelete
     * @Description: 哈希删除数据
     * @param key
     * @param hashKeys
     * @return
     * @return: Object
     */
    public Object hmDelete(String key, Object... hashKeys) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.delete(key, hashKeys);
    }

    /**
     *
     * @Title: lPush
     * @Description: 列表添加
     * @param k
     * @param v
     * @return: void
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     *
     * @Title: lPushAll
     * @Description: 列表添加集合
     * @param key
     * @param values
     * @return: void
     */
    public void lPushAll(String key, List<? extends Object> values) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPushAll(key, values);
    }

    /**
     *
     * @Title: lRange
     * @Description: 列表获取
     * @param k
     * @param l
     * @param l1
     * @return
     * @return: List<? extends Object>
     */
    public List<? extends Object> lRange(String k, long l, long l1) {
        ListOperations<String, List<? extends Object>> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     *
     * @Title: add
     * @Description: 集合添加
     * @param key
     * @param value
     * @return: void
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     *
     * @Title: setMembers
     * @Description: 集合获取
     * @param key
     * @return
     * @return: Set<Object>
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }


    /**
     *
     * @Title: zAdd
     * @Description: 有序集合添加
     * @param key
     * @param value
     * @param scoure
     * @return: void
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     *
     * @Title: zAddAll
     * @Description: 一次性添加set集合
     * @param key
     * @param setValue
     * @param scoure
     * @return: void
     */
    public void zAddAll(String key, Set<Object> setValue, double scoure) {
        for(Object object : setValue) {
            zAdd(key, object, scoure);
        }
    }

    /**
     *
     * @Title: rangeByScore
     * @Description: 有序集合获取
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     * @return: Set<Object>
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }

    /**
     *
     * @Title: removeRangeByScore
     * @Description: 根据分数范围删除ZSet集合中的元素（minScoure和maxSource相同，则是根据分数精确删除）
     * @param key
     * @param minScoure
     * @param maxSource
     * @return
     * @return: long
     */
    public long removeRangeByScore(String key, double minScoure, double maxSource) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.removeRangeByScore(key, minScoure, maxSource);
    }

    public void zRemove(String key,Object... values) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.remove(key, values);
    }


    /**
     * 获取 过期时间
     * @param key
     * @param timeUnit
     */
    public Long getKeyExpireTime(String key,TimeUnit timeUnit) {
        return redisTemplate.getExpire(key, timeUnit);
    }
}

Liduomi

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
【Springboot+Redis】

一、配置spring: redis: database: 0 # Redis数据库索引（默认为0） host: 127.0.0.1 # Redis服务器地址 port: 6379 # Redis服务器连接端口 password: # Redis服务器连接密码（默认为空） timeout: 60s # 连接超时时间 lettuce: pool:
复制链接

扫一扫