SpringData Redis

---

1 SpringData Redis简介

Redis是一个基于内存的数据结构存储系统，它可以用作数据库或者缓存。它支持多种类型的数据结构，这些数据结构类型分别为String（字符串）、List（列表）、Set（集合）、Hash（散列）和 Zset（有序集合）。

SpringData Redis的作用是通过一段简单的配置即可访问redis服务，它的底层是对java提供的redis开发包(比如jedis等)进行了高度封装，主要提供了如下功能：

• 连接池自动管理，提供了一个高度封装的RedisTemplate类,基于这个类的对象可以对redis进行各种操作
• 针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口
  • ValueOperations：简单字符串类型数据操作
  • SetOperations：set类型数据操作
  • ZSetOperations：zset类型数据操作
  • HashOperations：map类型的数据操作
  • ListOperations：list类型的数据操作

2 Redis环境搭建

2.1 安装redis的依赖环境

[root@localhost src]# yum -y install gcc automake autoconf libtool make

2.2 上传安装包

获取到安装包,并将它上传到linux的/usr/local/src/目录下

[root@localhost src]# ls
redis-5.0.4.tar.gz

2.3 解压

解压安装包,得到一个redis-5.0.4目录

[root@localhost src]# tar -zxvf redis-5.0.4.tar.gz 
[root@localhost src]# ls
redis-5.0.4  redis-5.0.4.tar.gz

2.4 编译

进入redis目录,在目录下执行make命令

[root@localhost src]# cd redis-5.0.4
[root@localhost redis-5.0.4]# make

2.5 安装

执行安装命令,注意此处指定了安装目录为/usr/local/redis

[root@localhost redis-5.0.4]# make PREFIX=/usr/local/redis install

2.6 复制配置文件

将配置文件复制到redis的安装目录的bin目录下

[root@localhost redis-5.0.4]# cd /usr/local/redis/bin/
[root@localhost bin]# ls
redis-benchmark  redis-check-aof  redis-check-rdb  redis-cli  redis-sentinel  redis-server
[root@localhost bin]# cp /usr/local/src/redis-5.0.4/redis.conf ./
[root@localhost bin]# ls
redis-benchmark  redis-check-aof  redis-check-rdb  redis-cli  redis.conf  redis-sentinel  redis-server

2.7 修改redis的配置文件

修改redis的配置文件,将注解绑定和保护模式关闭,方便我们从客户端连接测试

[root@localhost bin]# vim redis.conf 

2.8 启动redis服务

[root@localhost bin]# ./src/redis-server redis.conf &

3 SpringData Redis入门案例

3.1 创建工程，引入坐标

<dependencies>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.3</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>2.1.8.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.8</version>
    </dependency>
</dependencies>

3.2 创建配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- redis 相关配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!--最大空闲数-->
        <property name="maxIdle" value="300"/>
        <!--连接时的最大等待毫秒数-->
        <property name="maxWaitMillis" value="3000"/>
        <!--在提取一个jedis实例时，是否提前进行验证操作；如果为true，则得到的jedis实例均是可用的-->
        <property name="testOnBorrow" value="false"/>
    </bean>
    
    <!--连接工厂-->
    <bean id="jedisConnectionFactory"
          class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:host-name="192.168.106.128" p:port="6379" p:pool-config-ref="poolConfig"/>

    <!--redisTemplate-->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"/>
    </bean>
</beans>

3.3 创建测试类，完成一条简单数据的存取

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RedisTest {
    
    

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test0() {
    
    
        //存入数据
        redisTemplate.opsForValue().set("name", "oldlu");
        //查询数据
        String name = (String) redisTemplate.opsForValue().get("name");
        System.out.println(name);
    }
}

4 SpringData Redis的序列化器

通过Redis提供的客户端查看入门案例中存入redis的数据

这时候会发现，存入的数据并不是简单的字符串，而是一些类似于二进制的数据，这是怎么回事呢？

原来，SpringData Redis在保存数据的时候，底层有一个序列化器在工作，它会将要保存的数据（键和值）按照一定的规则进行序列化操作后再进行存储。spring-data-redis提供如下几种序列化器：

• StringRedisSerializer: 简单的字符串序列化
• GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化
• Jackson2JsonRedisSerializer: 序列化对象为json字符串
• GenericJackson2JsonRedisSerializer:功能同上,但是更容易反序列化
• OxmSerializer: 序列化对象为xml字符串
• JdkSerializationRedisSerializer: 序列化对象为二进制数据

RedisTemplate默认使用的是JdkSerializationRedisSerializer对数据进行序列化。

那么如何选择自己想要的序列化器呢？SpringData提供了两种方式：

1. 通过配置文件配置

   <!--redisTemplate-->
   <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
       <property name="connectionFactory" ref="jedisConnectionFactory"/>
       
       <!--指定非hash类型的数据序列化器-->
       <property name="keySerializer">
          <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
       </property>
       <property name="valueSerializer">
          <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
       </property>
   </bean>

2. 通过RedisTemplate设定

   @Test
   public void test1() {
         
         
       redisTemplate.setKeySerializer(new StringRedisSerializer());
       redisTemplate.setValueSerializer(new StringRedisSerializer());
   
       //存入数据
       redisTemplate.opsForValue().set("name", "oldlu");
       //查询数据
       String name = (String) redisTemplate.opsForValue().get("name");
       System.out.println(name);
   }
   

5 SpringData Redis运行原理分析

我们从入门案例中已经知道SpringData Redis操作Redis服务器只要是通过RestTemplate实现的，那么RestTemplate底层到底是如何操作redis的呢，下面我们通过源码追踪的形式看一看。

1、首先看配置文件中关于RestTemplate的bean的配置，可以看到在RedisTemplate的bean声明中注入了一个JedisConnectionFactory实例，顾名思义，这个连接工厂是用来获取Jedis连接的，那么通过这种方式RedisTemplate就可以拿到操作Redis服务器的句柄了。

2、使用debug运行入门案例，观察创建好的RestTemplate实例，可以看到里面主要有序列化器和redis的连接信息，基于这些，我们就可以对redis进行操作了

3、跟踪进入set方法，我们可以看到set方法中使用了一个connection来进行操作，这个connection的类型是JedisConnetion，而这个connection肯定是通过配置文件配置的JedisConnectionFactory产生的，也就是底层开始调用jedis的api了。

4、继续追踪set方法，选择JedisStringCommands实现

5、继续之宗set方法，可以看到底层已经获取到了jedis的实例，再调用set方法已经在调jedis的set了

6、再追踪一步，就会发现，底层最终调用的是jedis的原生API，setCommand方法，这个方法就是jedis提供的对redis的各种操作命令了。

至此，我们的分析完毕。得到的结论就是：

SpringData提供redisTemplate就是在原生的Jedis或者其他操作redis的技术上做的一层封装，它屏蔽掉了这些原生技术的实现细节，统一了调用接口，使得我们的操作更加简单明了。

6 SpringData Redis常见操作

本章节我们来学习如何使用SpringData Redis来操作Redis的各种数据类型.

在Redis中有五种常见类型,SpringData Redis对每一种数据类型都提供了一个xxxOperations的API,他们分别是:

• ValueOperations :用来操作字符串类型数据
• HashOperations:用来操作hash类型数据
• ListOperations:用来操作list类型数据
• SetOperations:用来操作set类型数据
• ZSetOperations:用来操作zset类型数据

6.1 String类型

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-redis.xml")
public class RedisStringTest {
    
    

    @Autowired
    private RedisTemplate redisTemplate;

    ValueOperations<String, String> operations = null;

    @Before
    public void init() {
    
    
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());

        operations = redisTemplate.opsForValue();
    }

    @Test
    public void testSet() {
    
    
        //向数据库中保存name--oldlu
        operations.set("name","oldlu");

        //相关数据库保存name1--oldlu1  有效时间为10s
        operations.set("name1", "oldlu1", 10, TimeUnit.SECONDS);

        //替换 oldlu    --->   heXXa   offset 索引位置是从0开始
        operations.set("name", "XX", 2);

        //当key不存在的时候,执行保存操作;当key存在的时候,什么都不做
        operations.setIfAbsent("name1","oldlu");

        //批量保存
        Map map = new HashMap();
        map.put("name2", "oldlu2");
        map.put("name3", "oldlu3");
        map.put("name4", "oldlu4");

        operations.multiSet(map);

        //追加 当key存在时,会执行追加操作;当key不存在时,会执行保存操作
        operations.append("name5", "oldlu");

    }

    @Test
    public void testGet() {
    
    
        //根据key获取value
        String value = operations.get("name");
        System.out.println(value);//heXXaoldlu

        //首先根据key获取value,然后再根据value进行截取,从start位置截取到end位置[包含start和end]
        String value2 = operations.get("name", 5, 7);
        System.out.println(value2);//heXXaoldlu-->Hei

        //批量获取
        List<String> keys = new ArrayList<>();
        keys.add("name2");
        keys.add("name3");
        keys.add("name4");
        List<String> values = operations.multiGet(keys);
        for (String s : values) {
    
    
            System.out.println(s);
        }

        //根据key获取value的长度
        Long size = operations.size("name");
        System.out.println(size);
    }

    //自增
    @Test
    public void testIncrement() {
    
    
        operations.set("age", "18");
        operations.increment("age");//自增1--->19
        System.out.println(operations.get("age"));
        operations.increment("age", 5);//自增5
        System.out.println(operations.get("age"));//---->24

        //自减
        operations.decrement("age")
    }

    //删除
    @Test
    public void testDelete() {
    
    
        //单个删除
        redisTemplate.delete("name");

        List<String> keys = new ArrayList<>();
        keys.add("name2");
        keys.add("name3");
        keys.add("name4");

        //批量删除
        redisTemplate.delete(keys);
    }
}

6.2 Hash类型

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-redis.xml")
public class RedisHashTest {
    
    

    @Autowired
    private RedisTemplate redisTemplate;

    HashOperations<String, String, Article> operations = null;

    @Before
    public void init() {
    
    
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());

        operations = redisTemplate.opsForHash();
    }

    //保存
    @Test
    public void testPut() {
    
    
        Article article = new Article();
        article.setTitle("黑马");
        article.setAuthor("黑马");
        article.setCreateTime(new Date());

        operations.put("article", "3", article);
    }

    //获取
    @Test
    public void testGet() {
    
    
        //判断hashkey是否存在
        Boolean flag = operations.hasKey("article", "3");
        System.out.println(flag);

        //根据key和hashkay获取操作
        Article article = operations.get("article", "2");
        System.out.println(article);

        //根据key获取所有的hashkey
        Set<String> set = operations.keys("article");
        for (String s : set) {
    
    
            System.out.println(s);
        }

        List<Article> articles = operations.values("article");
        for (Article art : articles) {
    
    
            System.out.println(art);
        }

        Map<String, Article> map = operations.entries("article");
        for (Map.Entry<String, Article> entry : map.entrySet()) {
    
    
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }

    //删除
    @Test
    public void testDelete() {
    
    
        //当hash中的数据全部被删除后,整个hash就没了
        operations.delete("article", "2", "3");
    }
}

6.3 List类型

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ListTest {
    
    

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    private ListOperations<String, String> operations;

    @Before
    public void before() {
    
    
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        operations = redisTemplate.opsForList();
    }

    //增加
    @Test
    public void testAdd() {
    
    
        // 将所有指定的值插入存储在键的列表的头部（或尾部）。
        // 如果键不存在，则在执行推送操作之前将其创建为空列表。
        operations.leftPush("names", "zhangsan");
        operations.leftPushAll("names", "lisi","wangwu","zhaoliu");

        operations.rightPush("names", "sunqi");
        operations.rightPushAll("names", "lisi","wangwu","zhaoliu");
    }

    //根据索引查询元素
    @Test
    public void testFind() {
    
    
        //0代表左边开始第一个元素
        String name1 = operations.index("names", 0);
        System.out.println(name1);
		
        //-1代表右边开始第一个元素
        String name2 = operations.index("names", -1);
        System.out.println(name2);
        
        //range代表一个范围(包含开始索引,结束索引)
        List<String> names = operations.range("names", 0, 1);
        for (String name : names) {
    
    
            System.out.println(name);
        }
    }
    
    //移除某个元素的值
    @Test
    public void testRemove() {
    
    
        //从坐标或者右边弹出第一个元素
        operations.rightPop("names");
        
        //弹出指定的元素
        // count > 0：删除左边起第几个等于指定值的元素
        // count < 0：删除右边起第几个等于指定值的元素
        // count = 0：删除所有等于value的元素。
        operations.remove("names", 1, "zhangsan");
    }
}

6.4 Set类型

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SetTest {
    
    

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    private SetOperations<String, String> operations;

    @Before
    public void before() {
    
    
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        operations = redisTemplate.opsForSet();
    }

    //添加
    @Test
    public void testAdd() {
    
    
        operations.add("names", "zhangsan", "li", "wangwu");
    }

    //查看集合中元素
    @Test
    public void testFind() {
    
    
        //查询集合中的所有元素
        operations.members("names");
        
        //随机获取集合中的一个元素
        String name = operations.randomMember("names");
        System.out.println(name);
		
        //随机获取集合中的多个元素
        operations.randomMembers("names",2).stream().forEach(System.out::println);
    }
    
    //移除元素
    @Test
    public void testRemove() {
    
    
        //根据指定的key--value进行移除
        operations.remove("names", "zhangsan", "li");
        
        //根据key随机移除并返回value
        String name = operations.pop("names");
        System.out.println(name);
    }
    
    //多集合的操作
    @Test
    public void testMoreSet() {
    
    
       operations.add("names1", "zhangsan", "li", "wangwu");
       operations.add("names2", "zhangsan", "li", "zhaoliu");

       //取交集
       operations.intersect("names1","names2").stream().forEach(System.out::println);

       //取并集
       operations.union("names1", "names2").stream().forEach(System.out::println);

       //取差集
       operations.difference("names1","names2").stream().forEach(System.out::println);
    }
}

6.5 ZSet类型

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-redis.xml")
public class ZSetTest {
    
    

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    private ZSetOperations<String, String> operations;

    @Before
    public void before() {
    
    
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        operations = redisTemplate.opsForZSet();
    }

    //添加
    @Test
    public void testAdd() {
    
    
        operations.add("students", "zhangsan", 100);
        operations.add("students", "lisi", 80);
        operations.add("students", "wangwu", 90);
    }

    //增减分数
    @Test
    public void testScore() {
    
    
        //根据key-value来增减分数
        operations.incrementScore("students", "lisi", -50);
    }

    //查询一个元素的信息
    @Test
    public void testFindOne() {
    
    
        //查询个人分数
        Double score = operations.score("students", "lisi");
        System.out.println(score);

        //查询个人排名
        Long rank = operations.rank("students", "lisi");
        System.out.println(rank);
    }

    //列表查询:分为两大类，正序和逆序。以下只列表正序的，逆序的只需在方法前加上reverse即可
    @Test
    public void testFindList() {
    
    
        //通过排名区间获取集合元素
        Set<String> students1 = operations.range("students", 1, 2);
        for (String stu : students1) {
    
    
            System.out.println(stu);
        }

        //通过排名区间获取集合元素和分数
        Set<ZSetOperations.TypedTuple<String>> students2 =
                operations.rangeWithScores("students", 1, 2);
        for (ZSetOperations.TypedTuple<String> tuple : students2) {
    
    
            String value = tuple.getValue();
            Double score = tuple.getScore();
            System.out.println("value-->" + value + ",score-->" + score);
        }

        //通过分数区间获取集合元素
        Set<String> students3 = operations.rangeByScore("students", 80, 90);
        for (String stu : students3) {
    
    
            System.out.println(stu);
        }


        //通过分数区间获取集合元素和分数
        Set<ZSetOperations.TypedTuple<String>> students4 =
                operations.rangeByScoreWithScores("students", 80, 90);
        for (ZSetOperations.TypedTuple<String> tuple : students4) {
    
    
            String value = tuple.getValue();
            Double score = tuple.getScore();
            System.out.println("value-->" + value + ",score-->" + score);
        }
    }

    //统计元素
    @Test
    public void testCount() {
    
    
        //统计集合大小
        Long zCard = operations.zCard("students");
        System.out.println(zCard);

        //统计分数区间的元素数量
        Long count = operations.count("students", 85, 95);
        System.out.println(count);
    }

    //移除元素
    @Test
    public void testRemove() {
    
    
        //通过key--value删除
        operations.remove("students", "zhangsan");

        //通过排名区间删除
        operations.removeRange("students", 0, 1);

        //通过分数区间删除
        operations.removeRangeByScore("students", 80, 90);
    }
}

7 Repository和Template的选用

经过前面的章节，我们学习了SpringData家族中jpa和redis的使用，在感受到SpringData技术使用方便的同时，也隐隐约约感觉有点问题，那就是jpa和redis的使用思路好像不是很一致。

我们使用SpringDataJpa的时候，采用了继承SpringData提供的一个接口的形式，即public interface ArticleDao extends JpaRepository<Article, Integer>,JpaSpecificationExecutor<Article>，但是使用SpingData Redis的时候，却是使用了在实现类中注入一个redisTemplate的方式，那么这两种方式到底有什么关系，用哪个更好呢？

其实这两种方式都可以完成我们对持久层的操作，但是对比两种方式的使用，就会发现：

第一种方式，直接继承xxxRepository接口，可以不必自己去写实现类，而轻松实现简单的增删改查、分页、排序操作，但是对于非常复杂的查询，用起来就比较的费力了；

第二种方式，直接使用xxxTemplate，就需要自己写实现类，但是这样增删改查可以自己控制，对于复杂查询来说，用起来更加得心应手。

所以，两种方式在企业开发中都可能用到，甚至有的项目开发中会同时使用两种方式:对于简单的操作，直接继承Repository接口，对于复杂操作，使用Template完成。所以我们用的时候也要根据实际场景进行灵活选用。

8 开发中遇到的常见问题

无法创建jedis,一些列一看就是配置文件的问题,大部分可能就是jedis于redis版本不符.

9 redis开发中的需求解决

9.1 expire命令可以设置key的存活时间

如果需要把有过期时间的key设置为不过期的，可以使用persist命令来持久化key。 命令 : PERSIST key

持久化key,默认不赋值就是永久为-1

9.2 过期时间查看

redis过期时间相关命令

1.EXPIRE PEXPIREEXPIRE接口定义：EXPIRE key “seconds"接口描述：设置一个key在当前时间"seconds”(秒)之后过期。返回1代表设置成功，返回0代表key不存在或者无法设置过期时间。PEXPIRE接口定义：PEXPIRE key “milliseconds"接口描述：设置一个key在当前时间"milliseconds”(毫秒)之后过期。返回1代表设置成功，返回0代表key不存在或者无法设置过期时间。

2.EXPIREAT PEXPIREATEXPIREAT接口定义：EXPIREAT key “timestamp"接口描述：设置一个key在"timestamp”(时间戳(秒))之后过期。返回1代表设置成功，返回0代表key不存在或者无法设置过期时间。PEXPIREAT接口定义：PEXPIREAT key “milliseconds-timestamp"接口描述：设置一个key在"milliseconds-timestamp”(时间戳(毫秒))之后过期。返回1代表设置成功，返回0代表key不存在或者无法设置过期时间

3.TTL PTTLTTL接口定义：TTL key接口描述：获取key的过期时间。如果key存在过期时间，返回剩余生存时间(秒)；如果key是永久的，返回-1；如果key不存在或者已过期，返回-2。PTTL接口定义：PTTL key接口描述：获取key的过期时间。如果key存在过期时间，返回剩余生存时间(毫秒)；如果key是永久的，返回-1；如果key不存在或者已过期，返回-2。