Redis 不良人

# 1. SELECT
作用： 切换到给定的数据库

# 2. FLUSHDB
作用： 清空当前库

# 3. FLUSHALL
作用： 情况所有库

# 4. redis客户端显示中文
在启动`redis-cli`时添加参数 `--raw`

# 1. DEL
作用：删除给定的一个或多个key，不存在的key会被忽略

# 2. EXISTS
作用：检查给定的key是否存在

# 3. EXPIRE
作用：为给定的key设置生存时间，当key过期时（生存时间为0），它会被自动删除

# 4. KEYS
作用：查找所有复核给定模式 pattern 的key。
语法：
	KEYS * 匹配数据库中所有的key
	KEYS h?llo 匹配hello,hallo和hollo等
	KEYS h*llo 匹配hllo和heeeello等
	KEYS h[ae]llo 匹配hello和hallo，但不匹配hillo，特殊符号用“\”隔开
	
# 5.MOVE
作用：将当前数据库的key移动到给定的数据库db中

# 6. PEXPIRE
作用：这个命令和EXPIRE命令的作用类似，但是它以毫秒为单位设置key的生存时间

# 7. TTL
作用：以秒为单位，返回给定key的剩余生存时间（TTL，time to live）

# 8. RANDOMKEY
作用：从当前数据库中随机返回（不删除）一个key

# 9. TYPE
作用：返回给定key所储存的值的类型

# 10. RENAME
作用：将key改名为newKey

# 1. 客户端方式之 BGSAVE
客户端可以使用 BGSAVE 命令来创建一个快照，当接收到客户端的 BGSAVE 命令时，Redis会调用fork来创建一个子线程，然后子线程负责将快照写入磁盘中，而父进程则继续处理命令请求。

fork解释：当一个进程创建子进程的时候，底层的操作系统会创建该进程的一个副本，在类unix系统中创建子进程的操作会进行优化。在刚开始的时候，父子进程共享相同内容，直到父进程或子进程对内存进行了写之后，对被写入的内存的共享才会结束服务。

# 2. 客户端方式之 SAVE
客户端还可以使用 SAVE 命令来创建一个快照，接收到 SAVE 命令的redis服务器在快照创建完毕之前将不再响应任何其他的命令。

# 3. 服务器配置方式之满足条件自动触发
如果用户在 redis.conf 中配置了save配置选项，redis会在save选项条件满足之后自动触发一次BGSAVE命令，如果设置多个save配置选项，当任意一个save配置选项条件满足时，redis也会触发一次BGSAVE命令。

# 4. 服务器接收客户端shutdown指令
当redis通过shutdown指令接收到关闭服务器的请求时，会执行一个save命令，阻塞所有的客户端，不再执行客户端执行发送的任何命令，并且在save命令执行完毕之后关闭服务器。

# 1. 客户端方式触发重写
执行 BGREWRITEAOF 命令，不会阻塞redis服务

# 2. 服务器配置方式自动触发
配置redis.conf中的auto-aof-rewrite-percentage选项
如果设置auto-aof-rewrite-percentage的值为100和auto-aof-rewrite-min-size 64mb，并且启动了AOF持久化时，那么当AOF文件体积大于64M，并且AOF文件的体积比上一次重写之后体积大了至少一倍（100%）时会自动触发，如果重写过于频繁，用户可以考虑将auto-aof-rewrite-percentage设置为更大

# 重写流程
1. redis调用fork，现在有父子两个进程，子进程根据内存中的数据库生成快照，往临时文件中写入重建数据库状态的命令
2. 父进程继续处理客户端请求，除了把写命令写入到原来的aof文件中，同时把收到的写命令缓存起来。这样就能保证如果子进程重写失败的话并不会出现问题
3. 当子进程把快照内容以命令方式写入到临时文件后，子进程发信号通知父进程。然后父进程把缓存的写命令也写入到临时文件
4. 现在父进程可以使用临时文件替换老的aof文件并重命名，后面收到的写命令也开始往新的aof文件中追加

<!-- 引入jedis连接依赖 -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.3.0</version>
</dependency>

public class RedisDemo {

    public static void main(String[] args) {

        // 创建 jedis 客户端对象
        // 如果连接失败，请检查redis配置文件的bind，默认是127.0.0.1，只能接受本机的访问请求
        Jedis jedis = new Jedis("192.168.116.128", 6379);

        // 选择一个库，默认是0
        jedis.select(0);

        // 获取redis中所有的key信息
        Set<String> keys = jedis.keys("*");
        keys.forEach(key -> System.out.println("key = " + key));

        // 操作库相关
        //jedis.flushDB(); // 清空当前库
        //jedis.flushAll(); // 清空所有库

        // 释放资源
        jedis.close();
    }
}

public class KeyDemo {

    private Jedis jedis;

    @Before
    public void before() {
        // 创建 jedis 客户端对象
        this.jedis = new Jedis("192.168.116.128", 6379);
    }

    @After
    public void after() {
        // 释放资源
        this.jedis.close();
    }

    // 测试key相关
    @Test
    public void testKeys() {
        // 设置一个key
        System.out.println(jedis.set("name", "ray")); // OK
        // 获取一个key
        System.out.println(jedis.get("name")); // ray
        // 判断key是否存在
        System.out.println(jedis.exists("name")); // true
        // 删除一个key
        System.out.println(jedis.del("name")); // 1

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

        System.out.println(jedis.set("age", "18")); // OK
        // 设置一个key的超时时间
        System.out.println(jedis.expire("age", 10)); // 1
        // 获取一个key的超时时间
        System.out.println(jedis.ttl("age")); // 10

    }
}

public class StringDemo {

    private Jedis jedis;

    @Before
    public void before() {
        // 创建 jedis 客户端对象
        this.jedis = new Jedis("192.168.116.128", 6379);
    }

    @After
    public void after() {
        // 清空当前表
        this.jedis.flushDB();
        // 释放资源
        this.jedis.close();
    }

    // 测试String相关
    @Test
    public void test1() {

        // 设置key和value
        System.out.println(jedis.set("k1", "v1")); // OK

        // 根据key获取值
        System.out.println(jedis.get("k1")); // v1

        // 往key追加value
        System.out.println(jedis.append("k1", "hello")); // 7

        // 根据key获取值
        System.out.println(jedis.get("k1")); // v1hello

        // 如果key不存在，相当于set
        System.out.println(jedis.append("k2", "v2")); // 2

        // 根据key获取值
        System.out.println(jedis.get("k2")); // v2

        // 返回字符串的长度
        System.out.println(jedis.strlen("k1")); // 7

        // 设置key和value
        System.out.println(jedis.set("views", "0")); // OK

        // 自增1
        System.out.println(jedis.incr("views")); // 1

        // 根据key获取值
        System.out.println(jedis.get("views")); // 1

        // 自减1
        System.out.println(jedis.decr("views")); // 0

        // 根据key获取值
        System.out.println(jedis.get("views")); // 0

        // 指定增加步长
        System.out.println(jedis.incrBy("views", 10)); // 10

        // 指定减去步长
        System.out.println(jedis.decrBy("views", 10)); // 0

        // 根据key获取值
        System.out.println(jedis.get("views")); // 0
    }

    @Test
    public void test2() {

        // 如果 key 不存在，返回 null
        System.out.println(jedis.getSet("db", "redis")); // null

        // 设置 key 和 value
        System.out.println(jedis.set("db", "redis")); // OK

        // 根据 key 获取值
        System.out.println(jedis.get("db")); // redis

        // 如果 key 存在，获取旧值，并设置新值
        System.out.println(jedis.getSet("db", "mongodb")); // redis

        // 根据 key 获取值
        System.out.println(jedis.get("db")); // mongodb
    }
}

package com.ray.demo;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.ListPosition;

import java.util.List;

/**
 * @Description: 测试 redis List
 * @Author Administrator
 * @Date 2020/11/28 17:19
 * @Version 1.0
 */
public class ListDemo {

    private Jedis jedis;

    @Before
    public void before() {
        // 创建 jedis 客户端对象
        this.jedis = new Jedis("192.168.116.128", 6379);
    }

    @After
    public void after() {
        // 清空当前表
        this.jedis.flushDB();
        // 释放资源
        this.jedis.close();
    }

    // 测试List相关
    @Test
    public void test1() {
        // 在队列左侧插入一个
        System.out.println(jedis.lpush("list", "one")); // 1

        // 在队列左侧插入多个
        System.out.println(jedis.lpush("list", "two", "three")); // 3

        // 获取list区间的值，-1代表最后一位
        List<String> lrange = jedis.lrange("list", 0, -1);
        lrange.forEach(v -> System.out.println("v = " + v));

        // 在队列右侧插入一个
        System.out.println(jedis.rpush("list", "zero")); // 4

        // 通过下标获取值
        System.out.println(jedis.lindex("list", 3)); // zero

        // 移除头元素
        System.out.println(jedis.lpop("list")); // three

        // 移除列表1个zero
        System.out.println(jedis.lrem("list", 1, "zero")); // 1

        // 返回长度
        System.out.println(jedis.llen("list")); // 2
    }


    @Test
    public void test2() {
        // # 在队列左侧插入多个
        System.out.println(jedis.lpush("list", "v1", "v2", "v3", "v4")); // 4

        // 获取list区间的值，-1代表最后一位
        List<String> lrange = jedis.lrange("list", 0, -1);
        lrange.forEach(v -> System.out.println("v = " + v));

        // 移除列表的最后一个元素，添加到新的列表中
        System.out.println(jedis.rpoplpush("list", "mylist")); // v1

        // 获取list区间的值，-1代表最后一位
        List<String> lrange2 = jedis.lrange("list", 0, -1);
        System.out.println(lrange2.size()); // 3

        // 获取list区间的值，-1代表最后一位
        List<String> lrange3 = jedis.lrange("mylist", 0, -1);
        System.out.println(lrange3.size()); // 1

        // 将值v0插入到列表mylist中值为v1的前面
        System.out.println(jedis.linsert("mylist", ListPosition.BEFORE, "v1", "v0")); // 2

        // 获取list区间的值，-1代表最后一位
        List<String> mylist = jedis.lrange("mylist", 0, -1);
        mylist.forEach(v -> System.out.println("v = " + v));
    }
}

public class SetDemo {

    private Jedis jedis;

    @Before
    public void before() {
        // 创建 jedis 客户端对象
        this.jedis = new Jedis("192.168.116.128", 6379);
    }

    @After
    public void after() {
        // 清空当前表
        this.jedis.flushDB();
        // 释放资源
        this.jedis.close();
    }

    // 测试Set相关
    @Test
    public void test1() {
        // 添加单个元素
        System.out.println(jedis.sadd("set", "v1")); // 1

        // 添加多个元素
        System.out.println(jedis.sadd("set", "v2", "v3", "v4", "v4")); // 3

        // 返回集合所有成员
        Set<String> set = jedis.smembers("set");
        set.forEach(v -> System.out.println("v = " + v));

        // 判断集合 list 是否包含 v2 元素
        System.out.println(jedis.sismember("set", "v2")); // true

        // 返回集合 list 中元素的数量
        System.out.println(jedis.scard("set")); // 4

        // 返回集合中的一个随机元素
        System.out.println(jedis.srandmember("set")); // v2

        // 随机移除一个元素
        System.out.println(jedis.spop("set")); // v4
    }

}

public class HashDemo {

    private Jedis jedis;

    @Before
    public void before() {
        // 创建 jedis 客户端对象
        this.jedis = new Jedis("192.168.116.128", 6379);
    }

    @After
    public void after() {
        // 清空当前表
        this.jedis.flushDB();
        // 释放资源
        this.jedis.close();
    }

    // 测试Hash相关
    @Test
    public void test1() {

        // 设置单个元素
        System.out.println(jedis.hset("myhash", "name", "ray")); // 1

        // 返回指定的值
        System.out.println(jedis.hget("myhash", "name")); // ray

        // 设置多个元素
        Map<String, String> values = new HashMap<>();
        values.put("age", "18");
        values.put("address", "gd");

        System.out.println(jedis.hset("myhash", values)); // 2

        // 返回所有的值
        Map<String, String> myhash = jedis.hgetAll("myhash");
        myhash.forEach((k,v) -> System.out.println("k = " + k + ", v = " + v));

        // 返回数量
        System.out.println(jedis.hlen("myhash"));

        // 返回key中的所有域
        Set<String> keys = jedis.hkeys("myhash");
        keys.forEach(k -> System.out.println("k = " + k));

        // 返回key中所有的值
        List<String> vals = jedis.hvals("myhash");
        vals.forEach(v -> System.out.println("v = " + v));
    }

}

public class ZsetDemo {

    private Jedis jedis;

    @Before
    public void before() {
        // 创建 jedis 客户端对象
        this.jedis = new Jedis("192.168.116.128", 6379);
    }

    @After
    public void after() {
        // 清空当前表
        this.jedis.flushDB();
        // 释放资源
        this.jedis.close();
    }

    // 测试Zset相关
    @Test
    public void test1() {

        // 添加一个值
        System.out.println(jedis.zadd("myset", 1.0, "one")); // 1

        // 添加多个值
        Map<String, Double> map = new HashMap<>();
        map.put("two", 2.0);
        map.put("three", 3.0);
        System.out.println(jedis.zadd("myset", map)); // 2

        // 返回有序集 key 中，指定区间内的成员
        Set<String> zrange = jedis.zrange("myset", 0, -1);
        zrange.forEach(x -> System.out.println("x = " + x));

        // 返回 score 值
        System.out.println(jedis.zscore("myset", "one")); // 1.0

        // 为 score 值加上增量
        System.out.println(jedis.zincrby("myset", 99.0, "one")); // 100.0

        // 返回 score 值
        System.out.println(jedis.zscore("myset", "one")); // 100.0

        // 返回有序集 key 的基数
        System.out.println(jedis.zcard("myset")); // 3

        // 计算 1-10 之间的人数
        System.out.println(jedis.zcount("myset", 1, 10)); // 2

        // 显示所有成员及其 score 值
        Set<Tuple> myset = jedis.zrangeWithScores("myset", 0, -1);
        myset.forEach(v -> System.out.println("v = " + v));
    }

}