Redis学习笔记

Redis学习笔记

一、Redis基础概念及安装步骤：

1、Redis是什么？

Redis是完全开源免费的，用C语言编写的，遵守BSD协议。

Redis是一个高性能的(key/value)分布式内存数据库，基于内存运行并支持持久化的NoSql数据库。

2、Redis三大特性

1、支持数据持久化，可以将内存中的数据保存到磁盘中，重启的时候可以再次进行使用（即rdb和aof）。

2、支持数据备份，即master-slave模式的主从复制数据备份。

3、支持多数据类型，支持String、list、hash、set、zset五大数据结构的存储。

3、Redis四大优势

1、高性能：Redis能读的速度是110000次/s,写的速度是81000次/s。

2、原子性：Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。

3、丰富的数据类型：Redis支持String、List、hash、set、zset五大数据类型。

4、16个数据库：Redis默认有16个数据库。

4、安装Redis

window下安装Redis:

1. 下载地址：https://github.com/tporadowski/redis/releases
   

2. 解压下载压缩文件夹，并打开文件夹，内容如下：
   

3. 打开一个 cmd 窗口 使用 cd 命令切换目录到 D:\tools\redis\window\Redis-x64-5.0.9 运行：
   redis-server.exe redis.windows.conf
   

4. 这时候另启一个 cmd 窗口，原来的不要关闭，不然就无法访问服务端了。
   切换到 redis 目录下运行:

redis-cli.exe -h 127.0.0.1 -p 6379

设置键值对:

set myKey abc

取出键值对:

get myKey

二、Redis常用命令及五大数据类型：

1、Redis数据库常用命令：

redis默认有16个数据库

1、sele在这里插入代码片ct 1 : 切换至数据库2

2、dbsize : 查看当前数据库key的数量

3、keys * : 查看当前数据库的所有key

4、 flushdb : 清空当前数据库

5、 flushall : 清空所有数据库

2、key关键字常用命令：

1、set keyName value : 设置key的值

2、get keyName : 获取key的值

3、del keyName ：删除key的值

4、type keyName : 查看key的数据类型

5、exists keyName :  判断key是否存在

6、move keyName 2 : 将key移至数据库2中

7、expire keyName 10 : 设置key的过期时间为10s

8、ttl keyName : 查看key还有多长时间过期(-1表示永远不过期，-2表示已经过期)

9、 keys * :查看当前库中的所有key

3、字符串(String)常用命令：

1、set key value ：设置指定 key 的值

2、get key : 获取指定 key 的值。

3、del key : 删除key

4、setex key seconds value : 将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。

5、setnx key value : 只有在 key 不存在时设置 key 的值。

6、mset key value [key value ...] : 同时设置一个或多个 key-value 对

7、msetnx key value [key value ...] : 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。

8、mget key [key ...] : 同时获取多个key的值

9、append key value : 如果 key 已经存在并且是一个字符串， APPEND 命令将指定的 value 追加到该 key 原来值的末尾。

10、getrange key start end : 返回 key 中字符串值的子字符

11、setrange key offset value  ：用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始。

12、strlen key : 返回 key 所储存的字符串值的长度

13、incr key ：将 key 中储存的数字值加一

14、decr key : 将 key 中储存的数字值减一

15、incrby key increment : 将 key 所储存的值加上给定的增量值（increment）

16、decrby key decrement: key 所储存的值减去给定的减量值（decrement）

4、Redis 列表(List)常用命令：

Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）

1、lpush key value1 [value2] : 在列表中添加一个或多个值(先进后出)

2、rpush key value1 [value2] : 在列表中添加一个或多个值(先进先出)

3、lrange key start stop : 获取列表指定范围内的元素

4、lpop key : 移出并获取列表的第一个元素

5、rpop key : 移除列表的最后一个元素，返回值为移除的元素

6、lindex key index : 通过索引获取列表中的元素

7、llen key : 获取列表长度

8、lrem key count value : 移除列表元素(移除列表中count个value)

9、ltrim key start stop : 对一个列表进行修剪，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。

10、rpoplpush source destination ：移除列表的最后一个元素，并将该元素添加到另一个列表并返回

11、lset key index value ：通过索引设置列表元素的值

12、linsert key before|after pivot value ：在列表的元素前或者后插入元素

5、Redis 集合(Set)常用命令：

Redis 的 Set 是 String 类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。

1、sadd key member1 [member2] : 向集合添加一个或多个成员

2、smembers key : 返回集合中的所有成员

3、scard key : 获取集合的成员数

4、srem key member1 [member2] : 移除集合中一个或多个成员

5、srandmember key [count] : 返回集合中一个或多个随机数

6、spop key : 移除并返回集合中的一个随机元素

7、smove source destination member : 将 member 元素从 source 集合移动到 destination 集合

8、sismember key member : 判断 member 元素是否是集合 key 的成员

9、sdiff key1 [key2] : 返回给定所有集合的差集

10、sdiffstore destination key1 [key2] ： 返回给定所有集合的差集并存储在 destination 中

11、sinter key1 [key2] : 返回给定所有集合的交集

12、sinterstore destination key1 [key2] ： 返回给定所有集合的交集并存储在 destination 中

13、sunion key1 [key2] : 返回所有给定集合的并集

14、sunionstore destination key1 [key2] ： 所有给定集合的并集存储在 destination 集合中

6、Redis 有序集合(zset)常用命令:

Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。

不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

1、zadd key score1 member1 [score2 member2] : 向有序集合添加一个或多个成员，或者更新已存在成员的分数

2、zrange key start stop : 通过索引区间返回有序集合指定区间内的成员

3、zrange key min max : 通过分数返回有序集合指定区间内的成员

4、zrem key member [member ...] : 移除有序集合中的一个或多个成员

5、zcard key : 获取有序集合的成员数

6、zcound key min max : 计算在有序集合中指定区间分数的成员数

7、zscore key member : 返回有序集中，成员的分数值

7、Redis 哈希(Hash)

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

Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿）。

1、hset key field value : 将哈希表 key 中的字段 field 的值设为 value 。

2、hget key field : 获取存储在哈希表中指定字段的值。

3、hmset key field1 value1 [field2 value2] : 同时将多个 field-value (域-值)对设置到哈希表 key 中。

4、hmget key field1 [field2] : 获取所有给定字段的值

5、hgetall key : 获取在哈希表中指定 key 的所有字段和值

6、hdel key field1 [field2] : 删除一个或多个哈希表字段

7、hlen key : 获取哈希表中字段的数量

8、hexists key field : 查看哈希表 key 中，指定的字段是否存在。 （类似判断map中是否存在某一个key）

9、hkeys key : 获取所有哈希表中的字段(类似于map中的key值)

10、hvals key : 获取哈希表中所有值。

11、hsetnx key field value : 只有在字段 field 不存在时，设置哈希表字段的值。

三、redis配置文件（redis.windows.conf）

1、通用配置 GENERAL

1、daemonize : Linux中需要将该值设置为yes

2、port : 端口，默认为6379

3、tcp-backlog ： 在高并发的环境下需要设置一个高的tcp-backlog值，来避免客户端链接缓慢的问题，默认值为511

4、bind ： 绑定的主机ip地址，默认绑定的是 127.0.0.1

5、timeout ： 在客户端空闲N秒后关闭连接(0禁用)，默认为0 表示永不关闭连接

6、loglevel ： 日志级别，redis设置了四个级别：debug、verbose、notice、warning

7、logfile : 日志文件的名字

8、syslog-enabled ： 系统日志，默认关闭 no

9、syslog-ident ： 系统日志的名字 默认 redis

10、databases ： 数据库，redis默认有16个数据库

2、安全配置 SECURITY

1、查看Redis密码：config get requirepass

2、查看Redis启动路径: config get dir

3、设置Redis登录密码：config set requirepass “123456”, 设置了密码之后，需要先输入auth "123456"之后才能访问redis

3、限制配置 LIMITS

1、maxclients ： 最大连接数 默认连接数为10000

2、maxmemory ： 设置最大内存空间（注意，在 64bit 系统下，maxmemory设置为 0 表示不限制 Redis 内存使用，在 32bit 系统 下，maxmemory隐式不能超过 3GB。）

3、maxmemory-policy ：最大内存空间的六种策略,其中在实际生产中绝对不能使用noeviction策略

volatile-lru：使用LRU算法删除带有过期集的key

allkeys-lru：根据LRU算法删除任何key

volatile-random：删除带有过期集的随机键

allkeys-random：删除一个随机的键，任何键

volatile-ttl：删除最近过期时间的密钥(较小的TTL)

noeviction：完全不过期

4、maxmemory-samples ： 在redis-3.0.0中的默认配置为5，如果增加，会提高LRU或TTL的精准度，redis作者测试的结果是当这 个配置为10时已经非常接近全量LRU的精准度了，并且增加maxmemory-samples会导致在主动清理时消耗更多的CPU时间。

4、RDB持久化相关配置 SNAPSHOTTING

1、save 900 1 ：表示900 秒内如果至少有 1 个 key 的值变化，则保存
save 300 10 ： 表示300 秒内如果至少有 10 个 key 的值变化，则保存
save 60 10000 ：表示60 秒内如果至少有 10000 个 key 的值变化，则保存

2、stop-writes-on-bgsave-error ：如果发生备份数据错误，停止前端写入 默认值为yes

3、rdbcompression ：默认值是yes。对于存储到磁盘中的快照，可以设置是否进行压缩存储。如果是的话，redis会采用LZF算法进 行压缩。如果你不想消耗CPU来进行压缩的话，可以设置为关闭此功能，但是存储在磁盘上的快照会比较大。

4、rdbchecksum ：默认值是yes。在存储快照后，我们还可以让redis使用CRC64算法来进行数据校验，但是这样做会增加大约10% 的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能。

5、dbfilename ： 设置快照的文件名，默认是 dump.rdb

6、dir : 设置快照文件的存放路径，这个配置项一定是个目录，而不能是文件名

5、AOF持久化相关配置 APPEND ONLY MODE

1、appendonly ：开启AOF模式 默认关闭 no

2、appendfilename “appendonly.aof” ： 默认备份数据文件名是appendonly.aof

3、appendfsync ：备份策略（从持久化角度讲，always是最安全的；从效率上讲，no是最快的；而redis默认设置进行了折中，选 择了everysec）

1、always ： 同步持久化，每次发数数据变更都会被立即记录到磁盘上，性能较差，但数据完整性较高

2、everysec ： 出厂默认，异步操作，每秒钟记录一次

3、no ：不进行备份操作

4、no-appendfsync-on-rewrite ：bgrewriteaof机制，在一个子进程中进行aof的重写，从而不阻塞主进程对其余命令的处理，同时 解决了aof文件过大问题。现在问题出现了，同时在执行bgrewriteaof操作和主进程写aof文件的操作，两者都会操作磁盘bgrewriteaof往往会涉及大量磁盘操作，这样就会造成主进程在写aof文件的时候出现阻塞的情形，现在no-appendfsync-on-rewrite参数出场了。如果该参数设置为no，是最安全的方式，不会丢失数据，但是要忍受阻塞的问题。如果设置为yes呢？这就相当于将appendfsync设置为no，这说明并没有执行磁盘操作，只是写入了缓冲区，因此这样并不会造成阻塞（因为没有竞争磁盘），但是如果这个时候redis挂掉，就会丢失数据。丢失多少数据呢？在linux的操作系统的默认设置下，最多会丢失30s的数据。因此，如果应用系统无法忍受延迟，而可以容忍少量的数据丢失，则设置为yes。如果应用系统无法忍受数据丢失，则设置为no。

5、auto-aof-rewrite-percentage ： aof文件的大小超过基准百分之多少后触发bgrewriteaof。默认这个值设置为100，意味着当前 aof是基准大小的两倍的时候触发bgrewriteaof。把它设置为0可以禁用自动触发的功能。

6、auto_aofrewrite_min_size : 当前aof文件大于多少字节后才触发。避免在aof较小的时候无谓行为。默认大小为64mb。
两个参数都是可以在conf里静态配置，或者通过config set来动态修改的。（在生产环境一般配置为5gb）

四、Redis持久化：

1、RDB

1、RDB是什么：在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里。Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。

2、Fork：fork的作用是复制一个与当前进程一样的进程。新进程的所有数据（变量、环境变量、程序计数器等）数值都和原进程一致，但是是一个全新的进程，并作为原进程的子进程。

3、如何触发RDB快照：

1、手动触发Redis进行RDB持久化：

 save：该命令会阻塞当前Redis服务器，执行save命令期间，Redis不能处理其他命令，直到RDB过程完成为止。显然该命令对于内存比较大的实例会造成长时间阻塞，这是致命的缺陷，为了解决此问题，Redis提供了第二种方式。

 bgsave：执行该命令时，Redis会在后台异步进行快照操作，快照同时还可以响应客户端请求。具体操作是Redis进程执行fork操作创建子进程，RDB持久化过程由子进程负责，完成后自动结束。阻塞只发生在fork阶段，一般时间很短。

2、当达到RDB持久化相关配置条件时：

4、如何恢复：将备份文件 (dump.rdb) 移动到 redis 安装目录并启动服务即可

5、优势：适合大规模的数据恢复 (当对数据完整性和一致性要求不高时)

6、劣势：①、在一定间隔时间做一次备份，所以如果redis意外down掉的话，就会丢失最后一次快照后的所有修改。②、fork的时候，内存中的数据被克隆了一份，大致2倍的膨胀性需要考虑

2、AOF

1、AOF是什么：

以日志的形式来记录每个写操作，将Redis执行过的所有写指令记录下来(读操作不记录)，只许追加文件但不可以改
写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。

2、rewrite：

1、rewrite是什么：AOF采用文件追加方式，文件会越来越大为避免出现此种情况，新增了重写机制,当AOF文件的大小超过所
设定的阈值时，Redis就会启动AOF文件的内容压缩，只保留可以恢复数据的最小指令集.可以使用命令bgrewriteaof

2、重写原理：AOF文件持续增长而过大时，会fork出一条新进程来将文件重写(也是先写临时文件最后再rename)，遍历新进程的内存中数据，每条记录有一条的Set语句。重写aof文件的操作，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件，这点和快照有点类似

3、触发机制：Redis会记录上次重写时的AOF大小，默认配置是当AOF文件大小是上次rewrite后大小的一倍且文件大于64M时触发

3、小结：

1、RDB持久化方式能够在指定的时间间隔能对你的数据进行快照存储

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

3、只做缓存：如果你只希望你的数据在服务器运行的时候存在,你也可以不使用任何持久化方式.

4、同时开启两种持久化方式：

①、在这种情况下,当redis重启的时候会优先载入AOF文件来恢复原始的数据,因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整.

②、RDB的数据不实时，同时使用两者时服务器重启也只会找AOF文件。那要不要只使用AOF呢？作者建议不要，因为RDB更适合用于备份数据库(AOF在不断变化不好备份)，快速重启，而且不会有AOF可能潜在的bug，留着作为一个万一的手段。

五、Redis事务

1、Redis事务的概念：

  Redis 事务的本质是一组命令的集合。事务支持一次执行多个命令，一个事务中所有命令都会被序列化。在事务执行过程，会按照顺序串行化执行队列中的命令，其他客户端提交的命令请求不会插入到事务执行命令序列中。

 总结说：redis事务就是一次性、顺序性、排他性的执行一个队列中的一系列命令。

2、Redis三阶段

1、开启：以MULTI开始一个事务

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

3、执行：由EXEC命令触发事务

3、Redis三特性

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

2、没有隔离级别的概念：队列中的命令没有提交之前都不会实际的被执行，因为事务提交前任何指令都不会被实际执行，也就不存在”事务内的查询要看到事务里的更新，事务外查询不能看到。

3、不保证原子性：Redis中，单条命令是原子性执行的，但事务不保证原子性，且没有回滚。事务中任意命令执行失败，其余的命令仍会被执行

4、Redis事务相关命令

1、watch key1 key2 ... : 监视一或多个key,如果在事务执行之前，被监视的key被其他命令改动，则事务被打断 （ 类似乐观锁 ）

2、multi : 标记一个事务块的开始

3、exec : 执行所有事务块的命令 （ 一旦执行exec后，之前加的监控锁都会被取消掉 ）

4、discard : 取消事务，放弃事务块中的所有命令

5、unwatch : 取消watch对所有key的监控

5、Redis事务使用案例：

（1）、正常执行

（2）、放弃事务

（3）、若在事务队列中存在命令性错误（类似于java编译性错误），则执行EXEC命令时，所有命令都不会执行

（4）、若在事务队列中存在语法性错误（类似于java的1/0的运行时异常），则执行EXEC命令时，其他正确命令会被执行，错误命令抛出异常。

（5）、使用watch监控

案例一：使用watch检测balance，事务期间balance数据未变动，事务执行成功

案例二：使用watch检测balance，在开启事务后（标注1处），在新窗口执行标注2中的操作，更改balance的值，模拟其他客户端在事务执行期间更改watch监控的数据，然后再执行标注1后命令，执行EXEC后，事务未成功执行。

一但执行 EXEC 开启事务的执行后，无论事务使用执行成功， WARCH 对变量的监控都将被取消。

故当事务执行失败后，需重新执行WATCH命令对变量进行监控，并开启新的事务进行操作。

总结：

watch指令类似于乐观锁，在事务提交时，如果watch监控的多个KEY中任何KEY的值已经被其他客户端更改，则使用EXEC执行事务时，事务队列将不会被执行，同时返回Nullmulti-bulk应答以通知调用者事务执行失败。

（6）、常见的几种锁：

1、行锁：只锁住一行

2、表锁：锁住整个表

3、悲观锁：当要对数据库中的一条数据进行修改的时候，为了避免同时被其他人修改，最好的办法就是直接对该数据进行加锁以防止并发。这种借助数据库锁机制，在修改数据之前先锁定，再修改的方式被称之为悲观并发控制。

4、乐观锁：乐观锁是相对悲观锁而言的，乐观锁假设数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测（检查其版本号是否变化），如果发现冲突了，则返回给用户错误的信息，让用户决定如何去做。

六、Redis的复制(Master/Slave)

1、概念：

就是我们所说的主从复制，主机数据更新后根据配置和策略，自动同步到备机的master/slaver机制，Master以写为主，Slave以读为主。

2、能干什么：

1、读写分离

2、容灾恢复

3、复制原理：

1、slave启动成功连接到master后会发送一个sync命令

2、Master接到命令启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slave,以完成一次完全同步

3、全量复制：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。

4、增量复制：Master继续将新的所有收集到的修改命令依次传给slave,完成同步

5、但是只要是重新连接master,一次完全同步（全量复制)将被自动执行

4、Redis主从复制使用案例

同时启动三个Redis服务，通过info replication查询对应Redis服务器信息

（1）、一主二仆（设置79为主机，80和81为从机）

1、配从不配主

2、从库配置主库信息：slaveof 127.0.0.1 6379

3、从机不能写入，只能读

4、如果主机挂了，从机会原地待命，等到主机恢复后，从机依然会继续同步主机

5、如果从机挂了，重新恢复后会变为主机，只能在次配置主机信息才能变为从机

(2)、薪火相传（设计79是80的主机，80是81的主机）

1、可以有效减轻master的写压力

2、中途变更转向，会清楚之前的数据，重新建立拷贝最新的

3、slaveof 新主机IP 新主机端口

(3)、反客为主（slaveof no one手动设置主机）

(4)、哨兵模式（sentinel）：反客为主的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库

1、调整结构，6379带着80、81

2、自定义的/myredis目录下新建sentinel.conf文件，名字绝不能错

3、 sentinel monitor 被监控数据库名字(自己起名字) 127.0.0.1 6379 1

  例如：sentinel monitor host6379 127.0.0.1 6379 1

4、上面最后一个数字1，表示主机挂掉后salve投票看让谁接替成为主机，得票数多少后成为主机

5、启动哨兵：redis-sentinel /myredis/sentinel.conf

第一步：在/myredis目录下创建sentinel.conf文件，并在该配置文件中编写监控内容，

第二步：启动哨兵 redis-sentinel

第三步：哨兵模式启动起来了，我们可以看到哨兵监控着79主机

第四步：79主机突然挂了

第五步：哨兵监控到79主机挂了，会通过算法会自动推荐出新的主机

第六步：最后哨兵通过投票，最终推荐80为新的主机

第七步：当再次恢复之前的79主机后，79会变为80的从机

七、Redis的Java客户端Jedis

Redis五种常用类型

1、第一步导入相应的jar包

<dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>2.7.1</version>
 </dependency>

2、创建Jedis对象

import java.util.Set;
		import redis.clients.jedis.Jedis;

		public class TestAPI {
			 public static void main(String[] args){
			Jedis jedis = new Jedis("127.0.0.1",6379);
		    jedis.set("k1","v1"); //设置key值
		    jedis.set("k2","v2");
		    jedis.set("k3","v3");
		  Set<String> sets = jedis.keys("*"); //获取key集合
	     }
	  }

3、String类型常用方法

public void testString() {
	Jedis jedis = new Jedis("127.0.0.1",6379);
	jedis.set("key1", "value1"); //设置key值
	jedis.set("key2", "value2");
	jedis.mset("key3","value3","key4","value4"); //获取指定的key值
	String val = jedis.get("key1");
	System.out.println(val);
	jedis.set("num1", "1");
	System.out.println(jedis.incr("num1"));  //加1
	System.out.println(jedis.incrBy("num1", 3));  //加3
	System.out.println(jedis.decrBy("num1", 2));  //减2
	Set<String> keys = jedis.keys("*");  //获取所有的key集合
	for(String key:keys) {
		System.out.println(key);
		System.out.println(jedis.get(key));
	}
	System.out.println("-----------------");
	List<String> list = jedis.mget("key1","key2","key3","num1");  //获取多个key的值集合
	for(String v:list) {
		System.out.println(v);
	}
}

4、List类型常用方法

public void testList() {
	Jedis jedis = new Jedis("127.0.0.1",6379);
	jedis.lpush("list1", "aa","bb","cc","dd");
	List<String> list = jedis.lrange("list1", 0, -1);
	for(String val:list) {
		System.out.println(val);
	}
	jedis.rpush("list2", "11","22","33","44");
	List<String> list2 = jedis.lrange("list2", 0, -1);
	for(String val:list2) {
		System.out.println(val);
	}
	System.out.println(jedis.lindex("list1", 2));
	System.out.println(jedis.llen("list2"));
}

5、Hash类型常用方法

public void testHash() {
	Jedis jedis = new Jedis("127.0.0.1",6379);
	Map<String,String> map = new HashMap<String,String>();
	map.put("m1", "v1");
	map.put("m2", "v2");
	map.put("m3", "v3");
	jedis.hmset("map1", map);
	System.out.println(jedis.hget("map1", "m2"));
}

6、Set类型常用方法

public void testSet() {
	Jedis jedis = new Jedis("127.0.0.1",6379);
	jedis.sadd("set1", "aa","bb","cc","dd","ee");
	Set<String> smembers = jedis.smembers("set1");
	for(String m:smembers) {
		System.out.println(m);
	}
}

7、ZSet类型常用方法

public void testZSet() {
	Jedis jedis = new Jedis("127.0.0.1",6379);
	jedis.zadd("zset1", 1, "zhangsan");
	jedis.zadd("zset1", 2, "lisi");
	jedis.zadd("zset1", 3, "wangwu");
	jedis.zadd("zset1", 5, "maliu");
	Set<String> set = jedis.zrange("zset1", 0, -1);
	for(String s:set) {
		System.out.println(s);
	}
}

事务管理

1、正常执行

public void testTransaction1() {
	Jedis jedis = new Jedis("127.0.0.1",6379);
	//开启事务
	Transaction transaction = jedis.multi();
	//操作命令入队
	transaction.set("t1", "aa");
	transaction.set("t2", "bb");
	transaction.set("t3", "cc");
	transaction.set("t4", "dd");
	//提交事务
	transaction.exec();
}

2、放弃事务

public void testTransaction2() {
	Jedis jedis = new Jedis("127.0.0.1",6379);
	//开启事务
	Transaction transaction = jedis.multi();
	//操作命令入队
	transaction.set("t1", "aa");
	transaction.set("t2", "bb");
	transaction.set("t3", "cc");
	transaction.set("t4", "dd");
	//放弃执行事务
	transaction.discard();
}

3、使用watch监控

public boolean testTransaction3() {
	Jedis jedis = new Jedis("127.0.0.1",6379);
	//可刷信用额度
	jedis.set("blance", "100");
	//欠额
	jedis.set("debt", "0");
	//实际花销金额
	int amtToSubtranct = 10;
	//开始监控blance
	jedis.watch("blance");
	//获取余额blance
	int blance = Integer.parseInt(jedis.get("blance"));
	//判断余额是否大于等于实际花费
	if(amtToSubtranct>blance) {
		jedis.unwatch();
		return false;
	}else {
		//开启事务
		Transaction transaction = jedis.multi();
		//执行命令入队
		transaction.decrBy("blance", amtToSubtranct);
		transaction.incrBy("debt", amtToSubtranct);
		//执行事务
		transaction.exec();
		return true;
	}
}

线程池：

/*线程池工具类/

public class JedisPoolUtil {

	//单例模式
	private static volatile JedisPool jedisPool = null;
	private JedisPoolUtil()chan{}

	//创建连接池，并返回连接池
	public static JedisPool getJedisPoolInstance(){
		if(null == jedisPool)
		{
			synchronized (JedisPoolUtil.class)
			{
				if(null == jedisPool)
				{
					JedisPoolConfig poolConfig = new JedisPoolConfig();
					//设置最大连接数为1000
					poolConfig.setMaxActive(1000);
					//设置当空闲连接数少于32个时就开始报出问题，提示连接数快要接近上限
					poolConfig.setMaxIdle(32);
					//设置最大等待时间为100秒
					poolConfig.setMaxWait(100*1000);
					//检查其连接可用性
					poolConfig.setTestOnBorrow(true);
					//创建连接池
					jedisPool = new JedisPool(poolConfig,"127.0.0.1",6379);
				}
			}
		}
		return jedisPool;
	}
	
	//当连接用完之后，需要释放连接资源，以便其他连接使用
	public static void release(JedisPool jedisPool,Jedis jedis){
		if(null != jedis){
			jedisPool.returnResourceObject(jedis);
		}
	}
 }

//测试使用线程池

public class TestPool {
	public static void main(String[] args) {
		//获取线程池
		JedisPool jedisPool = JedisPoolUtil.getJedisPoolInstance();
		Jedis jedis = null;
		try {
			//通过线程池创建Jedis对象
			jedis = jedisPool.getResource();
			jedis.set("aa","bb");
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//释放连接
			JedisPoolUtil.release(jedisPool, jedis);
		}
	}
}