Redis基础与使用SpringBoot整合Redis
Redis进阶学习之数据持久化
Redis进阶学习之主从复制、读写分离
Redis进阶学习之哨兵模式和分片集群
Redis主从复制集群搭建
Redis哨兵集群搭建
Redis分片集群搭建
Redis使用RedisTemplate配置和访问集群
Redis缓存策略
Redis缓存异常场景分类
NoSQL最常见的解释是“non-relational”, “Not Only SQL”也被很多人接受。NoSQL仅仅是一个概念,泛指非关系型的数据库,区别于关系数据库,它们不保证关系数据的ACID特性。
单机MYSQL的年代
------->
缓存(Memcached) + MySQL+ 垂直拆分(读写分离)
------->
分库分表 + 水平拆分(表行的拆分) + MySQL 集群
MySQL最初使用MyISAM引擎: (表锁(100万条数据)) ,十分影响效率!;高并发下就会出现严重的锁问题,之后使用 Innodb引擎(行锁),慢慢的就开始使用分库分表来解决写的压力
------->
随着互联网web2.0网站的兴起,传统的关系型数据库无法进行分析处理。MySQL等关系型数据库不够用了,数据量很多, 变化很快
用户的个人信息, 社交网络, 地理位置, 用户自己产生的数据, 用户日志等等爆发式增长!
这时候我们就需要使用NoSQL数据库。
NoSQL数据库种类繁多,但是一个共同的特点都是去掉关系数据库的关系型特性。数据之间无关系,这样就非常容易扩展。无形之间,在架构的层面上带来了可扩展的能力。
NoSQL数据库都具有非常高的读写性能,尤其在大数据量下,同样表现优秀。这得益于它的无关系性,数据库的结构简单。一般MySQL使用Query Cache。NoSQL的Cache是记录级的,是一种细粒度的Cache,所以NoSQL在这个层面上来说性能就要高很多。
NoSQL无须事先为要存储的数据建立字段,随时可以存储自定义的数据格式。而在关系数据库里,增删字段是一件非常麻烦的事情。如果是非常大数据量的表,增加字段简直就是——个噩梦。这点在大数据量的Web 2.0时代尤其明显。
NoSQL在不太影响性能的情况,就可以方便地实现高可用的架构。比如Cassandra、HBase模型,通过复制模型也能实现高可用。
Redis(Remote Dictionary Server ),即远程字典服务,是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。Redis根本是使用内存存储。
代码如下(示例):
// 拉取redis镜像
docker pull redis:latest
// 在6379端口启动redis容器
docker run -itd --name redis -p 6379:6379 redis
// 通过exec命令对redis的容器执行bash并使用redis-cli 访问redis容器
docker exec -it redis /bin/bash
redis-cli
可合并为:docker exec -it redis redis-cli
String类型的value除了是字符串还可以是数字
- 通过get [key]获取[value]值,set [key] [value]添加键值对
- 通过getset在获取值的时候设置新值
例如图中getset key2 value2 ,redis中不存在key2的[key],则会返回nil并添加key2的[key]及其[value];
当再次访问时可以查看新赋值的[value];
当存在key2的键,使用getset key2 value3会返回value2,之后再查询key2的[value]值时可以看到新的值为value3
List是简单的字符串列表,按照插入顺序排序。可以添加一个元素到列表的头部(左边)或者尾部(右边)
(1)添加和查看操作
// 添加一个list 并从左部按顺序插入
127.0.0.1:6379> lpush list one
(integer) 1
127.0.0.1:6379> lpush list two
(integer) 2
127.0.0.1:6379> lpush list three
(integer) 3
127.0.0.1:6379> lpush list four
(integer) 4
// 查看list 0到3的值
127.0.0.1:6379> lrange list 0 3
1) "four"
2) "three"
3) "two"
4) "one"
// 可以使用lrange list 0 -1查看全部
127.0.0.1:6379> lrange list 0 -1
1) "four"
2) "three"
3) "two"
4) "one"
// 从右部插入一个值并查看list
127.0.0.1:6379> rpush list zero
(integer) 5
127.0.0.1:6379> lrange list 0 -1
1) "four"
2) "three"
3) "two"
4) "one"
5) "zero"
// 查看list长度
127.0.0.1:6379> llen list
(integer) 5
// 查看下标为0的value(左边)
127.0.0.1:6379> lindex list 0
"four"
// 查看list是否存在
127.0.0.1:6379> exists list
(integer) 1
127.0.0.1:6379> exists list3
(integer) 0
(2) lset更新
// 根据下标更新value
127.0.0.1:6379> LRANGE list 0 -1
1) "zero"
2) "five"
3) "four"
4) "three"
127.0.0.1:6379> lset list 0 six
OK
(3)linsert在指定value后面插入值
127.0.0.1:6379> LRANGE list 0 -1
1) "six"
2) "five"
3) "four"
4) "three"
127.0.0.1:6379> linsert list before three two
(integer) 5
127.0.0.1:6379> LRANGE list 0 -1
1) "six"
2) "five"
3) "four"
4) "two"
5) "three"
127.0.0.1:6379> linsert list after two one
(integer) 6
127.0.0.1:6379> LRANGE list 0 -1
1) "six"
2) "five"
3) "four"
4) "two"
5) "one"
6) "three"
(4) lpop和rpop删除
// 移除头部(左边两个元素),移除尾部(右边)一个值
127.0.0.1:6379> lpop list 2
1) "four"
2) "three"
127.0.0.1:6379> rpop list
"zero"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
(5)使用lrem删除指定value
从左到右删除几个指定的value值
lrem list [count] [value]
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "three"
4) "two"
5) "one"
127.0.0.1:6379> lrem list 1 three
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "three"
3) "two"
4) "one"
127.0.0.1:6379> lrem list 2 two
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "one"
127.0.0.1:6379> lpush list one
(integer) 3
127.0.0.1:6379> lpush list one
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "one"
2) "one"
3) "three"
4) "one"
127.0.0.1:6379> lrem list 2 one
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "one"
(6) rpoplpush删除list尾部的值存到新list中
127.0.0.1:6379> LRANGE list 0 -1
1) "zero"
2) "five"
3) "four"
4) "three"
5) "two"
127.0.0.1:6379> rpoplpush list list2
"two"
127.0.0.1:6379> LRANGE list 0 -1
1) "zero"
2) "five"
3) "four"
4) "three"
127.0.0.1:6379> LRANGE list2 0 -1
1) "two"
(7)ltrim截取
127.0.0.1:6379> LRANGE list 0 -1
1) "zero"
2) "five"
3) "four"
4) "three"
5) "two"
6) "one"
// 从下标0截取到下标4
127.0.0.1:6379> ltrim list 0 4
OK
127.0.0.1:6379> LRANGE list 0 -1
1) "zero"
2) "five"
3) "four"
4) "three"
5) "two"
(1)Set添加操作
127.0.0.1:6379> sadd set one
(integer) 1
127.0.0.1:6379> sadd set two
(integer) 1
127.0.0.1:6379> sadd set three
(integer) 1
// set中的值是无序
127.0.0.1:6379> smembers set
1) "one"
2) "three"
3) "two"
// set中的值不能重复的
127.0.0.1:6379> sadd set three
(integer) 0
127.0.0.1:6379> smembers set
1) "one"
2) "three"
3) "two"
(2)Set 查看操作
// smembers :查看set数据
127.0.0.1:6379> smembers set
1) "one"
2) "three"
3) "two"
// 查看某个值是不是在Set集合中
127.0.0.1:6379> sismember set four
(integer) 0
127.0.0.1:6379> sismember set one
(integer) 1
// 查看Set集合的大小
127.0.0.1:6379> scard set
(integer) 3
(3)移除操作
// 移除set集合中的one成员
127.0.0.1:6379> srem set one
(integer) 1
127.0.0.1:6379> smembers set
1) "three"
2) "two"
// 随机在set在取值一个成员
127.0.0.1:6379> SRANDMEMBER set
"two"
127.0.0.1:6379> SRANDMEMBER set
"three"
// 随机在set集合中删除一个成员
127.0.0.1:6379> spop set
"three"
127.0.0.1:6379> smembers set
1) "two"
// smove 将set中的two成员移到set2中
127.0.0.1:6379> smembers set
1) "one"
2) "three"
3) "two"
127.0.0.1:6379> smove set set2 two
(integer) 1
127.0.0.1:6379> smembers set
1) "one"
2) "three"
127.0.0.1:6379> smembers set2
1) "two"
(4)差集、交集和并集
127.0.0.1:6379> smembers set
1) "one"
2) "three"
127.0.0.1:6379> smembers set2
1) "one"
2) "two"
// sdiff 找出set集合与set2集合不一样的成员
127.0.0.1:6379> sdiff set set2
1) "three"
// sinter 找出set集合与set2集合一样的成员
127.0.0.1:6379> sinter set set2
1) "one"
// sunion set集合和set2集合的并集
127.0.0.1:6379> sunion set set2
1) "one"
2) "three"
3) "two"
Map 集合,多个Key-Value组合的Map
(1)添加操作
// 添加一个key-value
27.0.0.1:6379> hset myhash field1 value1
(integer) 1
// 添加多个key-value
127.0.0.1:6379> hmset myhash field1 value1 field2 value2
OK
// 在Redis 4.0.0,HMSET被视为已弃用。使用HSET 添加多个key-value
127.0.0.1:6379> hset myhash field3 value3 field4 value4
(integer) 2
(2)查看操作
// hget 查看myhash哈希表中field 为field1的value值
127.0.0.1:6379> hget myhash field1
"value1"
// 查看多个key
127.0.0.1:6379> hmget myhash field1 field2
1) "value1"
2) "value2"
// hgetall 查看myhash 哈希表的所有值
127.0.0.1:6379> hgetall myhash
1) "field1"
2) "value1"
3) "field2"
4) "value2"
5) "field3"
6) "value3"
7) "field4"
8) "value4"
// 查看myhash的长度
127.0.0.1:6379> hlen myhash
(integer) 4
// 查看myhash中某个field 是否存在
127.0.0.1:6379> HEXISTS myhash field2
(integer) 1
127.0.0.1:6379> HEXISTS myhash field5
(integer) 0
(3)hdel 删除操作
127.0.0.1:6379> hdel myhash field1
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "value2"
3) "field3"
4) "value3"
5) "field4"
6) "value4"
(4)HINCRBY 对某个field 的value值增加指定长度
127.0.0.1:6379> HSET MYHASH FIELD5 5
(integer) 1
127.0.0.1:6379> HINCRBY MYHASH FIELD5 1
(integer) 6
127.0.0.1:6379> hgetall MYHASH
1) "FIELD5"
2) "6"
比较HASH中两个不同的插入HSET 和 HSETNX :
- HSET 将哈希表 key 中的域 field 的值设为 value 。如果 key 不存在,一个新的哈希表被创建并进行 HSET 操作,返回 1 。如果域 field 已经存在于哈希表中,旧值将被覆盖,返回 0。
- HSETNX 将哈希表 key 中的域 field 的值设置为 value。若域 field 已经存在,该操作无效,返回 0;如果 key 不存在,一个新哈希表被创建并执行 HSETNX 命令,返回 1。
(1)添加操作
127.0.0.1:6379> zadd myzset 1 one
(integer) 1
127.0.0.1:6379> zadd myzset 2 two
(integer) 1
127.0.0.1:6379> zadd myzset 3 three
(integer) 1
127.0.0.1:6379> zadd myzset 2 two1
(integer) 1// 同个位置则有添加先后
127.0.0.1:6379> zrange myzset 0 -1
1) "one"
2) "two"
3) "two1"
4) "three"
(2)查看操作
// 查看myzset所有值(默认从小到大)
127.0.0.1:6379> zrange myzset 0 -1
1) "one"
2) "two"
3) "two1"
4) "three"
// 从小到大查看myzset
127.0.0.1:6379> ZRANGEBYSCORE myzset -inf +inf
1) "one"
2) "two"
3) "two1"
4) "three"
// 从大到小查看myzset
127.0.0.1:6379> ZREVRANGE myzset 0 -1
1) "three"
2) "two1"
3) "two"
4) "one"
// 从小到大查看myzset,带上value值
127.0.0.1:6379> ZRANGEBYSCORE myzset -inf +inf withscores
1) "one"
2) "1"
3) "two"
4) "2"
5) "two1"
6) "2"
7) "three"
8) "3"
// 查看value值小于等于2的集合
127.0.0.1:6379> ZRANGEBYSCORE myzset -inf 2 withscores
1) "one"
2) "1"
3) "two"
4) "2"
5) "two1"
6) "2"
// 查看myzset大小
127.0.0.1:6379> zcard myzset
(integer) 3
// 查看某区间的数据数量
127.0.0.1:6379> zcount myzset 1 2
(integer) 2
(3)删除操作
// 删除myzset中two1的数据
127.0.0.1:6379> zrem myzset two1
(integer) 1
127.0.0.1:6379> zrange myzset 0 -1
1) "one"
2) "two"
3) "three"
Redis HyperLogLog 是用来做基数统计的算法,HyperLogLog 的优点是,在输入元素的数量或者体积非常非常大时,计算基数所需的空间总是固定 的、并且是很小的。
什么是基数?
比如数据集 {1, 3, 5, 7, 5, 7, 8}, 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内,快速计算基数
127.0.0.1:6379> pfadd mypf a b c d
(integer) 1
127.0.0.1:6379> pfadd mypf2 a b e f
(integer) 1
127.0.0.1:6379> PFCOUNT mypf
(integer) 4
127.0.0.1:6379> PFCOUNT mypf2
(integer) 4
// 合并产生新的基数集为不重复的数
127.0.0.1:6379> PFMERGE mypf3 mypf mypf2
OK
127.0.0.1:6379> PFCOUNT mypf3
(integer) 6
Redis 事务可以一次执行多个命令, 并且带有以下三个重要的保证:
一个事务从开始到执行会经历以下三个阶段:开始事务;命令入队;执行事务。
(1)开启、执行和取消事务
// 开启事务,将执行加入事务队列中,exec执行所有指令
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> get k1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) "v1"
3) OK
4) "v2"
// DISCARD取消事务,加入事务中的队列都不会被执行
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> DISCARD
OK
127.0.0.1:6379> get k3
(nil)
127.0.0.1:6379> get k4
(nil)
(2)异常
127.0.0.1:6379> MULTI
OK
// 队列存在使用不存在的指令执行队列时所有指令都不会被执行(编译型异常)
127.0.0.1:6379(TX)> set k1
(error) ERR wrong number of arguments for 'set' command
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> get k1
QUEUED
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> set k1 "v1"
QUEUED
127.0.0.1:6379(TX)> get k1
QUEUED
// 正确的指令,但k1不是增量,会报错,不影响队列中其它指令(运行时异常)
127.0.0.1:6379(TX)> incr k1
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) "v1"
3) (error) ERR value is not an integer or out of range
当有多个线程同时抢购时,会发生超发现象。
超发现象:共享数据被多个线程所修改,无法保证其执行顺序。则会导致扣除的库存大于实际库存。
解决超发现象:如果一个事务读取到数据之后,就将数据直接锁定,不允许其他线程操作,直至当前数据库事务完成才释放这条数据的锁。但是执行效率性能将大大下降。
乐观锁不加锁,通过CAS(Compare And Swap)操作来实现线程安全。
CAS执行流程:获取一个数据库存,处理业务,在更新库存的时候判断当前的库存和之前获取的库存是否一致,一致则扣库存执行操作,否则结束。
CAS流程会产生ABA问题:
ABA:线程1和线程2获取的库存都是A,线程1扣完库存之后,库存为B,此时线程2以B作为最新库存进行扣除,但此时线程1又取消扣库存,此时的库存又变回A,导致线程2读取的库存错误。
----->>解决此问题的方法可以加入版本号的限制,只要在操作过程中修改库存,无论业务正常,回退,还是异常,版本号只能递增,不能回退递减,每次通过比较数据的版本号来查看此数据是否被修改过。
------>>但加入版本号限制导致大量的请求失败,请求失败会重新请求直至成功,这个过程会造成大量的SQL查询。一般可以使用限制时间或者重入次数的方法。
开启两个窗口访问redis,
// 对watch_key 进行监控(监控早于下一个事务)
127.0.0.1:6379> set watch_key 10
OK
127.0.0.1:6379> get watch_key
"10"
127.0.0.1:6379> watch key
OK
127.0.0.1:6379> multi
OK
// 更新watch_key,执行事务成功
127.0.0.1:6379(TX)> set key 11
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
// 对watch_key 进行监控,上一个事务已为watch_key进行监控,不能再对watch_key进行更新
127.0.0.1:6379> get watch_key
"10"
127.0.0.1:6379> watch key
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key 12
QUEUED
// 执行事务失败
127.0.0.1:6379(TX)> exec
(nil)
Lettuce Redis是Java 客户端的开发包
在SpringBoot2.x之前,使用Jedis作为Java连接开发工具,Jedis采用的直连,实例是非线程安全的,常常通过JedisPool连接池去管理实例( BIO 模式)
在SpringBoot2.x之后使用 lettuce,采用 netty(NIO模式), 实例可以在多个线程中进行共享, 不存在线程不安全的情况,可以减少线程连接池数量。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
spring:
redis:
host: 127.0.0.1
port: 6379
password: 123456
database: 0
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
@Bean
@ConditionalOnMissingBean(
name = {"redisTemplate"}
) // 可以自己定义一个 redisTemplate 来替换这个默认的
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
// 默认的RedisTemplate 没有过多的设置, redis对象都是需要序列化的
// 两个泛型都是Object, Object类型, 我们后使用需要强制转换
RedisTemplate<Object, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
@Bean
@ConditionalOnMissingBean // 由于string 是redis中最常使用的类型, 所以说单独提出来了一个bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}
SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个 StringRedisTemplate。我们开发工程中使用其他类型时需要进行一个类型的转换,所以我们可以自定义一个Redis泛型的模板。
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
// 一般直接使用
RedisTemplate<String, Object> template = new RedisTemplate();
template.setConnectionFactory(factory);
// // Json序列化配置
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// String序列号
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
@Component
public class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
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));
}
}
}
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
* @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代表所有值
* @return
*/
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;
}
}
}
redisTemplate.opsForValue();//操作字符串
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet();//操作set
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForZSet();//操作zset
...
@SpringBootTest
class RedisTests {
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
redisTemplate.opsForValue().set("key","value");
System.out.println(redisTemplate.opsForValue().get("key"));
}
}