一、简介

SpringBoot框架中已经集成了redis，在1.x.x的版本时默认使用的jedis客户端，现在是2.x.x版本默认使用的lettuce客户端，两种客户端的区别如下：

Jedis和Lettuce都是Redis Client
Jedis 是直连模式，在多个线程间共享一个 Jedis 实例时是线程不安全的，
如果想要在多线程环境下使用 Jedis，需要使用连接池，
每个线程都去拿自己的 Jedis 实例，当连接数量增多时，物理连接成本就较高了。
Lettuce的连接是基于Netty的，连接实例可以在多个线程间共享，
所以，一个多线程的应用可以使用同一个连接实例，而不用担心并发线程的数量。
当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。
通过异步的方式可以让我们更好的利用系统资源，而不用浪费线程等待网络或磁盘I/O。
Lettuce 是基于 netty 的，netty 是一个多线程、事件驱动的 I/O 框架，
所以 Lettuce 可以帮助我们充分利用异步的优势。

二、jedis客户端模式

1. Maven依赖（先在pom中引入redis及其它jar包）

<!-- spring 1.5之后spring boot 的自带的Jedis的版本就是2.9.0, 低于该版本启动报错 -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

yml配置文件中加入redis相关配置

datasource:
  redis:
    host: localhost
    port: 30539
    database: 13
    password:

Redis工具类编写点击下载

import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import redis.clients.jedis.*;

import javax.annotation.PostConstruct;
import java.lang.reflect.Field;
import java.util.*;

/**
 * redis工具类
 *
 * @author Colin.Ye
 * @version 1.0
 * @ClassName RedisController
 * @date 2018/1/12
 **/
@Component
public class RedisUtil {

    final Logger logger = LoggerFactory.getLogger(getClass());
    /**
     * 数据源
     */
    private ShardedJedisPool shardedJedisPool;

    @Value("${datasource.redis.host}")
    private String host;
    @Value("${datasource.redis.port}")
    private int port;

    @Value("${datasource.redis.database}")
    private int db;

    /**
     * 切换redis库
     *
     * @param jedis
     */
    private void setDb(JedisShardInfo jedis) {
        Class<? extends JedisShardInfo> clz = jedis.getClass();
        Field declaredField = null;
        try {
            declaredField = clz.getDeclaredField("db");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        declaredField.setAccessible(true);
        try {
            declaredField.set(jedis, db);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    @PostConstruct
    public void init() {
        JedisPoolConfig config = new JedisPoolConfig();// Jedis池配置
//      TODO 从配置文件读取配置
//        config.setMaxTotal(Integer.MAX_VALUE); // 最大连接数, 默认8个
        config.setMaxIdle(1000 * 60);// 对象最大空闲时间
        config.setMaxWaitMillis(1000 * 20);// 获取对象时最大等待时间
        config.setTestOnBorrow(false);
//      TODO 根据配置文件线程数量循环创建连接
        List<JedisShardInfo> jdsInfoList = new ArrayList<JedisShardInfo>(1);
        JedisShardInfo infoA = new JedisShardInfo(host, port);
        setDb(infoA);
        jdsInfoList.add(infoA);

        JedisShardInfo infoB = new JedisShardInfo(host, port);
        setDb(infoB);
        jdsInfoList.add(infoB);

        JedisShardInfo infoC = new JedisShardInfo(host, port);
        setDb(infoC);
        jdsInfoList.add(infoC);

        this.shardedJedisPool = new ShardedJedisPool(config, jdsInfoList);
//		jedis = shardedJedisPool.getResource();
    }

    /**
     * 获取数据库连接
     *
     * @return conn
     */
    public ShardedJedis getConnection() {
        ShardedJedis jedis = null;
        try {
            jedis = shardedJedisPool.getResource();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return jedis;
    }

    /**
     * 关闭数据库连接
     *
     * @param conn
     */
    public void closeConnection(ShardedJedis jedis) {
        if (null != jedis) {
            try {
//				shardedJedisPool.returnResource(jedis);
                jedis.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

//	/**
//	 * 获取jedis
//	 * @return
//	 */
//	public ShardedJedis jedis(){
//		return this.jedis;
//	}

    /**
     * 设置数据
     *
     * @param conn
     */
    public boolean setData(String key, String value) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            jedis.set(key, value);
            return true;
        } catch (Exception e) {
            System.out.println(e);
        } finally {
            closeConnection(jedis);
        }
        return false;
    }

    public Long llen(String key) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            Long l = jedis.llen(key);
            return l;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return 0L;
    }

    /**
     * 设置数据
     *
     * @param conn
     */
    public boolean rpush(String key, String value) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            jedis.rpush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return false;
    }

    /**
     * 设置数据
     *
     * @param conn
     */
    public boolean sadd(String key, String value) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            jedis.sadd(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return false;
    }

    /**
     * 获取数据
     *
     * @param conn
     */
    public String getData(String key) {
        String value = null;
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            value = jedis.get(key);
            return value;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return value;
    }

    public boolean isMember(String key, String member) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            boolean result = jedis.sismember(key, member);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return false;
    }

    public Set<String> smembers(String key) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            Set<String> s = jedis.smembers(key);
            return s;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return null;
    }

    /**
     * 获取List集合
     *
     * @param key
     * @param clazz
     * @return
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    public List getListJsonData(String key, Class clazz) {
        List<String> userList = null;
        List list = new ArrayList();
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            userList = jedis.lrange(key, 0, -1);
            for (String str : userList) {
                list.add(JSON.parseObject(str, clazz));
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return list;
    }

    /**
     * 使用rpush方式插入List集合
     *
     * @param key
     * @param clazz
     * @return
     */
    public boolean rpushJsonData(String key, Object o) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            jedis.rpush(key, JSON.toJSONString(o));
            logger.info(o.toString());
            return true;
        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            closeConnection(jedis);
        }
        return false;
    }

    /**
     * 存储map格式数据（map的key和value必须是String）
     *
     * @param key
     * @return
     */
    public boolean hmset(String key, Map<String, String> params) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            jedis.hmset(key, params);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return false;
    }

    /**
     * 查询map格式数据（map的key和value必须是String）
     *
     * @param key
     * @param obj 可以为LIST、SET、数组、字符串
     * @return 返回list集合
     */
    public List<Map<String, String>> hmget(String key, Object obj) {
        ShardedJedis jedis = getConnection();
        String[] array = {};
        String str = null;
        if (obj instanceof String) {
            str = obj.toString().replace(" ", "");
            array = str.split(",");
        } else if (obj instanceof List || obj instanceof Set) {
            str = obj.toString().replace(" ", "");
            str = str.substring(1, str.length() - 1);
            array = str.split(",");
        } else if (obj instanceof String[]) {
            array = (String[]) obj;
        }
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        List<String> cities = jedis.hmget(key, array);
        for (int i = 0; i < array.length; i++) {
            Map<String, String> map = new HashMap<String, String>();
            map.put(array[i], cities.get(i));
            list.add(map);
        }
        closeConnection(jedis);
        return list;
    }

    /**
     * 查询map格式数据（返回所有map）
     *
     * @param key
     * @return 返回list集合
     */
    public Map<String, String> hgetAll(String key) {
        ShardedJedis jedis = getConnection();
        Map<String, String> map = new HashMap<String, String>();
        try {
            map = jedis.hgetAll(key);
            return map;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return map;
    }

    public boolean setJsonData(String key, Object o) {
        ShardedJedis jedis = null;
        try {
            jedis = shardedJedisPool.getResource();
            jedis.set(key, JSON.toJSONString(o));
            logger.info(o.toString());
            return true;
        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            closeConnection(jedis);
        }
        return false;
    }

    @SuppressWarnings("all")
    public Object getJsonData(String key, Class clazz) {
        String value = null;
        ShardedJedis jedis = null;
        try {
            jedis = shardedJedisPool.getResource();
            value = jedis.get(key);
//			shardedJedisPool.returnResource(jedis);
            return JSON.parseObject(value, clazz);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return null;
    }

    public String lpop(final String key) {
        String value = null;
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            value = jedis.lpop(key);
            return value;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return value;
    }

    public Boolean sismember(final String key, final String member) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            Boolean value = jedis.sismember(key, member);
            return value;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return false;
    }

    public Long zadd(final String key, int score, String member) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            Long l = jedis.zadd(key, score, member);
            return l;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }

        return 0L;

    }

    public Set<String> zrevrange(final String key, int start, int end) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            Set<String> s = jedis.zrevrange(key, start, end);
            return s;

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return null;
    }

    public String zrevrangeByscore(final String key) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            Set<String> s = jedis.zrevrangeByScore(key, "+inf", "-inf");
            Iterator<String> it = s.iterator();
            while (it.hasNext()) {
                return (String) it.next();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return null;

    }

    public Set<Tuple> zrevrangeWithScores(final String key, int start, int end) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            Set<Tuple> set = jedis.zrevrangeWithScores(key, start, end);
            return set;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return null;
    }

    public int zincrby(final String key, int score, String member) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            Double d = jedis.zincrby(key, score, member);
            return d.intValue();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return 0;
    }

    public int zscore(final String key, String member) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            Double d = jedis.zscore(key, member);
            if (d == null) {
                return 0;
            }
            return d.intValue();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeConnection(jedis);
        }
        return 0;
    }

    /**
     * 删除数据
     *
     * @param key
     * @return
     */
    public long del(String key) {
        ShardedJedis jedis = null;
        try {
            jedis = getConnection();
            long count = jedis.del(key);
            return count;
        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            closeConnection(jedis);
        }
        return 0;
    }

    /**
     * 设置过期时间
     *
     * @param key
     * @param seconds 秒
     * @return
     */
    public boolean expire(String key, int seconds) {
        ShardedJedis jedis = null;
        try {
            jedis = shardedJedisPool.getResource();
            jedis.expire(key, seconds);
            return true;
        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            closeConnection(jedis);
        }
        return false;
    }


    /**
     * 设置连接池
     *
     * @return 数据源
     */
    public void setShardedJedisPool(ShardedJedisPool shardedJedisPool) {
        this.shardedJedisPool = shardedJedisPool;
    }

    /**
     * 获取连接池
     *
     * @return 数据源
     */
    public ShardedJedisPool getShardedJedisPool() {
        return shardedJedisPool;
    }
}

三、lettuce客户端模式

1. Maven依赖（先在pom中引入redis及其它jar包）

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.4.2</version>
</dependency>

yml配置文件中加入redis相关配置

spring:
  redis:
    host: localhost # Redis服务器地址
    port: 30539 # Redis服务器连接端口
    database: 13 # Redis数据库索引（默认为0）
    password: # Redis服务器连接密码（默认为空）
    timeout: 10000ms # 连接超时时间（毫秒）
    lettuce:
      pool:
        max-active: 200 # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1ms # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 10 # 连接池中的最大空闲连接
        min-idle: 0 # 连接池中的最小空闲连接

Redis配置类编写点击下载
SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate。但是，这个RedisTemplate的泛型是<Object,Object>，写代码不方便，需要写好多类型转换的代码；我们需要一个泛型为<String,Object>形式的RedisTemplate。并且，这个RedisTemplate没有设置数据存在Redis时，key及value的序列化方式。

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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * redis配置类
 *
 * @author Colin.Ye
 * @version 1.0
 * @ClassName RedisConfig
 * @date 2019/8/22
 **/
@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

Redis工具类编写点击下载

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类
 *
 * @author Colin.Ye
 * @version 1.0
 * @ClassName RedisUtil
 * @date 2019/8/22
 **/
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // =============================common============================

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    // ============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================Map=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     *              //     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     *              //     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

借鉴文章如下:
SpringBoot整合Redis及Redis工具类撰写
 spring boot 集成 redis lettuce

SpringBoot整合Redis及工具类编写

一、简介

二、jedis客户端模式

三、lettuce客户端模式

相关文章