Redis 入门、基础。（五种基本类型使用场景）
文章目录
- 1. 概况
-
- 1.1 认识 NoSQL
-
- 1.1.1 查询方式
- 1.1.2 事务
- 1.1.3 总结
- 2. 认识 Redis
- 4. Redis 常见命令
-
- 4.1 Redis 数据结构介绍
- 4.2 Redis 通用命令
- 4.3 Redis 命令之 String 命令
- 4.4 Redis 命令的层级结构
- 4.5 Redis 命令之 Hash 命令
- 4.6 Redis 命令之 List 命令
- 4.7 set 唯一不排序
- 4.8 SortedSet 唯一且排序
- 4.9 BitMap
- 5. SpringDataRedis
-
- 5.1 快速入门
- 5.2 数据序列化器
- 5.3 StringRedisTemplate
1. 概况
1.1 认识 NoSQL
NoSql 可以翻译做Not Only Sql（不仅仅是SQL），或者是No Sql（非Sql的）数据库。是相对于传统关系型数据库而言，有很大差异的一种特殊的数据库，因此也称之为非关系型数据库。
1.1.1 查询方式
传统关系型数据库会基于Sql语句做查询，语法有统一标准；
而不同的非关系数据库查询语法差异极大，五花八门各种各样。
1.1.2 事务
传统关系型数据库 能满足事务ACID的原则。
而 非关系型数据库 往往不支持事务，或者不能严格保证ACID的特性，只能实现基本的一致性。
1.1.3 总结
除了上述四点以外，在存储方式.扩展性.查询性能上关系型与非关系型也都有着显著差异，总结如下：
2. 认识 Redis
Redis诞生于2009年全称是Remote Dictionary Server 远程词典服务器，是一个基于内存的键值型NoSQL数据库。
特征：
- 键值（key-value）型，value支持多种不同数据结构，功能丰富
- 单线程，每个命令具备原子性
- 低延迟，速度快（基于内存.IO多路复用.良好的编码）。
- 支持数据持久化
- 支持主从集群.分片集群
- 支持多语言客户端
Redis的官方网站地址：https://redis.io/
4. Redis 常见命令
4.1 Redis 数据结构介绍
Redis是一个key-value的数据库，key一般是String类型，不过value的类型多种多样：
4.2 Redis 通用命令
通用指令是部分数据类型的，都可以使用的指令，常见的有：
- KEYS：查看符合模板的所有key
- DEL：删除一个指定的key
- EXISTS：判断key是否存在
- EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除
- TTL：查看一个KEY的剩余有效期
对应 RedisTemplate 方法：
// 匹配key
redisTemplate.keys("");
// 判断key是否存在
redisTemplate.hasKey(key);
// 删除key
redisTemplate.delete(key);
// 指定key有效期
redisTemplate.expire(key,time,TimeUnit.MINUTES);
// 根据key获取过期时间
Long expire = redisTemplate.getExpire(key);
4.3 Redis 命令之 String 命令
String 类型，也就是字符串类型，是Redis中最简单的存储类型。
其value是字符串，不过根据字符串的格式不同，又可以分为3类：
- string：普通字符串
- int：整数类型，可以做自增.自减操作
- float：浮点类型，可以做自增.自减操作
不管是哪种格式，底层都是字节数组形式存储，只不过是编码方式不同。字符串类型的最大空间不能超过 512 MB。 
String的常见命令有：
- SET：添加或者修改已经存在的一个 String 类型的键值对
- GET：根据 key 获取 String 类型的 value
- MSET：批量添加多个String类型的键值对
- MGET：根据多个 key 获取多个 String 类型的 value
- INCR：让一个整型的key自增1
- INCRBY:让一个整型的 key 自增并指定步长，例如：incrby num 2 让num值自增2
- INCRBYFLOAT：让一个浮点类型的数字自增并指定步长
- SETNX：添加一个 String 类型的键值对，前提是这个 key 不存在，否则不执行
- SETEX：添加一个 String 类型的键值对，并且指定有效期
RedisTemplate 方法：
ValueOperations ops = redisTemplate.opsForValue();
// 单独设置有效期（不推荐单独用）
ops.expire("StringKey",1,TimeUnit.MINUTES);
// 设置值 and 有效期（推荐这种）
ops.set("key", "value", 1, TimeUnit.MINUTES);
// 操作数值 增加 减少（INCR INCRBY）
ops.increment("key", 1);
ops.increment("key", -1);
// （SETNX + SETEX）：这个key不存在执行 存在则不执行，多用于互斥锁
ops.setIfAbsent("key", "value", 10, TimeUnit.SECONDS)
// 获取缓存值
ops.get("StringKey");
4.4 Redis 命令的层级结构
Redis 没有类似 MySQL中的 Table 的概念，我们该如何区分不同类型的key呢？
例如，需要存储用户.商品信息到 redis，有一个用户id是1，有一个商品id恰好也是1，此时如果使用id作为key，那就会冲突了，该怎么办？
我们可以通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范：
Redis的key允许有多个单词形成层级结构，多个单词之间用’:'隔开，格式如下：项目名:业务名:类型:id
这个格式并非固定，也可以根据自己的需求来删除或添加词条。
例如我们的项目名称叫 snow，有user和product两种不同类型的数据，我们可以这样定义key：
- user 相关的key：snow:user:1
- product 相关的key：snow:product:1
如果Value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储：
| key | value |
|---|---|
| snow:user:1 | {“id”:1, “name”: “Snow”, “age”: 21} |
| snow:product:1 | {“id”:1, “name”: “Apple”, “price”: 9999} |
4.5 Redis 命令之 Hash 命令
Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构。
String结构是将对象序列化为JSON字符串后存储，当需要修改对象某个字段时很不方便：
| key | value |
|---|---|
| snow:user:1 | {“id”:1, “name”: “Snow”, “age”: 88} |
| snow:product:1 | {“id”:1, “name”: “Apple”, “price”: 9999} |
Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD：
| Key | value | |
|---|---|---|
| field | value | |
| snow:user:1 | name | Snow |
| age | 88 | |
| snow:product:1 | name | Apple |
| price | 9999 |
Hash 类型的常见命令
- HSET key field value：添加或者修改 hash 类型 key 的 field 的值
- HGET key field：获取一个hash类型key的field的值
- HMSET：批量添加多个hash类型key的field的值
- HMGET：批量获取多个hash类型key的field的值
- HGETALL：获取一个hash类型的key中的所有的field和value
- HKEYS：获取一个hash类型的key中的所有的field
- HVALS：获取一个hash类型的key中的所有的value
- HINCRBY:让一个hash类型key的字段值自增并指定步长
- HSETNX：添加一个hash类型的key的field值，前提是这个field不存在，否则不执行
// 添加 put / putAll
// 初始数据:
template.opsForHash().put("redisHash","name","tom");
template.opsForHash().put("redisHash","age",26);
template.opsForHash().put("redisHash","class","6");
Map<String,Object> testMap = new HashMap();
testMap.put("name","jack");
testMap.put("age",27);
testMap.put("class","1");
template.opsForHash().putAll("redisHash1",testMap);
// 仅当hashKey不存在时才设置散列hashKey的值。
System.out.println(template.opsForHash().putIfAbsent("redisHash","age",30));
System.out.println(template.opsForHash().putIfAbsent("redisHash","kkk","kkk"));
//结果：
false
true
// 删除
template.opsForHash().delete("redisHash","name")
// 判断key是否存在
template.opsForHash().hasKey("redisHash","age")
// 获取
template.opsForHash().get("redisHash","age")
// 增加散列hashKey的值（整型）
System.out.println(template.opsForHash().get("redisHash","age"));
System.out.println(template.opsForHash().increment("redisHash","age",1));
// 结果：
26
27
// 获取key所对应的散列表的key
System.out.println(template.opsForHash().keys("redisHash1"));
//redisHash1所对应的散列表为{class=1, name=jack, age=27}
//结果：[name, class, age]
// 获取key所对应的散列表的大小个数
template.opsForHash().size("redisHash1");
//redisHash1所对应的散列表为{class=1, name=jack, age=27}
//结果：3
// 获取整个哈希存储的值
template.opsForHash().values("redisHash");
// 结果：[tom, 26, 6]
// 获取整个哈希存储
template.opsForHash().entries("redisHash");
// 结果：{age=26, class=6, name=tom}
// 使用Cursor在key的hash中迭代，相当于迭代器。
Cursor<Map.Entry<Object, Object>> curosr = ops.scan("redisHash", ScanOptions.ScanOptions.NONE);
while(curosr.hasNext()){
Map.Entry<Object, Object> entry = curosr.next();
System.out.println(entry.getKey()+":"+entry.getValue());
}
//结果：
age:28.1
class:6
kkk:kkk
4.6 Redis 命令之 List 命令
Redis中的List类型与Java中的 LinkedList 类似，可以看做是一个 双向链表 结构。既可以支持正向检索也可以支持反向检索。
特征也与LinkedList类似：
- 有序
- 元素可以重复
- 插入和删除快
- 查询速度一般
常用来存储一个有序数据，例如：朋友圈点赞列表，评论列表等。
List的常见命令有：
- LPUSH key element … ：向列表左侧插入一个或多个元素
- LPOP key：移除并返回列表左侧的第一个元素，没有则返回nil
- RPUSH key element … ：向列表右侧插入一个或多个元素
- RPOP key：移除并返回列表右侧的第一个元素
- LRANGE key star end：返回一段角标范围内的所有元素
- BLPOP和BRPOP：与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil
// 从左边插入
template.opsForList().leftPush("list","java");
// 从右边插入
template.opsForList().rightPush("listRight","java");
// 把一个数组批量插入到列表中
String[] stringarrays = new String[]{"1","2","3"};
// 可以插入数组也可以插入集合
template.opsForList().leftPushAll("listarray", stringarrays);
//template.opsForList().rightPushAll("listarrayright",stringarrays);
template.opsForList().range("listarray",0, -1);
// 结果:[3, 2, 1]
// 获取
template.opsForList().range("listRight",0, -1);
template.opsForList().index("listRight",2);//下标从0开始
// 结果如下:
[java, python, c++]
c++
// 获取长度
template.opsForList().size("list")
// 弹出
template.opsForList().range("list",0,-1);
template.opsForList().leftPop("list");
template.opsForList().range("list",0,-1);
// 结果:
[c++, python, oc, java, c#, c#]
c++
[python, oc, java, c#, c#]
4.7 set 唯一不排序
Redis的Set结构与Java中的HashSet类似，可以看做是一个value为null的HashMap。因为也是一个hash表，因此具备与HashSet类似的特征：
- 无序
- 元素不可重复
- 查找快
- 支持交集、并集、差集等功能
Set的常见命令有：
- SADD key member … ：向set中添加一个或多个元素
- SREM key member … : 移除set中的指定元素
- SCARD key： 返回set中元素的个数
- SISMEMBER key member：判断一个元素是否存在于set中
- SMEMBERS：获取set中的所有元素
- SINTER key1 key2 … ：求key1与key2的交集
eg:
求交集：SINTER s1 s2
求s1与s2的不同：SDIFF s1 s2 （A）
求s1与s2的并集：SUNION s1 s2
练习：
- 将下列数据用Redis的Set集合来存储：
- 张三的好友有：李四、王五、赵六
- SADD zs lisi wangwu zhaoliu
- 李四的好友有：王五、麻子、二狗
- SADD lisi wangwu mazi ergou
- 利用Set的命令实现下列功能：
- 计算张三的好友有几人
- SCARD zs
- 计算张三和李四有哪些共同好友
- SINTER zs li
- 查询哪些人是张三的好友却不是李四的好友
- SDIFF zs lisi
- 查询张三和李四的好友总共有哪些人
- SUNION zs lisi
- 判断李四是否是张三的好友
- SISMEMBER zs lisi
- 判断张三是否是李四的好友
- SISMEMBER lisi zs
- 将李四从张三的好友列表中移除
- SREM zs lisi
常用方法：
// 判断当前登录用户是否已经点赞
String key = BLOG_LIKED_KEY + id;
Boolean isMember = stringRedisTemplate.opsForSet().isMember(key, userId.toString());
// 保存用户到Redis的set集合
stringRedisTemplate.opsForSet().add(key, userId.toString());
// 把用户从Redis的set集合移除
stringRedisTemplate.opsForSet().remove(key, userId.toString());
// 求两个 key 的交集
Set<String> intersect = stringRedisTemplate.opsForSet().intersect(key, key2);
使用场景：
需求：利用Redis中恰当的数据结构，实现共同关注功能。在博主个人页面展示出当前用户与博主的共同关注呢。
当然是使用我们之前学习过的set集合咯，在set集合中，有交集并集补集的api，我们可以把两人的关注的人分别放入到一个set集合中，然后再通过api去查看这两个set集合中的交集数据。
4.8 SortedSet 唯一且排序
Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加 hash表。
SortedSet具备下列特性：
- 可排序
- 元素不重复
- 查询速度快
因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能。
SortedSet的常见命令有：
- ZADD key score member：添加一个或多个元素到sorted set ，如果已经存在则更新其score值
- ZREM key member：删除sorted set中的一个指定元素
- ZSCORE key member : 获取sorted set中的指定元素的score值
- ZRANK key member：获取sorted set 中的指定元素的排名
- ZCARD key：获取sorted set中的元素个数
- ZCOUNT key min max：统计score值在给定范围内的所有元素的个数
- ZINCRBY key increment member：让sorted set中的指定元素自增，步长为指定的increment值
- ZRANGE key min max：按照score排序后，获取指定排名范围内的元素
- ZRANGEBYSCORE key min max：按照score排序后，获取指定score范围内的元素
- ZDIFF、ZINTER、ZUNION：求差集、交集、并集
注意：所有的排名默认都是升序，如果要降序则在命令的Z后面添加REV即可，例如：
- 升序获取sorted set 中的指定元素的排名：ZRANK key member
- 降序获取sorted set 中的指定元素的排名：ZREVRANK key memeber
练习题：
将班级的下列学生得分存入Redis的SortedSet中：
Jack 85, Lucy 89, Rose 82, Tom 95, Jerry 78, Amy 92, Miles 76
并实现下列功能：
- 删除Tom同学
- 获取Amy同学的分数
- 获取Rose同学的排名
- 查询80分以下有几个学生
- 给Amy同学加2分
- 查出成绩前3名的同学
- 查出成绩80分以下的所有同学
// 保存用户到Redis的set集合 zadd key value score
stringRedisTemplate.opsForZSet().add(key, userId.toString(), System.currentTimeMillis());
// 获取当前登录用户是否已经点赞
String key = BLOG_LIKED_KEY + id;
Double score = stringRedisTemplate.opsForZSet().score(key, userId.toString());
// 把用户从Redis的set集合移除 key value
stringRedisTemplate.opsForZSet().remove(key, userId.toString());
// 查询top5的点赞用户 zrange key 0 4 (范围查询)
Set<String> top5 = stringRedisTemplate.opsForZSet().range(key, 0, 4);
4.9 BitMap
BitMap 的操作命令有：
- SETBIT：向指定位置（offset）存入一个0或1
- GETBIT ：获取指定位置（offset）的bit值
- BITCOUNT ：统计BitMap中值为1的bit位的数量
- BITFIELD ：操作（查询、修改、自增）BitMap中bit数组中的指定位置（offset）的值
- BITFIELD_RO ：获取BitMap中bit数组，并以十进制形式返回
- BITOP ：将多个BitMap的结果做位运算（与 、或、异或）
- BITPOS ：查找bit数组中指定范围内第一个0或1出现的位置
实现签到
//写入Redis SETBIT key offset 1（签到）
stringRedisTemplate.opsForValue().setBit(key, dayOfMonth, true);
统计连续签到天数
@Override
public Result signCount() {
// 1.获取当前登录用户
Long userId = UserHolder.getUser().getId();
// 2.获取日期
LocalDateTime now = LocalDateTime.now();
// 3.拼接key
String keySuffix = now.format(DateTimeFormatter.ofPattern(":yyyyMM"));
String key = USER_SIGN_KEY + userId + keySuffix;
// 4.获取今天是本月的第几天
int dayOfMonth = now.getDayOfMonth();
// 5.获取本月截止今天为止的所有的签到记录，返回的是一个十进制的数字 BITFIELD sign:5:202203 GET u14 0
List<Long> result = stringRedisTemplate.opsForValue().bitField(
key,
BitFieldSubCommands.create()
.get(BitFieldSubCommands.BitFieldType.unsigned(dayOfMonth)).valueAt(0)
);
if (result == null || result.isEmpty()) {
// 没有任何签到结果
return Result.ok(0);
}
Long num = result.get(0);
if (num == null || num == 0) {
return Result.ok(0);
}
// 6.循环遍历
int count = 0;
while (true) {
// 6.1.让这个数字与1做与运算，得到数字的最后一个bit位 // 判断这个bit位是否为0
if ((num & 1) == 0) {
// 如果为0，说明未签到，结束
break;
}else {
// 如果不为0，说明已签到，计数器+1
count++;
}
// 把数字右移一位，抛弃最后一个bit位，继续下一个bit位
num >>>= 1;
}
return Result.ok(count);
}
5. SpringDataRedis
SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，官网地址：https://spring.io/projects/spring-data-redis
- 提供了对不同Redis客户端的整合（Lettuce和Jedis）
- 提供了RedisTemplate统一API来操作Redis
- 支持Redis的发布订阅模型
- 支持Redis哨兵和Redis集群
- 支持基于Lettuce的响应式编程
- 支持基于JDK.JSON.字符串.Spring对象的数据序列化及反序列化
- 支持基于Redis的JDKCollection实现
SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中：
5.1 快速入门
导入坐标：
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-data-redisartifactId>
dependency>
<dependency>
<groupId>org.apache.commonsgroupId>
<artifactId>commons-pool2artifactId>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
配置文件：
spring:
redis:
host: 127.0.0.1
port: 6379
password: pwd
lettuce:
pool:
max-active: 8 #最大连接
max-idle: 8 #最大空闲连接
min-idle: 0 #最小空闲连接
max-wait: 100ms #连接等待时间
测试
@SpringBootTest
class RedisDemoApplicationTests {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Test
void testString() {
// 写入一条String数据
redisTemplate.opsForValue().set("name", "SNOW");
// 获取string数据
Object name = redisTemplate.opsForValue().get("name");
System.out.println("name = " + name);
}
}
5.2 数据序列化器
RedisTemplate可以接收任意Object作为值写入Redis：
只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的：
缺点：
- 可读性差
- 内存占用较大
可以自定义如下配置：
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){
// 创建RedisTemplate对象
RedisTemplate<String, Object> template = new RedisTemplate<>();
// 设置连接工厂
template.setConnectionFactory(connectionFactory);
// 创建JSON序列化工具
GenericJackson2JsonRedisSerializer jsonRedisSerializer =
new GenericJackson2JsonRedisSerializer();
// 设置Key的序列化
template.setKeySerializer(RedisSerializer.string());
template.setHashKeySerializer(RedisSerializer.string());
// 设置Value的序列化
template.setValueSerializer(jsonRedisSerializer);
template.setHashValueSerializer(jsonRedisSerializer);
// 返回
return template;
}
}
这里采用了JSON序列化来代替默认的JDK序列化方式。最终结果如图：
图略。
整体可读性有了很大提升，并且能将Java对象自动的序列化为JSON字符串，并且查询时能自动把JSON反序列化为Java对象。
不过，其中记录了序列化时对应的 class 名称，目的是为了查询时实现自动反序列化。这会带来额外的内存开销。
5.3 StringRedisTemplate
方法详解
尽管之前 JSON 的序列化方式可以满足我们的需求，但依然存在一些问题，如下：
{
"Class": "com.snow.Student",
"name": "wang",
"age": 18
}
为了在反序列化时知道对象的类型，JSON序列化器会将类的 class 类型写入json结果中，存入Redis，会带来额外的内存开销。
为了减少内存的消耗，我们可以采用手动序列化的方式，换句话说，就是不借助默认的序列化器，而是我们自己来控制序列化的动作，同时，我们只采用String的序列化器，这样，在存储value时，我们就不需要在内存中就不用多存储数据，从而节约我们的内存空间
这种用法比较普遍，因此SpringDataRedis就提供了RedisTemplate的子类：StringRedisTemplate，它的key和value的序列化方式默认就是String方式。
省去了我们自定义RedisTemplate的序列化方式的步骤，而是直接使用：
@SpringBootTest
class RedisStringTests {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Test
void testString() {
// 写入一条String数据
stringRedisTemplate.opsForValue().set("verify:phone:13600008888", "124143");
// 获取string数据
Object name = stringRedisTemplate.opsForValue().get("name");
System.out.println("name = " + name);
}
private static final ObjectMapper mapper = new ObjectMapper();
@Test
void testSaveUser() throws JsonProcessingException {
// 创建对象
User user = new User("虎哥", 21);
// 手动序列化
String json = mapper.writeValueAsString(user);
// 写入数据
stringRedisTemplate.opsForValue().set("user:200", json);
// 获取数据
String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
// 手动反序列化
User user1 = mapper.readValue(jsonUser, User.class);
System.out.println("user1 = " + user1);
}
}
此时我们再来看一看存储的数据，小伙伴们就会发现那个class数据已经不在了，节约了我们的空间~
{
"name": "wang",
"age": 18
}
总结：
RedisTemplate的两种序列化实践方案：
- 方案一：
- 自定义RedisTemplate
- 修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer
会占用额外的内存空间 记录字节码
- 方案二：
- 使用StringRedisTemplate
- 写入Redis时，手动把对象序列化为JSON
- 读取Redis时，手动把读取到的JSON反序列化为对象
