Redis
一 引言
1.数据库压力过大
由于用户量增大,请求数量也随之增大,数据压力过大。
2.数据不同步
多台服务器之间,数据不同步
3.传统锁失效
多台服务器之间的锁,已经不存在互斥性了
二 Redis介绍
1.NoSQL 介绍
NoSQL，泛指非关系型的数据库，NoSQL即Not-Only SQL,它可以作为关系型数据库的良好补充.
1.键值(Key-Value)存储数据库
相关产品:Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB 典型应用:内容缓存，主要用于处理大量数据的高访问负载； 数据模型:一系列键值对； 优势:快速查询； 劣势:存储的数据缺少结构化.
2.列存储数据库
相关产品:Cassandra, HBase, Riak; 典型应用:分布式的文件系统； 数据模型:以列簇式存储，将同一列数据存在一起； 优势:查找速度快，可扩展性强，更容易进行分布式扩展； 劣势:功能相对局限.
3.文档型数据库
相关产品:CouchDB、MongoDB; 典型应用:Web应用(与Key-Value类似,Value是结构化的); 数据模型:一系列键值对； 优势:数据结构要求不严格； 劣势:查询性能不高，而且缺乏统一的查询语法.
4.图形(Graph)数据库
相关数据库:Neo4J、lnfoGrid、lnHnite Graph; 典型应用:社交网络； 数据模型:图结构； 优势:利用图结构相关算法； 劣势:需要对整个图做计算才能得出结果，不容易做分布式的集群方案.
2.数据库分类
1.关系型数据库(表) MySQL,Oracle,SQLServer,DB2,SQLite.... 注意：关系型数据库最大的不足,就是受限于磁盘读写能力(I/O)! 2.非关系型数据库(基于内存) Redis,MongoDB,ElasticSearch,HBase.... 非关系型数据库是为了弥补关系型数据库的不足的!
3.非关系型数据库的分类
①.键值对型:redis ②.列存储型:hbase ③.图形类型:neo4j ④.文档型.mongodb
4.Redis概念
Redis是一种用C语言实现的,开源的,键值对类型的非关系型数据库! Redis:REmote Dictionary Server（远程字典服务器），它是一个完全开源免费且遵守BSD协议，用C语言开发的，高性能key-value型分布式内存数据库，它是基于内存运行并支持持久化的NoSQL数据库.可用 于缓存,事件发布或订阅，高速队列等场景.该数据库使用ANSI C语言编写，支持网络，提供字符串，哈希，列表，队列，集合结构直接存取，基于内存，可持久化.Redis是当前最热门的NoSql数据库之一，也被人们称为数据结构服务器.
5.Redis的使用场景
①.缓存(数据查询、短连接、新闻内容、商品内容等等,最常用); ②.消息队列,任务队列(秒杀、抢购、12306 等)等队列; ③.获取最新的N个数据(取最新文档、排行榜等); ④.计数器应用,网站访问统计等; ⑤.发布/订阅消息(消息通知); ⑥.数据过期处理(可以精确到毫秒),优惠券/红包等; ⑦.商品列表,评论列表,聊天室好友列表等实时性要求较高的场景; ⑧.分布式集群架构中的 session 分离和集中存储; ⑨.各种排行榜.
6.应用场景详解
1.会话缓存
最常用的一种使用Redis的情景是会话缓存（session cache）.用Redis缓存会话比其他存储（如 Memcached）的优势在于:Redis提供持久化.
2.消息队列
Reids在内存存储引擎领域的一大优点是提供list和set操作,这使得Redis能作为一个很好的消息队 列平台来使用.Redis作为队列使用的操作，就类似于本地程序语言（如Python）对list的 push/pop 操作.
3.排行榜/计数器
Redis在内存中对数字进行递增或递减的操作实现的非常好.集合（Set）和有序集合（Sorted Set） 也使得我们在执行这些操作的时候变的非常简单,Redis正好提供了这两种数据结构.
4.发布/订阅
Redis的发布/订阅的使用场景非常多,经常在社交网络连接中使用，还可作为基于发布/订阅的脚本触 发器,甚至用Redis的发布/订阅功能来建立聊天系统!
7.Redis的数据类型
①.string字符串类型; ②.hash类型; ③.list列表类型; ④.set集合类型; ⑤.zset有序集合类型; ⑥.hyperloglog计算近似值的; ⑦.GEO地理坐标类型; ⑧.bit字节类型.
8.Reids的特点
Redis本质上是一个Key-Value类型的内存数据库，很像memcached,整个数据库的加载都是在内存当中进行操作，定期通过异步操作把数据库数据flush到硬盘上进行保存. 正因为是纯内存的操作，所以Redis的性能非常出色，每秒可以处理超过10万次读写操作，是已知性能最快的Key-Value DB. Redis的出色之处不仅仅是性能,它的最大的魅力是支持保存多种数据结构，此外单个value的最大限制 是1GB，不像memcached只能保存1MB的数据，因此Redis可以用来实现很多有用的功能. 比方说可以用Redis的List数据类型来做FIFO双向链表,实现一个轻量级的高性能消息队列服务;用它的Set类型可以做高性能的tag系统等.另外Redis也可以对存入的Key-Value设置expire时间,因此也可以被当作一个功能加强版的memcached来用.
9.Redis优点
1 速度快：因为redis基于内存缓存，对数据可以进行高并发读写； 2 支持丰富数据类型：支持string,list,set,sorted set,hash; 3 支持事务：操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行; 4 丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除; 5 扩展性和可用性高：支持垂直扩展，提升硬件性能;通过集群支持水平扩展.
10.Redis缺点
Redis的主要缺点是数据库容量受到物理内存的限制，不能用作海量数据的高性能读写，因此Redis适合的场景主要局限在较小数据量的高性能操作和运算上. 另外Redis(ACID处理非常简单)也无法做到太复杂的关系数据库模型.
11.Redis与其他Key-Value缓存
• Redis支持数据的持久化,可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用. • Redis不仅仅支持简单的key-valu e类型的数据，同时还提供list,set,zset,hash等数据结构的 存储. • Redis支持数据的备份，即master-slave模式的数据备份.
四 安装 Redis
1.Docker-Compose安装
version: '3.1' services: redis: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis environment: -TZ=Asia/Shanghai ports: -6379:6379
2.redis-cli连接Redis
进去Redis容器的内部 docker exec -it 容器id bash 在容器内部,使用redis-cli连接
3.图形化界面连接Redis
4.redis的通讯机制
ping-pong机制
五 Redis常用命令
1.Redis存储数据的结构
常用的5种数据结构: key-string：—个key对应一个值。 key-hash：—个key对应一个Map。 key-list：—个key对应一个列表。 key-set：—个key对应一个集合。 key-zset：-个key对应一个有序的集合。 另外三种数据结构: HyperLogLog：计算近似值的。 GEO：地理位置。 BT：一般存储的也是一个字符串,存储的是一个byte[]。
2.五种常用的存储数据结构图
五种常用的存储数据结构图 •key-string：最常用的,一般用于存储一个值。 •key-hash：存储一个对象数据的。 •key-list ：使用list结构实现栈和队列结构。 •key-set ：交集,差集和并集的操作。 •key-zset:排行榜,积分存储等操作。
3.string常用命令
1.添加值
set key value
2.取值
get key
3.批量操作
mset key value [key value...] mget key [key...]
4.自增命令
incr key(自增1)
5.自减命令
decr key(自减1)
6.自增或自减指定数量
incrby key increment decrby key increment
7.设置值的同时指定生存时间
设置值的同时，指定生存时间（每次向Redis中添加数据时，尽量都设置上生存时间） setex key second value
8.设置值,当前key不存在
#8.设置值，如果当前key不存在的话（如果这个key存在，什么事都不做，如果这个key不存在，和set命令一样） setnx key value
9.在key对应的value
在key对应的valu e后，追加内容 append key value
10.查看value字符串的长度
strlen key
4.hash常用命令
1.存储数据&获取数据
hset key field value hget key field
2.批量操作
hmset key field value [field value . hmget key field [field ...]
3.自增
hincrby key field increment
4.设置值
设置值（如果key-field不存在，那么就正常添加，如果存在，什么事都不做） hsetnx key field value
6.检查field是否存在
hexists key field
7.删除key对应的field
可以删除多个 hdel key field [field ...]
8.获取当前hash(field和value)
获取当前hash结构中的全部field和value hgetall key
9.获取当前hash(field)
获取当前hash结构中的全部field hkeys key
10.获取当前hash(value)
获取当前hash结构中的全部value hvals key
11.获取当前hash(数量)
获取当前hash结构中field的数量 hlen key
5.list常用命令
list的数据类型---->对应的java中的数据结构(栈/队列) lpush,lpop--->栈 lpush:入栈,每次是从list集合的左侧入栈; lpop:出栈,每次取list集合的栈顶的数据; rpush,rpop--->队列 rpush:入队,每次是从list集合的右侧入队; rpop:出队,每次从对尾取值.
1.存储数据(lpush&rpush)
存储数据 lpush key value [value ...] 从左侧插入数据 rpush key value [value ...] 从右侧插入数据
2.存储数据(lpushx&rpushx)
存储数据（如果key不存在，什么事都不做，如果key存在，但是不是list结构，什么都不做） lpushx key value rpushx key value
3.修改数据
修改数据（在存储数据时，指定好你的索引位置，覆盖之前索引位置的数据，index超出整个列表的 长度，也会失败） lset key index value
4.弹栈方式获取数据
lpop key 左侧弹出数据 rpop key 从右侧弹出数据
5.获取指定索引范围的数据
获取指定索引范围的数据（start从0开始，stop输入-1,代表最后一个，-2代表倒数第二个） lrange key start stop
6.获取指定索引位置的数据
lindex key index
7.获取整个列表的长度
llen key
8.删除列表中的数据
删除列表中的数据（他是删除当前列表中的count个value值，count > 0从左侧向右侧删除，count < 0从右侧向左侧删除，count == 0删除列表中全部的value） lrem key count value
9.保留列表中的数据
保留列表中的数据（保留你指定索引范围内的数据，超过整个索引范围被移除掉） ltrim key start stop
10.rpoplpush
将一个列表中最后的一个数据，插入到另外一个列表的头部位置 rpoplpush list1 list2
6.set常用命令
1.存储数据
sadd key member [member ...]
2.获取数据
获取数据（获取全部数据） smembers key
3.随机获取一个数据
随机获取一个数据（获取的同时，移除数据，count默认为1,代表弹出数据的数量） spop key [count]
4.交集
交集（取多个set集合交集） sinter set1 set2 ...
5.并集
并集（获取全部集合中的数据） sunion set1 set2 ...
6.差集
差集（获取多个集合中不一样的数据） sdiff set1 set2 ...
7.删除数据
srem key member [member ...]
8.查看当前的set集合
#查看当前的set集合中是否包含这个值 sismember key member
7.zset常用命令
1.添加数据
添加数据（score必须是数值。member不允许重复的。） zadd key score member [score member ...]
2.修改member的分数
修改member的分数（如果member是存在于key中的，正常增加分数，如果memeber不存在，这个命令就相当zadd） zincrby key increment member
3.查看指定的member的分数
zscore key member
4.获取zset中数据的数量
zcard key
5.根据score的范围查询member数量
根据score的范围查询member数量 zcount key min max
6.删除zset中的成员
删除zset中的成员 zrem key member [member...]
7.根据分数从小到大排序
根据分数从小到大排序，获取指定范围内的数据（withscores如果添加这个参数，那么会返回member对应的分数） zrange key start stop [withscores]
8.根据分数从大到小排序
根据分数从大到小排序，获取指定范围内的数据（withscores如果添加这个参数，那么会返回member对应的分数） zrevrange key start stop [withscores]
8.key常用命令
1.查看Redis中的全部的key
查看Redis中的全部的key （pattern： * , xxx*, *xxx） keys pattern
2.查看某一个key是否存在
查看某一个key是否存在（1 - key存在，0 - key不存在） exists key
3.删除key
del key [key ...]
4.设置key的生存时间
设置key的生存时间，单位为秒，单位为毫秒，设置还能活多久 expire key second pexpire key milliseconds 设置key的生存时间，单位为秒，单位为毫秒，设置能活到什么时间点 expireat key timestamp pexpireat key milliseconds
5.查看key的剩余生存时间
查看key的剩余生存时间，单位为秒，单位为毫秒（-2 -当前key不存在，-1 -当前key没有设置生存时间，具体剩余的生存时间） ttl key pttl key
6.移除key的生存时间
移除key的生存时间（1 -移除成功，0 - key不存在生存时间，key不存在） persist key
7.选择操作的库
select 0~15
8.移动key到另外一个库中
移动key到另外一个库中 move key db
9.库的常用命令
1.清空当前所在的数据库
flushdb
2.清空全部数据库
flushall
3.查看当前数据库中有多少个key
dbsize
4.查看最后一次操作的时间
lastsave
5.实时监控Redis服务接收到的命令
monitor
10.关于key的命令
如果你们项目中有 1亿 个key,如何过滤出想要的key? keys pattern通配符.---->该答案并不是面试官想要的答案!!! keys product* keys命令会造成redis线程阻塞,而scan不会! 更好的答案是回答 scan命令: scan cursor match pattern SCAN 0 match product*
六 Java连接redis
1.Jedis 连接
1.导入需要的依赖
<dependency> <groupId>redis.clientsgroupId> <artifactId>jedisartifactId> <version>2.9.0version> dependency> <dependency> <groupId>com.alibabagroupId> <artifactId>fastjsonartifactId> <version>1.2.46version> dependency> <dependency> <groupId>org.projectlombokgroupId> <artifactId>lombokartifactId> dependency>
2.测试1
@Test public void test1() { Jedis jedis = new Jedis("172.20.10.8", 6379); String result = jedis.ping(); System.out.println("result=" + result); jedis.close(); }
2.测试2
//Jedis存储一个对象到Redis以byte[]的形式 @Test public void test2() { //1.连接Redis服务 Jedis jedis = new Jedis("172.20.10.8", 6379); //2.1 准备 key(String)-value(User) String key = "user"; User user = new User(); user.setId(2); user.setUsername("特没谱"); user.setPassword("sb"); //2.2 将 key 和 valu e 转换为 byte口 byte[] key = SerializationUtils.serialize("user1"); byte[] userByte = SerializationUtils.serialize(user); jedis.set(key, userByte); jedis.close(); }
3.测试 3
//获取对象-以byte口形式在Redis中获取 @Test public void test3() { //1.连接Redis服务 Jedis jedis = new Jedis("172.20.10.8", 6379); byte[] result = jedis.get(SerializationUtils.serialize("user1")); //反序列化 User user = (User) SerializationUtils.deserialize(result); System.out.println("user=" + user.toString()); jedis.close(); }
4.测试4
//存储对象-以String形式存储 @Test public void test1() { //1.连接 Redis Jedis jedis = new Jedis("172.20.10.8", 6379); User user = new User(); user.setId(1); user.setUsername("syc"); user.setPassword("123"); //转化为json字符串 String string = JSON.toJSONString(user); String json = JSON.toJSONString(user); jedis.set("user2", json); System.out.println(json); jedis.close(); }
5.测试5
//获取对象-以String形式获取 @Test public void test2() { Jedis jedis = new Jedis("172.20.10.8", 6379); String json = jedis.get("user2"); //将value反序列化为User User user = JSON.parseObject(json, User.class); System.out.println("user=" + user.toString()); jedis.close(); }
2.Jedis连接池的操作
使用连接池操作Redis,避免频繁创建和销毁链接对象消耗资源@Test public void test1() { //Jedis jedis = new Jedis("10.11.53.143", 6379); JedisPool pool=new JedisPool("172.20.10.8", 6379); //使用Jedis的连接池,来获取Jedis对象 Jedis jedis = pool.getResource(); User user = new User(); user.setId(1); user.setUsername("syc"); user.setPassword("123"); //转化为json字符串 String string = JSON.toJSONString(user); String json = JSON.toJSONString(user); jedis.set("user3", json); jedis.close(); }
@Test public void test2() { //Jedis jedis = new Jedis("10.11.53.143", 6379); //1.创建连接池配置信息 GenericObjectPoolConfig poolConfig=new GenericObjectPoolConfig(); //设置连接池中的最大连接数 poolConfig.setMaxTotal(100); //设置jedis对象的最大空闲时间 poolConfig.setMaxIdle(10); poolConfig.setMinIdle(5); //当连接池中没有jedis对象,在3秒钟内如果获取不到jedis对象,就会产生超时 poolConfig.setMaxWaitMillis(3000); JedisPool pool=new JedisPool(poolConfig,"172.20.10.8", 6379); //使用Jedis的连接池,来获取Jedis对象 Jedis jedis = pool.getResource(); User user = new User(); user.setId(1); user.setUsername("yqq"); user.setPassword("123"); String json = JSON.toJSONString(user); jedis.set("user4", json); jedis.close(); }
3.Redis的管道操作
因为在操作Redis的时候,执行一个命令需要先发送请求到Redis服务器,这个过程需 要经历网络的延迟,Redis还需要给客户端一个响应。 如果我需要一次性执行很多个命令,上述的方式效率很低,可以通过Redis的管道,先 将命令放到客户端的一个Pipeline中,之后一次性的将全部命令都发送到Redis服务, Redis服务一次性的将全部的返回结果响应给客户端。// Redis管道的操作 @Test public void pipeline(){ //1.创建连接池 JedisPool pool = new JedisPool("192.168.199.109”,6379); long l = System.currentTimeMillis。； /*//2.获取一个连接对象 Jedis jedis = pool.getResource。； //3.执行 incr - 100000次 for (int i = 0; i < 100000; i++) { jedis.incr("pp"); } //================================ //2. 获取一个连接对象 Jedis jedis = pool.getResource(); //3.创建管道 Pipeline pipelined = jedis.pipelined(); //3.执行incr - 100000次放到管道中 for (int i = 0; i < 100000; i++) { pipelined.incr("qq"); } //4.执行命令 pipelined. syncAndReturnAll。; //5. 释放资源 jedis.close(); System.out.println(System.currentTimeMillis() - l);
七 Redis其他配置及集群
1.Redis的事务
Redis的事务：一次事务操作,改成功的成功,该失败的失败。 先开启事务,执行一些列的命令,但是命令不会立即执行,会被放在一个队列中,如果 你执行事务,那么这个队列中的命令全部执行,如果取消了事务,一个队列中的命令全 部作废。 •开启事务：multi •输入要执行的命令：被放入到一个队列中 •执行事务：exec •取消事务：discard Redis的事务向发挥功能,需要配置watch监听机制 在开启事务之前,先通过watch命令去监听一个或多个key,在开启事务之后,如果有 其他客户端修改了我监听的key,事务会自动取消。 如果执行了事务,或者取消了事务,watch监听自动消除,一般不需要手动执行 unwatch。
@Test public void test1() { //Jedis jedis = new Jedis("10.11.53.143", 6379); JedisPool pool=new JedisPool("172.20.10.8", 6379); //使用Jedis的连接池,来获取Jedis对象 Jedis jedis = pool.getResource(); //开启事务 Transaction transaction = jedis.multi(); //redis.clients.jedis.exceptions.JedisDataException: // Cannot use Jedis when in Multi. Please use Transation or reset jedis state. //jedis.set("name","yyg"); //注意:redis中事务的使用,要利用Transaction对象来执行!不能用Jedis对象! transaction.set("name","易青青"); //提交事务 transaction.exec(); //取消事务 //transaction.discard(); jedis.close(); }
2.Redis持久化机制
1.RDB
RDB是Redis默认的持久化机制 ・RDB持久化文件,速度比较快,而且存储的是一个二进制的文件,传输起来很方便。 ・RDB持久化的时机: save 900 1：在900秒内,有1个key改变了,就执行RDB持久化。 save 300 10：在300秒内,有10个key改变了,就执行RDB持久化。 save 60 10000：在60秒内,有10000个key改变了,就执行RDB持久化。 RDB无法保证数据的绝对安全
2. AOF
AOF持久化机制默认是关闭的,Redis官方推荐同时开启RDB和AOF持久化,更安全, 避免数据丢失。 •AOF持久化的速度,相对RDB较慢的,存储的是一个文本文件,到了后期文件会比较大,传输困难。 •AOF持久化时机。 appendfsync always：每执行一个写操作,立即持久化到AOF文件中,性能比较低。 appendfsync everysec ：每秒执行一次持久化。 appendfsync no ：会根据你的操作系统不同,环境的不同,在一定时间内执行一次持久化。 •AOF相对RDB更安全,推荐同时开启AOF和RDB。 注意事项： 同时开启RDB和AOF的注意事项: 如果同时开启了AOF和RDB持久化,那么在Redis宕机重启之后,需要加载一个持久化文件,优先选择AOF文件 如果先开启了RDB,再次开启AOF,如果RDB执行了持久化,那么RDB文件中的内容会被AOF覆盖掉。
加载自定义配置文件
1.redis.conf解读
实现跨机器访问redis服务器
保护模式，一般为yes ,在集群中建议开启
redis服务器端口：可以修改
内存设置
满足条件就自动持久化保存到磁盘》优化调优 如：save 900 1：在900秒内,有1个key改变了,就执行RDB持久化。
数据备份到dump.rdb文件
连接服务器需要密码
最多连接客户端数量
内存大小，一般根据机器性能默认分配
redis的内存淘汰策略,
当为no时，只开启RDB持久化机制， 当为yes时，就开启了AOF持久化机制，这个时候相当于两种机制同时存在
在开启AOF持久化机制后，有自己的数据库文件
AOF的3种持久化规则
3.数据的备份与恢复命令
save : 手动备份数据到磁盘中 恢复: 只需要把dump.rdb文件复制到data目录下,只要redis一启动,就会自动恢复.
4.redis内存调优配置
redis的内存淘汰策略: XMEMORY POLICY: how Redis will select what to remove when maxmemory # is reached. You can select among five behaviors: # # 如下是默认自带的几种(8种)淘汰策略(重点): # volatile-lru -> Evict using approximated LRU among the keys with an expire set. # allkeys-lru -> Evict any key using approximated LRU. # volatile-lfu -> Evict using approximated LFU among the keys with an expire set. # allkeys-lfu -> Evict any key using approximated LFU. # volatile-random -> Remove a random key among the ones with an expire set. # allkeys-random -> Remove a random key, any key. # volatile-ttl -> Remove the key with the nearest expire time (minor TTL) # noeviction -> Don't evict anything, just return an error on write operations. # # LRU means Least Recently Used 最近最少使用算法 # LFU means Least Frequently Used 最近最少频繁使用算法 The default is:默认的内存淘汰策略：可以在下面修改策略 # maxmemory-policy noeviction 不驱除
5.redis的持久化方案及实现原理
①.rdb(默认)---->bgsave 设置rdb的持久化规则: save 900 1 save 300 10 save 60 10000 默认redis会使用 LZF 算法对dump.rdb文件进行压缩. Compress string objects using LZF when dump.rdb databases? 特点: 默认开启; 性能好:不会每执行一次redis增删改操作就进行一次IO操作. 生成的rdb备份文件较小,所以后来恢复速度就快; 数据完整性不够好,存在数据丢失的风险. ②.aof---->bgrewriteof aof的3种持久化规则: appendfsync always：只要做一次数据操作就做持久化 appendfsync everysec：每秒做一次持久化 appendfsync no 特点: 默认没有开启; 性能没有RDB好; 数据完整性好. aof文件会很大,备份恢复速度就较慢.
6.Redis的主从架构
单机版Redis存在读写瓶颈的问题
1.指定yml文件
version: "3.1" services: redis1: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis1 environment: - TZ=Asia/Shanghai ports: - 7001:6379 volumes: - ./conf/redis1.conf:/usr/local/redis/redis.conf command: ["redis-server","/usr/local/redis/redis.conf"] redis2: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis2 environment: - TZ=Asia/Shanghai ports: - 7002:6379 volumes: - ./conf/redis2.conf:/usr/local/redis/redis.conf links: - redis1:master command: ["redis-server","/usr/local/redis/redis.conf"] redis3: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis3 environment: - TZ=Asia/Shanghai ports: - 7003:6379 volumes: - ./conf/redis3.conf:/usr/local/redis/redis.conf links: - redis1:master command: ["redis-server","/usr/local/redis/redis.conf"]
2.conf
3.主机
4.从机1
5.从机2
6.总结
redis2和redis3从节点配置 replicaof master 6379 info replication :查看主从机信息
7.redis的高可用实现方案
1.主从复制:一主多从,主机可写,从机备份.类似于MySQL的读写分离,存在的问题是一但主节点down掉,整个 Redis都不可用. 2️.哨兵(2.x)机制:启用一个哨兵程序(节点),监控其余节点的状态,根据选举策略,进行主从切换. 缺点:每个节点的数据依旧是一致的,仍无法实现分布式的数据库. 3️.集群(3.x):结合上述两种模式,多主多从,实现高可用、分布数据存储.
8.哨兵
哨兵可以帮助我们解决主从架构中的单点故障问题
1.docker-compose.yml
version: "3.1" services: redis1: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis1 environment: - TZ=Asia/Shanghai ports: - 7001:6379 volumes: - ./conf/redis1.conf:/usr/local/redis/redis.conf - ./conf/sentinel1.conf:/data/sentinel.conf command: ["redis-server","/usr/local/redis/redis.conf"] redis2: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis2 environment: - TZ=Asia/Shanghai ports: - 7002:6379 volumes: - ./conf/redis2.conf:/usr/local/redis/redis.conf - ./conf/sentinel2.conf:/data/sentinel.conf links: - redis1:master command: ["redis-server","/usr/local/redis/redis.conf"] redis3: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis3 environment: - TZ=Asia/Shanghai ports: - 7003:6379 volumes: - ./conf/redis3.conf:/usr/local/redis/redis.conf - ./conf/sentinel3.conf:/data/sentinel.conf links: - redis1:master command: ["redis-server","/usr/local/redis/redis.conf"]
2.主机配置文件
daemonize yes #指定Master节点的ip和端口（主） sentinel monitor master 172.20.10.8 6379 2 #哨兵每隔多久监听一次redis架构 sentinel down-after-milliseconds mymaster 10000
3.从机配置文件
daemonize yes #指定Master节点的ip和端口（主） sentinel monitor master 172.20.10.8 6379 2 #哨兵每隔多久监听一次redis架构 sentinel down-after-milliseconds mymaster 10000
4.启动sentine
在Redis容器内部启动sentine即可 redis-sentinel sentinel.conf
5.查看sentinel运行状态
redis-cli -p 26379 info
9. Redis的集群
Redis集群在保证主从加哨兵的基本功能之外,还能够提升Redis存储数据的能力。
1.准备yml文件
version: "3.1" services: redis1: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis1 environment: - TZ=Asia/Shanghai ports: - 7001:7001 - 17001:17001 volumes: - ./conf/redis1.conf:/usr/local/redis/redis.conf command: ["redis-server","/usr/local/redis/redis.conf"] redis2: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis2 environment: - TZ=Asia/Shanghai ports: - 7002:7002 - 17002:17002 volumes: - ./conf/redis2.conf:/usr/local/redis/redis.conf command: ["redis-server","/usr/local/redis/redis.conf"] redis3: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis3 environment: - TZ=Asia/Shanghai ports: - 7003:7003 - 17003:17003 volumes: - ./conf/redis3.conf:/usr/local/redis/redis.conf command: ["redis-server","/usr/local/redis/redis.conf"] redis4: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis4 environment: - TZ=Asia/Shanghai ports: - 7004:7004 - 17004:17004 volumes: - ./conf/redis4.conf:/usr/local/redis/redis.conf command: ["redis-server","/usr/local/redis/redis.conf"] redis5: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis5 environment: - TZ=Asia/Shanghai ports: - 7005:7005 - 17005:17005 volumes: - ./conf/redis5.conf:/usr/local/redis/redis.conf command: ["redis-server","/usr/local/redis/redis.conf"] redis6: image: daocloud.io/library/redis:5.0.7 restart: always container_name: redis6 environment: - TZ=Asia/Shanghai ports: - 7006:7006 - 17006:17006 volumes: - ./conf/redis6.conf:/usr/local/redis/redis.conf command: ["redis-server","/usr/local/redis/redis.conf"]
2.conf配置文件
#指定redi s的端口号 port 7006 #开启Redis集群 cluster-enabled yes #集群信息的文件 cluster-config-file nodes-7006.conf #集群的对外ip地址 cluster-announce-ip 172.20.10.8 #集群的对外port cluster-announce-port 7006 #集群的总线端口 cluster-announce-bus-port 17006 注意：需要配置6个 redis.conf 端口分别为1-6
3.启动6个节点
redis-cli --cluster create 172.20.10.8:7001 172.20.10.8:7002 172.20.10.8 :7003 172.20.10.8:7004 172.20.10.8:7005 172.20.10.8:7006 --cluster-rep licas 1 注意：启动前先关闭Linux防火墙 6个节点，自动划分三个主机，三个从节点
4.集群内操作
redis-cli -c -p 7001|7002 -c 表示集群模式 cluster 注意： 在集群内部任意任意主机或节点存储数据，都会根据 key 进行crc16算法，并且对16384取余，根据最终结果，将key-value存到指定redis(主机)节点上
5.查看主从机信息
10.Java连接Redis集群
1.测试1
@Test public void test1() { //服务器节点集群 Set<HostAndPort> nodes = new HashSet<>(); nodes.add(new HostAndPort("172.20.10.8", 7001)); nodes.add(new HostAndPort("172.20.10.8", 7002)); nodes.add(new HostAndPort("172.20.10.8", 7003)); nodes.add(new HostAndPort("172.20.10.8", 7004)); nodes.add(new HostAndPort("172.20.10.8", 7005)); nodes.add(new HostAndPort("172.20.10.8", 7006)); JedisCluster cluster = new JedisCluster(nodes); cluster.hset("cluster", "name", "testCluster"); cluster.hset("cluster", "info", "3333"); //cluster.close(); }
2.测试2
@Test public void test2() { //服务器节点集群 Set<HostAndPort> nodes = new HashSet<>(); nodes.add(new HostAndPort("172.20.10.8", 7001)); nodes.add(new HostAndPort("172.20.10.8", 7002)); nodes.add(new HostAndPort("172.20.10.8", 7003)); nodes.add(new HostAndPort("172.20.10.8", 7004)); nodes.add(new HostAndPort("172.20.10.8", 7005)); nodes.add(new HostAndPort("172.20.10.8", 7006)); JedisCluster cluster = new JedisCluster(nodes); String name = cluster.hget("cluster", "name"); String info = cluster.hget("cluster", "info"); System.out.println("name=" + name + "\n"+"info=" + info); //cluster.close(); }
八 Redis常见问题
1.key的生存时间
key的生存时间到了，Redis会立即删除吗？不会立即删除。 •定期删除：Redis每隔一段时间就去会去查看Redis设置了过期时间的key,会再 100ms的间隔中默认查看3个key。 •惰性删除：如果当你去查询一个已经过了生存时间的key时,Redis会先查看当前 key的生存时间,是否已经到了,直接删除当前key,并且给用户返回一个空值。
2.Redis的淘汰机制
在Redis内存已经满的时候,添加了一个新的数据,执行淘汰机制。 •volatile-lru：在内存不足时,Redis会在设置过了生存时间的key中干掉一个最近 最少使用的key。 •allkeys-lru：在内存不足时,Redis会在全部的key中干掉一个最近最少使用的 key。 •volatile-lfu：在内存不足时,Redis会在设置过了生存时间的key中干掉一个最近 最少频次使用的key。 •allkeys-lfu：在内存不足时,Redis会在全部的key中干掉一个最近最少频次使用 的key。 •volatile-random ：在内存不足时,Redis会再设置过了生存时间的key中随机干掉 一个。 •allkeys-random:在内存不足时,Redis会在全部的key中随机干掉一个。 •volatile-ttl:在内存不足时,Redis会在设置过了生存时间的key中干掉一个剩余生存时间最少的key。 •noeviction ：（默认）在内存不足时,直接报错。
3.缓存的常见问题
1.缓存穿透
问题出现的原因：查询的数据，Redis中没有，数据库中也没有。 1：根据id查询时，如果id是自增的，将id的最大值放到Redis中，在查询数据库之前，直接比较一下id。 2:如果id不是整形，可以将全部的id放到set中，在用户查询之前，去set中查看一下是否有一个id。 3:获取客户端的ip地址，可以将ip的访问添加限制。
2.缓存击穿
问题：缓存中的热点数据，突然到期了，造成了大量的请求都去访问数据库，造成数据库宕机? 1.在访问缓存中没有的时候，直接添加一个锁，让几个请求去访问数据库，避免数据库宕机。 2.热点数据的生存时间去掉。
3.缓存雪崩
4.缓存倾斜
九 SSM+Redis
1.web.xml
<servlet> <servlet-name>SpringMVCservlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class> <init-param> <param-name>contextConfigLocationparam-name> <param-value>classpath:spring/spring-web.xmlparam-value> init-param> <load-on-startup>1load-on-startup> servlet> <servlet-mapping> <servlet-name>SpringMVCservlet-name> <url-pattern>/url-pattern> servlet-mapping> <listener> <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class> listener> <context-param> <param-name>contextConfigLocationparam-name> <param-value>classpath:spring/application-*.xmlparam-value> context-param> <filter> <filter-name>Encodingfilter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class> <init-param> <param-name>encodingparam-name> <param-value>UTF-8param-value> init-param> filter> <filter-mapping> <filter-name>Encodingfilter-name> <url-pattern>/*url-pattern> filter-mapping>
2.spring-web.xml
<context:component-scan base-package="com.yyg.redis.web"/>
<mvc:annotation-driven/>
<mvc:resources mapping="/html/**" location="/html/"/>
<mvc:resources mapping="/js/**" location="/js/"/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/html/"/>
<property name="suffix" value=".html"/>
bean>
3.application-service.xml
<context:component-scan base-package="com.yyg.redis.service"/>
4.application-redis.xml
<context:property-placeholder location="classpath:conf/redis.properties"/> <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"> <property name="maxTotal" value="${redis.maxTotal}"/> <property name="maxIdle" value="${redis.maxIdle}"/> <property name="maxWaitMillis" value="${redis.maxWait}"/> bean> <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"> <property name="hostName" value="${redis.host}"/> <property name="port" value="${redis.port}"/> <property name="password" value="${redis.password}"/> <property name="poolConfig" ref="poolConfig"/> bean> <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate"> <property name="connectionFactory" ref="connectionFactory"/> <property name="enableTransactionSupport" value="true"/> <property name="keySerializer"> <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/> property> bean> <bean id="redisUtil" class="com.yyg.redis.util.RedisUtil"> <property name="redisTemplate" ref="redisTemplate"/> bean>
5.application-dao.xml
<context:property-placeholder location="classpath:conf/*.properties"/> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="url" value="${jdbc.url}"/> <property name="driverClassName" value="${jdbc.driver}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> bean> <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/> bean> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.yyg.redis.mapper"/> bean>
6.mybatis-config.xml
<configuration> <settings> <setting name="logImpl" value="STDOUT_LOGGING"/> settings> <typeAliases> <typeAlias type="com.yyg.redis.domain.Msg"/> typeAliases> <plugins> <plugin interceptor="com.github.pagehelper.PageInterceptor"> <property name="helperDialect" value="mysql"/> plugin> plugins> configuration>
7.db.properties
jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/yqq?useUnicode=true&characterEncoding=UTF8&useSSL=false jdbc.username=root jdbc.password=root
8.redis.properties
redis.host=172.20.10.8 redis.port=6379 redis.password= redis.maxIdle=300 redis.maxTotal=600 redis.maxWait=1000
9.控制层接口
@Controller public class MsgController { @Autowired private MsgService msgService; @GetMapping("/index") public String showIndex() { return "index"; } @ResponseBody @PostMapping("/addMsg") public Map<String, Object> addMsg(Msg msg) { boolean result = msgService.addMsg(msg); Map<String, Object> map = new HashMap<>(); if (result) { map.put("code", 200); map.put("msg", "success"); } else { map.put("code", -1); map.put("msg", "error"); } return map; } @ResponseBody @GetMapping("/queryMsg") public List<Msg> queryMsg(){ return msgService.listMsg(); } }
10.业务处理
@Service public class MsgServiceImpl implements MsgService { @Autowired private MsgMapper msgMapper; @Autowired private RedisUtil redisUtil; @Override public boolean addMsg(Msg msg) { //在进行数据库的添加,删除,修改等更新的时候,要考虑"双写一致性"问题! boolean result = msgMapper.addMsg(msg) > 0; if (result) { //第一种方案:删除某个key对应的缓存,把key-value //redisUtil.del("msg_list"); //第二种方案:使得该key-value直接过期 redisUtil.expire("msg_list", 0); //TODO:在分布式项目中,可以利用消息队列,在数据库更新成功后,发出一个消息(把缓存的key,id,内容等) //TODO:另外的一个服务中,就可以接收到该消息,从而做出redis缓存的更新! } return result; } @Override public List<Msg> listMsg() { //添加redis缓存,业务逻辑实现步骤: //1.先直接去redis缓存中查询是否有缓存 //2.如果有缓存---->直接返回缓存结果 //3.如果没有缓存--->进行数据库的查询--->把该结果存到redis缓存中 List<Msg> msgs; List<Object> list = redisUtil.lGet("msg_list", 0, -1); if (list != null && list.size() > 0) { System.out.println("执行redis缓存..."); msgs = JSON.parseArray(list.get(0).toString(), Msg.class); } else { System.out.println("执行数据库查询..."); msgs = msgMapper.findAll(); //查询mysql数据库 String json = JSON.toJSONString(msgs); Random random = new Random(); int time = random.nextInt(10000); //预防因为缓存过期时间同时失效,而造成的缓存雪崩问题 redisUtil.lSet("msg_list", json, 3000 + time); } return msgs; } }
11.RedisUtil
package com.yyg.redis.util; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.util.CollectionUtils; public class RedisUtil { private RedisTemplate<String, Object> redisTemplate; public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) { this.redisTemplate = 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(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); //redisTemplate.opsForHash().put(); 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) * @return */ 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) * @return */ 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 * @return 值 */ 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 * 对应多个键值 * @return true 成功 false 失败 */ 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) * @return */ public double hincr(String key, String item, double by) { return redisTemplate.opsForHash().increment(key, item, by); } /** * hash递减 * * @param key * 键 * @param item * 项 * @param by * 要减少记(小于0) * @return */ public double hdecr(String key, String item, double by) { return redisTemplate.opsForHash().increment(key, item, -by); } // ============================set============================= /** * 根据key获取Set中的所有值 * * @param key * 键 * @return */ 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 * 键 * @return */ 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 * 键 * @return */ 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倒数第二个元素，依次类推 * @return */ 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 * 值 * @return */ 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 * 时间(秒) * @return */ 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; } } }
12.效果图
十 SpringBoot+Redis
1.依赖
<dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-webartifactId> dependency> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-data-jpaartifactId> dependency> <dependency> <groupId>mysqlgroupId> <artifactId>mysql-connector-javaartifactId> dependency> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-cacheartifactId> dependency> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-data-redisartifactId> dependency> <dependency> <groupId>com.alibabagroupId> <artifactId>fastjsonartifactId> <version>1.2.39version> dependency> <dependency> <groupId>org.projectlombokgroupId> <artifactId>lombokartifactId> dependency>
2.yml配置
cache: default-exp: 10000 #redis缓存总的过期时间,单位是秒 server: port: 8080 spring: application: name: redis-cache-demo datasource: url: jdbc:mysql://localhost:3306/db4?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&serverTimezone=UTC driver-class-name: com.mysql.cj.jdbc.Driver username: root password: root jpa: show-sql: true database: mysql hibernate: ddl-auto: update cache: #设置项目中使用的缓存类型 type: redis redis: host: 172.20.10.8 port: 6379 database: 0 #password:
3.控制层接口
@RestController @RequestMapping("/user") public class UserController { @Autowired private UserService userService; @GetMapping("/{id}") public ResponseEntity<User> findById(@PathVariable Long id) { User user = userService.findById(id); HttpStatus status = user == null ? HttpStatus.NOT_FOUND : HttpStatus.OK; return new ResponseEntity<>(user, status); } @PostMapping public User addUser(@RequestBody User user) { return userService.addUser(user); } @PutMapping public User updateUser(@RequestBody User user) { return userService.updateUser(user); } @DeleteMapping("/{id}") public String deleteById(@PathVariable Long id) { userService.deleteById(id); return "success"; } }
4.业务处理
@Service public class UserServiceImpl implements UserService { @Autowired private UserRepository userRepository; /** * @Cacheable:作用在查询方法上. "value"是redis缓存的key的前缀,"key"是缓存的具体的key的值;---->redis的key=user_02 * 该注解会把当前方法的返回值缓存起来! * redis缓存的形式为:key-value * #: SpEL表达式,用来取参数的值或者取出系统中自带的对象的值! * unless = "#result eq null ":当result结果为null的时候不进行缓存! */ @Cacheable(value = "user_", key = "#id", unless = "#result eq null") @Override public User findById(Long id) { //Optionaloptional = userRepository.findById(id); //User user = optional.get(); //return optional.orElse(new User()); //userRepository.findAll(Sort.by(Sort.Direction.DESC,"id","name")); return userRepository.findById(id).orElse(null); } /** * 添加方法:当往mysql数据库中添加新数据的时候,一般不需要往redis缓存中做任何操作! * 缓存预热: * 注意:value和key的值不能为空! */ @CachePut(value = "user_", key = "#result.id") @Override public User addUser(User user) { return userRepository.save(user); } /** * 双写一致性: * 缓存更新. * CacheEvict:用在删除方法上面,用来清除某个redis的缓存 */ @CacheEvict(value = "user_", key = "#id") @Override public void deleteById(Long id) { userRepository.deleteById(id); } /** * @CachePut:用在添加或者更新方法上面,用来更新redis缓存! */ @CachePut(value = "user_", key = "#user.id", unless = "#result eq null") @Override public User updateUser(User user) { return userRepository.saveAndFlush(user); } }
5.RedisCacheConfig
@Configuration @EnableCaching public class RedisCacheConfig { @Value("${cache.default-exp}") private long exps; @Value("${spring.redis.host}") private String host; @Value("${spring.redis.port}") private int port; //@Value("${spring.redis.timeout}") //private int timeout; //@Value("${spring.redis.password}") //private String password; /** * 设置redis中key的生成规则 */ @Bean public KeyGenerator keyGenerator() { return new KeyGenerator() { @Override public Object generate(Object target, Method method, Object... params) { StringBuffer sb = new StringBuffer(); sb.append(target.getClass().getName()); sb.append(method.getName()); for (Object obj : params) { sb.append(obj.toString()); } return sb.toString(); } }; } /** * RedisTemplate配置 */ @Bean public RedisTemplate<?, ?> redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<Object, Object> template = new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值 Jackson2JsonRedisSerializer<JSON> serializer = new Jackson2JsonRedisSerializer<>(JSON.class); ObjectMapper mapper = new ObjectMapper(); mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); serializer.setObjectMapper(mapper); template.setValueSerializer(serializer); template.setHashValueSerializer(serializer); // 使用StringRedisSerializer来序列化和反序列化redis的key值 template.setKeySerializer(new StringRedisSerializer()); //使得上面的配置生效 template.afterPropertiesSet(); return template; } @Bean public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { // 生成一个默认配置，通过config对象即可对缓存进行自定义配置 RedisSerializer<String> redisSerializer = new StringRedisSerializer(); // 使用Jackson2JsnRedisSerializer来序列化和反序列化redis的value值 Jackson2JsonRedisSerializer<JSON> serializer = new Jackson2JsonRedisSerializer<>(JSON.class); // 配置序列化 RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig(); config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer)); config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer)); // 设置缓存的默认过期时间 config.entryTtl(Duration.ofSeconds(exps)); // 不缓存空值 config.disableCachingNullValues(); return RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config).build(); } }
6.业务处理
@Service public class UserServiceImpl implements UserService { @Autowired private UserRepository userRepository; /** * @Cacheable:作用在查询方法上. "value"是redis缓存的key的前缀,"key"是缓存的具体的key的值;---->redis的key=user_02 * 该注解会把当前方法的返回值缓存起来! * redis缓存的形式为:key-value * #: SpEL表达式,用来取参数的值或者取出系统中自带的对象的值! * unless = "#result eq null ":当result结果为null的时候不进行缓存! */ @Cacheable(value = "user_", key = "#id", unless = "#result eq null") @Override public User findById(Long id) { //Optionaloptional = userRepository.findById(id); //User user = optional.get(); //return optional.orElse(new User()); //userRepository.findAll(Sort.by(Sort.Direction.DESC,"id","name")); return userRepository.findById(id).orElse(null); } /** * 添加方法:当往mysql数据库中添加新数据的时候,一般不需要往redis缓存中做任何操作! * 缓存预热: * 注意:value和key的值不能为空! */ @CachePut(value = "user_", key = "#result.id") @Override public User addUser(User user) { return userRepository.save(user); } /** * 双写一致性: * 缓存更新. * CacheEvict:用在删除方法上面,用来清除某个redis的缓存 */ @CacheEvict(value = "user_", key = "#id") @Override public void deleteById(Long id) { userRepository.deleteById(id); } /** * @CachePut:用在添加或者更新方法上面,用来更新redis缓存! */ @CachePut(value = "user_", key = "#user.id", unless = "#result eq null") @Override public User updateUser(User user) { return userRepository.saveAndFlush(user); } }//使得上面的配置生效 template.afterPropertiesSet(); return template; } @Bean public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { // 生成一个默认配置，通过config对象即可对缓存进行自定义配置 RedisSerializerredisSerializer = new StringRedisSerializer(); // 使用Jackson2JsnRedisSerializer来序列化和反序列化redis的value值 Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer<>(JSON.class); // 配置序列化 RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig(); config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer)); config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer)); // 设置缓存的默认过期时间 config.entryTtl(Duration.ofSeconds(exps)); // 不缓存空值 config.disableCachingNullValues(); return RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config).build(); } }
6.业务处理
@Service public class UserServiceImpl implements UserService { @Autowired private UserRepository userRepository; /** * @Cacheable:作用在查询方法上. "value"是redis缓存的key的前缀,"key"是缓存的具体的key的值;---->redis的key=user_02 * 该注解会把当前方法的返回值缓存起来! * redis缓存的形式为:key-value * #: SpEL表达式,用来取参数的值或者取出系统中自带的对象的值! * unless = "#result eq null ":当result结果为null的时候不进行缓存! */ @Cacheable(value = "user_", key = "#id", unless = "#result eq null") @Override public User findById(Long id) { //Optionaloptional = userRepository.findById(id); //User user = optional.get(); //return optional.orElse(new User()); //userRepository.findAll(Sort.by(Sort.Direction.DESC,"id","name")); return userRepository.findById(id).orElse(null); } /** * 添加方法:当往mysql数据库中添加新数据的时候,一般不需要往redis缓存中做任何操作! * 缓存预热: * 注意:value和key的值不能为空! */ @CachePut(value = "user_", key = "#result.id") @Override public User addUser(User user) { return userRepository.save(user); } /** * 双写一致性: * 缓存更新. * CacheEvict:用在删除方法上面,用来清除某个redis的缓存 */ @CacheEvict(value = "user_", key = "#id") @Override public void deleteById(Long id) { userRepository.deleteById(id); } /** * @CachePut:用在添加或者更新方法上面,用来更新redis缓存! */ @CachePut(value = "user_", key = "#user.id", unless = "#result eq null") @Override public User updateUser(User user) { return userRepository.saveAndFlush(user); } }
