Redis

Redis 基础: 本文
Redis 分布式缓存: https://blog.yexca.net/archives/225/

Redis 是一个基于内存的 key-value 结构数据库，是互联网技术领域使用最为广泛的存储中间件

官网： https://redis.io
中文网： https://www.redis.net.cn/

Redis 基于内存存储，读写性能高，适合存储热点数据 (商品、资讯、新闻) 。是用 C 语言开发的一个开源的高性能键值对数据库，存储 value 类型比较丰富，也被称为结构化的 NoSql (Not Only SQL) 数据库

NoSql 泛指非关系型数据库，并不是要取代关系型数据库，而是关系型数据库的补充

关系型数据库 (RDBMS)：

MySQL
Oracle
DB2
SQLServer

非关系型数据库 (NoSQL)：

Redis
Mongo DB
MemCached

Redis 下载安装与运行

下载地址：

Windows: https://github.com/microsoftarchive/redis/releases
Linux: https://download.redis.io/releases/
cn: http://www.redis.cn/download.html

Windows 版直接解压即可使用，Linux 版：

解压 tar -zxvf redis-4.0.0.tar.gz -C /usr/local
安装依赖环境 yum install gcc-c++
进入安装目录，编译 make
进入 redis 的 src 目录安装 make install

Docker 部署

拉取镜像

1
docker pull redis

获取配置文件，下载对应版本，抽取配置文件即可，Linux 为 redis.conf

创建 Redis 数据映射文件夹，例如

1
2
mkdir /home/redis
mkdir /home/redis/data

修改配置文件，传送至部署机子，例如使用 scp 从 Win 传至 Linux

1
scp pathOfFile root@IP:/PathOfFile

启动

1
docker run -p 6379:6379 --name redis -v /home/redis/redis.conf:/etc/redis/redis.conf  -v /home/redis/data:/data -d redis redis-server /etc/redis/redis.conf

参考资料： https://cloud.tencent.com/developer/article/1670205

Redis 数据类型

Redis 的 key 是字符串类型，value 有 5 种常用的数据类型

字符串 (string)：普通字符串
哈希 (hash)：也叫散列
列表 (list)：按插入顺序排序，可以有重复元素
集合 (set)：无序集合，不允许重复元素
有序集合 (sorted set/zset)：集合中每个元素关联一个分数 (score)，根据分数升序排序

Redis 数据类型

Redis 常用命令

Redis 大小写不敏感

字符串操作常用命令：

1
2
3
4
5
6
7
8
# 设置指定 key 值
SET key value
# 获取指定 key 值
GET key
# 设置指定 key 值，并将 key 的过期时间设为 seconds 秒
SETEX key seconds value
# 只在 key 不存在时才设置 key 的值
SETNX key value

hash 是一个 string 类型的 field 和 value 映射表，特别适合存储对象，常用命令：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# 将哈希表 key 中的 field 值设为 value
HSET key field value
# 获取存储在哈希表中指定字段的值
HGET key field
# 删除存储在哈希表中的指定字段
HDEL key field
# 获取哈希表中所有字段
HKEYS key
# 获取哈希表中所有值
HVALS key

列表是简单的字符串列表，按照插入顺序排列，常用命令：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# 将一个或多个值插入到列表头部
LPUSH key value1 [value2]
# 获取列表指定范围内的元素
LRANGE key start stop
# 移除并获取列表最后一个元素
RPOP key
# 获取列表长度
LLEN key
# 移出并获取列表的最后一个元素
# 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
BRPOP key1 [key2] timeout

类似队列，先进先出

集合是字符串类型的无序集合，集合成员唯一，常用命令：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# 向集合添加一个或多个成员
SADD key member1 [member2]
# 返回集合中的所有成员
SMEMBERS key
# 获取集合的成员数
SCARD key
# 返回给定所有集合的交集
SINTER key2 [key2]
# 返回所有给定集合的并集
SUNION key1 [key2]
# 移除集合中一个或多个成员
SREM key member1 [member2]

有序集合是字符串类型元素的集合，每个成员关联一个 double 类型的分数，常用命令：

1
2
3
4
5
6
7
8
# 向有序集合添加一个或多个成员
ZADD key score1 member1 [score2 member2]
# 通过索引区间返回有序集合中指定区间内的成员
ZRANGE key start stop [WITHSCORES]
# 有序集合中对指定成员的分数加上增量increment
ZINCRBY key increment member
# 移除有序集合中的一个或多个成员
ZREM key member1 [member2]

除了各数据类型专有，还有通用命令，即所有类型都可以使用的命令：

1
2
3
4
5
6
7
8
# 查找所有符合给定模式(pattern)的key
KEYS pattern # pattern可以为*
# 检查指定key是否存在
EXISTS key
# 返回key所存储的值的类型
TYPE key
# 在key存在时删除key
DEL key

在 Java 中操作 Redis

如同使用 JDBC 操作 MySQL 数据库一样，需要使用 Redis 的 Java 客户端进行操作 Redis

Redis 的 Java 客户端很多，常用的几种：

Jedis
Lettuce
Spring Data Redis

Jedis 封装最好，与 Redis 命令相同，是官方推荐；Lettuce 对线程调用更好，性能更好；Spring 对 Redis 客户端进行了整合，提供了 Spring Data Redis，在 Spring Boot 项目中还提供了对应的 Starter，即 spring-boot-starter-data-redis

Spring Data Redis

Spring Data Redis 是 Spring 的一部分，提供了在 Spring 应用中通过简单的配置就可以访问 Redis 服务，对 Redis 底层开发包进行了高度封装。在 Spring 项目中，可以使用Spring Data Redis来简化 Redis 操作。网址： https://spring.io/projects/spring-data-redis

Maven 坐标：

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Spring Data Redis 中提供了一个高度封装类 RedisTemplate 对相关 api 进行了归类封装，将同一类型的操作封装为 operation 接口：

ValueOperations：string 数据操作
SetOperations：set 类型数据操作
ZSetOperations：zset 类型数据操作
HashOperations：hash 类型的数据操作
ListOperations：list 类型的数据操作

配置 Redis 数据源，配置文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
# application
spring:
  profiles:
    active: dev
  redis:
    host: ${sky.redis.host}
    port: ${sky.redis.port}
    password: ${sky.redis.password}
    database: ${sky.redis.database}

# -dev
sky:
  redis:
    host: localhost
    port: 6379
    password: 123456
    # 使用哪个数据库，不填默认为 0
    database: 10 

Redis 默认有 16 个数据库 (0-15)，可以通过修改配置文件来指定数据库的数量

编写配置类，创建 RedisTemplate 对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
@Configuration
@Slf4j
public class RedisConfiguration {
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        log.info("开始创建 Redis 对象");
        RedisTemplate redisTemplate = new RedisTemplate();
        // 设置 redis 的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 设置 redis key 的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

此配置类不是必须的，SpringBoot 框架会自动装配 RedisTemplate 对象，不过默认的序列化器为 JdkSerializationRedisSerializer，存储到 Redis 中的数据与原始数据有差别

字符串类型数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
@SpringBootTest
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    public void testString(){
        // set
        redisTemplate.opsForValue().set("name", "Tom");
        // get
        String name =(String) redisTemplate.opsForValue().get("name");
        System.out.println(name);
        // setex
        redisTemplate.opsForValue().set("code", "1234", 2, TimeUnit.MINUTES);
        // setnx
        redisTemplate.opsForValue().setIfAbsent("lock","1");
        redisTemplate.opsForValue().setIfAbsent("lock","2");
    }
}

哈希类型数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
@Test
public void testHash(){
    HashOperations hashOperations = redisTemplate.opsForHash();
    // hset
    hashOperations.put("100", "name", "Jerry");
    hashOperations.put("100", "age", "20");
    // hget
    String name =(String) hashOperations.get("100", "name");
    System.out.println(name);
    // hkeys
    Set keys = hashOperations.keys("100");
    System.out.println(keys);
    // hvals
    List values = hashOperations.values("100");
    System.out.println(values);
    // hdel
    hashOperations.delete("100", "name");
}

列表类型数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
@Test
public void testList(){
    ListOperations listOperations = redisTemplate.opsForList();
    // lpush
    listOperations.leftPushAll("mylist", "a", "b", "c");
    listOperations.leftPush("mylist", "d");
    // lrange
    List mylist = listOperations.range("mylist", 0, -1);
    System.out.println(mylist);
    // rpop
    listOperations.rightPop("mylist");
    // llen
    Long size = listOperations.size("mylist");
    System.out.println(size);
}

集合类型数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
@Test
public void testSet(){
    SetOperations setOperations = redisTemplate.opsForSet();
    // sadd
    setOperations.add("set1","a","b","c","d");
    setOperations.add("set2","a","b","x","y");
    // smembers
    Set members = setOperations.members("set1");
    System.out.println(members);
    // scard
    Long size = setOperations.size("set1");
    System.out.println(size);
    // sinter
    Set intersect = setOperations.intersect("set1", "set2");
    System.out.println(intersect);
    // sunion
    Set union = setOperations.union("set1", "set2");
    System.out.println(union);
    // srem
    setOperations.remove("set1", "a", "b");
}

有序集合类型数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
@Test
public void testZset(){
    ZSetOperations zSetOperations = redisTemplate.opsForZSet();
    // zadd
    zSetOperations.add("zset1", "a", 10);
    zSetOperations.add("zset1", "b", 12);
    zSetOperations.add("zset1", "c", 9);
    // zrange
    Set zset = zSetOperations.range("zset1", 0, -1);
    System.out.println(zset);
    // zincrby
    zSetOperations.incrementScore("zset1", "c", 10);
    // zrem
    zSetOperations.remove("zset1", "a", "b");
}

通用命令操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
@Test
public void testCommon(){
    // keys
    Set keys = redisTemplate.keys("*");
    System.out.println(keys);
    // exists
    Boolean name = redisTemplate.hasKey("name");
    System.out.println(name);
    // type
    for (Object key : keys) {
        DataType type = redisTemplate.type(key);
        System.out.println(type.name());
    }
    // del
    redisTemplate.delete("set2");
}