redis相关知识点

redis 的相关知识点

启动

启动代码
```
 redis-cli -a 密码
```

通用命令

expire: 设置有效期

expire name 10

key

key *

相关数据类型

String

set：添加或者修改已经存在的一个String类型的键值对

set age 19

get：根据key获取String类型的value

get age

mset：批量添加多个String类型的键值对

mset k1 v1 k2 v2

mget：根据多个key获取多个String类型的value

mget k1 k2

incr：让一个整型的key自增1

 incr age

 19--->20

incrby:让一个整型的key自增并指定步长

incrby age 2

incrby age -1

incrbyfloat：让一个浮点类型的数字自增并指定步长

incrbyfloat score 0.5

setnx：添加一个String类型的键值对，前提是这个key不存在，否则不执行

setnx name leixin

setex：添加一个String类型的键值对，并且指定有效期

 setex names 10 "leixin"

Hash类型

HSET key field value：添加或者修改hash类型key的field的值

 hset leixin:name name "leixin"

 hset leixin:name name2 "leixin"

HGET key field：获取一个hash类型key的field的值

hget leixin:name name2

HMSET：批量添加多个hash类型key的field的值

HMGET：批量获取多个hash类型key的field的值

HGETALL：获取一个hash类型的key中的所有的field和value

hgetall leixin:name

HKEYS：获取一个hash类型的key中的所有的field

hkeys leixin:name

HVALS：获取一个hash类型的key中的所有的value

hvals leixin:name

HINCRBY:让一个hash类型key的字段值自增并指定步长

hincrby leixin:name age 2

HSETNX：添加一个hash类型的key的field值，前提是这个field不存在，否则不执行

List

特征与LinkedList类似：

有序
元素可以重复
插入和删除快
查询速度一般
常用来存储一个有序数据，例如：朋友圈点赞列表，评论列表等。

如何利用List结构模拟一个栈?

入口和出口在同一边

如何利用List结构模拟一个队列?

入口和出口在不同边

如何利用List结构模拟一个阻塞队列?

入口和出口在不同边出队时采用BLPOP或BRPOP

LPUSH key element ... ：向列表左侧插入一个或多个元素
```
lpush users 1 2 3 4 5
```
此时实际为 5 4 3 2 1
RPUSH key element ... ：向列表右侧插入一个或多个元素
```
 rpush users 6 7
```
此时实际为 5 4 3 2 1 6 7
LPOP key count：移除并返回列表左侧的count个元素，没有则返回nil
```
 lpop users 3
```
此时移除并返回 5 4 3
RPOP key count：移除并返回列表右侧的count元素
```
 rpop users 3
```
此时移除并返回的是 7 6 1
LRANGE key star end：返回一段角标范围内的所有元素
```
 lrange users 0 0
```
此时返回的是 2
BLPOP和BRPOP：与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil
```
 blpop users2 100
```
此时等待中

这个时候新开一个控制台
```
lpush users2 1
```
此时不超过100s的话就会出来结果
```
1) "users2"

2) "1"

(34.91s)
```

Set

Redis的Set结构与Java中的HashSet类似，可以看做是一个value为null的HashMap。因为也是一个hash表，因此具备与HashSet类似的特征：

无序
元素不可重复
查找快
支持交集、并集、差集等功能

SADD key member ... ：向set中添加一个或多个元素
```
sadd s1 a b c
```
SREM key member ... : 移除set中的指定元素
```
srem s1 a
```
SCARD key：返回set中元素的个数
```
scard s1
```
SISMEMBER key member：判断一个元素是否存在于set中
```
sismember s1 b
```
SMEMBERS：获取set中的所有元素
```
smembers s1
```
SINTER key1 key2 ... ：求key1与key2的交集
SDIFF key1 key2 ... ：求key1与key2的差集
SUNION key1 key2 ..：求key1和key2的并集

SortedSet

可排序
元素不重复
查询速度快

ZADD key score member：添加一个或多个元素到sorted set ，如果已经存在则更新其score值
```
zadd students 87 jack 88 jerry
```
ZREM key member：删除sorted set中的一个指定元素
```
zrem students jack
```
ZSCORE key member : 获取sorted set中的指定元素的score值
```
zscore students jerry
```
ZRANK key member：获取sorted set 中的指定元素的排名
```
 zrank students jerry
```
排名是从0开始的
ZCARD key：获取sorted set中的元素个数
```
 zcard students
```
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即可

SpringDataRedis

API	返回值类型	说明
redisTemplate.opsForValue()	ValueOperations	操作String类型数据
redisTemplate.opsForHash()	HashOperations	操作Hash类型数据
redisTemplate.opsForList()	ListOperations	操作List类型数据
redisTemplate.opsForSet()	SetOperations	操作Set类型数据
redisTemplate.opsForZSet()	ZSetOperations	操作SortedSet类型数据
redisTemplate		通用的命令

快速入门

导入依赖

<dependency>

            <groupId>org.apache.commons</groupId>

            <artifactId>commons-pool2</artifactId>

</dependency>

<dependency>

            <groupId>com.fasterxml.jackson.core</groupId>

            <artifactId>jackson-databind</artifactId>

</dependency>

配置文件

spring:

  redis:

    host: 192.168.122.120

    port: 6379

    password: 73883672

    jedis:

      pool:

        max-active: 8

        max-idle: 0

        max-wait: 100ms

进行测试

@Autowired

    private RedisTemplate redisTemplate;

    @Test

    void testString() {

        //写入一条String数据

        redisTemplate.opsForValue().set("name","google");

        //获取String数据

        Object name = redisTemplate.opsForValue().get("name");

        System.out.println(name);

    }

此时会发现redis数据库只有一些转码了的序列，此时我们需要进行手动序列化

@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;

    }

}

此时测试注入对象

 @Test

    void testSaveUser(){

        //User有两个参数，一个是name，一个是age

        redisTemplate.opsForValue().set("user:100",new User("leixin",20));

        User o =(User) redisTemplate.opsForValue().get("user:100");

        System.out.println("o = "+o);

    }

此时发现多了一个class参数，数据量一大，这是非常浪费空间的。
```
{

  "@class": "com.leixin.pojo.User",

  "name": "leixin",

  "age": 20

}
```

简单优化

使用StringRedisTemplate
写入Redis时，手动把对象序列化为JSON
读取Redis时，手动把读取到的JSON反序列化为对象

 @Autowired

    private StringRedisTemplate stringRedisTemplate;

    @Test

    void testString(){

    stringRedisTemplate.opsForValue().set("name","leixin");

    String name = stringRedisTemplate.opsForValue().get("name");

    System.out.println(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);

    }

	@Test

    void testHash() {

        stringRedisTemplate.opsForHash().put("user:400", "name", "虎哥");

        stringRedisTemplate.opsForHash().put("user:400", "age", "21");

        Map<Object, Object> entries = 		stringRedisTemplate.opsForHash().entries("user:400");

        System.out.println("entries = " + entries);

    }