Redis介绍 AND SpringBoot集成Redis

redis

1.redis介绍

Redis定义

Redis是C语言开发的一个开源的高性能键值对（key-value）数据库，可以用作数据库，缓存，消息中间件，他是一个种非关系型数据库。

特点

• 性能优秀，数据在内存中，读写速度非常快，支持10W的并发请求。
• 单进程单线程是线程安全的
• 丰富的数据类型，String，list，hash,set,zset
• 支持数据的持久化，可以将内存中的数据保存到磁盘中，重启时加载
• 主从复制，哨兵，高可用可以用作分布式锁，可以作为消息中间件使用，支持发布订阅。

2.redis安装

1.直接到https://github.com/MicrosoftArchive/redis/releases下载，我这里说一下解压版本的安装。
2.直接解压redis-xx.zip
3.进入目录，在redis.windows.conf中搜索requirepassword设置redis的认证密码。
4.在命令行进入redis的安装目录执行：redis-server.exe --service-install redis.windows.conf
5.在windows 服务中找到redis启动。

3.redis的数据类型

string（字符串）

string是redis最基本的类型，一个key对应一个value

string类型是二进制安全的，redis的string可以包含任何数据。

string类型最大能存储512MB

使用命令 set，get 就可以实现存储string

127.0.0.1:6379> set xpf "heixiaofei"
OK
127.0.0.1:6379> get xpf
"heixiaofei"
127.0.0.1:6379>

Hash(哈希)

Redis Hash 是一个键值（key=>value）对集合

Redis Hash 是一个string类型的field和value的映射表，hash适合用于存储对象

Redis存储hash使用，HMSET,HGET 命令，每个hash可以存储40多亿键值对

127.0.0.1:6379> del xpf
(integer) 1
127.0.0.1:6379> hmset xpf filed1 "xxxx" field2 "yyyy"
OK
127.0.0.1:6379> hget xpf field2
"yyyy"
127.0.0.1:6379> hget xpf filed1
"xxxx"
127.0.0.1:6379>

List<列表>

Redis列表是简单的字符串列表，按照插入顺序排序。

Redis 的列表最多可存储40多亿元素

127.0.0.1:6379> del xpf
(integer) 1
127.0.0.1:6379> lpush xpf redis
(integer) 1
127.0.0.1:6379> lpush xpf mongodb
(integer) 2
127.0.0.1:6379> lpush xpf rabbitMQ
(integer) 3
127.0.0.1:6379> lrange xpf 0 10
1) "rabbitMQ"
2) "mongodb"
3) "redis"
127.0.0.1:6379> lrange xpf 0 2
1) "rabbitMQ"
2) "mongodb"
3) "redis"
127.0.0.1:6379>

Set<集合>

Redis的Set是string类型的无序集合

集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是o(1)

sadd命令，添加一个string元素到key对应的set集合中，成功返回1，存在返回0（集合内元素的唯一性）

127.0.0.1:6379> del xpf
(integer) 1
127.0.0.1:6379> sadd xpf redis
(integer) 1
127.0.0.1:6379> sadd xpf mongodb
(integer) 1
127.0.0.1:6379> sadd xpf rabbitMQ
(integer) 1
127.0.0.1:6379> sadd xpf redis
(integer) 0
127.0.0.1:6379> smembers xpf
1) "redis"
2) "rabbitMQ"
3) "mongodb"
127.0.0.1:6379>

zset(sorted set:有序集合)

Redis zset和set一样也是string类型元素的集合，且不允许重复的成员

每个元素都会关联一个double类型的分数，redis通过分数为集合中元素升序排列

zset中成员是唯一的，但分数（score)可以重复

zadd 命令

127.0.0.1:6379> del xpf
(integer) 1
127.0.0.1:6379> zadd xpf 4 redis
(integer) 1
127.0.0.1:6379> zadd xpf 3 mongodb
(integer) 1
127.0.0.1:6379> zadd xpf 2 rabbitMQ
(integer) 1
127.0.0.1:6379> zadd xpf 2 redis
(integer) 0
127.0.0.1:6379> zrangebyscore xpf 0 1000
1) "rabbitMQ"
2) "redis"
3) "mongodb"
127.0.0.1:6379> zadd xpf 6 redis
(integer) 0
127.0.0.1:6379> zrangebyscore xpf 0 1000
1) "rabbitMQ"
2) "mongodb"
3) "redis"
127.0.0.1:6379>
<!--从这里可以看出，当第二次加同一个元素时，返回的结果为0，但是score发生了改变。排序发生了变化 -->

4.Redis的发布订阅

Redis支持发布订阅的消息通信模式，发送者（pub)发送消息，订阅者（sub)接收消息

当有新消息通过PUBLISH命令发送给频道channel1时，这个消息就会被发送给它的三个客户端：

订阅 redisChat 频道

D:\developmentTools\redis\redis-3.2>redis-cli
127.0.0.1:6379> auth xykj.8387
OK
127.0.0.1:6379> subscribe redisChat
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1
1) "message"
2) "redisChat"

给 RedisChat 频道推送消息

127.0.0.1:6379> publish redisChat "redis is a great caching technique"
(integer) 1
127.0.0.1:6379>

这个时候订阅消息的客户端就会接收到发送的消息。

3) "redis is a great caching technique"

5.redis的事务

一个事务从开始到执行会经历以下三个阶段：

• 开始事务。
• 命令入队。
• 执行事务。

127.0.0.1:6379> multi //开始事务
OK
127.0.0.1:6379> set a aaa    //命令入队
QUEUED
127.0.0.1:6379> set b bbb //命令入队
QUEUED 
127.0.0.1:6379> set c ccc //命令入队
QUEUED
127.0.0.1:6379> exec //执行事务
1) OK
2) OK
3) OK
127.0.0.1:6379>

单个redis命令执行时原子性的，但redis没有在事务上增加任何维持原子性的机制，所以redis事务的执行并不是原子性的。

批量指令并非原子化的操作，中间某条指令的失败不会导致前面的指令回滚，也不会导致后面的指令不执行。

6.redis数据备份与恢复

数据备份

redis SAVE 命令用于创建当前数据库的备份

127.0.0.1:6379> save
OK

该命令在redis的安装目录中创建dump.rdb文件

使用BGSAVE 命令也可以创建redis备份文件，在后台运行

127.0.0.1:6379> bgsave
Background saving started
127.0.0.1:6379>

数据恢复

将备份文件dump.rdb移动到redis安装目录并启动服务，获取redis目录使用 config get dir 命令

127.0.0.1:6379> config get dir
1) "dir"
2) "D:\\developmentTools\\redis\\redis-3.2"

7.SpringBoot 集成 redis

源码下载地址：

https://github.com/prettycharacter/boot_redis.git

1.创建项目

使用idea创建一个SpringBoot项目

File→new→project→Spring Initializr→next…

2.引入依赖

 <!--加入redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

3.编写application.yml配置文件

# 增加redis的配置
spring:
  redis:
    #redis的数据库索引，默认为0
    database: 0
    #redis服务器地址
    host: 127.0.0.1
    #redis 服务器端口
    port: 6379
    password: xykj.8387
    redis:
      pool:
        # 连接池最大连接数
        max-active: 200
        # 阻塞等待时间
        max-wait: -1
        #最大空闲连接
        max-idle: 10
        #最小空闲连接
        min-idle: 10
    # 连接超时时间
    timeout: 1000

4.自定义一个redisTemplate

SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate。但是，这个RedisTemplate的泛型是<Object,Object>，写代码不方便，需要写好多类型转换的代码；我们需要一个泛型为<String,Object>形式的RedisTemplate。

package xpf.learn.redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author xpf
 * @date 2020/5/26 11:45
 */
@Configuration
public class RedsiConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用String的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        //hash的key也采用String的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        //value序列化采用jackson
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        //hash 的value序列化方式采用jackson
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();

        return redisTemplate;
    }
}

5.编写redis工具类

package xpf.learn.redis.util;

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

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

/**
 * @author xpf
 * @date // :
 */
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

//=============================common============================

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    //================================Map=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    //============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

6.写一个测试

package xpf.learn.redis;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import xpf.learn.redis.entity.User;
import xpf.learn.redis.util.RedisUtil;

import javax.annotation.Resource;

@SpringBootTest
class RedisApplicationTests {
    @Resource
    private RedisUtil redisUtil;

    @Test
    void testRedis() {
        User user = new User();
        user.setUserName("xpf");
        user.setPassword("xpf6960585");
        user.setType("管理员");
        redisUtil.set("user", user);
    }
}

测试结果：redis库中多个一个key为user的数据。

8.启动项目就加载缓存

1.编写初始化类

package xpf.learn.redis.init;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import xpf.learn.redis.service.InitService;

/**
 *ApplicationRunner
 * 在开发中可能会有这样的情景。需要在容器启动的时候执行一些内容。比如读取配置文件，数据库连接之类的。
 * SpringBoot给我们提供了两个接口来帮助我们实现这种需求。这两个接口分别为CommandLineRunner和ApplicationRunner。
 * 他们的执行时机为容器启动完成的时候。
 *
 *ApplicationListener 监听器
 *当我们使用spring boot项目开发时候，碰到应用启动后做一些初始化操作，可以使用ApplicationListener。
 * 比如：netty 随着应用启动完成后进行初始化、初始化定时任务
 * @author xpf
 * @date 2020/5/26 14:31
 */
@Component
public class init implements ApplicationRunner {

    @Autowired
    private InitService initService;

    @Async
    @Override
    public void run(ApplicationArguments args) throws Exception {
            initService.init();
    }
}

2.初始化数据服务

package xpf.learn.redis.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.task.TaskExecutor;
import org.springframework.stereotype.Service;
import xpf.learn.redis.entity.User;
import xpf.learn.redis.util.RedisUtil;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * @author xpf
 * @date 2020/5/26 15:05
 */
@Service
public class InitService {
    Logger logger = LoggerFactory.getLogger(InitService.class);
    @Resource
    private RedisUtil redisUtil;
    @Resource
    private TaskExecutor taskExecutor;

    public void init() {
        logger.info("进入初始化缓存的方法+++++++++++++++++++++++++");
        User xpf = new User();
        xpf.setUserName("xpf");
        xpf.setPassword("xpf696058");
        xpf.setType("小神童");
        redisUtil.set("xpf", xpf);
    }