redis

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API

安装redis

下载使用linux系统

安装redis需要用的环境（因为redis是c++编写需要c++环境）

yum install gcc-c++
安装c++运行环境由于redis是由C语言编写的，它的运行需要C环境
gcc -v	c环境是否安装成功
make编译
make install安装
如果安装成功usr/local/bin中出现redis-cli等文件

2.通过wet方式下载

$ wget https://download.redis.io/releases/redis-6.2.5.tar.gz
$ tar xzf redis-6.2.5.tar.gz
$ cd redis-6.2.5
$ make

配置

1.将opt/redis/redisconfig复制一份到usr/bin
cd /usr/local/bin
mkdir myredisconfig
cp /opt/redis-6.2.5/redis.conf  myredisconfig
2.redis默认不是后台启动的改为后台启动
daemonize yes
3.启动服务
[root@localhost bin]# redis-server myredisconfig/redis.conf 
[root@localhost bin]# redis-cli -p 6379
测试redis服务是否可用
redis-cli -p 6379
输入ping出现PONG则ok
shutdown停止服务
exit退出服务

redis基础

redis有16个数据库默认在第一个

select index 切换数据库

flushdb 清空当前数据库

flushall清空所有数据库

String

	set key value 设置
							set“”和没有双引号的区别
								没有不能空格，否则保错
									“”可以保存空格，截取空格也会算在内
					mset key value 设置多个
					get key  获取
					mget key 获取多个
					keys *显示所有键
					exists key是否存在，存在为1否则0
					del key删除
					type key显示键的类型
					expire key 秒 设置过期时间（过期后删除）
					persist key 取消设置过期时间
					ttl key 获取当前键的时间（剩余时间如果为空显示-2）
					append key追加键
					strlen key获取长度
					flushdb	删除数据库
					incr age数值加一
					decr age数值减一
					incrby key value 数值加value
					decrby key value 数值减value
					getrange key  n  n2 截取字符(显示截下的部分)
					getrange key 0 -1截取所有字符
					setrange key 下标  内容		替换 
					setex key 时间 内容	设置内容时给定时间
					setnx key 如果key不存在则添加成功1如果存在返回0
					msetnx key value批量判断			--同时成功或失败
					存储json字符串 set usr{name:zhangsan,age 14}
					getset 取出赋值
						getset key 参数
							先获取上次的并赋值新的
								get获取新值

list

		lpush key value  从队伍左侧推入一个
			lpush key value[空格]value[空格]'va lue'多个推入如果value有空格加双引号
				list添加可重复，有顺序（从右到左）
		lrange db 值  0 -1获取db里的所有值
		lpop key 	弹出最左侧的值
		rpop key 	弹出最右侧的值(删除)
		lindex key 下标	 通过下表来获取	最左侧的值为0（最新的值）（小标从0开始）
		llen key 获取key的长度
		itrim key 1 3截取1-3下表的元素
			lrange key 0 -1
		rpoplpush	key key2	将key最右侧的数据弹出添加到key2中
		lset key 下标 value 		替换将下标为x的元素设置为value
		linsert key before value value2  插入	在key的value前面插入value2
		linsert key after value value2   插入	在keyde value后面插入value2
		lrem key count values

set

	sadd key value 添加
				sadd key value value value 批量添加
					set不可重复，有顺序
			smembers key 显示
			sismember key value 判断value在key中是否存在0，1
			scard key 获取长度
			srem key value 移除key里面value的元素
			srandmember key 随机获取一个value
			spop key 随机删除一个value
			smove key1 key2 value 	将key1里的value移动到key2
			sdiff key1 key2 求差集	已key1为1 key2为2 去除相同之后的部分剩下的就是差集
			sinter key1 key2 求交集	求它们之间相同的
			sunion key1 key2 求并集	去除一个相同的，使他们互不相同

hash

		hset key <key value> 添加以键值对的方式
				hset key <key value>	<key value>批量添加
			hget key <key>获取
			hgetall key 获取所有key的值
				hkeys  key 获取key中的所有<key>值
				hvals key 获取key中是哟<value>的值
			hdel key <key>删除
			hlen key 获取长度
			hexists key <key>判断keyd里面的<key>是否存在

zset

	zadd key  score value 添加
			zrange key 0 -1 显示所有键
			zrangebyscore key -inf +inf 按分数从小到大排序
			zrangebyscore key -inf +inf withscores带上分数查询排序
			zrangebyscore key -inf 85 withscores代表从负无穷到85
			zrem key value 移除key的value元素
			zcard key 获取长度
			zcount key n n2 获取n到n2之间的个数

地理空间（geospatial)

geoadd

将指定的地理空间位置（纬度、经度、名称）添加到指定的key中

geoadd city 13.361389 38.115556 '城市'

getpos

从key里返回所有给定位置元素的位置（经度和纬度）

geopos city '城市'

geodist

返回两个给定位置之间的距离。

如果两个位置之间的其中一个不存在，那么命令返回空值。

指定单位的参数 unit 必须是以下单位的其中一个：

m 表示单位为米。
km 表示单位为千米。
mi 表示单位为英里。
ft 表示单位为英尺。

如果用户没有显式地指定单位参数，那么 GEODIST 默认使用米作为单位。

127.0.0.1:6379> geodist cantania:city shanghai beijing 数据随意拿的，
"166274.1516"从北京到上海距离m
127.0.0.1:6379> geodist cantania:city shanghai beijing ft
"545518.8700"
127.0.0.1:6379> geodist cantania:city shanghai beijing mi
"103.3182"
127.0.0.1:6379> geodist cantania:city shanghai beijing km
"166.2742"

georadius

如果用户没有显式地指定单位参数，那么 GEODIST 默认使用米作为单位。

127.0.0.1:6379> georadius cantania:city 20 40 400 km
(empty array)
127.0.0.1:6379> georadius cantania:city 20 40 1000 km 在cantania:city中以 20 40 为中心寻找，1000km中所有的
1) "shanghai"
2) "beijing"

在给定以下可选项时，命令会返回额外的信息：

WITHDIST: 在返回位置元素的同时，将位置元素与中心之间的距离也一并返回。距离的单位和用户给定的范围单位保持一致。
WITHCOORD: 将位置元素的经度和维度也一并返回。
WITHHASH: 以 52 位有符号整数的形式，返回位置元素经过原始 geohash 编码的有序集合分值。这个选项主要用于底层应用或者调试，实际中的作用并不大。

命令默认返回未排序的位置元素。通过以下两个参数，用户可以指定被返回位置元素的排序方式：

ASC: 根据中心的位置，按照从近到远的方式返回位置元素。
DESC: 根据中心的位置，按照从远到近的方式返回位置元素。
在默认情况下， GEORADIUS 命令会返回所有匹配的位置元素。虽然用户可以使用 COUNT <count> 选项去获取前 N 个匹配元素，但是因为命令在内部可能会需要对所有被匹配的元素进行处理，所以在对一个非常大的区域进行搜索时，即使只使用 COUNT 选项去获取少量元素

georadiusbymember

这个命令和 GEORADIUS 命令一样，都可以找出位于指定范围内的元素，但是 GEORADIUSBYMEMBER 的中心点是由给定的位置元素决定的，而不是像 GEORADIUS 那样，使用输入的经度和纬度来决定中心点

127.0.0.1:6379> georadiusbymember cantania:city shanghai 500 km查询在上海500km的城市
1) "shanghai"
2) "beijing"

基数是指同一个元素中不重复的个数

HyperLogLogs

HyperLogLog 是一种用于计算唯一事物的概率数据结构（从技术上讲，这称为估计集合的基数）。通常，计算唯一项需要使用与要计算的项数成正比的内存量，因为您需要记住过去已经看过的元素，以避免对它们进行多次计数。然而，有一组算法可以用内存来换取精度：在 Redis 实现的情况下，您最终会得到一个带有标准误差的估计度量，该误差小于 1%。该算法的神奇之处在于您不再需要使用与计数的项目数量成正比的内存量，而是可以使用恒定量的内存！最坏情况下为 12k 字节，

127.0.0.1:6379> pfadd mykey1 a b c d e f		添加
(integer) 1
127.0.0.1:6379> pfcount mykey1					计数
(integer) 6
127.0.0.1:6379> pfadd mykey2 a c d f m z j i
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 8
127.0.0.1:6379> pfmerge mykey3 mykey1 mykey2	合并到mykey3如果有重复的会去除
OK
127.0.0.1:6379> pfcount mykey3
(integer) 10

bitmaps

位图 —

位图不是实际的数据类型，而是在 String 类型上定义的一组面向位的操作。由于字符串是二进制安全的 blob，并且它们的最大长度为 512 MB，因此它们适合设置最多 2^32 个不同的位。

位操作分为两组：恒定时间的单个位操作，例如将位设置为 1 或 0，或获取其值，以及对位组的操作，例如计算给定位范围内设置位的数量（例如，人口计数）。

位图的最大优点之一是它们在存储信息时通常可以极大地节省空间。例如，在不同用户由增量用户 ID 表示的系统中，仅使用 512 MB 内存就可以记住 40 亿用户的单个位信息（例如，知道用户是否想要接收时事通讯）。

 OK
127.0.0.1:6379> setbit day 0 1设置 1打卡 0未打卡
(integer) 0
127.0.0.1:6379> setbit day 1 0
(integer) 0
127.0.0.1:6379> setbit day 2 1
(integer) 0
127.0.0.1:6379> setbit day 3 1
(integer) 0
127.0.0.1:6379> setbit day 4 0
(integer) 0
127.0.0.1:6379> getbit day 2获取某一天的记录
(integer) 1
127.0.0.1:6379> bitcount day统计打卡了多少次
(integer) 3 ```

## redis事务

[MULTI] [EXEC]、 [DISCARD] 和 [WATCH]是 Redis 事务相关的命令。事务可以一次执行多个命令， 并且带有以下两个重要的保证：

- 事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
- 事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。

```bash
127.0.0.1:6379> multi	#开启事务
OK
127.0.0.1:6379(TX)> set k1 v1#命令入队
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> exec#提交事务
1) OK
2) OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> discard#放弃事务
OK
127.0.0.1:6379>

事务中的错误

使用事务时可能会遇上以下两种错误：

事务在执行 EXEC 之前，入队的命令可能会出错。比如说，命令可能会产生语法错误（参数数量错误，参数名错误，等等），或者其他更严重的错误，比如内存不足（如果服务器使用 maxmemory 设置了最大内存限制的话）。
命令可能在 EXEC 调用之后失败。举个例子，事务中的命令可能处理了错误类型的键，比如将列表命令用在了字符串键上面，诸如此类。
对于发生在 EXEC 执行之前的错误，客户端以前的做法是检查命令入队所得的返回值：如果命令入队时返回 QUEUED ，那么入队成功；否则，就是入队失败。如果有命令在入队时失败，那么大部分客户端都会停止并取消这个事务。

不过，从 Redis 2.6.5 开始，服务器会对命令入队失败的情况进行记录，并在客户端调用 EXEC 命令时，拒绝执行并自动放弃这个事务。

在 Redis 2.6.5 以前， Redis 只执行事务中那些入队成功的命令，而忽略那些入队失败的命令。而新的处理方式则使得在流水线（pipeline）中包含事务变得简单，因为发送事务和读取事务的回复都只需要和服务器进行一次通讯。

至于那些在 EXEC 命令执行之后所产生的错误，并没有对它们进行特别处理：即使事务中有某个/某些命令在执行时产生了错误，事务中的其他命令仍然会继续执行。

用java解释为编译错误，运行异常

编译错误

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> setget k#当语法错误后面的根本不会执行
(error) ERR unknown command `setget`, with args beginning with: `k`, 
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.

运行异常

127.0.0.1:6379> set k1 'aaa'
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incr k1#运行时一定会报错
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> exec
1) (error) ERR value is not an integer or out of range#运行异常
#至于那些在 [EXEC]命令执行之后所产生的错误， 并没有对它们进行特别处理： 即使事务中有某个/某些命令在执行时产生了错误， 事务中的其他命令仍然会继续执行。
2) OK
127.0.0.1:6379>

watch监视

1.监视money现在的钱数
2.开启事务
3.花掉10元
exec这时候有另一条线程来了，修改了money的值
结果失败nil
因为watch money监视的值与现在要执行的值不一致所以会失败
先解除监视unwatch
重新监视money最新的值

lidea连接redis

1.注释bind 127.0.0.1

2.设置reis密码

requirepass 123456

登录使用auth x

3保护关闭

protected-mode no

springboot-redis

redisutils

自定义的redistemplate模板(使用狂神的)

@Component
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    // =============================common============================
    /**
    * 指定缓存失效时间
    * @param key 键
    * @param time 时间(秒)
    */
    public boolean expire(String key, long time) {
        try{
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 根据key 获取过期时间
       * @param key 键 不能为null
       * @return 时间(秒) 返回0代表为永久有效
       */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
    /**
       * 判断key是否存在
       * @param key 键
       * @return true 存在 false不存在
       */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 删除缓存
       * @param key 可以传一个值 或多个
       */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }
    // ============================String=============================
    /**
       * 普通缓存获取
       * @param key 键
       * @return 值
       */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }
    /**
       * 普通缓存放入
       * @param key  键
       * @param value 值
       * @return true成功 false失败
       */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 普通缓存放入并设置时间
       * @param key  键
       * @param value 值
       * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
       * @return true成功 false 失败
       */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time,
                        TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 递增
       * @param key  键
       * @param delta 要增加几(大于0)
       */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }
    /**
       * 递减
       * @param key  键
       * @param delta 要减少几(小于0)
       */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }
// ================================Map=================================
    /**
       * HashGet
       * @param key 键 不能为null
       * @param item 项 不能为null
       */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }
    /**
       * 获取hashKey对应的所有键值
       * @param key 键
       * @return 对应的多个键值
       */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }
    /**
       * HashSet
       * @param key 键
       * @param map 对应多个键值
       */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * HashSet 并设置时间
       * @param key 键
       * @param map 对应多个键值
       * @param time 时间(秒)
       * @return true成功 false失败
       */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 向一张hash表中放入数据,如果不存在将创建
       *
       * @param key  键
       * @param item 项
       * @param value 值
       * @return true 成功 false失败
       */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 向一张hash表中放入数据,如果不存在将创建
       *
       * @param key  键
       * @param item 项
       * @param value 值
       * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
       * @return true 成功 false失败
       */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 删除hash表中的值
       *
       * @param key 键 不能为null
       * @param item 项 可以使多个 不能为null
       */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }
    /**
       * 判断hash表中是否有该项的值
       *
       * @param key 键 不能为null
       * @param item 项 不能为null
       * @return true 存在 false不存在
       */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }
    /**
       * hash递增 如果不存在,就会创建一个 并把新增后的值返回
       *
       * @param key 键
       * @param item 项
       * @param by  要增加几(大于0)
       */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }
    /**
       * hash递减
       *
       * @param key 键
       * @param item 项
       * @param by  要减少记(小于0)
       */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }
// ============================set=============================
    /**
       * 根据key获取Set中的所有值
       * @param key 键
       */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
       * 根据value从一个set中查询,是否存在
       *
       * @param key  键
       * @param value 值
       * @return true 存在 false不存在
       */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 将数据放入set缓存
       *
       * @param key  键
       * @param values 值 可以是多个
       * @return 成功个数
       */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**
       * 将set数据放入缓存
       *
       * @param key  键
       * @param time  时间(秒)
       * @param values 值 可以是多个
       * @return 成功个数
       */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**
       * 获取set缓存的长度
       *
       * @param key 键
       */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**
       * 移除值为value的
       *
       * @param key  键
       * @param values 值 可以是多个
       * @return 移除的个数
       */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
// ===============================list=================================
    /**
       * 获取list缓存的内容
       *
       * @param key  键
       * @param start 开始
       * @param end  结束 0 到 -1代表所有值
       */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
       * 获取list缓存的长度
       *
       * @param key 键
       */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**
       * 通过索引 获取list中的值
       *
       * @param key  键
       * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0
     时，-1，表尾，-2倒数第二个元素，依次类推
       */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
       * 将list放入缓存
       *
       * @param key  键
       * @param value 值
       */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 将list放入缓存
       * @param key  键
       * @param value 值
       * @param time 时间(秒)
       */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 将list放入缓存
       *
       * @param key  键
       * @param value 值
       * @return
       */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 将list放入缓存
       *
       * @param key  键
       * @param value 值
       * @param time 时间(秒)
       * @return
       */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 根据索引修改list中的某条数据
       *
       * @param key  键
       * @param index 索引
       * @param value 值
       * @return
       */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
       * 移除N个值为value
       *
       * @param key  键
       * @param count 移除多少个
       * @param value 值
       * @return 移除的个数
       */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count,
                    value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

Redis 持久化

Redis 提供了不同级别的持久化方式:

RDB持久化方式能够在指定的时间间隔能对你的数据进行快照存储.
AOF持久化方式记录每次对服务器写的操作,当服务器重启的时候会重新执行这些命令来恢复原始的数据,AOF命令以redis协议追加保存每次写的操作到文件末尾.Redis还能对AOF文件进行后台重写,使得AOF文件的体积不至于过大.

RDB的优点

RDB是一个非常紧凑的文件,它保存了某个时间点得数据集,非常适用于数据集的备份,比如你可以在每个小时报保存一下过去24小时内的数据,同时每天保存过去30天的数据,这样即使出了问题你也可以根据需求恢复到不同版本的数据集.
RDB是一个紧凑的单一文件,很方便传送到另一个远端数据中心或者亚马逊的S3（可能加密），非常适用于灾难恢复.
RDB在保存RDB文件时父进程唯一需要做的就是fork出一个子进程,接下来的工作全部由子进程来做，父进程不需要再做其他IO操作，所以RDB持久化方式可以最大化redis的性能.
与AOF相比,在恢复大的数据集的时候，RDB方式会更快一些.

RDB的缺点
如果你希望在redis意外停止工作（例如电源中断）的情况下丢失的数据最少的话，那么RDB不适合你.虽然你可以配置不同的save时间点(例如每隔5分钟并且对数据集有100个写的操作),是Redis要完整的保存整个数据集是一个比较繁重的工作,你通常会每隔5分钟或者更久做一次完整的保存,万一在Redis意外宕机,你可能会丢失几分钟的数据.
RDB 需要经常fork子进程来保存数据集到硬盘上,当数据集比较大的时候,fork的过程是非常耗时的,可能会导致Redis在一些毫秒级内不能响应客户端的请求.如果数据集巨大并且CPU性能不是很好的情况下,这种情况会持续1秒,AOF也需要fork,但是你可以调节重写日志文件的频率来提高数据集的耐久度.

AOF 优点
使用AOF 会让你的Redis更加耐久: 你可以使用不同的fsync策略：无fsync,每秒fsync,每次写的时候fsync.使用默认的每秒fsync策略,Redis的性能依然很好(fsync是由后台线程进行处理的,主线程会尽力处理客户端请求),一旦出现故障，你最多丢失1秒的数据.
AOF文件是一个只进行追加的日志文件,所以不需要写入seek,即使由于某些原因(磁盘空间已满，写的过程中宕机等等)未执行完整的写入命令,你也也可使用redis-check-aof工具修复这些问题.
Redis 可以在 AOF 文件体积变得过大时，自动地在后台对 AOF 进行重写：重写后的新 AOF 文件包含了恢复当前数据集所需的最小命令集合。整个重写操作是绝对安全的，因为 Redis 在创建新 AOF 文件的过程中，会继续将命令追加到现有的 AOF 文件里面，即使重写过程中发生停机，现有的 AOF 文件也不会丢失。而一旦新 AOF 文件创建完毕，Redis 就会从旧 AOF 文件切换到新 AOF 文件，并开始对新 AOF 文件进行追加操作。
AOF 文件有序地保存了对数据库执行的所有写入操作，这些写入操作以 Redis 协议的格式保存，因此 AOF 文件的内容非常容易被人读懂，对文件进行分析（parse）也很轻松。导出（export） AOF 文件也非常简单：举个例子，如果你不小心执行了 FLUSHALL 命令，但只要 AOF 文件未被重写，那么只要停止服务器，移除 AOF 文件末尾的 FLUSHALL 命令，并重启 Redis ，就可以将数据集恢复到 FLUSHALL 执行之前的状态。

AOF 缺点
对于相同的数据集来说，AOF 文件的体积通常要大于 RDB 文件的体积。
根据所使用的 fsync 策略，AOF 的速度可能会慢于 RDB 。在一般情况下，每秒 fsync 的性能依然非常高，而关闭 fsync 可以让 AOF 的速度和 RDB 一样快，即使在高负荷之下也是如此。不过在处理巨大的写入载入时，RDB 可以提供更有保证的最大延迟时间（latency）。

工作方式

当 Redis 需要保存 dump.rdb 文件时，服务器执行以下操作:

Redis 调用forks. 同时拥有父进程和子进程。
子进程将数据集写入到一个临时 RDB 文件中。
当子进程完成对新 RDB 文件的写入时，Redis 用新 RDB 文件替换原来的 RDB 文件，并删除旧的 RDB 文件。

这种工作方式使得 Redis 可以从写时复制（copy-on-write）机制中获益。

只追加操作的文件（Append-only file，AOF）

快照功能并不是非常耐久（dura ble）：如果 Redis 因为某些原因而造成故障停机，那么服务器将丢失最近写入、且仍未保存到快照中的那些数据。从 1.1 版本开始， Redis 增加了一种完全耐久的持久化方式： AOF 持久化。

你可以在配置文件中打开AOF方式:

appendonly yes

从现在开始，每当 Redis 执行一个改变数据集的命令时（比如 SET），这个命令就会被追加到 AOF 文件的末尾。这样的话，当 Redis 重新启时，程序就可以通过重新执行 AOF 文件中的命令来达到重建数据集的目的。

怎样从RDB方式切换为AOF方式

在 Redis 2.2 或以上版本，可以在不重启的情况下，从 RDB 切换到 AOF ：

为最新的 dump.rdb 文件创建一个备份。
将备份放到一个安全的地方。
执行以下两条命令:
redis-cli config set appendonly yes
redis-cli config set save “”
确保写命令会被正确地追加到 AOF 文件的末尾。
执行的第一条命令开启了 AOF 功能： Redis 会阻塞直到初始 AOF 文件创建完成为止，之后 Redis 会继续处理命令请求，并开始将写入命令追加到 AOF 文件末尾。

执行的第二条命令用于关闭 RDB 功能。这一步是可选的，如果你愿意的话，也可以同时使用 RDB 和 AOF 这两种持久化功能。

重要:别忘了在 redis.conf 中打开 AOF 功能！否则的话，服务器重启之后，之前通过 CONFIG SET 设置的配置就会被遗忘，程序会按原来的配置来启动服务器。

redis订阅与发布

推送消息的格式

消息是一个有三个元素的多块响应。

第一个元素是消息类型:

subscribe: 表示我们成功订阅到响应的第二个元素提供的频道。第三个参数代表我们现在订阅的频道的数量。
unsubscribe:表示我们成功取消订阅到响应的第二个元素提供的频道。第三个参数代表我们目前订阅的频道的数量。当最后一个参数是0的时候，我们不再订阅到任何频道。当我们在Pub/Sub以外状态，客户端可以发出任何redis命令。
message: 这是另外一个客户端发出的发布命令的结果。第二个元素是来源频道的名称，第三个参数是实际消息的内容。

主从复制

127.0.0.1:6310> info replication#查看当前是主从
# Replication
role:master     // 主机标识
connected_slaves:1   // 他有一个从机
slave0:ip=127.0.0.1  // 从机地址
,port=6320  // 从机端口
,state=online // 从机状态 
slaveof 127.0.0.1 6310设置127.0.0.1 6310为主

在 Redis 复制的基础上，使用和配置主从复制非常简单，能使得从 Redis 服务器（下文称 slave）能精确得复制主 Redis 服务器（下文称 master）的内容。每次当 slave 和 master 之间的连接断开时， slave 会自动重连到 master 上，并且无论这期间 master 发生了什么， slave 都将尝试让自身成为 master 的精确副本。

哨兵模式

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。

哨兵模式概述

哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

哨兵

这里的哨兵有两个作用

通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。

然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。

用文字描述一下故障切换（failover）的过程。假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。这样对于客户端而言，一切都是透明的。

1、配置哨兵模式sentinel.conf（最基本配置）

sentinel monitor 被监控的名称 主机地址 端口 1sentinel monitor myredis 127.0.0.1 6379 1

这里的 ’1‘ 代表的是如果有1个sentinel（哨兵）判断某个master（主机）宕机，那么该主机宕机下线（也就是至少多少个sentinel同意，master才下线）

2、开启哨兵

./redis-sentinel /kconfig/sentinel.conf

哨兵模式的优缺点

优点

哨兵集群，基于主从复制模式，所有的主从配置的优点，它都有。
主从可以切换，故障可以转移，系统的可用性就会更好。
哨兵模式就是主从模式的升级版，从收到到自动，更加健壮。

缺点

Redis不好在线扩容，集群容量一旦达到上限，在线扩容就会十分麻烦。
实现哨兵模式的配置比较麻烦，并且其中有很多选项

哨兵模式配置文件中的全部配置

# Example   sentinel.conf
# 哨兵sentinel实例运行的端口   默认是26379，如果有哨兵集群，我们还需要配置每个哨兵端口
port 26379
#哨兵sentinel的工作目录
dir /tmp
#哨兵 sentine1 监控的redis主节点的 ip port   
# master-name  ，可以自己命名的主节点名字 只能由字母A-Z、数字0-9、这三个字符"  .   -  _ "组成。
# quorum配置多少个sentine1哨兵统- -认为master主节点失联那么这时客观上认为主节点失联了
# sentine1 monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor mymaster   127.0.0.1   6379   2
#当在Redis实例中开启了requirepass foobared 授权密码这样所有连接kedis实例的客户端都要提供密码
#设置哨兵sentinel连接主从的密码注意必须为主从设置- - 样的验证密码
# sentine1 auth-pass <master-name> <password>
sentine1 auth-pass mymaster MySUPER--secret-0123passwOrd
#指定多少毫秒之后主节点没有应答哨兵sentine1 此时哨兵主观上认为主节点下线默认30秒
# sentinel down-after-mi 11i seconds <master-name> <mi 11iseconds>
sentine1 down-after-mi 11iseconds mymaster 30000
#这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行同步，这个数字越小，完成fai lover所需的时间就越长，但是如果这个数字越大，就意味着越多的slave因为replication而 不可用。可以通过将这个值设为1来保证每次只有一个slave处于不能处理命令请求的状态。
# sentine1 paralle1-syncs <master-name> <numslaves>
sentine1 paralle1-syncs mymaster 1
#故障转移的超时时间failover-timeout 可以用在以下这些方面:
#1.同一个sentine1对同一 个master两次fai lover之间的间隔时间。
#2.当一个slave从一 个错误的master那里同步数据开始计算时间。直到s1ave被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的failover所需要的时间。
#4.当进行failover时，配置所有s1aves指向新的master所需的最大时间。不过，即使过了这个超时，slaves 依然会被正确配置为指向master,但是就不按parallel-syncs所配置的规则来了
#默认三分钟
# sentine1 failover-timeout <master-name> <milliseconds>
sentine1 fai lover-ti meout mymaster 180000
# SCRIPTS EXECUTION
#配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
#对于脚本的运行结果有以下规则:
#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
#若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
#一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被-一个SIGKILL信号终止，之后重新执行。
#通知型脚本:当sentine1有任何警告级别的事件发生时(比如说redis实例的主观失效和客观失效等等)，将会去调用这个脚本，这时这个脚本应该通过邮件，SMS等 方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，一 个是事件的类型，一个是事件的描述。如果sentine1. conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentine1无法正常启动成功。
#通知脚本
# she11编程
# sentine1 notification-script <master-name> <script-path>
sentine1 notificati on-script mymaster /var/redis/notify. sh
#客户端重新配置主节点参数脚本
#当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。
#以下参数将会在调用脚本时传给脚本: 
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
#目前<state>总是“failover",
# <role>是“Teader"或者"observer"中的-一个。
#参数from-ip， from-port， to-ip，to-port是用来和旧的master和新的master(即旧的s lave)通信的
#这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentine1 client-reconfig-script <master-name> <script-path>
sentine1 client-reconfig-script mymaster /var/redis/reconfig.sh #一般都是由运维来配置!

posted @ 2021-10-08 10:53 是星辰闪耀阅读(44) 评论(0) 收藏举报

刷新页面返回顶部

一起去看流星雨

redis

redis

安装redis

redis基础

String

list

set

hash

zset

地理空间（geospatial)

geoadd

getpos

geodist

georadiusbymember

HyperLogLogs

bitmaps

事务中的错误

watch监视

lidea连接redis

springboot-redis

redisutils

Redis 持久化

RDB的优点

RDB的缺点

AOF 优点

AOF 缺点

工作方式

只追加操作的文件（Append-only file，AOF）

怎样从RDB方式切换为AOF方式

redis订阅与发布

推送消息的格式

主从复制

哨兵模式

哨兵模式概述

哨兵

哨兵模式的优缺点

哨兵模式配置文件中的全部配置

公告