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 2incrby 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

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

    sismember s1 b

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

    smembers s1
  2. SINTER key1 key2 ... ：求key1与key2的交加
  3. SDIFF key1 key2 ... ：求key1与key2的差集
  4. 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

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

     zrank students jerry

    排名是从0开始的

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

     zcard students
  3. ZCOUNT key min max：统计score值在给定范畴内的所有元素的个数
  4. ZINCRBY key increment member：让sorted set中的指定元素自增，步长为指定的increment值
  5. ZRANGE key min max：依照score排序后，获取指定排名范畴内的元素
  6. ZRANGEBYSCORE key min max：依照score排序后，获取指定score范畴内的元素
  7. ZDIFF、ZINTER、ZUNION：求差集、交加、并集
  8. 留神：所有的排名默认都是升序，如果要降序则在命令的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通用的命令

疾速入门

  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数据库只有一些转码了的序列，此时咱们须要进行手动序列化

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