关于java:redis相关知识点

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

expire: 设置有效期

expire name 10

key

key *

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"

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 不存在，否则不执行

特色与 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)
```

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 的并集

可排序
元素不反复
查问速度快

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 即可

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);
    }

关于java:redis相关知识点

redis 的相干知识点

启动

通用命令

相干数据类型

String

Hash 类型

List

Set

SortedSet

SpringDataRedis

疾速入门

简略优化