Spring Data 操作 Redis

前言

安装 Redis

首先确认你的 Redis 服务已经启动了。

这里我在客户端设置密码为 root。若不输入密码，是不能进行操作的，使用 auth root之后就能进行操作了。

具体操作请参考：https://www.jianshu.com/p/0b03a3e05e1d

注意，我这里的操作是没有使用 auth 的。

redis 127.0.0.1:6379> config set requirepass root
OK
redis 127.0.0.1:6379> get *
(error) ERR operation not permitted
redis 127.0.0.1:6379> auth root
OK
redis 127.0.0.1:6379> get *
(nil)
redis 127.0.0.1:6379>

回顾一下Redis的存储数据类型

结构类型	结构存储的值	结构的读写能力
String	可以是字符串、整数或者浮点数	对整个字符串或者字符串的其中一部分执行操作；对象和浮点数执行自增(increment)或者自减(decrement)
List	一个链表，链表上的每个节点都包含了一个字符串	从链表的两端推入或者弹出元素；根据偏移量对链表进行修剪(trim)；读取单个或者多个元素；根据值来查找或者移除元素
Set	包含字符串的无序收集器(unorderedcollection)，并且被包含的每个字符串都是独一无二的、各不相同	添加、获取、移除单个元素；检查一个元素是否存在于某个集合中；计算交集、并集、差集；从集合里卖弄随机获取元素
Hash	包含键值对的无序散列表	添加、获取、移除单个键值对；获取所有键值对
Zset	字符串成员(member)与浮点数分值(score)之间的有序映射，元素的排列顺序由分值的大小决定	添加、获取、删除单个元素；根据分值范围(range)或者成员来获取

创建项目

然后在 idea 中创建一个 SpringBoot 项目，选择NoSQL组件。

项目内容

resources 中

这个里边本来是要配置信息的，可本案例中使用代码配置的方式。因此，这里的配置信息就没写。

pom.xml 文件

本案例使用了 jedis 连接的方式，因为 SpringData2.x中默认使用的是其他的连接方式，因此需要将其默认配置排除掉。再加入 jedis 的依赖，而 jedis 的依赖又需要 commons 这个依赖，所以这里一并引入。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>org.feng</groupId>
    <artifactId>springdata-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springdata-redis</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

RedisConfig

package org.feng.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Redis 配置类
 */
@Configuration
public class RedisConfig {

    /**
     * 创建JedisPoolConfig对象，在该对象中完成一些连接池配置
     */
    @Bean
    public JedisPoolConfig jedisPoolConfig () {
        JedisPoolConfig config = new JedisPoolConfig();
        // 配置最大空闲数
        config.setMaxIdle(10);
        // 配置最小空闲数
        config.setMinIdle(5);
        // 配置最大连接数
        config.setMaxTotal(20);
        return config;
    }


    @Bean
    public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory jedisConnectionFactory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(jedisConnectionFactory);

        // 设置 key 的序列化方式为 String序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }

    @Autowired
    public JedisConnectionFactory jedisConnectionFactory (JedisPoolConfig jedisPoolConfig) {
        //单机版jedis
        RedisStandaloneConfiguration redisStandaloneConfiguration =
                new RedisStandaloneConfiguration();
        //设置redis服务器的host或者ip地址
        redisStandaloneConfiguration.setHostName("localhost");
        //设置redis的服务的端口号
        redisStandaloneConfiguration.setPort(6379);
        //设置默认使用的数据库
        redisStandaloneConfiguration.setDatabase(0);
        //设置密码
        // redisStandaloneConfiguration.setPassword("root");

        //获得默认的连接池构造器(怎么设计的，为什么不抽象出单独类，供用户使用呢)
        JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =
                (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)JedisClientConfiguration.builder();
        //指定jedisPoolConifig来修改默认的连接池构造器（真麻烦，滥用设计模式！）
        jpcb.poolConfig(jedisPoolConfig);
        //通过构造器来构造jedis客户端配置
        JedisClientConfiguration jedisClientConfiguration = jpcb.build();
        //单机配置 + 客户端配置 = jedis连接工厂
        return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
    }
}

RedisUtil

package org.feng.util;

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

import java.time.Duration;
import java.util.Arrays;
import java.util.List;

/**
 * RedisTemplate 的封装类
 */
@Component
public class RedisUtil {
    private final RedisTemplate<String, Object> redisTemplate;

    @Autowired
    public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 判断redis中是否有 key
     * @param key 目标key
     * @return 存在时返回true
     */
    public boolean hasKey(String key){
        Boolean hasKey = redisTemplate.hasKey(key);
        if(hasKey != null){
            return hasKey;
        }
        return false;
    }

    /**
     * 存储 set
     * @param key 键
     * @param value 值
     * @return 存储成功返回 true
     */
    public boolean set(String key, Object value){
        boolean flag = false;
        try{
            redisTemplate.opsForValue().set(key, value);
            flag = true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 更新缓存
     * @return 更新成功时返回 true
     */
    public boolean getAndSet(String key, Object value){
        boolean flag = false;
        try {
            redisTemplate.opsForValue().getAndSet(key, value);
            flag = true;
        } catch (Exception e){
            e.printStackTrace();
        }

        return flag;
    }

    /**
     * 删除
     * @param key
     * @return
     */
    public boolean delete(String key){
        Boolean delete = false;
        try{
            delete = redisTemplate.delete(key);
        } catch (Exception e){
            e.printStackTrace();
        }
        return delete;
    }

    /**
     * 存储 set 并设置超时时长
     * @param key 键
     * @param value 值
     * @param timeout 超时时间（超过该时间，redis 会自动删除 key）
     */
    public void setWithTime(String key, Object value, Duration timeout){
        redisTemplate.opsForValue().set(key, value, timeout);
    }

    /**
     * 获取 key 对应的值
     * @param key 键
     * @return value
     */
    public Object get(String key){
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 查询多个结果：传入多个key即可
     * @param key 键
     * @return 多个 value
     */
    public List<Object> getList(String...key){
        return redisTemplate.opsForValue().multiGet(Arrays.asList(key));
    }


    /**
     * 获取 redisTemplate 对象
     * @return RedisTemplate 实例
     */
    public RedisTemplate<String, Object> getRedisTemplate(){
        return redisTemplate;
    }
}

测试

package org.feng;

import org.feng.util.RedisUtil;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.Assert;

import java.io.Serializable;
import java.time.Duration;
import java.time.LocalDate;

@SpringBootTest
class SpringdataRedisApplicationTests {

    @Autowired
    private RedisUtil redisUtil;

    @Test
    void contextLoads() throws InterruptedException {
        String key1 = "first";
        String value1 = "1234567";
        redisUtil.setWithTime(key1, value1, Duration.ofSeconds(3));

        Assert.isTrue(redisUtil.hasKey(key1), key1 + " is must exist !");

        // 自定义对象
        Person value2  = new Person();
        value2.setName("小凤");
        value2.setPassword("123445");
        value2.setAge(10);
        value2.setRegisterDay(LocalDate.of(2020,2, 21));
        String key2 = "second";
        redisUtil.set(key2, value2);
        Assert.isTrue(redisUtil.hasKey(key2), key2 + " is must exist !");

        // 输出结果
        redisUtil.getList(key1, key2).forEach(System.out::println);
        // 3s 之后
        Thread.sleep(3000);
        Assert.isTrue(!redisUtil.hasKey(key1), key1 + " is must not exist !");
    }


    private static class Person implements Serializable {

        private static final long serialVersionUID = 7813755876899907524L;

        private String name;
        private String password;
        private Integer age;
        private LocalDate registerDay;

        public Person() {
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }

        public Integer getAge() {
            return age;
        }

        public void setAge(Integer age) {
            this.age = age;
        }

        public LocalDate getRegisterDay() {
            return registerDay;
        }

        public void setRegisterDay(LocalDate registerDay) {
            this.registerDay = registerDay;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", password='" + password + '\'' +
                    ", age=" + age +
                    ", registerDay=" + registerDay +
                    '}';
        }
    }
}

测试结果