Spring Boot 2.1.3 RedisTemplate 概述与操作 Redis 5 种数据类型

爱被打了一巴掌 2023-06-16 10:52 3阅读 0赞

**目录**

RedisTemplate 概述

Redis 依赖 与 配置

字符串(String) 处理

列表(List) 处理

哈希(Hash) 处理

集合(Set) 处理

有序集合(sorted set)

切换 Jedis 实现

--------------------

# RedisTemplate 概述 #

1、Redis 是一个缓存、消息代理和功能丰富的键值存储。Spring Boot 为[Lettuce][] 和[Jedis][] 客户端库提供基本的自动配置，并为 [Spring Data Redis][] 提供抽象。[官网传送][Link 1]。

2、spring-boot-starter-data-redis 启动器，整合了需要的依赖项，默认情况下，它使用 [Lettuce][] 作为客户端。这个启动器同时处理传统应用程序和反应性应用程序(reactive applications)。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly93YW5nbWFveGlvbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

3、官方还提供了一个 spring-boot-starter-data-redis-reactive 启动器，用于与具有 reactive 支持的其他存储保持一致。

4、可以像注入任何其他 Spring Bean 一样注入一个自动配置的 RedisConnectionFactory、StringRedisTemplate 或普通的 RedisTemplate 实例。class StringRedisTemplate extends RedisTemplate<String, String>

5、默认情况下，Redis 实例尝试连接本地主机（localhost）端口为 6379 的 Redis 服务器,默认使用空密码，连接 0 号数据库：

REDIS [(RedisProperties)][RedisProperties]

spring.redis.cluster.max-redirects= # Maximum number of redirects to follow when executing commands across the cluster.
    spring.redis.cluster.nodes= # Comma-separated list of "host:port" pairs to bootstrap from.
    spring.redis.database=0 # Database index used by the connection factory.
    spring.redis.url= # Connection URL. Overrides host, port, and password. User is ignored. Example: redis://user:password@example.com:6379
    spring.redis.host=localhost # Redis server host.
    spring.redis.jedis.pool.max-active=8 # Maximum number of connections that can be allocated by the pool at a given time. Use a negative value for no limit.
    spring.redis.jedis.pool.max-idle=8 # Maximum number of "idle" connections in the pool. Use a negative value to indicate an unlimited number of idle connections.
    spring.redis.jedis.pool.max-wait=-1ms # Maximum amount of time a connection allocation should block before throwing an exception when the pool is exhausted. Use a negative value to block indefinitely.
    spring.redis.jedis.pool.min-idle=0 # Target for the minimum number of idle connections to maintain in the pool. This setting only has an effect if it is positive.
    spring.redis.lettuce.pool.max-active=8 # Maximum number of connections that can be allocated by the pool at a given time. Use a negative value for no limit.
    spring.redis.lettuce.pool.max-idle=8 # Maximum number of "idle" connections in the pool. Use a negative value to indicate an unlimited number of idle connections.
    spring.redis.lettuce.pool.max-wait=-1ms # Maximum amount of time a connection allocation should block before throwing an exception when the pool is exhausted. Use a negative value to block indefinitely.
    spring.redis.lettuce.pool.min-idle=0 # Target for the minimum number of idle connections to maintain in the pool. This setting only has an effect if it is positive.
    spring.redis.lettuce.shutdown-timeout=100ms # Shutdown timeout.
    spring.redis.password= # Login password of the redis server.
    spring.redis.port=6379 # Redis server port.
    spring.redis.sentinel.master= # Name of the Redis server.
    spring.redis.sentinel.nodes= # Comma-separated list of "host:port" pairs.
    spring.redis.ssl=false # Whether to enable SSL support.
    spring.redis.timeout= # Connection timeout.

6、可以实现 LettuceClientConfigurationBuilderCustomizer 接口，以实现更高级的定制。如果使用的是 Jedis 客户端，则实现 JedisClientConfigurationBuilderCustomizer 接口。

<table> 
 <tbody> 
  <tr> 
   <td>RedisTemplate 默认自己的序列化速度并不理想，实际生产中遇到一次需要将数据库查出来的一个 List 对象放到 Redis 中，当时数据量达到 20 万行，结果 put 的时间长达 6、7 秒，然后当使用 alibaba 的 fastjson 先将 List 对象序列化为字符串，然后在 put 到缓存，此时时间降到了 100 毫秒内，而 fastjson 序列化同样非常之快。取值时，同样将取出的字符串使用 fastjosn 反序列化成 List 即可。</td> 
  </tr> 
 </tbody> 
</table>

7、[Redis 三个客户端框架：Jedis、Redisson、Lettuce 对比。][Redis _Jedis_Redisson_Lettuce]

# Redis 依赖 与 配置 #

RedisAutoConfiguration 中已经自动将 RedisTemplate 添加到了容器中，直接获取使用即可.

1、RedisTemplate 对 lettuce 与 Jedis 封装之后，使用更加简单，如同使用 JDBCTemplate 对 JDBC 进行了封装。封装之后不需要再关心打开与关闭连接等繁琐的操作，而且它提供性能更好的连接池等。

2、本文环境 Spring Boot 2.1.3 + Java JDK 1.8，pom.xml 文件中导入依赖，然后在需要地方直接注入 RedisTemplate 或者 StringRedisTemplate 使用即可：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    
    
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.7.0</version>
    </dependency>

3、全局配置文件配置 Redis 如下，连接本地没有设置密码的 Redis 服务器：

#Redis 配置，以下除了 timeout 外全部为默认配置.
    spring:
      redis:
        host: localhost
        port: 6379
        database: 0
        password:
        timeout: 10000
        lettuce:
          pool:
            max-active: 8
            max-idle: 8
            min-idle: 0
            max-wait: -1ms

3、Redis 支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)，RedisTemplate 分别提供了对应的 API 进行操作它们。

# [字符串(String) 处理][String_] #

org.springframework.data.redis.core.ValueOperations 处理 String 类型数据:

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>set(K key, V value)</td> 
   <td>存储到 redis。key 已经存在时，覆盖旧值，不存在时新增。key、value 不能为 null</td> 
  </tr> 
  <tr> 
   <td>set(K key, V value, long timeout, TimeUnit unit)</td> 
   <td>设置失效时间为指定时间。超过后 key 会被移除</td> 
  </tr> 
  <tr> 
   <td>set(K key, V value, Duration timeout)</td> 
   <td>设置超时时间，Duration 是 Jdk 8 的 API。超过指定时间后，key 被移除</td> 
  </tr> 
  <tr> 
   <td>set(K key, V value, long offset)</td> 
   <td>覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始</td> 
  </tr> 
  <tr> 
   <td>get(Object key)</td> 
   <td>获取指定 key 的 value，key 不存在时，返回 null。key 不能 null</td> 
  </tr> 
  <tr> 
   <td>getAndSet(K key, V value)</td> 
   <td>获取 key 的旧值，并赋值新的 value。key 不能 null</td> 
  </tr> 
  <tr> 
   <td>get(K key, long start, long end)</td> 
   <td>获取指定 key 指定范围的字符串 [start,end]，从索引 0 开始。key 不能 null</td> 
  </tr> 
  <tr> 
   <td>append(K key, String value)</td> 
   <td>将新的 value 追加到 key 的旧值尾部，key 不存在时，自动新建。key 不能为 null。</td> 
  </tr> 
  <tr> 
   <td>Long size(K key)</td> 
   <td>获取 key 的 value 的长度，key 不存在时，返回 0。key 不能为 null。</td> 
  </tr> 
  <tr> 
   <td> <p>Boolean setIfAbsent(K key, V value)</p> </td> 
   <td>如果 key 不存在，则新增，否则不改变原来的值。其余重载方法与 set 方法对应。key、value 不能为 null。</td> 
  </tr> 
  <tr> 
   <td>Boolean setIfAbsent(K key, V value, long timeout, TimeUnit unit)<br> Boolean setIfAbsent(K key, V value, Duration timeout)</td> 
   <td>1、key 不存在时进行设值，返回 true; 否则 key 存在时，不进行设值，返回 false.<br> 2、此方法相当于先设置 key，然后设置 key 的过期时间，它的操作是原子性的，是事务安全的。<br> 3、相当于：SET anyLock unique_value NX PX 30000，NX是指如果key不存在就成功，key存在返回false，PX可以指定过期时间</td> 
  </tr> 
  <tr> 
   <td>Boolean setIfPresent(K key, V value, Duration timeout)</td> 
   <td>key 存在时，才修改它的值，否则不新增，与 setIfAbsent 相反。</td> 
  </tr> 
  <tr> 
   <td>Long increment(K key)</td> 
   <td>将存储为字符串值的整数值增加1，并返回结果。key 不存在时自动新增</td> 
  </tr> 
  <tr> 
   <td>Long increment(K key, long delta)</td> 
   <td>将存储为字符串值的整数值增加 delta，并返回结果。key 不存在时自动新增。delta 为负数时，做减法</td> 
  </tr> 
  <tr> 
   <td>Double increment(K key, double delta)</td> 
   <td>将存储为字符串值的小数值增加 delta，并返回结果。key 不存在时自动新增</td> 
  </tr> 
  <tr> 
   <td>Long decrement(K key)</td> 
   <td>将存储为字符串的整数值减1，key 不存在时自动创建</td> 
  </tr> 
  <tr> 
   <td>Long decrement(K key, long delta)</td> 
   <td>减去指定的数值，key 不存在时自动创建。delta</td> 
  </tr> 
  <tr> 
   <td>List multiGet(Collection keys)</td> 
   <td>同时获取多个 key 的值，按请求的 key 的顺序返回对应的 value，key 不存在的返回 null。</td> 
  </tr> 
  <tr> 
   <td>multiSet(Map&lt;? extends K, ? extends V&gt; map)</td> 
   <td>同时存储多个 key-value</td> 
  </tr> 
  <tr> 
   <td>Boolean multiSetIfAbsent(Map&lt;? extends K, ? extends V&gt; map)</td> 
   <td>当 key 不存在时新增，否则进行操作。</td> 
  </tr> 
 </tbody> 
</table>

[ValueOperations源码。][ValueOperations]

本文演示源码：[https://gitee.com/wangmx1993/wmx-redis/blob/master/src/test/java/com/wmx/wmxredis/RedisTest.java][https_gitee.com_wangmx1993_wmx-redis_blob_master_src_test_java_com_wmx_wmxredis_RedisTest.java]

import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.data.redis.core.*;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import javax.annotation.Resource;
    import java.time.Duration;
    import java.util.*;
    import java.util.concurrent.TimeUnit;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class RedisStuWebApplicationTests {
    
        //注入 RedisTemplate 或者 StringRedisTemplate 其中一个即可，前者是后者的父类，它们都已经默认在 Spring 容器中了。
        //org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration 中已经自动将 RedisTemplate 添加到了容器中，直接获取使用即可.
        @Resource
        private RedisTemplate redisTemplate;
    
        @Resource
        private StringRedisTemplate stringRedisTemplate;
    
        //org.springframework.data.redis.core.ValueOperations 处理 String 类型数据
        @Test
        public void test1() {
            redisTemplate.getConnectionFactory().getConnection().flushAll();//清空 redis 所有缓存的数据。
            ValueOperations<String, String> valueOperations = stringRedisTemplate.opsForValue();
            valueOperations.set("user.name", "张无忌 ");//添加值
            valueOperations.set("upload.process", "65", 60, TimeUnit.SECONDS);//添加值，失效时间60秒
            valueOperations.set("user.status", "online", Duration.ofSeconds(20));//添加值，失效时间20秒
    
            String user_name = valueOperations.get("user.name");//取值
            String upload_process = valueOperations.get("upload.process");//取值
            String user_status = valueOperations.get("user.status");//取值
            String user_status2 = valueOperations.get("user.status", 2, 4);//取值，截取子符串
            //输出：张无忌 , 65, online, lin
            System.out.println(user_name + ", " + upload_process + ", " + user_status + ", " + user_status2);
    
            Integer hello = valueOperations.append("user.hit", "Hello");//为末尾追加值
            String hit1 = valueOperations.get("user.hit");//取值
            Integer hello2 = valueOperations.append("user.hit", " World");//为末尾追加值
            String hit2 = valueOperations.get("user.hit");//取值
            Long size = valueOperations.size("user.hit");//字符串的长度
            //输出：5 - Hello, 11 - Hello World
            System.out.println(hello + " - " + hit1 + ", " + hello2 + " - " + hit2 + ", " + size);
    
            //key 不存在时，才进行添加
            Boolean aBoolean1 = valueOperations.setIfAbsent("name", "三丰", 60, TimeUnit.SECONDS);
            Boolean aBoolean2 = valueOperations.setIfAbsent("name", "四喜", 60, TimeUnit.SECONDS);
            System.out.println(aBoolean1 + ", " + aBoolean2 + ", " + valueOperations.get("name"));//输出：true, false, 三丰
    
            //key 存在时，才进行添加
            Boolean age1 = valueOperations.setIfPresent("age", "45", Duration.ofSeconds(60));
            valueOperations.set("age", "35");
            Boolean age2 = valueOperations.setIfPresent("age", "55", Duration.ofSeconds(60));
            System.out.println(age1 + ", " + age2 + ", " + valueOperations.get("age"));//输出：false, true, 55
    
            valueOperations.set("l1", "1", Duration.ofSeconds(60));
            valueOperations.set("d1", "3.14", Duration.ofSeconds(60));
            valueOperations.set("total", "100", Duration.ofSeconds(60));
            Long count1 = valueOperations.increment("l1");//数值做加法
            Long count2 = valueOperations.increment("l1", 10L);
            Double d1 = valueOperations.increment("d1", 40.00);
            Long total1 = valueOperations.decrement("total");//数值做减法
            Long total2 = valueOperations.decrement("total2", 35);
            System.out.println(count1 + ", " + count2 + ", " + d1 + ", " + total1 + ", " + total2);//输出：2, 12, 43.14, 99, 64
    
            List<String> keyList = new ArrayList<>();
            keyList.add("l1");
            keyList.add("d1");
            keyList.add("f1");
            List<String> list = valueOperations.multiGet(keyList);//同时获取多个 key 的 value
            System.out.println(list);//[12, 43.140000000000001, null]
    
            Map<String, String> dataMap = new LinkedHashMap<>();
            dataMap.put("multi_name", "雄霸");
            dataMap.put("multi_age", "44");
            valueOperations.multiSet(dataMap);//同时设置多个key-value
            //输出：[雄霸, 44]
            System.out.println(valueOperations.multiGet(Arrays.asList(new String[]{"multi_name", "multi_age"})));
        }
    }

# [列表(List) 处理][List_] #

org.springframework.data.redis.core.ListOperations 处理 List 类型数据：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Long size(K key)</td> 
   <td>返回存储在键中的列表的长度。键不存在时，返回 0；key 存储的值不是列表时返回错误。</td> 
  </tr> 
  <tr> 
   <td>Long leftPush(K key, V value</td> 
   <td>将指定的值插入到列表的头部。键不存在自动创建。（从左边插入）。返回 list 的大小(size)。</td> 
  </tr> 
  <tr> 
   <td>Long leftPushAll(K key, V... values)</td> 
   <td>批量从左插入。key 不能为 null。返回 list 的大小(size)。</td> 
  </tr> 
  <tr> 
   <td>Long leftPushAll(K key, Collection values)</td> 
   <td>批量从左插入。key，values 不能为 null。</td> 
  </tr> 
  <tr> 
   <td>Long leftPush(K key, V pivot, V value)</td> 
   <td>对于名字为 key 的 list，从左往右先查询第一个出现的 pivot 元素，然后将 value 插入到它的左边。</td> 
  </tr> 
  <tr> 
   <td>Long leftPushIfPresent(K key, V value)</td> 
   <td>只有当 key 存在时，才新增，否则不处理。</td> 
  </tr> 
  <tr> 
   <td>Long rightPush(K key, V value)</td> 
   <td>右侧插入，key 不存在时，自动创建</td> 
  </tr> 
  <tr> 
   <td>Long rightPush(K key, V pivot, V value)</td> 
   <td>从左往右查找第一个 pivot 元素，然后将新的 value 插入到它的右侧。</td> 
  </tr> 
  <tr> 
   <td>Long rightPushAll(K key, Collection values)</td> 
   <td>右侧批量插入</td> 
  </tr> 
  <tr> 
   <td>Long rightPushAll(K key, V... values)</td> 
   <td>右侧批量插入</td> 
  </tr> 
  <tr> 
   <td>Long rightPushIfPresent(K key, V value)</td> 
   <td>当 key 存在时，进行右侧插入，否则不处理。</td> 
  </tr> 
  <tr> 
   <td>set(K key, long index, V value)</td> 
   <td>为名字为 key 的列表索引为 index 的元素替换为新的 value 值。key 必须存在，index 索引不能越界</td> 
  </tr> 
  <tr> 
   <td>Long remove(K key, long count, Object value)</td> 
   <td>删除列表(key) 中指定个数(count)的元素(value)。count=0：删除所有 value；count&gt;0：从左往右删除 count 个 value；count&lt;0，从右往左删除。</td> 
  </tr> 
  <tr> 
   <td>List range(K key, long start, long end)</td> 
   <td>查询 list 的元素值，索引范围为 [start,end]，-1 表示倒数第一个元素</td> 
  </tr> 
  <tr> 
   <td>V index(K key, long index)</td> 
   <td>获取列表中指定索引处的元素。index 越界时，返回 null；key 不存在时，返回 null。索引 index=-1 表示倒数第一个元素。</td> 
  </tr> 
  <tr> 
   <td>V leftPop(K key)</td> 
   <td>弹出最左边的元素，弹出之后该值在列表中将不复存在。当列表为空时，返回 null。</td> 
  </tr> 
  <tr> 
   <td>V rightPop(K key)</td> 
   <td>弹出最右边的元素，弹出之后该值在列表中将不复存在。当列表为空时，返回 null。</td> 
  </tr> 
  <tr> 
   <td>V leftPop(K key, long timeout, TimeUnit unit)</td> 
   <td>弹出最左边的元素，当元素不存在时，线程阻塞等待，直到存在新元素，或者超时抛出异常</td> 
  </tr> 
  <tr> 
   <td>V rightPop(K key, long timeout, TimeUnit unit)</td> 
   <td>弹出最右边的元素，当元素不存在时，线程阻塞等待，直到存在新元素，或者超时抛出异常</td> 
  </tr> 
 </tbody> 
</table>

[ListOperations 源码。][ListOperations]

//org.springframework.data.redis.core.ListOperations 处理 List 类型数据
        @Test
        public void test2() {
            redisTemplate.getConnectionFactory().getConnection().flushAll();//清空 redis 所有缓存的数据。
            ListOperations<String, String> opsForList = stringRedisTemplate.opsForList();
            Long aLong1 = opsForList.leftPush("list_1", "USA");//将值添加到 list 头部
            Long aLong2 = opsForList.leftPush("list_1", "China");//将值添加到 list 头部
            Long aLong3 = opsForList.leftPushAll("list_1", new String[]{"Java", "C++", "USA", "WPF"});//将多个值添加到 list 头部
            Long size = opsForList.size("list_1");//获取 list 大小
            Long aLong4 = opsForList.leftPush("list_1", "Java", "C#");//将值添加到 list 头部
            Long aLong5 = opsForList.rightPush("list_1", "USA", "Tomcat");//将值添加到 list 头部
            //输出：1, 2, 6, 7, 8, 6
            System.out.println(aLong1 + ", " + aLong2 + ", " + aLong3 + ", " + aLong4 + ", " + aLong5 + ", " + size);
            System.out.println(opsForList.range("list_1", 0, -1));//输出：[WPF, USA, Tomcat, C++, C#, Java, China, USA]
    
            Long aLong = opsForList.leftPushIfPresent("list_2", "Apple");//当 key 存在时，才进行添加
            System.out.println(aLong + ", " + aLong5);//0, 8
    
            opsForList.rightPush("list_2", "2019");//将值添加到 list 尾部
            opsForList.rightPush("list_2", "2018");
            opsForList.rightPush("list_2", "2017");
            opsForList.set("list_2", 1, "2008");
            System.out.println(opsForList.range("list_2", 0, -1));//获取指定索引范围的值，[2019, 2008, 2017]
    
            //同时将多个值添加到右侧
            opsForList.rightPushAll("list_3", new String[]{"mysql", "oracle", "sql server", "redis", "oracle", "sql server", "redis", "oracle"});
            System.out.println(opsForList.range("list_3", 0, -1));//输出：[mysql, oracle, sql server, redis, oracle, sql server, redis, oracle]
            //删除 list 中所有的 "sql server" 值
            Long remove1 = opsForList.remove("list_3", 0, "sql server");//2 - [mysql, oracle, redis, oracle, redis, oracle]
            System.out.println(remove1 + " - " + opsForList.range("list_3", 0, -1));
            //从右往左删除第一次出现的 redis 值
            Long remove2 = opsForList.remove("list_3", -1, "redis");//1 - [mysql, oracle, redis, oracle, oracle]
            System.out.println(remove2 + " - " + opsForList.range("list_3", 0, -1));
            //从左往右删除第一次、第二次出现的 oracle 值
            Long remove3 = opsForList.remove("list_3", 2, "oracle");//2 - [mysql, redis, oracle]
            System.out.println(remove3 + " - " + opsForList.range("list_3", 0, -1));
    
            opsForList.rightPushAll("list_4", new String[]{"mysql", "oracle", "redis", "DB2"});
            String index1 = opsForList.index("list_4", -1);//查询倒数第一个元素
            String leftPop1 = opsForList.leftPop("list_4");//弹出头部第一个元素
            String rightPop1 = opsForList.rightPop("list_4");//弹出尾部第一个元素
            System.out.println(index1 + ", " + leftPop1 + ", " + rightPop1);//DB2, mysql, DB2
    
            opsForList.rightPushAll("list_5", new String[]{"Python", "C#", "Java"});
            for (int i = 0; i < 4; i++) {
                //弹出头部元素，当超过60秒还没有元素时，抛出异常 RedisCommandTimeoutException
                //System.out.println(opsForList.leftPop("list_5", 60, TimeUnit.SECONDS));//可以手动通过 redis 客户添加元素：lpush list_5 wmx
            }
        }

# [哈希(Hash) 处理][Hash_] #

org.springframework.data.redis.core.HashOperations 处理 Hash 类型数据：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Long size(H key)</td> 
   <td>获取指定 hash(key) 的元素个数，kye 不存在时，返回 0</td> 
  </tr> 
  <tr> 
   <td>Boolean hasKey(H key, Object hashKey)</td> 
   <td>判断 hash 中 是否存在指定的元素,key 不存在时，返回 false</td> 
  </tr> 
  <tr> 
   <td>Set keys(H key)</td> 
   <td>获取指定 hash(key) 中所有的 hashKey。key 不存在时，返回空集合[].</td> 
  </tr> 
  <tr> 
   <td>List values(H key)</td> 
   <td>获取指定 hash(key) 的所有值。key 不存在时，返回空 list</td> 
  </tr> 
  <tr> 
   <td>Long delete(H key, Object... hashKeys)</td> 
   <td>删除指定的 hash(key) 中指定的元素(hansKeys)，返回成功删除元素个数，key 不存在时返回 0</td> 
  </tr> 
  <tr> 
   <td>void put(H key, HK hashKey, HV value)</td> 
   <td>往 key 中插入键值对 hashKey-value。hashKey 重复时，后插入的覆盖旧值。key 不存在时，自动新增</td> 
  </tr> 
  <tr> 
   <td>void putAll(H key, Map&lt;? extends HK, ? extends HV&gt; m)</td> 
   <td>单次插入多个元素。key 不存在时自动新增</td> 
  </tr> 
  <tr> 
   <td>Boolean putIfAbsent(H key, HK hashKey, HV value)</td> 
   <td>key 或者 hashKey 不存在时，才插入值</td> 
  </tr> 
  <tr> 
   <td>HV get(H key, Object hashKey)</td> 
   <td>获取 hash 中指定的 hashKey，key 不存在时，返回 null.</td> 
  </tr> 
  <tr> 
   <td>Map&lt;HK, HV&gt; entries(H key)</td> 
   <td>获取指定 key 的 hash map。key 不存在时，返回空 map。</td> 
  </tr> 
  <tr> 
   <td>Long lengthOfValue(H key, HK hashKey)</td> 
   <td>获取 key 对应的 hash map 的 hashKey 对应的元素值的长度</td> 
  </tr> 
  <tr> 
   <td>List multiGet(H key, Collection hashKeys)</td> 
   <td>同时获取 key 对应的 hash map 中的多个元素值，hashKey 不存在时，返回 null</td> 
  </tr> 
  <tr> 
   <td>Long increment(H key, HK hashKey, long delta)</td> 
   <td>为指定 key 的 hash map 中的元素 hashKey 的数值加上整数值 delta。key 不存在时，直接新增。</td> 
  </tr> 
  <tr> 
   <td>Double increment(H key, HK hashKey, double delta)</td> 
   <td>为指定 key 的 hash map 中的元素 hashKey 的数值加上浮点数值 delta。key 不存在时，直接新增</td> 
  </tr> 
 </tbody> 
</table>

[HashOperations 源码。][HashOperations]

//org.springframework.data.redis.core.HashOperations 处理 hash 数据类型
        @Test
        public void test3() {
            redisTemplate.getConnectionFactory().getConnection().flushAll();//清空 redis 所有缓存的数据。
    
            HashOperations<String, Object, Object> opsForHash = stringRedisTemplate.opsForHash();
            Long delete = opsForHash.delete("hash_1", "name", "age");//删除指定元素
            Boolean hasKey = opsForHash.hasKey("hash_1", "name");//判断是否含有指定的元素
            Object name1 = opsForHash.get("hash_1", "name");//获取指定的元素
            Set<Object> keys = opsForHash.keys("hash_1");//获取所有的 key
            Long hash_1 = opsForHash.size("hash_1");//获取 hash 的大小
            System.out.println(delete + ", " + hasKey + ", " + name1 + ", " + keys + ", " + hash_1);//输出：0, false, null, [], 0
    
            Map<String, String> dataMap = new HashMap<>();
            dataMap.put("age", "33");
            dataMap.put("name", "Li Si");
            dataMap.put("address", "人民东路45号");
            opsForHash.put("hash_1", "name", "Zan San");//为 hash 添加单个元素
            opsForHash.putAll("hash_1", dataMap);//为 hash 添加多个元素
            opsForHash.putIfAbsent("hash_2", "name", "Chang Sha");//当 key 或者 hashKey 不存在时，才插入值
    
            List<Object> list = opsForHash.values("hash_1");//获取所有的 values
            Map<Object, Object> entries = opsForHash.entries("hash_1");//获取整个 hash
            Long lengthOfValue1 = opsForHash.lengthOfValue("hash_1", "name");//获取元素的长度
            Long lengthOfValue2 = opsForHash.lengthOfValue("hash_1", "age");
            List<Object> multiGet = opsForHash.multiGet("hash_1", Arrays.asList(new String[]{"name", "address", "birthday"}));//同时获取多个元素值
    
            //[Li Si, 人民东路45号, 33], {name=Li Si, address=人民东路45号, age=33}, 5, 2, [Li Si, 人民东路45号, null]
            System.out.println(list + ", " + entries + ", " + lengthOfValue1 + ", " + lengthOfValue2 + ", " + multiGet);
    
            Long increment_age1 = opsForHash.increment("hash_1", "age", 20);//数值元素做加法
            Double increment_age2 = opsForHash.increment("hash_1", "age", 20.45D);
            System.out.println(increment_age1 + ", " + increment_age2);//53, 73.45
        }

# [集合(Set) 处理][Set_] #

org.springframework.data.redis.core.SetOperations 处理无序集合(Set) 类型数据：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Long add(K key, V... values)</td> 
   <td>往 set 中添加元素，key 不存在时，自动新建。value 重复时，覆盖旧值。返回 set 中的元素个数</td> 
  </tr> 
  <tr> 
   <td>Long remove(K key, Object... values)</td> 
   <td>移除 set 中的元素。返回 set 中剩余的元素个数.</td> 
  </tr> 
  <tr> 
   <td>Boolean move(K key, V value, K destKey)</td> 
   <td>将 key 对应的 set 中的值 value 剪切到目标 set(destKey) 中。key、value、destKey 不存在时，不做任何操作.</td> 
  </tr> 
  <tr> 
   <td>V pop(K key)</td> 
   <td>随机弹出 set 中的一个元素，弹出后，set 中就没有了。当 set 为空时，返回 null.</td> 
  </tr> 
  <tr> 
   <td>List pop(K key, long count)</td> 
   <td>随机弹出 set 中 count 个元素，如果 set 的大小为 3，而 count 为 5，此时只会返回 3 个元素。</td> 
  </tr> 
  <tr> 
   <td>Long size(K key)</td> 
   <td>获取 key 对应 set 的集合大小. key 不存在时，返回 0</td> 
  </tr> 
  <tr> 
   <td>Set members(K key)</td> 
   <td>获取 set 中所有的元素，key 不存在时，返回空 set.</td> 
  </tr> 
  <tr> 
   <td>V randomMember(K key)</td> 
   <td>从 set 中随机返回一个元素，set 中此元素还会存在。key 不存在时，返回 null.</td> 
  </tr> 
  <tr> 
   <td>List randomMembers(K key, long count)</td> 
   <td>随机返回 set 中 count 个元素。</td> 
  </tr> 
  <tr> 
   <td>Boolean isMember(K key, Object o)</td> 
   <td>判断 key 对应的 set 中是否包含元素 o。key 不存在时，返回 false。</td> 
  </tr> 
  <tr> 
   <td>Set union(K key, K otherKey)</td> 
   <td>获取 key 与 otherKey 对应的 set 的并集。旧值不受影响，返回合并后的值。</td> 
  </tr> 
  <tr> 
   <td>Set union(K key, Collection otherKeys)</td> 
   <td>获取多个 set 的并集</td> 
  </tr> 
  <tr> 
   <td>Long unionAndStore(K key, K otherKey, K destKey)</td> 
   <td>求 key 、otherKey 的 set 并集，并将结果添加到 destKey 中。destKey 不存在时，自动创建。返回新集合中的元素个数。当 destKey 中事先已经有值，则会被先清除。</td> 
  </tr> 
  <tr> 
   <td>Long unionAndStore(K key, Collection otherKeys, K destKey)</td> 
   <td>将多个 set 的并集结果放入到 destKey 对应的 set 中，destKey 不存在时，自动创建。当 destKey 中事先已经有值，则会被先清除。</td> 
  </tr> 
  <tr> 
   <td>Set difference(K key, K otherKey)</td> 
   <td>求 key 与 otherKey 对应的 set 的差集，key 减去 otherKey 后剩余的结果。</td> 
  </tr> 
  <tr> 
   <td>Set difference(K key, Collection otherKeys)</td> 
   <td>获取 key 与所有 otherKeys 的差集。</td> 
  </tr> 
  <tr> 
   <td>Long differenceAndStore(K key, K otherKey, K destKey)</td> 
   <td>将差集结果放入到 destKey 中。当 destKey 中事先已经有值，则会被先清除。</td> 
  </tr> 
  <tr> 
   <td>Long differenceAndStore(K key, Collection otherKeys, K destKey)</td> 
   <td>将差集结果放入到 destKey 中。当 destKey 中事先已经有值，则会被先清除。</td> 
  </tr> 
  <tr> 
   <td>Set intersect(K key, K otherKey)</td> 
   <td>获取 key 与 otherKey 的交集，双方都拥有的元素</td> 
  </tr> 
  <tr> 
   <td>Set intersect(K key, Collection otherKeys)</td> 
   <td>获取 key 与其它所有 otherKeys 的交集</td> 
  </tr> 
  <tr> 
   <td>Long intersectAndStore(K key, K otherKey, K destKey)</td> 
   <td>将交集结果放到 destKey 集合中。当 destKey 中事先已经有值，则会被先清除。</td> 
  </tr> 
  <tr> 
   <td>Long intersectAndStore(K key, Collection otherKeys, K destKey)</td> 
   <td>将交集结果放到 destKey 集合中。当 destKey 中事先已经有值，则会被先清除。</td> 
  </tr> 
 </tbody> 
</table>

[SetOperations 源码。][SetOperations]

//org.springframework.data.redis.core.SetOperations 处理 Set 类型数据：
        @Test
        public void test4() {
            stringRedisTemplate.getConnectionFactory().getConnection().flushAll();//情况所有缓存数据
            SetOperations<String, String> opsForSet = stringRedisTemplate.opsForSet();
            Long add = opsForSet.add("set_1", "C", "Java", "Python");//往集合添加元素
            Long remove = opsForSet.remove("set_1", "C");//删除元素
            String set_1 = opsForSet.pop("set_1");//随机弹出 set 中的一个元素
            System.out.println(add + ", " + remove + ", " + set_1);//3, 1, Python
    
            opsForSet.add("set_2", "华山", "泰山", "衡山");
            Set<String> set_2 = opsForSet.members("set_2");//查询 set 中的所有元素
            opsForSet.move("set_1", "Java", "set_2");
            System.out.println(set_2);//[泰山, 衡山, 华山]
            Long size = opsForSet.size("set_2");//获取 set 的大小
            System.out.println(opsForSet.members("set_2") + ", " + size);//[泰山, 衡山, 华山], 3
    
            Boolean member1 = opsForSet.isMember("set_2", "泰山");//判断 set 中是否含义指定的元素值
            Boolean member2 = opsForSet.isMember("set_2", "嵩山");
            System.out.println(member1 + ", " + member2);//true, false
    
            opsForSet.add("set_3", "Oracle", "Mysql", "DB2", "H2", "Sql Server");
            List<String> set_3 = opsForSet.pop("set_3", 3);
            System.out.println(set_3);//[Oracle, DB2, Mysql]
    
            opsForSet.add("set_4", "段誉", "乔峰", "虚竹", "王语嫣", "慕容复");
            System.out.println(opsForSet.members("set_4") + ", " + opsForSet.randomMember("set_41"));
            System.out.println(opsForSet.randomMembers("set_4", 3));//随机弹出 set 中指定个数的元素，如随机弹出其中3个元素
    
            opsForSet.add("set_5_1", "a", "b", "c", "1", "2", "3");
            opsForSet.add("set_5_2", "x", "y", "c", "21", "2", "3");
            Set<String> union1 = opsForSet.union("set_5_1", "set_5_2");//两个集合求并集
            System.out.println(opsForSet.members("set_5_1") + ", " + opsForSet.members("set_5_2"));
            System.out.println(union1);//[3, a, x, c, b, 2, 21, 1, y]
    
            //多个集合求并集
            Set<String> set_5_1 = opsForSet.union("set_5_1", Arrays.asList(new String[]{"set_5_2", "set_4"}));
            System.out.println(set_5_1);//[王语嫣, 段誉, 21, a, 3, 虚竹, x, b, c, 慕容复, 1, y, 乔峰, 2]
    
            //多个集合求并集，并将结果存储到新的集合中
            Long aLong = opsForSet.unionAndStore("set_5_1", "set_5_2", "set_5_3");
            System.out.println(aLong + ", " + opsForSet.members("set_5_3"));//9, [3, a, x, c, b, 2, 21, 1, y]
    
            Set<String> difference = opsForSet.difference("set_5_1", "set_5_2");//求两个集合的差集
            System.out.println(difference);//[a, 1, b]
    
            Set<String> intersect = opsForSet.intersect("set_5_1", "set_5_2");//求两个集合的交集
            opsForSet.intersectAndStore("set_5_1", "set_5_2", "set_5_3");//当set_5_3集合中有值时，会先被清除
            System.out.println(intersect);//[3, c, 2]
        }

# [有序集合(sorted set)][sorted set] #

org.springframework.data.redis.core.ZSetOperations 处理有序集合(Set) 的数据：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Boolean add(K key, V value, double score)</td> 
   <td>为有序集合添加元素. 如果 value 已经存在，则更新. score 表示权重，用于排序，值越小，排序越靠前(由小到大)。key 不存在时，直接新增。成功插入时返回 true，失败时返回 false。</td> 
  </tr> 
  <tr> 
   <td>Long rank(K key, Object o)</td> 
   <td>获取元素 o 在有序集合中的索引</td> 
  </tr> 
  <tr> 
   <td>Set range(K key, long start, long end)</td> 
   <td>获取有序的集合中指定索引范围的值，索引从0开始，-1 表示倒数第一个元素。</td> 
  </tr> 
  <tr> 
   <td>Set rangeByScore(K key, double min, double max)</td> 
   <td>根据权重范围查询</td> 
  </tr> 
  <tr> 
   <td>Set rangeByScore(K key, double min, double max, long offset, long count)</td> 
   <td>offset 表示偏移量，count 表示需要获取的个数</td> 
  </tr> 
  <tr> 
   <td>Long count(K key, double min, double max)</td> 
   <td>获取权重在 [min,max] 直接的元素个数</td> 
  </tr> 
  <tr> 
   <td>Long remove(K key, Object... values)</td> 
   <td>删除有序集合中指定的元素(value)</td> 
  </tr> 
  <tr> 
   <td>Long removeRange(K key, long start, long end)</td> 
   <td>删除有序集合中指定索引范围内的元素</td> 
  </tr> 
  <tr> 
   <td>Long removeRangeByScore(K key, double min, double max)</td> 
   <td>删除有序集合中指定权重范围内的元素</td> 
  </tr> 
  <tr> 
   <td>Long zCard(K key)</td> 
   <td>获取集合的大小</td> 
  </tr> 
  <tr> 
   <td>Long size(K key)</td> 
   <td>获取集合的大小，底层调用 zCard</td> 
  </tr> 
  <tr> 
   <td>Double score(K key, Object o)</td> 
   <td>获取集合中指定元素的权重。</td> 
  </tr> 
 </tbody> 
</table>

[ZSetOperations 源码。][ZSetOperations]

//org.springframework.data.redis.core.ZSetOperations 处理有序集合(Set) 的数据：
        @Test
        public void test5() {
            stringRedisTemplate.getConnectionFactory().getConnection().flushAll();//清空所有缓存
            ZSetOperations<String, String> opsForZSet = stringRedisTemplate.opsForZSet();
            Boolean add1 = opsForZSet.add("zset1", "C++", 3.8);
            Boolean add2 = opsForZSet.add("zset1", "Java", 0.3);
            Boolean add3 = opsForZSet.add("zset1", "Python", 2.5);
            Set<String> zset1 = opsForZSet.range("zset1", 0, -1);
            System.out.println(add1 + ", " + add2 + ", " + add3 + ", " + zset1);//输出：true, true, true, [Java, Python, C++]
    
            Long rank = opsForZSet.rank("zset1", "C++");
            Long count = opsForZSet.count("zset1", 0.3, 2.5);
            Long size = opsForZSet.size("zset1");
            Double score = opsForZSet.score("zset1", "Java");
            //输出：2, 2, 3, 0.3, [Java, Python, C++]
            System.out.println(rank + ", " + count + ", " + size + ", " + score + ", " +
                    opsForZSet.range("zset1", 0, -1));
    
            opsForZSet.add("zset2", "12", 0);
            opsForZSet.add("zset2", "3c", 1);
            opsForZSet.add("zset2", "4f", 2);
            opsForZSet.add("zset2", "6h", 3);
            opsForZSet.add("zset2", "7p", 4);
            Long remove = opsForZSet.remove("zset2", "4f");
            //Long aLong = opsForZSet.removeRange("zset2", 1, 2);
            Long zset2 = opsForZSet.removeRangeByScore("zset2", 2.0, 3.0);
            System.out.println(opsForZSet.range("zset2", 0, -1));
        }

# 切换 Jedis 实现 #

1、spring Boot 为[Lettuce][] 和[Jedis][] 客户端库提供基本的自动配置，默认情况下，使用 [Lettuce][] 作为客户端，如果想要切换 Jedis 客户端，则分为如下两步：

**一：切换依赖：**排除掉 spring-boot-starter-data-redis 中默认的 lettuce 依赖，然后引入 jedis 依赖。

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                
                <exclusions>
                    <exclusion>
                        <artifactId>lettuce-core</artifactId>
                        <groupId>io.lettuce</groupId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            
            
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
            </dependency>

**二：[修改配置][Link 2]**：将 lettuce 配置切换为 jedis 配置

#Redis 配置，以下除了 timeout 外全部为默认配置.
    spring:
      redis:
        host: localhost
        port: 6379
        database: 2
        password:
        timeout: 10000
        jedis:
          pool:
            max-active: 8
            max-idle: 8
            min-idle: 0
            max-wait: -1ms

![20200918162134866.gif][]

**三：切换原理**

1、应用启动时，自动加载 org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration 配置类。

@Configuration
    @ConditionalOnClass(RedisOperations.class)
    @EnableConfigurationProperties(RedisProperties.class)
    @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
    public class RedisAutoConfiguration {

2、如果应用中有 lettuce 依赖，则会自动使用 Lettuce 客户端，同理如果应用中有 jedis 依赖，则自动换为 Jedis 客户端。

演示源码：[https://gitee.com/wangmx1993/wmx-redis/blob/master/src/main/resources/application.yml][https_gitee.com_wangmx1993_wmx-redis_blob_master_src_main_resources_application.yml]

[Lettuce]: https://github.com/lettuce-io/lettuce-core/
[Jedis]: https://github.com/xetorthio/jedis/
[Spring Data Redis]: https://github.com/spring-projects/spring-data-redis
[Link 1]: https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/htmlsingle/#boot-features-redis
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly93YW5nbWFveGlvbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191126114553500.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly93YW5nbWFveGlvbmcuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[RedisProperties]: https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/redis/RedisProperties.java
[Redis _Jedis_Redisson_Lettuce]: https://www.cnblogs.com/liyan492/p/9858548.html
[String_]: https://www.redis.net.cn/order/3544.html
[ValueOperations]: https://github.com/spring-projects/spring-data-redis/blob/master/src/main/java/org/springframework/data/redis/core/ValueOperations.java
[https_gitee.com_wangmx1993_wmx-redis_blob_master_src_test_java_com_wmx_wmxredis_RedisTest.java]: https://gitee.com/wangmx1993/wmx-redis/blob/master/src/test/java/com/wmx/wmxredis/RedisTest.java
[List_]: https://www.redis.net.cn/order/3577.html
[ListOperations]: https://github.com/spring-projects/spring-data-redis/blob/master/src/main/java/org/springframework/data/redis/core/ListOperations.java
[Hash_]: https://www.redis.net.cn/order/3564.html
[HashOperations]: https://github.com/spring-projects/spring-data-redis/blob/master/src/main/java/org/springframework/data/redis/core/HashOperations.java
[Set_]: https://www.redis.net.cn/order/3594.html
[SetOperations]: https://github.com/spring-projects/spring-data-redis/blob/master/src/main/java/org/springframework/data/redis/core/SetOperations.java
[sorted set]: https://www.redis.net.cn/order/3609.html
[ZSetOperations]: https://github.com/spring-projects/spring-data-redis/blob/master/src/main/java/org/springframework/data/redis/core/ZSetOperations.java
[Link 2]: https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/htmlsingle/#appendix
[20200918162134866.gif]: https://img-blog.csdnimg.cn/20200918162134866.gif
[https_gitee.com_wangmx1993_wmx-redis_blob_master_src_main_resources_application.yml]: https://gitee.com/wangmx1993/wmx-redis/blob/master/src/main/resources/application.yml