redis中文网：https://www.redis.net.cn/

Redis绿色版(Windows)

Redis常用命令

String字符串操作命令

命令
set key value: 设置指定key的值
get key: 获取指定key的值
setex key seconds value: 设置指定key的值，并将key的有效时间设置为seconds秒
ttl key: 获取key的剩余存活时间s
setnx key value: 只有在key不存在时设置key的值
mset key1 value1 key2 value2 ...:批量添加key和value
mget key1 key2 ...:批量获取key对应的value
incr/decr key:让整型的key自增/(自减)1，每执行一次自增/(自减)一次
incrby key number:指定key自增的步长number
incrbyfloat key number:指定浮点数类型的数字自增并指定步长

演示如下：

> set name jack
> get name 
jack
> setex id 60 10 
> get id
10
(60s后)
> get id 
null
> setnx age 10
1
> setnx age 10
0

127.0.0.1:6379> mset name1 hh name2 ee name3 gg
OK
127.0.0.1:6379> mget name1 name2 name3
1) "hh"
2) "ee"
3) "gg"

127.0.0.1:6379> set age 18
OK
127.0.0.1:6379> incr age
(integer) 19
127.0.0.1:6379> incr age
(integer) 20

127.0.0.1:6379> incrby age 3
(integer) 23
127.0.0.1:6379> incrby age 3
(integer) 26

Hash哈希操作命令

Redis hash 是一个string类型的field和value的映射表，hash适合用于存储对象

命令(key:键，field:字段，value:字段的值)
hset key field value:添加或修改哈希表key中的字段field的值
hget key field: 获取存储在哈希表中指定字段的值
hmset key field1 value1 field2 value2...: 批量添加多个hash类型key的field的值
hmget key field1 filed2 field3...: 批量获取多个hash类型key的field的值
hgetall key: 获取一个hash类型的key中所有的field和value
hkeys key: 获取哈希表中key所有的字段
hvals key: 获取哈希表中key所有的值
hincrby key field number: 让一个hash类型key的字段值自增并指定步长
hsetnx key field value: 添加一个hash类型的key的field值，前提是这个field不存在，否则不执行（1成功0失败）
hdel key field: 删除存储在哈希表中的指定字段

演示如下：

CentOS7:0>hset user1 name zhangsan
"1"
CentOS7:0>hset user1 age 18
"1"
CentOS7:0>hset user1 id 1
"1"

CentOS7:0>hget user1 id
"1"

CentOS7:0>hmset use2 id 2 name lishi age 19
"OK"

CentOS7:0>hmget user1 id name age
1) "1"
2) "zhangsan"
3) "18"

CentOS7:0>hgetall user1
1) "name"
2) "zhangsan"
3) "age"
4) "18"
5) "id"
6) "1"

CentOS7:0>hkeys user1
1) "name"
2) "age"
3) "id"

CentOS7:0>hvals user1
1) "zhangsan"
2) "18"
3) "1"

CentOS7:0>hincrby user1 age 3
"21"
CentOS7:0>hincrby user1 age 3
"24"

CentOS7:0>hsetnx user1 sex 男
"1"
CentOS7:0>hsetnx user1 sex 女
"0"

CentOS7:0>hdel user1 sex
"1"

List列表操作命令

Redis列表是简单的字符串列表，按照插入顺序排序。【有序，元素可以重复，插入和删除快，查询速度一般】
把redis的列表可以看成一个双向链表结构。既可以正向检索也可以反向检索

常用命令(key键，element元素)：
lpush key element1 element2..: 将一个或多个值插入到列表左侧,返回列表的长度
lpop key: 移除并返回列表左侧的第一个元素，没有则返回nil
rpush key element1 element2..: 向列表右侧插入一个或多个元素,返回列表长度
rpop key: 移除并返回列表右侧的第一个元素
lrange key start end: 获取列表指定范围(start,end)内的元素
blpop和brpop key seconds: 与lpop或rpop类似，只不过没有元素时等待指定时间，而不是直接返回nil
llen key: 获取列表长度

演示如下：(顺序为从左侧第一个开始为0号元素)
lpush list a> a
rpush list b> a<->b
lpush list c> c<->a<->b
lpop list > a<->b
rpop list > a

CentOS7:0>lpush mylist a b c d
"4"

CentOS7:0>lpop mylist
"d"

CentOS7:0>rpush mylist e f
"5"

CentOS7:0>rpop mylist
"f"

CentOS7:0>lrange mylist 0 3
1) "c"
2) "b"
3) "a"
4) "e"

CentOS7:0>llen mylist
"4"

对于blpop和brpop我们执行blpop mylist2 100(设置最大阻塞时间为100s，此时还没有mylist2，阻塞)
1
2
CentOS7:0>brpop mylist2 100
# 界面阻塞了，暂时无法执行其他任务
我们此时多开另一个窗口执行下面命令创建mylist2,添加元素 1，2，3
1
2
3
4
5
[root@localhost ~]# redis-cli
127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> lpush mylist2 1 2 3
(integer) 3
回到之前的界面，会发现执行完成，返回了移除的元素
1
2
3
CentOS7:0>brpop mylist2 100
1) "mylist2"
2) "1"
思考：
用list结构模拟栈：入口和出口在同一边(lpush和lpop 或 rpush和rpop)
用list结构模拟队列：入口和出口不在同一边(lpush和rpop 或 rpush和lpop)
用list结构模拟一个阻塞队列：入口和出口在不同边，出队采用blpop或brpop

Set类型操作命令

Redis set和java中的HashSet类似，集合成员是唯一的，集合中不能出现重复的数据。【无序，元素不可重复，查找快，支持交集、并集、差集等功能】

常用命令：(key键、member成员)
sadd key member1 member2...: 向set中添加一个或多个成员
srem key member1 member2...: 删除set中一个或多个成员
scard key: 获取set中的成员个数
sismember key member: 判断一个元素是否存在于set中(1存在、0不存在)
smembers key: 获取set中的所有成员
sinter key1 key2...: 返回给定所有集合的交集
sunion key1 key2...: 返回所有给定集合的并集(重复元素只会记录一次!!)
sdiff key1 ke2: 求key1和key2的差集(删除key1和key2相同的成员，保留key2中没有的key1的成员)

演示如下：

CentOS7:0>sadd s1 a b c d
"4"

CentOS7:0>srem s1 c d
"2"

CentOS7:0>scard s1
"2"

CentOS7:0>sismember s1 a
"1"

CentOS7:0>smembers s1
1) "a"
2) "b"

CentOS7:0>sadd s2 b c
"2"
CentOS7:0>sinter s1 s2
1) "b"

CentOS7:0>sunion s1 s2
1) "a"
2) "c"
3) "b"

CentOS7:0>sdiff s1 s2
1) "a"

SortedSet类型操作命令

Redis的SortedSet是一个可排序的set集合，与java中的TreeSet有些类似，但底层数据结构差别很大。SortedSet中的每个元素都会关联一个double类型的score属性(分数为权重排序)。可以基于score属性对元素排序，底层实现是一个跳表(SkipList)加hash表。【可排序，元素不重复，查询速度快】基于其特性常被用来实现排行榜这样的功能。

常用命令：(key键、score分数属性、member成员)
zadd key score1 member1 [score2 member2]: 添加一个或多个元素，如果已经存在则更新其score值
zrem key member1 member2...: 删除一个或多个成员
zscore key member: 获取SortedSet中指定成员的score值
zrank key member: 获取SortedSet中指定成员的排名(0开始，默认升序)
zcard key: 获取成员个数
zcount key min max: 统计score值在给定范围内的所有成员个数
zincrby key increment member: 让sorted set 中指定的成员自增，步长为increment
zrange key min max [withscores]: 按score排序后，获取指定排名范围内的成员
zrangebyscore key min max: 按score排序后，获取指定score范围内的成员
zdiff、zinter、zunion: 求差集、交集、并集
所有的排序默认都是升序，如果要降序则在命令z后添加rev即可（如zrevrank,zrevscore）

演示如下：

# 添加学生 Jack 85，Lucy 89,Rose 82,Tom 95,Jerry 78,Amy 92,Miles 76
CentOS7:0>zadd stus 85 Jack 89 Lucy 82 Rose 95 Tom 78 Jerry 92 Amy 76 Miles
"7"

# 删除Tom同学
CentOS7:0>zrem stus Tom
"1"

# 获取Amy同学的分数
CentOS7:0>zscore stus Amy
"92"

# 获取Rose同学的排名（降序排序，下标从0开始）
CentOS7:0>zrevrank stus Rose
"3"

# 获取所有同学总数
CentOS7:0>zcard stus
"6"

# 获取分数在80以下的总人数
CentOS7:0>zcount stus 0 80
"2"

# 给Amy同学加两分
CentOS7:0>zincrby stus 2 Amy
"94"

# 获取成绩排名前3名的同学
CentOS7:0>zrevrange stus 0 2 
1) "Amy"
2) "Lucy"
3) "Jack"

# 查出成绩80分以下的所有同学
CentOS7:0>zrangebyscore stus 0 80
1) "Miles"
2) "Jerry"

# 加上withscores就会显示对应成员的分数
CentOS7:0>zrangebyscore stus 0 80 withscores
1) "Miles"
2) "76"
3) "Jerry"
4) "78"

通用命令

Redis的通用命令是不分数据类型的，都可以使用的命令：
keys pattern: 查找所有符合给定模式(pattern)的key

keys * :查找所有key

exists key: 检查给定key是否存在

type key: 返回key所储存的值的类型

del key: 该命令用于在key存在时删除key

expire key seconds: 给一个key设置有效期

expire name 20:key为name有效期为20s
默认创建一个key不设置时间，有效期为永久

演示如下

> keys *
mylist
set2
name
5
zset1
set1
username
> keys set*
set2
set1
> exists set1
1
> exists id
0
> type name
string
> type mylist
list
> type 5
hash
> del set1 set2
2

127.0.0.1:6379> expire name 20
(integer) 1
127.0.0.1:6379> get name
"zhangsan"
127.0.0.1:6379> get name
(nil)

Redis的Java客户端

官网位置：https://redis.io/docs/latest/develop/connect/clients/
Redis的Java客户端很多，常用的几种：

Jedis：以redis命令作为方法名称，学习成本第，简单实用，Jedis实例线程不安全，多线程环境要基于连接池来使用
Lettuce：基于Netty实现的，支持同步，异步和响应式编程方式，并且线程安全。支持redis哨兵模式，集群模式和管道模式。
Redisson：基于redis实现的分布式，可伸缩的java数据结构集合。包含了诸如Map、Queue、Lock、Semaphore、Atomiclong等功能
Spring Data Redis：底层兼容了Jedis和Lettuce

Jedis

创建maven项目引入依赖

<!--jedis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>5.1.0</version>
</dependency>

<!--单元测试-->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>

建立连接、测试操作redis、释放资源

package cn.xnj.test;


public class JedisTest {

    private Jedis jedis;

    //1. 建立连接
    @BeforeEach
    void setUp(){
        //建立连接
        jedis = new Jedis("192.168.255.128",6379);
        //设置密码
        jedis.auth("123456");
        //选择数据库
        jedis.select(0);
    }

    //2.1.  测试String
    @Test
    void test_String(){
        //存入数据
        String result = jedis.set("name", "张三");
        System.out.println("result:"+result);  //result:OK
        //获取数据
        String name = jedis.get("name");
        System.out.println("name:"+name);  //name:张三
    }

    //2.2. 测试Hash
    @Test
    void test_Hash(){
        //存 :hset key field value
        jedis.hset("user:1","name","张三");
        jedis.hset("user:1","age","21");
        //获取
        Map<String, String> map = jedis.hgetAll("user:1");
        System.out.println(map);//{name=张三, age=21}
    }


    //3. 释放连接
    @AfterEach
    void tearDown(){
        if (jedis!=null){
            jedis.close();
        }
    }
}

Jedis连接池

Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此推荐使用jedis连接池代替jedis的直连方式

创建一个用于创建和管理jedis连接池的类

package cn.xnj;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisConnectionFactory {
    private static final JedisPool jedispool;

    static {
        // 配置连接池
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大连接
        jedisPoolConfig.setMaxTotal(8);
        //最大空闲连接
        jedisPoolConfig.setMaxIdle(8);
        //最小空闲连接
        jedisPoolConfig.setMinIdle(0);
        //设置最长等待时间， ms
        jedisPoolConfig.setMaxWaitMillis(200);
        // 初始化连接池 参数：配置，ip，端口，超时时间，密码
        jedispool = new JedisPool(jedisPoolConfig,"192.168.255.128",6379,1000,"123456");
    }

    //获取Jedis对象
    public static Jedis getJedis(){
        return jedispool.getResource();
    }
}

建立连接就可以直接使用JedisConnectionFactory.getJedis()即可

public class JedisTest {

    private Jedis jedis;

    //1. 建立连接
    @BeforeEach
    void setUp(){
        //建立连接
        //jedis = new Jedis("192.168.255.128",6379);
        //使用连接池来连接
        jedis = JedisConnectionFactory.getJedis();
        //设置密码
        jedis.auth("123456");
        //选择数据库
        jedis.select(0);
    }

    //2.1.  测试String
    @Test
    void test_String(){
        //存入数据
        String result = jedis.set("name", "张三");
        System.out.println("result:"+result);  //result:OK
        //获取数据
        String name = jedis.get("name");
        System.out.println("name:"+name);  //name:张三
    }

    //2.2. 测试Hash
    @Test
    void test_Hash(){
        //存 :hset key field value
        jedis.hset("user:1","name","张三");
        jedis.hset("user:1","age","21");
        //获取
        Map<String, String> map = jedis.hgetAll("user:1");
        System.out.println(map);//{name=张三, age=21}
    }


    //3. 释放连接
    @AfterEach
    void tearDown(){
        if (jedis!=null){
            jedis.close();
        }
    }
}

Spring Data Redis

Spring Data Redis是Spring的一部分，对redis底层开发进行了高度封装。
在Spring项目中，可以使用Spring Data Redis来简化操作。

导入Spring Data Redis的maven坐标

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置Redis数据源application.yml

spring:
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 10 #不写默认为0

编写配置类，创建RedisTemplate对象
com/xxx/config/RedisConfiguration

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@Slf4j
public class RedisConfiguration {
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory){
        log.info("开始创建redisTemplate模板对象...");
        RedisTemplate redisTemplate = new RedisTemplate();
        //设置redis的连接工厂
        redisTemplate.setConnectionFactory(factory);
        //设置redis key 的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

通过RedisTemplate对象操作Redis
这里使用单元测试演示

package com.xnj.test;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@SpringBootTest
public class SpringDataRedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testRedisTemplate(){
        //操作字符串类型
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //操作hash类型
        HashOperations hashOperations = redisTemplate.opsForHash();
        //操作list类型
        ListOperations listOperations = redisTemplate.opsForList();
        //操作set类型
        SetOperations setOperations = redisTemplate.opsForSet();
        //操作zset类型
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
    }
    //操作字符串类型
    @Test
    public void testString(){
        //set,get,setex,setnx
        redisTemplate.opsForValue().set("city","岳阳");
        Object city = redisTemplate.opsForValue().get("city");
        System.out.println(city);//岳阳
        //设置一个过期时间60秒的key
        redisTemplate.opsForValue().set("code","1234",60, TimeUnit.SECONDS);
        //判断key是否存在,如果存在返回true,不存在返回false,如果key不存则创建
        Boolean lock1 = redisTemplate.opsForValue().setIfAbsent("lock", "1");
        Boolean lock2 = redisTemplate.opsForValue().setIfAbsent("lock", "2");
        System.out.println(lock1);//true
        System.out.println(lock2);//false
    }

    //操作hash类型
    @Test
    public void testHash() {
        //hset,hget,hdel,hkeys,hvals
        HashOperations hashOperations = redisTemplate.opsForHash();
        //参数1:key,参数2:hashKey,参数3:value
        hashOperations.put("user", "name", "张三");
        hashOperations.put("user", "age", "20");

        //获取hashKey对应的值
        String name = (String) hashOperations.get("user", "name");
        System.out.println(name);//张三

        //获取所有的hashKey
        Set user = hashOperations.keys("user");
        System.out.println(user);//[age, name]
        //获取所有的value
        List user1 = hashOperations.values("user");
        System.out.println(user1);//[20, 张三]

        //删除一个hashKey
        hashOperations.delete("user","name");
    }

    //操作列表list类型
    @Test
    public void testList(){
        //lput,lrange,rpop,llen
        ListOperations listOperations = redisTemplate.opsForList();
        //从左边插入数据,参数1:key,参数2:value...
        listOperations.leftPushAll("mylist", "a", "b", "c");
        listOperations.leftPush("mylist", "d");

        //从右边弹出数据,参数1:key,参数2:起始位置,参数3:结束位置
        List mylist = listOperations.range("mylist", 0, -1);
        System.out.println(mylist);//[d, c, b, a]

        //从右边弹出(移除)数据,参数:key
        Object o = listOperations.rightPop("mylist");
        System.out.println(o);//a

        //得到列表的长度,参数:key
        Long size = listOperations.size("mylist");
        System.out.println(size);//3
    }

    //操作集合类型的数据
    @Test
    public void testSet(){
        //sadd,smembers,scard,sinter,sunion,srem
        SetOperations setOperations = redisTemplate.opsForSet();
        //添加  参数1:key,参数2:value...
        setOperations.add("set1", "a", "b", "c");
        setOperations.add("set2", "a", "b", "d");

        //获取集合所有值,参数:key
        Set set1 = setOperations.members("set1");
        System.out.println(set1);//[b, c, a]

        //获取集合的长度,参数:key
        Long size = setOperations.size("set1");
        System.out.println(size);//3

        //交集,参数1:key1,参数2:key2...
        Set intersect = setOperations.intersect("set1", "set2");
        System.out.println(intersect);//[b, a]

        //并集,参数1:key1,参数2:key2...
        Set union = setOperations.union("set1", "set2");
        System.out.println(union);//[b, a, c, d]

        //删除元素,参数1:key,参数2:value...,返回值是删除的个数
        setOperations.remove("set1", "a", "b");

        //判断元素是否存在,参数1:key,参数2:value
        Boolean c = setOperations.isMember("set1", "c");
        System.out.println(c);//true
    }

    //操作有序集合类型
    @Test
    public void testZSet() {
        //zadd,zrange,,zrem,zrem
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        //添加元素,参数1:key,参数2:value,参数3:score
        zSetOperations.add("zset1","a",10);
        zSetOperations.add("zset1","b",12);
        zSetOperations.add("zset1","c",8);

        //获取有序集合所有元素,参数1:key,参数2:起始位置,参数3:结束位置
        Set zset1 = zSetOperations.range("zset1", 0, -1);
        System.out.println(zset1);//[c, a, b]

        //为有序集合中元素c添加权重,
        zSetOperations.incrementScore("zset1","c",10);

        //删除有序集合中的元素,参数1:key,参数2：value...返回值是Long类型,删除的个数
        zSetOperations.remove("zset1","a","b");
    }

    //通用命令操作
    @Test
    public void testCommon() {
        //keys,del,type,exists
        //查询redis中所有的key,参数:pattern
        Set keys = redisTemplate.keys("*");
        System.out.println(keys);//[mylist, set2, user, set1, zset1]

        //判断key是否存在,参数:key
        Boolean user = redisTemplate.hasKey("user");
        System.out.println(user);//true

        //获取key的类型
        for (Object key : keys) {
            DataType type = redisTemplate.type(key);
            System.out.println(key + "的类型是:" + type.name());
             /*
             mylist的类型是:LIST
             set2的类型是:SET
             user的类型是:HASH
             set1的类型是:SET
             zset1的类型是:ZSET
             */
        }

        //删除key,参数:key
        redisTemplate.delete("mylist");

    }
}

Redis层级目录结构

Redis的key允许有多个单词形成层级结构，多个单词之间用:隔开，格式举例如下：

项目名:业务名:类型:id

这个格式不固定，可以再添加词条或删除词条。相同的是，它都会在redis中创建一个层次结构的key
例如项目名为xnj，有user和product两种类型数据，定义如下的key：

user相关：xnj:user:1
product相关：xnj:product:1

如果Value是一个java对象，例如user对象，则可以将对象序列化为json字符串后存储

key	value
xnj:user:1	‘{“id”:1, “name”:”Jack”, “age”: 21}’
xnj:product:1	‘{“id”:1, “name”:”小米11”, “price”: 4999}’

示例如下
如果你使用图形化工具将会看到：xnj目录下有product和user目录
product和user目录下分别有kye 1和2

RESP.app Redis Console
连接中...
已连接。
CentOS:0>set  xnj:user:1  '{"id":1, "name":"Jack", "age": 21}'
"OK"
CentOS:0>set  xnj:product:1 '{"id":1, "name":"小米11", "price": 4999}'
"OK"
CentOS:0>get 1
null
CentOS:0>get xnj:user:1
"{"id":1, "name":"Jack", "age": 21}"
CentOS:0>set xnj:user:2 '{"id":2, "name":"Rose", "age": 18}'
"OK"
CentOS:0>set xnj:product:2 '{"id":2, "name":"荣耀6", "price": 2999}'
"OK"