@[Toc]

一、Redis介绍

Redis是一种基于键值对（key-value）的NoSQL数据库，与很多键值对 数据库不同的是，Redis中的值可以是由string（字符串）、hash（哈希）、 list（列表）、set（集合）、zset（有序集合）、Bitmaps（位图）、 HyperLogLog、GEO（地理信息定位）等多种数据结构和算法组成，因此 Redis可以满足很多的应用场景，而且因为Redis会将所有数据都存放在内存 中，所以它的读写性能非常惊人。不仅如此，Redis还可以将内存的数据利 用快照和日志的形式保存到硬盘上，这样在发生类似断电或者机器故障的时 候，内存中的数据不会“丢失”。除了上述功能以外，Redis还提供了键过期、发布订阅、事务、流水线、Lua脚本等附加功能。总之，如果在合适的 场景使用好Redis，它就会像一把瑞士军刀一样所向披靡。

二、整合Redis

1、spring-boot-starter-data-redis介绍

Spring Boot 提供了对 Redis 集成的组件包：spring-boot-starter-data-redis，它依赖于 spring-data-redis 和lettuce。Spring Boot 1.0 默认使⽤的是 Jedis 客户端，2.0 替换成了 Lettuce。

• Lettuce：是⼀个可伸缩线程安全的 Redis 客户端，多个线程可以共享同⼀个 RedisConnection，它利⽤优秀 Netty NIO 框架来⾼效地管理多个连接。
• Spring Data：是 Spring 框架中的⼀个主要项⽬，⽬的是为了简化构建基于 Spring 框架应⽤的数据访问，包括⾮关系数据库、Map-Reduce 框架、云数据服务等，另外也包含对关系数据库的访问⽀持。
• Spring Data Redis：是 Spring Data 项⽬中的⼀个主要模块，实现了对 Redis 客户端 API 的⾼度封装，使对 Redis 的操作更加便捷。

2、引入依赖

创建一个SpringBoot项目，引入相关依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--使⽤ commons-pool 2 创建 Redis 连接池-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

如果习惯使用Jdedis，也可以从spring-boot-stater-data-redis 排除 Lettuce ，使用Jedis ：

        <!--排除lettuce，使用jedis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

3、配置

3.1、application 配置

在application.properties中添加Redis相关配置：

# Redis
# Redis 数据库索引（默认为 0）
spring.redis.database=0
# Redis 服务器地址
spring.redis.host=localhost
# Redis 服务器连接端⼝
spring.redis.port=6379 
# Redis 服务器连接密码（默认为空）
spring.redis.password=
# 连接池最⼤连接数（使⽤负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最⼤阻塞等待时间（使⽤负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最⼤空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最⼩空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0

3.2、缓存配置

在自动配置类里可以为 Redis 设置⼀些全局配置，⽐如配置主键的⽣产策略 KeyGenerator，如不配置会默认使⽤参数名作为主键。

@Configuration
//开启缓存配置
@EnableCaching
public class RedisConfig {

    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
}

3.3、测试

在单元测试中，注⼊ RedisTemplate。String 是最常⽤的⼀种数据类型，普通的 key/value 存储都可以归为此类，value 其实不仅是 String 也可以是数字。

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testString() {
        redisTemplate.opsForValue().set("trytry", "it's time");
        Assert.assertEquals("it's time", redisTemplate.opsForValue().get("trytry"));
    }

}

在这个单元测试中，我们使⽤ redisTemplate 存储了⼀个字符串 "it's time"，存储之后获取进⾏验证，多次进⾏set 相同的 key，键对应的值会被覆盖。

综上所述，进行使⽤ spring-boot-starter-data-redis只需要上面的三步。

三、操作Redis各数据类型

Redis ⽀持多种数据类型，实体、哈希、列表、集合、有序集合，通过spring-boot-starter-data-redis都可以进行存储、读取、超时失效、删除操作。

1、实体

新建一个实体类：

public class User implements Serializable {
    private String name;
    private String description;

    public User(String name, String description) {
        this.name = name;
        this.description = description;
    }
}

将实体类放入缓存，再取出来：

 @Test
    public void testModel(){
        User user=new User("zhangtiedan","头铁");
        //获取一个操作对象
        ValueOperations<String, User> operations=redisTemplate.opsForValue();
        //将user存入缓存
        operations.set("tiedan", user);
        //取出缓存中的user
        User u=operations.get("tiedan");
        System.out.println("user: "+u.toString());
    }

运行结果：

2、超时失效

Redis 在存⼊每⼀个数据的时候都可以设置⼀个超时时间，过了这个时间就会⾃动删除数据，这种特性⾮常适合我们对阶段数据的缓存。

新建⼀个 User 对象，存⼊ Redis 的同时设置 100 毫秒后失效，设置⼀个线程暂停 1000 毫秒之后，判断数据是否存在并打印结果。

 @Test
    public void testExpire() throws InterruptedException {
        User user=new User("gangdan","人狠话不多");
        ValueOperations<String, User> operations=redisTemplate.opsForValue();
        //将user存⼊ Redis 的同时设置 100 毫秒后失效
        operations.set("expire", user,100, TimeUnit.MILLISECONDS);
        Thread.sleep(1000);
        boolean exists=redisTemplate.hasKey("expire");
        if(exists){
            System.out.println("exists is true");
        }else{
            System.out.println("exists is false");
        }
    }

运行结果：

3、删除数据

删除数据也是必需的。

 @Test
    public void testDelete(){
        User user=new User("hage","不怂但是没什么用");
        ValueOperations<String, User> operations=redisTemplate.opsForValue();
        //存入
        redisTemplate.opsForValue().set("deletekey", user);
        System.out.println("存入--是否存在："+redisTemplate.hasKey("deletekey"));
        //删除
        redisTemplate.delete("deletekey");
        System.out.println("删除--是否存在："+redisTemplate.hasKey("deletekey"));
    }

运行结果：

4、Hash（哈希）

Redis 存储⼀个 key会有⼀个最⼩内存，不管你存的这个键多⼩，都不会低于这个内存，因此合理的使⽤ Hash 可以帮我们节省很多内存。

在Redis中，哈希类型是指键值本身又是一个键值对 结构，形如value={{field1，value1}，...{fieldN，valueN}}。

String和Hash的区别

Hash Set 就在哈希表 Key 中的域（Field）的值设为 value。如果 Key 不存在，⼀个新的哈希表被创建并进⾏ HSET 操作；如果域（field）已经存在于哈希表中，旧值将被覆盖。

    @Test
    public  void  testHash(){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put("hash","you","you");
        String value=(String) hash.get("hash","you");
        System.out.println("hash value :"+value);
    }

运行结果：

Hash set 的时候需要传⼊三个参数，第⼀个为 key，第⼆个为 field，第三个为存储的值。⼀般情况下 Key 代表⼀组数据，field 为 key 相关的属性，⽽ value 就是属性对应的值。

5、List

Redis List 的应⽤场景⾮常多，也是 Redis 最重要的数据结构之⼀。 使⽤ List 可以轻松的实现⼀个队列，List 典型的应⽤场景就是消息队列，可以利⽤ List 的 Push 操作，将任务存在 List 中，然后⼯作线程再⽤POP 操作将任务取出进⾏执⾏。

List push和pop示意图

    @Test
    public void testList() {
        ListOperations<String, String> list = redisTemplate.opsForList();
        list.leftPush("list","you");
        list.leftPush("list","go");
        list.leftPush("list","home");
        String value=(String)list.leftPop("list");
        System.out.println("list value :"+value.toString());
    }

运行结果：

上面的例子上⾯的例⼦从左侧插⼊⼀个 key 为 "list" 的队列，然后取出左侧最近的⼀条数据。List 有很多 API可以操作，⽐如从右侧进⾏插⼊队列从右侧进⾏读取，或者通过⽅法 range 读取队列的⼀部分。接着上⾯的例⼦使⽤ range 来读取。

子列表获取、删除等操作

       List<String> values=list.range("list",0,2);
        for (String v:values){
            System.out.println("list range :"+v);
        }

运行结果：

6、Set

集合（set）类型也是用来保存多个的字符串元素，但和列表类型不一 样的是，集合中不允许有重复元素，并且集合中的元素是无序的，不能通过 索引下标获取元素。

集合类型示意图

   @Test
    public void testSet() {
        String key="set";
        SetOperations<String, String> set = redisTemplate.opsForSet();
        set.add(key,"kick");
        set.add(key,"you");
        set.add(key,"you");
        set.add(key,"now");
        Set<String> values=set.members(key);
        for (String v:values){
            System.out.println("set value :"+v);
        }
    }

运行结果：

Redis 为集合提供了求交集、并集、差集等操作，可以⾮常⽅便的使⽤。

• difference

difference() 函数会把 key 1 中不同于 key 2 的数据对⽐出来

 @Test
    public  void  testDifference(){
        SetOperations<String, String> set = redisTemplate.opsForSet();
        String key1="setMore1";
        String key2="setMore2";
        set.add(key1,"it");
        set.add(key1,"you");
        set.add(key1,"you");
        set.add(key1,"know");
        set.add(key2,"xx");
        set.add(key2,"know");
        Set<String> diffs=set.difference(key1,key2);
        for (String v:diffs){
            System.out.println("diffs set value :"+v);
        }
    }

运行结果：

• unions

unions 会取两个集合的合集。

@Test
    public void  testUnions(){
        SetOperations<String, String> set = redisTemplate.opsForSet();
        String key3="setMore3";
        String key4="setMore4";
        set.add(key3,"it");
        set.add(key3,"you");
        set.add(key3,"xx");
        set.add(key4,"aa");
        set.add(key4,"bb");
        set.add(key4,"know");
        Set<String> unions=set.union(key3,key4);
        for (String v:unions){
            System.out.println("unions value :"+v);
        }
    }

运行结果：

7、ZSet

有序集合（ZSet）相对于哈希、列表、集合来说会有一点点陌生，但既然叫有序 集合，那么它和集合必然有着联系，它保留了集合不能有重复成员的特性， 但不同的是，有序集合中的元素可以排序。但是它和列表使用索引下标作为 排序依据不同的是，它给每个元素设置一个分数（score）作为排序的依据。

有序集合类型示意图

    @Test
    public void testZset(){
        String key="zset";
        redisTemplate.delete(key);
        ZSetOperations<String, String> zset = redisTemplate.opsForZSet();
        zset.add(key,"it's",1);
        zset.add(key,"your",6);
        zset.add(key,"show",4);
        zset.add(key,"time",3);
        Set<String> zsets=zset.range(key,0,3);
        for (String v:zsets){
            System.out.println("zset value :"+v);
        }
        Set<String> zsetB=zset.rangeByScore(key,0,3);
        for (String v:zsetB){
            System.out.println("zsetB value :"+v);
        }
    }

运行结果：

在实际开发中，不会给每⼀个使⽤的类都注⼊redisTemplate 来直接使⽤，⼀般都会对业务进⾏
简单的包装，最后提供出来对外使⽤。

参考：

【1】：《Spring Boot Vue全栈开发实战》
【2】：《精通 Spring Boot 42 讲》
【3】：《Redis开发和运维》
【4】：Spring Boot(三)：Spring Boot 中 Redis 的使用
【5】：SpringBoot非官方教程 | 第九篇： springboot整合Redis
【6】：spring-data-redis文档