关于java:redis相关知识点

redis 的相干知识点

启动

1. 启动代码

    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

1. LPUSH key element …：向列表左侧插入一个或多个元素

   lpush users 1 2 3 4 5

   此时理论为 5 4 3 2 1

2. RPUSH key element …：向列表右侧插入一个或多个元素

    rpush users 6 7

   此时理论为 5 4 3 2 1 6 7

3. LPOP key count：移除并返回列表左侧的 count 个元素，没有则返回 nil

    lpop users 3

   此时移除并返回 5 4 3

4. RPOP key count：移除并返回列表右侧的 count 元素

    rpop users 3

   此时移除并返回的是 7 6 1

5. LRANGE key star end：返回一段角标范畴内的所有元素

    lrange users 0 0

   此时返回的是 2

6. 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 相似的特色：

• 无序
• 元素不可反复
• 查找快
• 反对交加、并集、差集等性能

1. SADD key member …：向 set 中增加一个或多个元素

   sadd s1 a b c

2. SREM key member … : 移除 set 中的指定元素

   srem s1 a

3. SCARD key：返回 set 中元素的个数

   scard s1

4. SISMEMBER key member：判断一个元素是否存在于 set 中

   sismember s1 b

5. SMEMBERS：获取 set 中的所有元素

   smembers s1

6. SINTER key1 key2 …：求 key1 与 key2 的交加
7. SDIFF key1 key2 …：求 key1 与 key2 的差集
8. SUNION key1 key2 ..：求 key1 和 key2 的并集

SortedSet

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

1. ZADD key score member：增加一个或多个元素到 sorted set，如果曾经存在则更新其 score 值

   zadd students 87 jack 88 jerry

2. ZREM key member：删除 sorted set 中的一个指定元素

   zrem students jack

3. ZSCORE key member : 获取 sorted set 中的指定元素的 score 值

   zscore students jerry

4. ZRANK key member：获取 sorted set 中的指定元素的排名

    zrank students jerry

   ​ 排名是从 0 开始的

5. ZCARD key：获取 sorted set 中的元素个数

    zcard students

6. ZCOUNT key min max：统计 score 值在给定范畴内的所有元素的个数
7. ZINCRBY key increment member：让 sorted set 中的指定元素自增，步长为指定的 increment 值
8. ZRANGE key min max：依照 score 排序后，获取指定排名范畴内的元素
9. ZRANGEBYSCORE key min max：依照 score 排序后，获取指定 score 范畴内的元素
10. ZDIFF、ZINTER、ZUNION：求差集、交加、并集
11. 留神：所有的排名默认都是升序，如果要降序则在命令的 Z 前面增加 REV 即可

SpringDataRedis

疾速入门

1. 导入依赖

   <dependency>
               <groupId>org.apache.commons</groupId>
               <artifactId>commons-pool2</artifactId>
   </dependency>
   <dependency>
               <groupId>com.fasterxml.jackson.core</groupId>
               <artifactId>jackson-databind</artifactId>
   </dependency>

2. 配置文件

   spring:
     redis:
       host: 192.168.122.120
       port: 6379
       password: 73883672
       jedis:
         pool:
           max-active: 8
           max-idle: 0
           max-wait: 100ms

3. 进行测试

   @Autowired
       private RedisTemplate redisTemplate;
       @Test
       void testString() {
           // 写入一条 String 数据
           redisTemplate.opsForValue().set("name","google");
           // 获取 String 数据
           Object name = redisTemplate.opsForValue().get("name");
           System.out.println(name);
       }

4. 此时会发现 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;
       }
   }
   
   

5. 此时测试注入对象

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

6. 此时发现多了一个 class 参数，数据量一大，这是十分节约空间的。

   {
     "@class": "com.leixin.pojo.User",
     "name": "leixin",
     "age": 20
   }

简略优化

1. 应用 StringRedisTemplate
2. 写入 Redis 时，手动把对象序列化为 JSON
3. 读取 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);
    }