redis（第一次发，试试水）

#Redis

wget http://download.redis.io/releases/redis-4.0.8.tar.gz

redis 默认有16个库

spring-data-redis(spring 封装了jedis )

RedisTemplate支持：

Key类型操作
ValueOperations	Redis String/Value 操作
ListOperations	Redis List 操作
SetOperations	Redis Set 操作
ZSetOperations	Redis Sort Set 操作
HashOperations	Redis Hash 操作
Value约束操作
BoundValueOperations	Redis String/Value key 约束
BoundListOperations	Redis List key 约束
BoundSetOperations	Redis Set key 约束
BoundZSetOperations	Redis Sort Set key 约束
BoundHashOperations	Redis Hash key 约束

Redis键命令

下表列出了与键相关的一些基本命令：

​

编号	命令	描述
1*	DEL key	此命令删除一个指定键(如果存在)。
2	DUMP key	此命令返回存储在指定键的值的序列化版本。
3*	EXISTS key	此命令检查键是否存在。
4*	EXPIRE key seconds	设置键在指定时间秒数之后到期/过期。
5	EXPIREAT key timestamp	设置在指定时间戳之后键到期/过期。这里的时间是Unix时间戳格式。
6	PEXPIRE key milliseconds	设置键的到期时间(以毫秒为单位)。
7	PEXPIREAT key milliseconds-timestamp	以Unix时间戳形式来设置键的到期时间(以毫秒为单位)。
8*	KEYS pattern	查找与指定模式匹配的所有键。
9*	MOVE key db	将键移动到另一个数据库。
10*	PERSIST key	删除指定键的过期时间，得永生。
11*	PTTL key	获取键的剩余到期时间。
12	RANDOMKEY	从Redis返回一个随机的键。
13*	RENAME key newkey	更改键的名称。
14*	PTTL key	获取键到期的剩余时间(以毫秒为单位)。
15	RENAMENX key newkey	如果新键不存在，重命名键。
16*	TYPE key	返回存储在键中的值的数据类型。

Redis字符串命令

下表列出了一些用于在Redis中管理字符串的基本命令。

编号	命令	描述说明
1	SET key value	此命令设置指定键的值。
2	GET key	获取指定键的值。
3	GETRANGE key start end	获取存储在键上的字符串的子字符串。
4	GETSET key value	设置键的字符串值并返回其旧值。
5	GETBIT key offset	返回在键处存储的字符串值中偏移处的位值。
6	[MGET key1 key2…]	获取所有给定键的值
7	SETBIT key offset value	存储在键上的字符串值中设置或清除偏移处的位
8	SETEX key seconds value	使用键和到期时间来设置值
9	SETNX key value	设置键的值，仅当键不存在时
10	SETRANGE key offset value	在指定偏移处开始的键处覆盖字符串的一部分
11	STRLEN key	获取存储在键中的值的长度
12	[MSET key value key value …]	为多个键分别设置它们的值
13	[MSETNX key value key value …]	为多个键分别设置它们的值，仅当键不存在时
14	PSETEX key milliseconds value	设置键的值和到期时间(以毫秒为单位)
15	INCR key	将键的整数值增加1
16	INCRBY key increment	将键的整数值按给定的数值增加
17	INCRBYFLOAT key increment	将键的浮点值按给定的数值增加
18	DECR key	将键的整数值减1
19	DECRBY key decrement	按给定数值减少键的整数值
20	APPEND key value	将指定值附加到键

Redis哈希命令

下表列出了与哈希/散列相关的一些基本命令。

例子：

在名称为’`myhash`‘的哈希中设置了Redis教程的详细信息(名称，描述，喜欢，访问者)。 

redis 127.0.0.1:6379> HMSET myhash name "redis tutorial" 
description "redis basic commands for caching" likes 20 visitors 23000 
OK 
127.0.0.1:6379> HGETALL myhash
1) "field1"
2) "Hello"
3) "field2"
4) "World"
5) "name"
6) "redis tutorial"

序号	命令	说明
1	[HDEL key field2 field2]	删除一个或多个哈希字段。
2	HEXISTS key field	判断是否存在散列字段。
3	HGET key field	获取存储在指定键的哈希字段的值。
4	HGETALL key	获取存储在指定键的哈希中的所有字段和值
5	HINCRBY key field increment	将哈希字段的整数值按给定数字增加
6	HINCRBYFLOAT key field increment	将哈希字段的浮点值按给定数值增加
7	HKEYS key	获取哈希中的所有字段
8	HLEN key	获取散列中的字段数量
9	[HMGET key field1 field2]	获取所有给定哈希字段的值
10	[HMSET key field1 value1 field2 value2 ]	为多个哈希字段分别设置它们的值
11	HSET key field value	设置散列字段的字符串值
12	HSETNX key field value	仅当字段不存在时，才设置散列字段的值
13	HVALS key	获取哈希中的所有值

Redis列表命令

下表列出了与列表相关的一些基本命令。

示例

redis 127.0.0.1:6379> LPUSH mylist "redis" 
(integer) 1 
redis 127.0.0.1:6379> LPUSH mylist "mongodb"
(integer) 2 
redis 127.0.0.1:6379> LPUSH mylist "mysql"
(integer) 3 
redis 127.0.0.1:6379> LRANGE mylist 0 10  
1) "mysql" 
2) "mongodb" 
3) "redis"

在上面的示例中，通过命令LPUSH将三个值插入到名称为“mylist”的Redis列表中。

序号	命令	说明
1	[BLPOP key1 key2 ] timeout	删除并获取列表中的第一个元素，或阻塞，直到有一个元素可用
2	[BRPOP key1 key2 ] timeout	删除并获取列表中的最后一个元素，或阻塞，直到有一个元素可用
3	BRPOPLPUSH source destination timeout	从列表中弹出值，将其推送到另一个列表并返回它; 或阻塞，直到一个可用
4	LINDEX key index	通过其索引从列表获取元素
5	LINSERT key BEFORE/AFTER pivot value	在列表中的另一个元素之前或之后插入元素
6	LLEN key	获取列表的长度
7	LPOP key	删除并获取列表中的第一个元素
8	[LPUSH key value1 value2]	将一个或多个值添加到列表
9	LPUSHX key value	仅当列表存在时，才向列表添加值
10	LRANGE key start stop	从列表中获取一系列元素
11	LREM key count value	从列表中删除元素
12	LSET key index value	通过索引在列表中设置元素的值
13	LTRIM key start stop	修剪列表的指定范围
14	RPOP key	删除并获取列表中的最后一个元素
15	RPOPLPUSH source destination	删除列表中的最后一个元素，将其附加到另一个列表并返回
16	[RPUSH key value1 value2]	将一个或多个值附加到列表
17	RPUSHX key value	仅当列表存在时才将值附加到列表

Redis集合命令

下表列出了与集合相关的一些基本命令。

示例

· 通过命令SADD将三个值插入到名称为“myset”的Redis集合中。

redis 127.0.0.1:6379> SADD myset "redis" 
(integer) 1 
redis 127.0.0.1:6379> SADD myset "mongodb" 
(integer) 1 
redis 127.0.0.1:6379> SADD myset "mysql" 
(integer) 1 
redis 127.0.0.1:6379> SADD myset "mysql" 
(integer) 0 
redis 127.0.0.1:6379> SMEMBERS "myset"  
1) "mysql" 
2) "mongodb" 
3) "redis"

序号	命令	说明
1	[SADD key member1 member2]	将一个或多个成员添加到集合
2	SCARD key	获取集合中的成员数
3	[SDIFF key1 key2]	减去多个集合
4	[SDIFFSTORE destination key1 key2]	减去多个集并将结果集存储在键中
5	[SINTER key1 key2]	相交多个集合
6	[SINTERSTORE destination key1 key2]	交叉多个集合并将结果集存储在键中
7	SISMEMBER key member	判断确定给定值是否是集合的成员
8	SMOVE source destination member	将成员从一个集合移动到另一个集合
9	SPOP key	从集合中删除并返回随机成员
10	[SRANDMEMBER key count]	从集合中获取一个或多个随机成员
11	[SREM key member1 member2]	从集合中删除一个或多个成员
12	[SUNION key1 key2]	添加多个集合
13	[SUNIONSTORE destination key1 key2]	添加多个集并将结果集存储在键中
14	[SSCAN key cursor MATCH pattern] [COUNT count]	递增地迭代集合中的元素

redis.conf 文件配置：

Untis单位：

# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# units are case insensitive so 1GB 1Gb 1gB are all the same.大小写不区分

密码设置：

redis默认是不用密码登录的。	

	进入redis编辑器， config get requirepass 可以查看密码，如果密码为"" 就表示登录redis不用密码，可以直接使用。config set requirepass "xxxx" 给redis 设置密码，auth xxx 登录。

限制：

maxclients (最大连接数。设置0表示不做限制)

maxmemory<types>（最大内存）

（重点）*maxmenory-policy(最大内存的管理策略)

	1.volatile-lru(least recently used):最近最少使用算法，从设置了过期时间的键中选择空转时间最长的键值对清除掉；

    	2.volatile-lfu(least frequently used):最近最不经常使用算法，从设置了过期时间的键中选择某段时间之内使用频次最小的键值对清除掉；

  		  3.volatile-ttl:从设置了过期时间的键中选择过期时间最早的键值对清除；

  		  4.volatile-random:从设置了过期时间的键中，随机选择键进行清除；

  		  5.allkeys-lru:最近最少使用算法，从所有的键中选择空转时间最长的键值对清除；

   		  6.allkeys-lfu:最近最不经常使用算法，从所有的键中选择某段时间之内使用频次最少的键值对清除；

    	  7.allkeys-random:所有的键中，随机选择键进行删除；

      	  8.noeviction:不做任何的清理工作，在redis的内存超过限制之后，所有的写入操作都会返回错误；但是读操作都能正常的进行;

maxmenory-samples

(重要)redis.conf文件的翻译：

（重点）redis 的持久化

fork:

rdb:  

	在redis.conf的	save 900 1 save 300 10  save 60 10000 进行策略配置，但是有一个缺点就是在最后的一次持久化的时候有可能 会导致缓存的丢失，（它在满足条件的时候就会进行创建dump.rdb 文件进行拷贝备份，在下次启动的时候会自动的进行加载，从而达到数据的备份。）

	save(只管保存，其他的什么也不管，线程阻塞)或者bgsave （异步进行快照操作）马上进行备份（二进制的方式保存到磁盘中 ）

	细节，百度

aof:

	AOF 则以日志的的方式，将所有对数据库进行过写入的命令（及其参数）记录到 AOF 文件，以此达到记录数据库状态的目的。重启的话，会把从最开始的命令一直执行到最后一条命令，缺点就是 会占用很大的空间

	Rewrite:AOF 采取文件追加方式，文件会越来越大，为了避免种问题，新增了重写机制，当AOF文件的大小超过所设定的值，redis就会启动AOF文件的内容压缩，只保存可以恢复数据的最小指令集。可以使用命令bgrewriteaof.

	注意：在某些特殊情况可能会造成AOF所储存的信息是不正确的，就会导致不能恢复，redis-check-aof -fix appendonly.aof 这条命令就会删除appendonly.aof 中的所有不符合语法的语句。（rdb 也是这个道理）还有就是 AOF和RDB同时存在的时候会先执行AOP文件。

Redis事务：

MULTI 、 EXEC 、 DISCARD 和 WATCH 是 Redis 事务相关的命令。

开启：以MULTI开始一个事务

入队：将多个命令入队到事务，接到这些命令并不会立即执行，而是放到等待执行的事务队列里面。

执行：由EXEC命令触发事务

特性：

单独的隔离操作：事务中的所有命令多会系列化，按顺序执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。 

没有隔离级别的概念：队列中的命令没有提交之前都不会实际的被执行，因为事务提交前任何指令都不会执行，

（重点）redis事务不保证原子性操作：事务中的命令如果有错误信息，那么错误的不执行，其他的还是会继续执行下去，并且没有回滚。 

EXEC 命令负责触发并执行事务中的所有命令：

• 如果客户端在使用 MULTI 开启了一个事务之后，却因为断线而没有成功执行 EXEC ，那么事务中的所有命令都不会被执行。

• 另一方面，如果客户端成功在开启事务之后执行 EXEC ，那么事务中的所有命令都会被执行。

  用法

  MULTI 命令用于开启一个事务，它总是返回 OK 。 MULTI 执行之后， 客户端可以继续向服务器发送任意多条命令， 这些命令不会立即被执行， 而是被放到一个队列中， 当 EXEC命令被调用时， 所有队列中的命令才会被执行。

  另一方面， 通过调用 DISCARD ， 客户端可以清空事务队列， 并放弃执行事务。

  以下是一个事务例子， 它原子地增加了 foo 和 bar 两个键的值：

  > MULTI
  OK
  > INCR foo
  QUEUED
  > INCR bar
  QUEUED
  > EXEC
  1) (integer) 1
  2) (integer) 1
  
  

  EXEC 命令的回复是一个数组， 数组中的每个元素都是执行事务中的命令所产生的回复。 其中， 回复元素的先后顺序和命令发送的先后顺序一致。

  当客户端处于事务状态时， 所有传入的命令都会返回一个内容为 QUEUED 的状态回复（status reply）， 这些被入队的命令将在 EXEC 命令被调用时执行。

事务中的错误

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

• 事务在执行 EXEC 之前，入队的命令可能会出错。比如说，命令可能会产生语法错误（参数数量错误，参数名错误，等等），或者其他更严重的错误，比如内存不足（如果服务器使用 maxmemory 设置了最大内存限制的话）。
• 命令可能在 EXEC 调用之后失败。举个例子，事务中的命令可能处理了错误类型的键，比如将列表命令用在了字符串键上面，诸如此类。

对于发生在 EXEC 执行之前的错误，客户端以前的做法是检查命令入队所得的返回值：如果命令入队时返回 QUEUED ，那么入队成功；否则，就是入队失败。如果有命令在入队时失败，那么大部分客户端都会停止并取消这个事务。

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

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

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

从协议的角度来看这个问题，会更容易理解一些。 以下例子中， LPOP 命令的执行将出错， 尽管调用它的语法是正确的：

Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
MULTI
+OK
SET a 3
abc
+QUEUED
LPOP a
+QUEUED
EXEC
*2
+OK
-ERR Operation against a key holding the wrong kind of value

EXEC 返回两条bulk-string-reply： 第一条是 OK ，而第二条是 -ERR 。 至于怎样用合适的方法来表示事务中的错误， 则是由客户端自己决定的。

最重要的是记住这样一条， 即使事务中有某条/某些命令执行失败了， 事务队列中的其他命令仍然会继续执行 —— Redis 不会停止执行事务中的命令。

以下例子展示的是另一种情况， 当命令在入队时产生错误， 错误会立即被返回给客户端：

MULTI
+OK
INCR a b c
-ERR wrong number of arguments for 'incr' command

因为调用 INCR 命令的参数格式不正确， 所以这个 INCR 命令入队失败。

为什么 Redis 不支持回滚（roll back）

如果你有使用关系式数据库的经验， 那么 “Redis 在事务失败时不进行回滚，而是继续执行余下的命令”这种做法可能会让你觉得有点奇怪。

以下是这种做法的优点：

• Redis 命令只会因为错误的语法而失败（并且这些问题不能在入队时发现），或是命令用在了错误类型的键上面：这也就是说，从实用性的角度来说，失败的命令是由编程错误造成的，而这些错误应该在开发的过程中被发现，而不应该出现在生产环境中。
• 因为不需要对回滚进行支持，所以 Redis 的内部可以保持简单且快速。

有种观点认为 Redis 处理事务的做法会产生 bug ， 然而需要注意的是， 在通常情况下， 回滚并不能解决编程错误带来的问题。 举个例子， 如果你本来想通过 INCR 命令将键的值加上 1 ， 却不小心加上了 2 ， 又或者对错误类型的键执行了 INCR， 回滚是没有办法处理这些情况的。

放弃事务

当执行 DISCARD 命令时， 事务会被放弃， 事务队列会被清空， 并且客户端会从事务状态中退出：

> SET foo 1
OK
> MULTI
OK
> INCR foo
QUEUED
> DISCARD
OK
> GET foo
"1"

使用 check-and-set 操作实现乐观锁

WATCH 命令可以为 Redis 事务提供 check-and-set （CAS）行为。

被 WATCH 的键会被监视，并会发觉这些键是否被改动过了。 如果有至少一个被监视的键在 EXEC 执行之前被修改了， 那么整个事务都会被取消， EXEC 返回nil-reply来表示事务已经失败。

举个例子， 假设我们需要原子性地为某个值进行增 1 操作（假设 INCR 不存在）。

首先我们可能会这样做：

val = GET mykey
val = val + 1
SET mykey $val

上面的这个实现在只有一个客户端的时候可以执行得很好。 但是， 当多个客户端同时对同一个键进行这样的操作时， 就会产生竞争条件。举个例子， 如果客户端 A 和 B 都读取了键原来的值， 比如 10 ， 那么两个客户端都会将键的值设为 11 ， 但正确的结果应该是 12 才对。

有了 WATCH ， 我们就可以轻松地解决这类问题了：

WATCH mykey
val = GET mykey
val = val + 1
MULTI
SET mykey $val
EXEC

使用上面的代码， 如果在 WATCH 执行之后， EXEC 执行之前， 有其他客户端修改了 mykey 的值， 那么当前客户端的事务就会失败。 程序需要做的， 就是不断重试这个操作， 直到没有发生碰撞为止。

这种形式的锁被称作乐观锁， 它是一种非常强大的锁机制。 并且因为大多数情况下， 不同的客户端会访问不同的键， 碰撞的情况一般都很少， 所以通常并不需要进行重试。

了解 WATCH

WATCH 使得 EXEC 命令需要有条件地执行： 事务只能在所有被监视键都没有被修改的前提下执行， 如果这个前提不能满足的话，事务就不会被执行。 了解更多->

WATCH 命令可以被调用多次。 对键的监视从 WATCH 执行之后开始生效， 直到调用 EXEC 为止。

用户还可以在单个 WATCH 命令中监视任意多个键， 就像这样：

redis> WATCH key1 key2 key3
OK

当 EXEC 被调用时， 不管事务是否成功执行， 对所有键的监视都会被取消。

另外， 当客户端断开连接时， 该客户端对键的监视也会被取消。

使用无参数的 UNWATCH 命令可以手动取消对所有键的监视。 对于一些需要改动多个键的事务， 有时候程序需要同时对多个键进行加锁， 然后检查这些键的当前值是否符合程序的要求。 当值达不到要求时， 就可以使用 UNWATCH 命令来取消目前对键的监视， 中途放弃这个事务， 并等待事务的下次尝试。

使用 WATCH 实现 ZPOP

WATCH 可以用于创建 Redis 没有内置的原子操作。举个例子， 以下代码实现了原创的 ZPOP 命令， 它可以原子地弹出有序集合中分值（score）最小的元素：

WATCH zset
element = ZRANGE zset 0 0
MULTI
ZREM zset element
EXEC

程序只要重复执行这段代码， 直到 EXEC 的返回值不是nil-reply回复即可。

地址

Redis 读写分离：

也就是大家所说的主从复制，主机数据更新后根据配置和策略，自动同步到备用记的master/slaver机制，Master以写为主，Slave以读为主（不能写）；

用法：

1.首先先复制并配置配置文件等等，做好前期准备。

2.配从（库）不配主（库）（每次与mater断开后，都需要重新连接，除非你配置进redis.conf文件）（info replication 查看当前的服务器角色是主服务器（role master）

3.修改配置文件的细节操作。拷贝多个redis.conf文件。开启daemonize yes .pid 文件姓名。指定端口，log文件名字，Dump.rdb文件。（slaveof no one  从库变主库 ）（slaveof  127.x.x.x  端口号  该库跟随那个大哥）

注意事项：当主库挂了，从库不会谋权篡位，会等待，当其中一个从库挂了，不会影响其他的从库。

哨兵：

相当于出问题的时候自动帮我们处理，主库挂了，就会在从库中投票选出主库，并且让其他的库也当他的从库，并且当原先那个主库恢复了，重新上线，也会成为新选出来那个主库的从库。

读写分离的相关配置

​