Home Redis
Post
Cancel

Redis

Posted Feb 23, 2024
By yexca
12 min read

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

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

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

关系型数据库 (RDBMS)：

  • MySQL
  • Oracle
  • DB2
  • SQLServer

非关系型数据库 (NoSQL)：

  • Redis
  • Mongo DB
  • MemCached

Redis 下载安装与运行

下载地址：

Windows 版之间解压即可使用，Linux 版：

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

相关文件说明：

  • /usr/local/redis-4.0.0/src/redis-server：Redis 服务启动脚本
  • /usr/local/redis-4.0.0/src/redis-cli：Redis 客户端脚本
  • /usr/local/redis-4.0.0/redis.conf：Redis 配置文件

服务端启动，以 Windows 版为例，启动命令：

1

redis-server.exe redis.windows.conf

默认端口号为 6379，默认无密码，启动完成后可以用客户端连接

  • 命令行连接

通过 redis-cli.exe 进行连接

1

redis-cli.exe -h ip -p port -a password

如果省略，则使用 127.0.0.1:6379

可以通过修改配置文件 (redis.windows.conf) 设置密码

1

requirepass 123456

修改完成后重启生效

  • 图形化连接

Github：https://github.com/qishibo/AnotherRedisDesktopManager

下载安装后新建连接，输入相关信息后连接即可

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 大小写不敏感

字符串操作常用命令：

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");
}
后端, Redis
SpringBoot JavaWeb
This post is licensed under CC BY 4.0 by the author.
Recently Updated
Contents

GoLand 函数

Hi SpringCloud