Redis 入门实战(7)-Spring Data Redis操作redis

Spring Data Redis 是的 Spring Data 家族的一部分，可轻松配置并访问Redis。 本文主要介绍在 SpringBoot 中使用 Spring Data Redis 操作 Redis，使用到的软件版本：Java 1.8.0_191、Redis 5.0.8、SpringBoot 2.4.13。

1、Spring Data Redis 功能介绍

a. 连接池自动管理，提供了一个高度封装的RedisTemplate类
b. 针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口
ValueOperations：简单K-V操作
SetOperations：set类型数据操作
ZSetOperations：zset类型数据操作
HashOperations：针对map类型的数据操作
ListOperations：针对list类型的数据操作
c. 提供了对key的bound便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须再次指定Key，即BoundKeyOperations：
BoundValueOperations
BoundSetOperations
BoundListOperations
BoundSetOperations
BoundHashOperations
d. 将事务操作封装，由容器控制。
e. 针对数据的序列化/反序列化，提供了多种可选择策略(RedisSerializer)
JdkSerializationRedisSerializer：POJO对象的存取场景，使用JDK本身序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作，最终redis-server中将存储字节序列,是目前最常用的序列化策略。
StringRedisSerializer：Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string，是new String(bytes, charset)和string.getBytes(charset)的直接封装,是最轻量级和高效的策略。
JacksonJsonRedisSerializer：jackson-json工具提供了javabean与json之间的转换能力，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。因为jackson工具在序列化和反序列化时，需要明确指定Class类型，因此此策略封装起来稍微复杂。(需要jackson-mapper-asl工具支持)
OxmSerializer：提供了将javabean与xml之间的转换能力，目前可用的三方支持包括jaxb，apache-xmlbeans；redis存储的数据将是xml格式。不过使用此策略，编程将会有些难度，而且效率最低，不建议使用。(需要spring-oxm模块的支持)

2、SpringBoot工程中引入Spring Data Redis依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.13</version>
    <relativePath />
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
    </dependency>
</dependencies>

3、Spring Data Redis配置(application.yml)

3.1、单点配置

spring:
  redis:
    password: 123456
    host: 10.49.196.10
    port: 6379

3.2、哨兵模式配置

spring:
  redis:
    sentinel:
      password: 123456
      master: mymaster
      nodes: 10.49.196.20:26379,10.49.196.21:26379,10.49.196.22:26379

3.3、集群模式配置

spring:
  redis:
    password: 123456
    cluster:
      nodes: 10.49.196.20:7000,10.49.196.20:7001,10.49.196.21:7000,10.49.196.21:7001,10.49.196.22:7000,10.49.196.22:7001

4、Spring Data Redis操作Redis

package com.abc.demo.general.redis;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisClusterNode;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.StringRedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
 * RedisTemplate操作reids
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringDataRedisCase {
    @Autowired
    private RedisTemplate<String, String> template;

    /**
     * Key-Value操作
     */
    @Test
    public void value() {
        template.opsForValue().set("name", "赵云");
        System.out.println(template.opsForValue().get("name"));

        template.boundValueOps("age").set("10");
        template.boundValueOps("age").increment(5);
        System.out.println(template.boundValueOps("age").get());
    }

    /**
     * Set操作
     */
    @Test
    public void set() {
        template.opsForSet().add("setkey", "v1", "v2", "v3");
        System.out.println(template.opsForSet().members("setkey"));

        template.boundSetOps("setkey2").add("v1", "v2", "v3");
        System.out.println(template.boundSetOps("setkey2").members());
    }

    /**
     * ZSet操作
     */
    @Test
    public void zset() {
        template.opsForZSet().add("zsetkey", "v1" , 1);
        template.opsForZSet().add("zsetkey", "v2" , 2);
        template.opsForZSet().add("zsetkey", "v3" , 3);
        System.out.println(template.opsForZSet().range("zsetkey", 1, 3));

        template.boundZSetOps("zsetkey2").add("v1" , 1);
        template.boundZSetOps("zsetkey2").add("v2" , 2);
        template.boundZSetOps("zsetkey2").add("v3" , 3);
        System.out.println(template.boundZSetOps("zsetkey").range(1, 3));
    }

    /**
     * List操作
     */
    @Test
    public void list() {
        template.opsForList().leftPush("list", "v1");
        template.opsForList().leftPush("list", "v2");
        template.opsForList().leftPush("list", "v3");
        System.out.println(template.opsForList().range("list", 1, 3));

        template.boundListOps("list2").leftPush("v1");
        template.boundListOps("list2").leftPush("v2");
        template.boundListOps("list2").leftPush("v3");
        System.out.println(template.boundListOps("list2").range(0, 3));
    }

    /**
     * Hash操作
     */
    @Test
    public void hash() {
        template.opsForHash().put("hash", "k1", "v1");
        template.opsForHash().put("hash", "k2", "v2");
        template.opsForHash().put("hash", "k3", "v3");
        System.out.println(template.opsForHash().entries("hash"));

        template.boundHashOps("hash2").put( "k1", "v1");
        template.boundHashOps("hash2").put( "k2", "v2");
        template.boundHashOps("hash2").put( "k3", "v3");
        System.out.println(template.boundHashOps("hash2").entries());
    }

    /**
     * Key操作
     */
    @Test
    public void key() {
        //获取所有key
        Set<String> keys = template.keys("*");
        System.out.println(keys);

        //判断key是否存在
        System.out.println(template.hasKey("name"));

        //设置过期时间
        template.expire("name", 10, TimeUnit.MINUTES);
        //获取过期时间
        System.out.println(template.getExpire("name"));

        //删除key
        template.delete("age");
    }

    /**
     * 管道操作
     */
    @Test
    public void pipelined() {
        List<Object> results = template.executePipelined(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
                StringRedisConnection stringRedisConn = (StringRedisConnection)redisConnection;
                for (int i = 0; i < 10; i++) {
                    stringRedisConn.set("key" + i, i + "");
                }
                return null;
            }
        });
        System.out.println(results);
    }

    /**
     * 集群管理操作，只有集群模式下才能操作
     */
    @Test
    public void cluster() {
        RedisClusterNode node = new RedisClusterNode("10.49.196.20", 7001);
        //获取主节点对应的从节点
        System.out.println(template.opsForCluster().getSlaves(node));

        //获取节点的key
        System.out.println(template.opsForCluster().keys(node, "*"));
    }
}