linux环境安装使用redis详解

Redis

1. NoSQL的引言

NoSQL ( Not Only SQL )，意即 不仅仅是SQL , 泛指非关系型的数据库。Nosql这个技术门类,早期就有人提出,发展至2009年趋势越发高涨。

2. 为什么是NoSQL

随着互联网网站的兴起，传统的关系数据库在应付动态网站，特别是超大规模和高并发的纯动态网站已经显得力不从心，暴露了很多难以克服的问题。如 商城网站中对商品数据频繁查询 、 对热搜商品的排行统计 、 订单超时问题 、以及微信朋友圈（音频，视频）存储等相关使用传统的关系型数据库实现就显得非常复杂，虽然能实现相应功能但是在性能上却不是那么乐观。nosql这个技术门类的出现，更好的解决了这些问题，它告诉了世界不仅仅是sql。

3. NoSQL的四大分类

3.1 键值(Key-Value)存储数据库

# 1.说明:– 这一类数据库主要会使用到一个哈希表，这个表中有一个特定的键和一个指针指向特定的数据。 # 2.特点– Key/value模型对于IT系统来说的优势在于简单、易部署。– 但是如果DBA只对部分值进行查询或更新的时候，Key/value就显得效率低下了。 # 3.相关产品– Tokyo Cabinet/Tyrant,– Redis– SSDB– Voldemort– Oracle BDB

3.2 列存储数据库

# 1.说明– 这部分数据库通常是用来应对分布式存储的海量数据。 # 2.特点– 键仍然存在，但是它们的特点是指向了多个列。这些列是由列家族来安排的。 # 3.相关产品– Cassandra、HBase、Riak.

3.3 文档型数据库

# 1.说明– 文档型数据库的灵感是来自于Lotus Notes办公软件的，而且它同第一种键值存储相类似该类型的数据模型是版本化的文档，半结构化的文档以特定的格式存储，比如JSON。文档型数据库可 以看作是键值数据库的升级版，允许之间嵌套键值。而且文档型数据库比键值数据库的查询效率更高 # 2.特点– 以文档形式存储 # 3.相关产品– MongoDB、CouchDB、 MongoDb(4.x). 国内也有文档型数据库SequoiaDB，已经开源。

3.4 图形(Graph)数据库

# 1.说明– 图形结构的数据库同其他行列以及刚性结构的SQL数据库不同，它是使用灵活的图形模型，并且能够扩展到多个服务器上。– NoSQL数据库没有标准的查询语言(SQL)，因此进行数据库查询需要制定数据模型。许多NoSQL数据库都有REST式的数据接口或者查询API。 # 2.特点 # 3.相关产品– Neo4J、InfoGrid、 Infinite Graph、

4. NoSQL应用场景

• 数据模型比较简单
• 需要灵活性更强的IT系统
• 对数据库性能要求较高
• 不需要高度的数据一致性

5. 什么是Redis

Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache and message broker.

Redis 开源 遵循BSD 基于内存数据存储 被用于作为 数据库 缓存 消息中间件

• 总结: redis是一个内存型的数据库

6. Redis特点

• Redis是一个高性能key/value内存型数据库
• Redis支持丰富的数据类型
• Redis支持持久化
• Redis单线程,单进程

7. Redis安装

# 0.准备环境– vmware15.x+– centos7.x+ # 1.下载redis源码包– Redis # 2.下载完整源码包– redis-4.0.10.tar.gz # 3.将下载redis资料包上传到Linux中 # 4.解压缩文件[root@localhost ~]# tar -zxvf redis-4.0.10.tar.gz[root@localhost ~]# ll # 5.安装gcc– yum install -y gcc # 6.进入解压缩目录执行如下命令– make MALLOC=libc # 7.编译完成后执行如下命令– make install PREFIX=/usr/redis # 8.进入/usr/redis目录启动redis服务– ./redis-server # 9.Redis服务端口默认是 6379 # 10.进入bin目录执行客户端连接操作– ./redis-cli -h ip地址 -p redis端口./redis-cli -h localhost -p 6379 # 11.连接成功出现上面界面连接成功

8. Redis数据库相关指令

8.1 数据库操作指令

# 1.Redis中库说明– 使用redis的默认配置器动redis服务后,默认会存在16个库,编号从0-15– 可以使用select 库的编号 来选择一个redis的库 # 2.Redis中操作库的指令– 清空当前的库 FLUSHDB– 清空全部的库 FLUSHALL # 3.redis客户端显示中文，get key，里面如果是中文使用如下登陆redis就可以显示中文– ./redis-cli -p 7000 –raw

8.2 操作key相关指令

# 1.DEL指令del– 语法 : DEL key [key …]– 作用 : 删除给定的一个或多个key 。不存在的key 会被忽略。– 可用版本： >= 1.0.0– 返回值： 被删除key 的数量。 # 2.EXISTS指令exists– 语法: EXISTS key– 作用: 检查给定key 是否存在。– 可用版本： >= 1.0.0– 返回值： 若key 存在，返回1 ，否则返回0。 # 3.EXPIREexpire– 语法: EXPIRE key seconds– 作用: 为给定key 设置生存时间(秒)，当key 过期时(生存时间为0 )，它会被自动删除。– 可用版本： >= 1.0.0– 时间复杂度： O(1)– 返回值：设置成功返回1 。 # 4.KEYS keys– 语法 : KEYS pattern– 作用 : 查找所有符合给定模式pattern 的key 。– 语法:KEYS * 匹配数据库中所有key 。KEYS h” />KEYS h*llo 匹配hllo 和heeeeello 等。KEYS h[ae]llo 匹配hello 和hallo ，但不匹配hillo 。特殊符号用 “\” 隔开– 可用版本： >= 1.0.0– 返回值： 符合给定模式的key 列表。 # 5.MOVEmove– 语法 : MOVE key db– 作用 : 将当前数据库的key 移动到给定的数据库db 当中。– 可用版本： >= 1.0.0– 返回值： 移动成功返回1 ，失败则返回0 。 # 6.PEXPIREpexpire– 语法 : PEXPIRE key milliseconds– 作用 : 这个命令和EXPIRE 命令的作用类似，但是它以毫秒为单位设置key 的生存时间，而不像EXPIRE 命令那样，以秒为单位。– 可用版本： >= 2.6.0– 时间复杂度： O(1)– 返回值：设置成功，返回1 key 不存在或设置失败，返回0 # 7.PEXPIREATpexpireat– 语法 : PEXPIREAT key milliseconds-timestamp– 作用 : 这个命令和EXPIREAT 命令类似，但它以毫秒为单位设置key 的过期unix 时间戳，而不是像EXPIREAT那样，以秒为单位。– 可用版本： >= 2.6.0– 返回值：如果生存时间设置成功，返回1 。当key 不存在或没办法设置生存时间时，返回0 。(查看EXPIRE 命令获取更多信息) # 8.TTL ttl– 语法 : TTL key– 作用 : 以秒为单位，返回给定key 的剩余生存时间(TTL, time to live)。– 可用版本： >= 1.0.0– 返回值：当key 不存在时，返回-2 。当key 存在但没有设置剩余生存时间时，返回-1 。否则，以秒为单位，返回key 的剩余生存时间。– Note : 在Redis 2.8 以前，当key 不存在，或者key 没有设置剩余生存时间时，命令都返回-1 。 # 9.PTTL pttl– 语法 : PTTL key– 作用 : 这个命令类似于TTL 命令，但它以毫秒为单位返回key 的剩余生存时间，而不是像TTL 命令那样，以秒为单位。– 可用版本： >= 2.6.0– 返回值： 当key 不存在时，返回-2 。当key 存在但没有设置剩余生存时间时，返回-1 。– 否则，以毫秒为单位，返回key 的剩余生存时间。– 注意 : 在Redis 2.8 以前，当key 不存在，或者key 没有设置剩余生存时间时，命令都返回-1 。 # 10.RANDOMKEY randomkey– 语法 : RANDOMKEY– 作用 : 从当前数据库中随机返回(不删除) 一个key 。– 可用版本： >= 1.0.0– 返回值：当数据库不为空时，返回一个key 。当数据库为空时，返回nil 。 # 11.RENAMErename– 语法 : RENAME key newkey– 作用 : 将key 改名为newkey 。当key 和newkey 相同，或者key 不存在时，返回一个错误。当newkey 已经存在时，RENAME 命令将覆盖旧值。– 可用版本： >= 1.0.0– 返回值： 改名成功时提示OK ，失败时候返回一个错误。 # 12.TYPEtype– 语法 : TYPE key– 作用 : 返回key 所储存的值的类型。– 可用版本： >= 1.0.0– 返回值：none (key 不存在)string (字符串)list (列表)set (集合)zset (有序集)hash (哈希表)

8.3 String类型

1. 内存存储模型

2. 常用操作命令

set Hello 你好

get Hello

mset name wuxinke sex 男 age 20

mget name age sex Hello

getset Hello oo200506

strlen name

append name liyi

getrange name 0 6

setex pp 20 TTV

psetex bir 10000 2021-12-12

setnx oo wuxinke

msetnx who 谁 where 那里 when 呵呵

decr age

decrby age 10

incr age

incrby age 100

incrbyfloat age 1.23235434434343443

8.4 List类型

list 列表 相当于java中list 集合 特点 元素有序 且 可以重复

1.内存存储模型

2.常用操作指令

lpush arr zhangsan zhaosi

lpushx arr wangwu

rpush arr zhaoliu

rpushx arr qianqi

lpop arr

rpop arr

lrange arr 0 -1

llen arr

lset arr 0 wuyifan

lindex arr 2

lrem arr 2 zhangsan

ltrim arr 0 1

linsert arr after wuyifan liuyifei

linsert arr before zhaoliu wujing

8.5 Set类型

特点: Set类型 Set集合 元素无序 不可以重复

1.内存存储模型

2.常用命令

sadd sets wuyifan

smembers sets

scard sets

spop sets

smove sets sets2 qianqi

srem sets liuyifei

sismember sets wangwu

srandmember sets2

sdiff sets sets2

sinter sets sets2

sunion sets sets2

8.6 ZSet类型

特点: 可排序的set集合 排序 不可重复 ZSET 官方 可排序SET sortSet

1.内存模型

2.常用命令

zadd zsets1 8 xiaoming 2 xiaohei

zcard zsets1

zrange zsets1 0 -1

zrevrange zsets1 0 -1

zrangebyscore zsets1 2 10

zrank zsets1 xiaohei

zrevrank zsets1 xiaohei

zscore zsets1 xiaoming

zrem zsets1 xiaoming

zincrby zsets1 10 xiaohei

8.7 hash类型

特点: value 是一个map结构 存在key value key 无序的

1.内存模型

2.常用命令

hset hsets1 oo1 zhangsan oo2 wangwu oo3 wuyifan hget hsets1 oo2 hgetall hsets1 hdel hsets1 oo3 hexists hsets1 oo2 hkeys hsets1 hvals hsets1 hmset hsets1 003 tansongyun oo4 maobuyi hmget hsets1 oo2 oo4 hsetnx hsets1 oo5 liyi hincrby hsets1 oo6 5 hincrbyfloat hsets1 oo7 2.3236523623235232622233238.8Redis可视化工具安装和连接 下载redis可视化工具，然后安装 修改配置文件redis.conf 修改为 0.0.0.0 然后加载配置文件redis

9. 持久化机制

client redis[内存] —–> 内存数据- 数据持久化–>磁盘 Redis官方提供了两种不同的持久化方法来将数据存储到硬盘里面分别是:

• 快照(Snapshot)
• AOF (Append Only File) 只追加日志文件

9.1 快照(Snapshot)

1. 特点

这种方式可以将某一时刻的所有数据都写入硬盘中,当然这也是 redis的默认开启持久化方式 ,保存的文件是以.rdb形式结尾的文件因此这种方式也称之为RDB方式。

2.快照生成方式

• 客户端方式: BGSAVE 和 SAVE指令
• 服务器配置自动触发

# 1.客户端方式之BGSAVE– a.客户端可以使用BGSAVE命令来创建一个快照,当接收到客户端的BGSAVE命令时,redis会调用fork¹来创建一个子进程,然后子进程负责将快照写入磁盘中,而父进程则继续处理命令请求。`名词解释: fork当一个进程创建子进程的时候,底层的操作系统会创建该进程的一个副本,在类unix系统中创建子进程的操作会进行优化:在刚开始的时候,父子进程共享相同内存,直到父进程或子进程对内存进行了写之后,对被写入的内存的共享才会结束服务` # 2.客户端方式之SAVE– b.客户端还可以使用SAVE命令来创建一个快照,接收到SAVE命令的redis服务器在快照创建完毕之前将不再响应任何其他的命令

• 注意: SAVE命令并不常用,使用SAVE命令在快照创建完毕之前,redis处于阻塞状态,无法对外服务

# 3.服务器配置方式之满足配置自动触发– 如果用户在redis.conf中设置了save配置选项,redis会在save选项条件满足之后自动触发一次BGSAVE命令,如果设置多个save配置选项,当任意一个save配置选项条件满足,redis也会触发一次BGSAVE命令 # 4.服务器接收客户端shutdown指令– 当redis通过shutdown指令接收到关闭服务器的请求时,会执行一个save命令,阻塞所有的客户端,不再执行客户端执行发送的任何命令,并且在save命令执行完毕之后关闭服务器

3.配置生成快照名称和位置

#1.修改生成快照名称– dbfilename dump.rdb # 2.修改生成位置– dir ./

9.2 AOF 只追加日志文件

1.特点

这种方式可以将所有客户端执行的写命令记录到日志文件中,AOF持久化会将被执行的写命令写到AOF的文件末尾,以此来记录数据发生的变化,因此只要redis从头到尾执行一次AOF文件所包含的所有写命令,就可以恢复AOF文件的记录的数据集.

2.开启AOF持久化

在redis的默认配置中AOF持久化机制是没有开启的，需要在配置中开启 # 1.开启AOF持久化– a.修改 appendonly yes 开启持久化– b.修改 appendfilename “appendonly.aof” 指定生成文件名称

3.日志追加频率

# 1.always 【谨慎使用】– 说明: 每个redis写命令都要同步写入硬盘,严重降低redis速度– 解释: 如果用户使用了always选项,那么每个redis写命令都会被写入硬盘,从而将发生系统崩溃时出现的数据丢失减到最少;遗憾的是,因为这种同步策略需要对硬盘进行大量的写入操作,所以redis处理命令的速度会受到硬盘性能的限制;– 注意: 转盘式硬盘在这种频率下200左右个命令/s ; 固态硬盘(SSD) 几百万个命令/s;– 警告: 使用SSD用户请谨慎使用always选项,这种模式不断写入少量数据的做法有可能会引发严重的写入放大问题,导致将固态硬盘的寿命从原来的几年降低为几个月。 # 2.everysec 【推荐】– 说明: 每秒执行一次同步显式的将多个写命令同步到磁盘– 解释： 为了兼顾数据安全和写入性能,用户可以考虑使用everysec选项,让redis每秒一次的频率对AOF文件进行同步;redis每秒同步一次AOF文件时性能和不使用任何持久化特性时的性能相差无几,而通过每秒同步一次AOF文件,redis可以保证,即使系统崩溃,用户最多丢失一秒之内产生的数据。 # 3.no 【不推荐】– 说明: 由操作系统决定何时同步– 解释：最后使用no选项,将完全有操作系统决定什么时候同步AOF日志文件,这个选项不会对redis性能带来影响但是系统崩溃时,会丢失不定数量的数据,另外如果用户硬盘处理写入操作不够快的话,当缓冲区被等待写入硬盘数据填满时,redis会处于阻塞状态,并导致redis的处理命令请求的速度变慢。

4.修改同步频率

# 1.修改日志同步频率– 修改appendfsync everysec|always|no 指定

9.3 AOF文件的重写

1. AOF带来的问题

AOF的方式也同时带来了另一个问题。持久化文件会变的越来越大。例如我们调用incr test命令100次，文件中必须保存全部的100条命令，其实有99条都是多余的。因为要恢复数据库的状态其实文件中保存一条set test 100就够了。为了压缩aof的持久化文件Redis提供了AOF重写(ReWriter)机制。

2. AOF重写

用来在一定程度上减小AOF文件的体积

3. 触发重写方式

# 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设置为更大

4. 重写原理

注意：重写aof文件的操作，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件,替换原有的文件这点和快照有点类似。 # 重写流程– 1. redis调用fork ，现在有父子两个进程 子进程根据内存中的数据库快照，往临时文件中写入重建数据库状态的命令– 2. 父进程继续处理client请求，除了把写命令写入到原来的aof文件中。同时把收到的写命令缓存起来。这样就能保证如果子进程重写失败的话并不会出问题。– 3. 当子进程把快照内容写入已命令方式写到临时文件中后，子进程发信号通知父进程。然后父进程把缓存的写命令也写入到临时文件。– 4. 现在父进程可以使用临时文件替换老的aof文件，并重命名，后面收到的写命令也开始往新的aof文件中追加。

9.4 持久化总结

两种持久化方案既可以同时使用(aof),又可以单独使用,在某种情况下也可以都不使用,具体使用那种持久化方案取决于用户的数据和应用决定。 无论使用AOF还是快照机制持久化,将数据持久化到硬盘都是有必要的,除了持久化外,用户还应该对持久化的文件进行备份(最好备份在多个不同地方)。

10. java操作Redis

10.1 环境准备

1. 引入依赖

redis.clientsjedis2.9.0

2.创建jedis对象

public static void main(String[] args) {//1.创建jedis对象Jedis jedis = new Jedis(“192.168.40.4”, 6379);//1.redis服务必须关闭防火墙 2.redis服务必须开启远程连接jedis.select(0);//选择操作的库默认0号库//2.执行相关操作//….//3.释放资源jedis.close();}

10.2 操作key相关API

private Jedis jedis;@Beforepublic void before(){this.jedis = new Jedis(“192.168.202.205”, 7000);}@Afterpublic void after(){jedis.close();} //测试key相关@Testpublic void testKeys(){//删除一个keyjedis.del(“name”);//删除多个keyjedis.del(“name”,”age”); //判断一个key是否存在exitsBoolean name = jedis.exists(“name”);System.out.println(name); //设置一个key超时时间 expire pexpireLong age = jedis.expire(“age”, 100);System.out.println(age); //获取一个key超时时间 ttlLong age1 = jedis.ttl(“newage”);System.out.println(age1); //随机获取一个keyString s = jedis.randomKey(); //修改key名称jedis.rename(“age”,”newage”); //查看可以对应值的类型String name1 = jedis.type(“name”);System.out.println(name1);String maps = jedis.type(“maps”);System.out.println(maps);} @Test public void testKey(){ //查询所有的key //Set keys = jedis.keys(“*”); //删除key //Long name = jedis.del(“name”); //检查给定的key是否存在 //Boolean name = jedis.exists(“name”); //为key设置生存时间，当key过期自动删除,设置时间为秒 //Long who = jedis.expire(“who”, 1000); //查询符合条件的所有key //Set keys1 = jedis.keys(“w*”); //移动key到指定数据库 //Long age = jedis.move(“age”, 1); //设置key的存活时间，过期自动删除，设置时间为毫秒 //Long oo = jedis.pexpireAt(“oo”, 10000); //查看key的剩余生存时间，时间为秒 //Long who = jedis.ttl(“who”); //查看key的剩余生存时间，时间为毫秒 //Long who = jedis.pttl(“who”); //从当前数据库中随机返回一个key，不删除 //String s = jedis.randomKey(); //修改key的名称 //String rename = jedis.rename(“when”, “hh”); //返回key存储值得类型 //String arr = jedis.type(“arr”); }

10.3操作String相关API

//测试String相关@Testpublic void testString(){//setjedis.set(“name”,”小陈”);//getString s = jedis.get(“name”);System.out.println(s);//msetjedis.mset(“content”,”好人”,”address”,”海淀区”);//mgetList mget = jedis.mget(“name”, “content”, “address”);mget.forEach(v-> System.out.println(“v = ” + v));//getsetString set = jedis.getSet(“name”, “小明”);System.out.println(set); //…………} @Test public void testString(){ //设置一个key或者给指定的key设置值value //String set = jedis.set(“wuxinke”, “吴帅”); //根据key获取value //String wuxinke = jedis.get(“wuxinke”); //一次设置多个key //String mset = jedis.mset(“hao”, “好好”,”weixin”,”OO200506″); //一次获取多个key的value //List mget = jedis.mget( “wuxinke”,”sex”, “weixin”); //获得key原始的值同时设置新的值 //String set = jedis.getSet(“wuxinke”, “吴帅”); //获取key存储的value值的长度 //Long weixin = jedis.strlen(“weixin”); //给key追加能容 //Long weixin = jedis.append(“weixin”, “0000”); //截取key的value值 //String weixin = jedis.getrange(“weixin”, 2, -1); //设置一个key存活的有效期，时间为秒 //String setex = jedis.setex(“hh”, 60, “xx”); //设置一个key存活的有效期，时间为毫秒 //String hao = jedis.psetex(“hao”, 30000,”ninhao”); //key存在不做任何操作，不存在添加 //Long setnx = jedis.setnx(“liyi”, “李艺”); //可以同时设置多个key，只要有一个存在都不保存 //Long msetnx = jedis.msetnx(“ww”, “123”, “aa”, “456”, “ee”, “789”); //对数值类型进行-1操作 //Long aa = jedis.decr(“aa”); //根据提供的数据进行减法操作 //Long aa = jedis.decrBy(“aa”, 10); //对数值类型+1操作 //Long aa = jedis.incr(“aa”); //根据提供的数据进行加法操作 //Long aa = jedis.incrBy(“aa”, 100); //根据提供的数据加上浮点数 //Double aa = jedis.incrByFloat(“aa”, 10.99); }

10.4操作List相关API

//测试List相关@Testpublic void testList(){ //lpushjedis.lpush(“names1″,”张三”,”王五”,”赵柳”,”win7″); //rpushjedis.rpush(“names1″,”xiaomingming”); //lrange List names1 = jedis.lrange(“names1”, 0, -1);names1.forEach(name-> System.out.println(“name = ” + name)); //lpop rpopString names11 = jedis.lpop(“names1”);System.out.println(names11); //llenjedis.linsert(“lists”, BinaryClient.LIST_POSITION.BEFORE,”xiaohei”,”xiaobai”); //…….. } @Test public void testList(){ //将值加入到key列表头部 //Long lpush = jedis.lpush(“arr”, “liyi”, “wuxinke”); //将值加入到key列表头部，但是必须保证key存在 //Long lpushx = jedis.lpushx(“arr”, “zhangziyi”, “zhangyixing”); //将值添加到key列表末尾 //Long rpush = jedis.rpush(“arr”, “yiyi”); //将值添加到key列表末尾，但必须保证key存在 //Long rpushx = jedis.rpushx(“arr”, “ziyi”, “zirui”); //返回和移除列表左边的第一个元素 //String arr = jedis.lpop(“arr”); //返回和移除列表右边的第一个元素 //String arr = jedis.rpop(“arr”); //获取某个key，下标区间的元素，起始索引0，结束-1 //List arr = jedis.lrange(“arr”, 0, -1); //获取列表元素个数 //Long arr = jedis.llen(“arr”); //设置某一个指定索引的值，索引必须存在 //String arr = jedis.lset(“arr”, 2, “123”); //获取某一个指定索引位置的元素 //String arr = jedis.lindex(“arr”, 2); //删除重复元素 //Long lrem = jedis.lrem(“arr”, 1, “yiyi”); //保存列表中指定区间的元素其他都删除 //String arr = jedis.ltrim(“arr”, 2, 4); //在某一个元素之前或者之后插入元素 //Long linsert = jedis.linsert(“arr”, BinaryClient.LIST_POSITION.BEFORE,”liuyifei”,”xingke”); }

10.5操作Set的相关API

//测试SET相关@Testpublic void testSet(){ //saddjedis.sadd(“names”,”zhangsan”,”lisi”); //smembersjedis.smembers(“names”); //sismemberjedis.sismember(“names”,”xiaochen”); //…} @Test public void testSet(){ //为集合添加元素 //Long sadd = jedis.sadd(“sets”, “zhaoliu”, “wangwu”); //显示集合中的所有元素，无序 //Set sets = jedis.smembers(“sets”); //返回集合中得个数 //Long scard = jedis.scard(“sets”); //随机返回一个元素，并删除该元素 //String sets = jedis.spop(“sets”); //从一个集合中向另一个集合中移动元素，必须是同一种类型 //Long smove = jedis.smove(“sets”, “sets2”, “zhaoxinbing”); //从集合中删除一个元素 //Long srem = jedis.srem(“sets”, “qianqi”); //判断一个集合中是否存在这个元素 //Boolean sismember = jedis.sismember(“sets”, “zhangsan”); //随机返回一个元素 //String sets = jedis.srandmember(“sets”); //去掉第一个集合中和其他集合含有的相同元素,不删除 //Set sdiff = jedis.sdiff(“sets”, “sets2”); //求交集 //Set sets = jedis.sinter(“sets”,”sets2″); //求和集 //Set sets = jedis.sunion(“sets”,”sets2″); }

10.6 操作ZSet相关API

//测试ZSET相关@Testpublic void testZset(){ //zaddjedis.zadd(“names”,10,”张三”); //zrangejedis.zrange(“names”,0,-1); //zcardjedis.zcard(“names”); //zrangeByScorejedis.zrangeByScore(“names”,”0″,”100″,0,5); //.. } @Test public void testZset(){ //添加一个有序集合元素 //Long zadd = jedis.zadd(“zsets1”, 86.3, “zhangsan”); //返回集合的元素个数 //Long zsets1 = jedis.zcard(“zsets1”); //按照分数查找一个范围内的元素 //Set zsets1 = jedis.zrangeByScore(“zsets1”, 80, 100); //返回排名 //Long zsets1 = jedis.zrank(“zsets1″,”zhangsan”); //倒序排名 //Long zsets1 = jedis.zrevrank(“zsets1”, “xiaohei”); //显示某一个元素的分数 //Double zscore = jedis.zscore(“zsets1”, “xiaohei”); //移除某一个元素 //Long zrem = jedis.zrem(“zsets1”, “xiaohei”); //给某一个特定元素加分 //Double zincrby = jedis.zincrby(“zsets1”, 10, “zahngsan”); }

10.7 操作Hash相关API

//测试HASH相关@Testpublic void testHash(){//hsetjedis.hset(“maps”,”name”,”zhangsan”);//hgetjedis.hget(“maps”,”name”);//hgetalljedis.hgetAll(“mps”);//hkeysjedis.hkeys(“maps”);//hvalsjedis.hvals(“maps”);//….} @Test public void testHash(){ //设置一个key/value对 //Long hset = jedis.hset(“hsets1”, “yijia”, “wuxinke”); //获得一个key对应的value //String hget = jedis.hget(“hsets1”, “yijia”); //获得所有的key/value对 //Map hsets1 = jedis.hgetAll(“hsets1”); //删除某一个key/value对 //Long hdel = jedis.hdel(“hsets1”, “oo6”); //判断一个key是否存在 //Boolean hexists = jedis.hexists(“hsets1”, “oo4”); //获得所有的key //Set hsets1 = jedis.hkeys(“hsets1”); //获得所有的value //List hsets1 = jedis.hvals(“hsets1”); //设置多个key/value 对 //HashMap map = new HashMap(); //map.put(“yijia”,”liyi”); //map.put(“996″,”nono”); //String hsets1 = jedis.hmset(“hsets1”, map); //获得多个key的value //List hmget = jedis.hmget(“hsets1”, “oo5”, “oo7”, “yijia”); //给一个不存在的key设置值 //Long hsetnx = jedis.hsetnx(“hsets1”, “love”, “liyi”); //对value进行加法运算 //Long aLong = jedis.hincrBy(“hsets1”, “yi1”, 5); //对value加入浮点值 //Double aDouble = jedis.hincrByFloat(“hsets1”, “yi2”, 9.99); }

11.SpringBoot整合Redis

Spring Boot Data(数据) Redis 中提供了 RedisTemplate和StringRedisTemplate ，其中StringRedisTemplate是RedisTemplate的子类，两个方法基本一致，不同之处主要体现在操作的数据类型不同， RedisTemplate中的两个泛型都是Object，意味着存储的key和value都可以是一个对象，而StringRedisTemplate的两个泛型都是String，意味着StringRedisTemplate的key和value都只能是字符串。 注意: 使用RedisTemplate默认是将对象序列化到Redis中,所以放入的对象必须实现对象序列化接口

11.1 环境准备

1.引入依赖

org.springframework.bootspring-boot-starter-data-redis2.5.3

2.配置application.propertie

spring.redis.host=localhostspring.redis.port=6379spring.redis.database=0

11.2 使用StringRedisTemplate和RedisTemplate

StringRedisTemplate操作 @Autowiredprivate StringRedisTemplate stringRedisTemplate;//对key进行操作@Testpublic void testKey(){//查询条件查询key*:匹配多个字母” />//Set keys = stringRedisTemplate.keys(“*”);//匹配所有key//Set keys = stringRedisTemplate.keys(“w*”);//匹配w开头的所有key//Set keys = stringRedisTemplate.keys(“a[ae]”);//匹配a开头，第二个字母a或者e//Set keys = stringRedisTemplate.keys(“a?”);//匹配a开头两个字母的key(第二个字母任意)//删除指定的key//Boolean ae = stringRedisTemplate.delete(“ae”);//删除指定的一个key，返回真假,true:删除成功，false:删除失败//ArrayList list = new ArrayList();//list.add(“where”);//list.add(“ww”);//list.add(“aa”);//Long delete = stringRedisTemplate.delete(list);//删除指定的多个key，返回删除个数//检查指定的key是否存在//Boolean sex = stringRedisTemplate.hasKey(“sex”);//返回真假，true:存在，false:不存在//给指定的key设置生存时间，过期自动删除,时间单位可以是 天，小时，分钟，秒，毫秒//Boolean ee = stringRedisTemplate.expire(“Hello”, Duration.ofSeconds(50));//返回真假，true:设置成功，false:设置失败//移动key到其他数据库中，redis有16个数据库，编号为0-15//Boolean oo = stringRedisTemplate.move(“oo”, 1);//返回真假，true:移动成功，false:移动失败//获取指定key的类型//DataType sex = stringRedisTemplate.type(“sex”);//返回DataType对象，DataType对象里面有对应的数据类型解释//获取指定key的存活的剩余时间单位秒//Long sex = stringRedisTemplate.getExpire(“Hello”);//返回存活的剩余时间//在当前数据库随机返回一个key，不删除//String s = stringRedisTemplate.randomKey();//修改key的名称//stringRedisTemplate.rename(“liyi”,”home”);}//对String进行操作@Testpublic void testString(){//设置一个key//stringRedisTemplate.opsForValue().set(“we”,”wuxinke and liyi”);//根据key获取对应的value//String we = stringRedisTemplate.opsForValue().get(“we”);//一次设置多个key和value//HashMap map = new HashMap();//map.put(“name1″,”zhangsan”);//map.put(“name2″,”zhaosi”);//map.put(“name3″,”wangwu”);//stringRedisTemplate.opsForValue().multiSet(map);//一次获取多个key的value//Collection collection = new ArrayList();//collection.add(“name1”);//collection.add(“name2”);//collection.add(“name3”);//List list = stringRedisTemplate.opsForValue().multiGet(collection);//根据key获取原始的value，同时设置新的value//String andSet = stringRedisTemplate.opsForValue().getAndSet(“we”, “Wuxinke Love Liyi”);//根据key获取对应value的长度//Long we = stringRedisTemplate.opsForValue().size(“we”);//返回value的长度,空格也算//根据key给对应的value追加内容//Integer we = stringRedisTemplate.opsForValue().append(“we”, ” 1314″);//返回追加之后的value长度，空格也算//截取value的内容，起始索引是0,-1表示末尾//String we = stringRedisTemplate.opsForValue().get(“we”, 0, -1);//设置一个新key存活的有效期，过期自动删除,时间单位可以是 天，小时，分钟，秒，毫秒//stringRedisTemplate.opsForValue().set(“#001″,”井001”,Duration.ofSeconds(60));//stringRedisTemplate.opsForValue().set(“#002″,”井002”,60*10, TimeUnit.SECONDS);//判断key是否存在，存在不做任何操作，存在做添加操作//Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(“Liyi”, “宁宁”);//返回真假，true：不存在，false：不存在//同时添加多个key，只要有一个存在都不做添加//HashMap map = new HashMap();//map.put(“keys4″,”value4”);//map.put(“keys5″,”value5”);//map.put(“Liyi”,”ll”);//Boolean aBoolean1 = stringRedisTemplate.opsForValue().multiSetIfAbsent(map);//返回真假，true：添加成功，false：添加失败//根据key对对应的value进行-1操作，value是数字必须是类型//Long age = stringRedisTemplate.opsForValue().decrement(“age”);//返回操作后的数值//根据key对对应的value进行减法操作,value是数字必须是类型//Long age1 = stringRedisTemplate.opsForValue().decrement(“age”, 2);//返回操作后的数值//根据key对对应的value进行+1操作，value是数字必须是类型//Long age = stringRedisTemplate.opsForValue().increment(“age”);//返回操作后的数值//根据key对对应的value进行加法操作，value是数字必须是类型//Long age = stringRedisTemplate.opsForValue().increment(“age”, 5);//返回操作后的数值//根据key对对应的value进行浮点数的加法操作，value是数字必须是类型//Double age = stringRedisTemplate.opsForValue().increment(“age”, 5.5);//返回操作后的数值}//对List集合进行操作@Testpublic void testList(){//将某一个数据加入到某个集合的头部，key不存在不会报错，会创建key类型为list//Long aLong = stringRedisTemplate.opsForList().leftPush(“a1”, “name1”);//返回集合中key的个数//将某一个数据加入到某个集合的头部，key不存在，不会创建key//Long aLong = stringRedisTemplate.opsForList().leftPushIfPresent(“aaaaaa”, “name3”);//返回集合中key的个数//将某一个数据加入到某个集合的末尾，key不存在不会报错，会创建key类型为list//Long aLong1 = stringRedisTemplate.opsForList().rightPush(“a”, “name4”);//返回集合中key的个数//将某一个数据加入到某个集合的末尾，key不存在，不会创建key//Long aLong1 = stringRedisTemplate.opsForList().rightPushIfPresent(“asss”, “name4”);//返回集合中key的个数//返回并移除列表左边的第一个元素//String arr = stringRedisTemplate.opsForList().leftPop(“arr”);//返回并移除列表右边的第一个元素//String arr = stringRedisTemplate.opsForList().rightPop(“arr”);//根据key获取某一个下标区间内的元素，起始索引：0，末尾：1//List arr = stringRedisTemplate.opsForList().range(“arr”, 2, -1);//获取列表内元素个数//Long arr1 = stringRedisTemplate.opsForList().size(“arr”);//给某个指定索引位置设置值，如果该索引有值就覆盖，索引必须存在//stringRedisTemplate.opsForList().set(“arr”,2,”zhangsan”);//获取指定索引位置的元素//String arr = stringRedisTemplate.opsForList().index(“arr”, 2);//删除重复元素，key：key，count：删除个数，value：元素名称//Long remove = stringRedisTemplate.opsForList().remove(“arr”, 2, “name1”);//保留列表中特定区间内的元素，其他都删除//stringRedisTemplate.opsForList().trim(“arr”,2,-1);}//对set集合进行操作@Testpublic void testSet(){//添加元素//Long add = stringRedisTemplate.opsForSet().add(“sets”, “李四”);//返回添加个数，1：添加一条，0：没有添加进去//显示集合中所有元素，无序//Set sets = stringRedisTemplate.opsForSet().members(“sets”);//返回集合中元素个数//Long size = stringRedisTemplate.opsForSet().size(“sets”);//随机返回一个元素，并将该元素删除//String sets = stringRedisTemplate.opsForSet().pop(“sets”);//从一个集合向另一个集合中移动元素，必须是同一种类型的key//Boolean move = stringRedisTemplate.opsForSet().move(“sets”, “张三”, “sets2”);//返回真假，true：成功，false：失败//从指定的key集合中删除一个或多个元素//Long remove = stringRedisTemplate.opsForSet().remove(“sets”, “6”, “李四”);//返回删除的个数//在指定的key中判断一个集合中是否包含指定元素//Boolean member = stringRedisTemplate.opsForSet().isMember(“sets”, “5”);//返回真假，true：存在，false：不存在//随机返回一个元素，不删除//String sets = stringRedisTemplate.opsForSet().randomMember(“sets”);//获取两个集合或多个集合没有重复的元素，不做删除//Set difference = stringRedisTemplate.opsForSet().difference(“sets”, “sets2”);//返回去重后的集合//获取两个集合或多个集合中重复的元素，不做删除//Set intersect = stringRedisTemplate.opsForSet().intersect(“sets”, “sets2”);//返回交集后的集合//获取两个集合或多个集合中所有的元素，不做删除//Set union = stringRedisTemplate.opsForSet().union(“sets”, “sets2”);//返回合集后的集合}//对ZSet集合进行操作@Testpublic void testZSet(){//向指定的集合中添加一个或多个元素//Boolean add = stringRedisTemplate.opsForZSet().add(“zsets1”, “张三”, 66.5);//ZSetOperations.TypedTuple typedTuple1 = new DefaultTypedTuple(“吴新科”,100.0);//ZSetOperations.TypedTuple typedTuple2 = new DefaultTypedTuple(“李艺”,99.9);//ZSetOperations.TypedTuple typedTuple3 = new DefaultTypedTuple(“赵四”,95.6);//HashSet<ZSetOperations.TypedTuple> hashSet = new HashSet();//hashSet.add(typedTuple1);//hashSet.add(typedTuple2);//hashSet.add(typedTuple3);//Long zsets1 = stringRedisTemplate.opsForZSet().add(“zsets1”, hashSet);//返回集合中元素个数//Long zsets1 = stringRedisTemplate.opsForZSet().size(“zsets1”);//返回指定范围内的元素，升序，起始索引：0，末尾：-1//Set zsets11 = stringRedisTemplate.opsForZSet().range(“zsets1”, 0, -1);//返回指定范围内的元素，降序，起始索引：0，末尾：-1//Set zsets11 = stringRedisTemplate.opsForZSet().reverseRange(“zsets1”,0,-1);//按照分数查找一个范围内的元素//Set zsets1 = stringRedisTemplate.opsForZSet().rangeByScore(“zsets1”,90.0,100.0);//返回指定元素的排名,排名按照添加顺序排名，第一名为0//Long zsets1 = stringRedisTemplate.opsForZSet().rank(“zsets1″,”李艺”);//返回指定元素的倒序排名，排名按照添加顺序排名，第一名为0//Long aLong = stringRedisTemplate.opsForZSet().reverseRank(“zsets1”, “吴新科”);//显示某一个元素的分数//Double score = stringRedisTemplate.opsForZSet().score(“zsets1”, “吴新科”);//移除某一个元素//Long remove = stringRedisTemplate.opsForZSet().remove(“zsets1”, “zahngsan”);//给某个特定元素加分//Double aDouble = stringRedisTemplate.opsForZSet().incrementScore(“zsets1”, “张三”, 5.5);//返回加分后的分数}//对hash集合进行操作@Testpublic void testHash(){//添加一个或多个元素//stringRedisTemplate.opsForHash().put(“map”,”吴新科”,”196″);//HashMap map = new HashMap();//map.put(“李艺”,”199″);//map.put(“吴旭”,”182″);//map.put(“李浩”,”112″);//stringRedisTemplate.opsForHash().putAll(“map”,map);//获得key对应的value//Object o = stringRedisTemplate.opsForHash().get(“map”, “吴新科”);//获得所有的key/value对//Map