星晨羽

狂胜——Redis学习笔记

【狂神说Java】Redis最新超详细版教程通俗易懂_哔哩哔哩_bilibili

总体大纲outline

nosql讲解，非关系型数据库

阿里巴巴架构演进

nosql数据模型

Nosql四大分类

CAP

BASE

Redis入门

五大基本类型

String
List
Set
Hash
Zset

三种特殊数据类型

geo
hyprologlog
bitmap

Redis配置文件如何读取
Redis持久化

Redis的一些事务操作
Redis实现订阅发布

消息队列

Redis主从复制

哨兵模式，现在公司中所有的集群都采用哨兵模式

缓存穿透，以及解决方式
缓存雪崩，以及雪崩方式，微服务一环套一环，可能会导致雪崩
基础API之jedis详情
SpringBoot集成Redis操作
Redis的实践分析

Nosql

大数据时代，一般的数据库无法进行分析处理了Hadoop

单机SQL时代，更多使用静态网页

如果数据量过大，一个机器放不下
数据量超过300万时一定要创建索引，数据库现在使用B+Tree，一个机器的内存也放不下
数据库访问量比较大，一开始是读写混合的，一个服务器也承受不了

出现这三种情况，就需要升级，但是如果没有这么大的数据量，应该从单机开始

Memcached缓存+MySQL+垂直拆分（读写分离）
网站百80%的操作都是在读，减轻数据库的压力可以使用缓存提高效率，缓存使用什么技术都没所谓

发展过程，先是优化数据结构和索引–文件缓存（IO操作）–Memcached（当时最热门的技术）

分库分表+水平拆分+M有SQL集群
使用缓存解决了读的问题，用分集群的方式解决读的问题，数据存在不同的库中

早些年，MySAM使用表锁，读取一行要将整个表锁起来，十分影响效率，高并发下会出现严重问题

后来转为innodb 行锁

慢慢的就开始使用分库分表来解决写的压力，将表拆分，不同的业务使用不同表，存放在不同的数据库中，不同的业务使用单独的数据库，结合微服务，mysql推出了表分区，但是很少公司使用

Mysql的集群已经满足了那个年代的需求

最近的年代
定位也是一种数据，Mysql的关系型数据库已经不够用了，数据量多，变化快，

非关系型数据库

Json
Bson
图型数据库

放在缓存中一段时间之后再进行持久化的操作，来保证效率和安全

存储很大的文件，会导致数据表很大效率会变低，如果有一种专门的数据库来处理这种数据Mysql压力就会变得十分小，研究如何处理这些问题

如果数据量变大，要在对数据库进行更改，增加一行是很难的

用户先访问企业防火墙，到负载均衡的主机，到App服务器，到mysql实例，然后是独立功能的服务器

最后总结为什么要用NoSQL

用户的个人信息、社交网络、地理位置、用户自己生产的数据、用户日志等等数据爆发式的生长，

NoSQL=Not Only SQL 不仅仅是SQL

泛指非关系型数据库，Web2.0的诞生，传统的关系型数据库很难对付Web2.0时代，尤其是超大规模的高并发的社区，

NoSQL在大数据环境下发展十分迅速

要存储的数据不是固定格式，以键值对来控制，Map< String , Object >,数据之间没有关系就很好扩展，Java现在要做面向接口编程也是为了解耦，

使用Redis也是为了高性能，官方的数据读取速度每秒11w次，写8w次

数据类型是多样性的，不需要事先设计数据库，不需要设计键值对，随取随用

传统的RDBMS和NoSQL

传统的RDBMS

结构化组织
sql
数据和关系都存储在表中 row column
数据定义语言
严格的一致性
基础的事务
。。。。

NoSQL

不仅仅是数据
没有固定查询语言
很多的存储方式，列存储、文档存储、图形存储（社交关系）
可以不用满足严格一致性，数据是可以有误差的，要保证的是最终一致性
CAP定理，和BASE理论
高性能、高可用、高可扩展

大数据时代的3V和3高
大数据时代的3V，主要是描述问题的

海量的Volume
多样的Variety
实时Velocity

大数据时代的3高，主要是对程序的要求

高并发
高可拓（随时水平拆分，机器不足，可用扩展来）
高性能

真正在公司中实践一定是：NoSQL+RDBMS一起使用才是最好的

阿里巴巴框架演进

第五代架构改进

敏捷开发
极限编程

业务快速增长，每天都要上线大量的小需求
应用系统日益膨胀，耦合恶化，架构越来越复杂，带来更高的开发成本，如何保持业务开发的敏捷性

开放，提升网站的开放性，吸引第三方开发者加入网站的建设
体验，网站并发压力快速增长，用户对体验提出了更高的要求

使用了各种数据库，这么多种类型的数据库导致数据架构非常复杂，要简化架构，增加一层就行，像是jdbc一样，
商品中的信息存在不同的数据库中
商品的基本信息
名称、价格、商家信息：

关系型数据库就可以解决 MySQL / Oracle
淘宝早些年就去IOE了，去掉IBM小型机，Oracle数据库，EMC存储设备

商家的描述、评论（文字比较多）

文档型数据库，MongoDB，

图片

分布式文件系统，FastDFS
淘宝自己的TFS
Google的GFS
Hadoop HDFS
阿里云的 oss

商品的关键字
搜索引擎

solr
elasticsearch
淘宝用的是 Isearch

商品热门的波段信息

内存数据库
Redis 、Tair 、Memacache

商品的交易，外部支付接口

第三方应用

大型互联网应用问题：

数据类型太多
数据源繁多，经常重构
数据要改造，大面积改造

阿里的解决方案

统一数据服务层UDSL，在网站应用集群和底层数据源之间，构建一层代理，统一数据层

模型数据映射

实现业务模型各属性与底层不同类型数据源的模型数据映射

统一的查询和更新API

提供了基于业务模型的统一的查询和更新的API，简化网站应用跨不同数据源的开发模式
性能优化

设计了一套统一的DSL，提供了统一的增删改查的API，开发速度问题是解决了，但是性能还是问题

网站数据庞大，只能缓存热点数据，解决方案，开发热点缓存平台，提供UDSL作为缓存系统

以上都是NoSQL入门概述

NoSQL的四大分类

KV键值对

新浪：Redis
美团：Redis+Tair
阿里，百度：Redis+memecache

文档型数据库（Bson格式和Json格式）

MongoDB
- MongoDB是一个基于分布式文件存储的数据库，C++编写，用来处理大量的文档
- MongoDB是一个介于关系型数据库和非关系型中间的产品，非关系型数据库中功能最丰富的，最像关系型数据库的
ConthDB

列存储数据库

HBase
分布式文件系统

图形关系数据库

不是用来存放图形的，是用来寸关系的，朋友圈社交，广告推荐
Neo4j，InfoGrid

Redis入门

Redis （Remote Dictionary Server），远程字典服务

开源、使用C语言编写，支持网络、基于内存可持久化的日志型，Key-Value数据库，提供多种语言的API，可以用多种语言调用，NoSQL技术之一，也被称之为结构化数据库之一

读的速度是11w，写的速度是8w

Redis能干嘛

内存存储，持久化，内存是断电即失的，持久化很重要，持久化有两种机制（RBD，AOF）
效率高，可以用于高速缓存
发布订阅系统
地图信息分析
计数器，（浏览量）
。。。

特性

多样的数据类型
持久化
集群
事务
。。

常用网站

Redis官网 https://redis.io
Redis中文网https://www.redis.net.cn

windows启动Redis

安装Redis

brew install redis
//安装redis
brew info redis
//查看软件详细信息，以来关系，注意事项等
brew list redis
安装包所在的位置

启动Redis

redis-server

启动之后不要关闭
连接测试

redis-cli

默认端口是6379
基本操作

Redis推荐使用Linux开发
好吧这里加入了Linux的知识，要开始学习Linux
退出Redis

redis-cli shutdown

CentOS7 安装Redis

常用的命令

netstat -lnpt ｜grep 6379
//查看6379=端口占用情况，netstat CentOS不自带，需要另外安装
yum install -y net-tools

kill -9 [PID]
//结束对应PID进程

ln -s /usr/local/redis/bin/redis-cli /usr/bin/redis
//创建链接，使之可以直接使用/bin之中的命令，这创建应该回到～目录进行创建，称为命令软链接

cp /usr/local/redis-5.0.3/redis.conf /usr/local/redis/bin/
//复制操作

make install PREFIX=/usr/local/redis
//安装到指定目录

 tar -zxvf redis-5.0.3.tar.gz
 //解压
 
 wget http://download.redis.io/releases/redis-5.0.3.tar.gz
 //通过链接下载

主要操作

不同版本的redis有不同的操作，选择高版本的redis，基本就只是解压，安装，选择配置文件启动

make install
make uninstall

Linux启动

退出

Redis测试性能

在/usr/local/bin 下有很多工具

benchmark压力测试工具，官方自带的性能测试工具

-h 指定服务器主机名
-p 指定服务器端口
-c 指定并发连接数
-n 指定请求数

测试100个并发，每个并发100000个请求

redis-benchmark  -p 6379 -c 100 -n 10000
不加-h 就默认本机

解读测试数据

10000个set请求使用0.17秒
每次请求都有100个并行的客户端
每次写入三个字符串
只有一台服务器来连接
下面的是每毫秒处理百分之多少的请求，
每秒能处理五万多次请求

基础知识
Redis是单线程的，Redis是基于内存操作的，CPU不是Redis的瓶颈，根据机器的内存和网络带宽的，可以用单线程实现

每秒10w+的QPS，完全不比使用key-value的Memecache差

单线程Redis

误区1，高性能服务器一定是多线程
误区2，多线程一定比单线程效率高
多线程要涉及CPU的上下文切换
核心：Redis是将所有数据全部放到内存中去操作，效率就是高，CPU上下文切换是耗时的操作，对于系统来说没有上下文切换，系统效率就是最高的，多次读写都是在一个cpu上的，在内存情况下效率就是最高的

Redis五大数据类型

String
List
Set
Hash
Zset

Redis官方介绍

Redis是内存中的数据结构存储系统，可以作用数据库、缓存、消息中间MQ
支持多种数据类型

String字符串
hash散列
list列表
set 集合
sorted sets有序集合
bimemaps
hyperloglog
geospatial

Redis内置了主从复制replication、LUAscripting脚本，LRU 驱动事件，transactions事务，和不同级别的磁盘持久化persistence
通过Redis哨兵Sentinel，和自动分区Cluster，提供高可用性high availability
Redis

redis-server &
#后台启动
redis-server   /etc/local/bin/redis.conf
#指定文件启动
-p
#指定端口启动

keys * 查询全部key
select 3 切换数据库3
dbsize 查看数据库大小
flushdb 清空当前库
flushall 清空所有数据
exists 判断某个key是否存在 EXISTS name
move 移除key move name 1
expire 设置过期时间，可以用作单点登录 expire name 10 10秒后过期
ttl 查看过期时间 EXISTS name
type 查看key的类型 type name
config set requirepass XXX 设置密码
config set requirepass “” 取消密码
auth xxx 登录

String

append 追加value

追加不存在的key会set key
strlen 查看value长度

incr xc 自增1，可以用作增加浏览量increase

decr xc 递减1

incrby 能设置自增量的自增 incrby xc 12 decrby xc 12

getrange 截取范围，下标从0开始 getrange xc 0 2 取xc第一到第三的数 getrange xc 0 -1 全部

setrange 修改范围的值 setrange xc 1 22 123456变122456

setex （set wth expire）设置key时顺便设置生存时间 setex xc aaa 30

setnx （ set if not exist ）参数不存在就设置，在分布式锁经常使用，如果存在就创建失败.

setex xc aa

mset 批量设置,空格间隔 mset xc1 1 xc2 2 xc3 3

mget mget xc1 xc2 xc3

msetnx 原子性操作，批量设置,要么都成功或失败，nx如果存在就创建失败

对象操作

设置一个对象，值为json字符串来保存一个对象

user:{id}:{filed}

getset 先get再set，规则就按getset来，无论key存不存在，都按getset来

数据结构是相同的

String类似的使用场景：value除了是外面的字符串还可以是我们的数字

计数器
统计多单位的数量
粉丝数
对象缓存存储

List

在Redis中可以将List作为、栈、队列、阻塞队列

实际上是一个链表，left、right 都可以插入值
如果key不存在，创建新的链表
如果key存在，新增value
移除所有值，空链表
在两边插入效率最高，对中间元素操作，效率会降低

消息排队、消息队列、堆、栈

lpush left push
lrange 显示list 范围range
rpush right push

Rpop right pop
Lpop left pop

Llen xc 返回xc集合（list）的长度
lindex list 0 获取list中第一给值
lrem remove指定下标

ltrim list截取保留指定数据

Rpoplpush pop再push到别的list

lset 设置指定下表值

exists 存在
Linsert 将某个具体的value插入到某个元素的前面或后面

Set

集合中的值不能重复，set是无需不重复原则

string和list的元素都是value，set中是member

sadd sadd myset xc像myset中插入xc
smembers 查看集合的全部值
sismember 判断是否存在 SISMEMBER myset xc 判断xc是否存在
scard 获取集合元素个数 scard myset
srem 移除某一个member srem myset myxc 移除myset集合指定myxc
srandmember 随机抽取几个member （srandmember myset）srandmember myset 2

spop 随机删除一个数据 spop myset
smove myset mysets xc2 将myset集合里的xc2移动到mysets里
sdiff difference set 差集，结果来自first_key为基准
sinter intersection set 交集
sunion union联合并集
- 将用户放到set中，共同关注、共同爱好、推荐好友

Hash

map集合，key - map 本质和string类型没有太大区别，还是一个简单的key - value，像是增加了一层

hset hset key field value 存值
hget 取值

hmset 存多个数据
hmget 取多个数据
hgetall 查全部数据

Hdel 删除 hdel myhash xc 删除myhash里的xc数据
hlen hlen myhash 获取myhash字段长度
hexists 判断hash中指定字段是否存在 hexists myhash xc
hkeys 获取key所有的field
hvals 获取所有的value

hincrby 递增，参数设置为负数就是递减
hsetnx 是否存在，不存在就创建设置，存在就不设置

做用户信息保存，比用string类型好点，存储经常变动的信息，hash更适合存储对象，

ZSet（有序集合）

在set的基础上增加了一个值

可以作为一个排行榜功能，进场刷新，或者任务等级排序之类的，都可以做

排序
zrangebyscore

zcard salary 获取salary集合的个数
zconut zcount myset 1 3 获取myset1-3区间的数量

三种特殊数据类型

geospatial
hyperloglog
bitmaps

Geospatial

可以推算地理位置的信息，两地之间的距离，方圆几公里之内的人

需要注意：

地球南北两极无法直接添加，
一般会下载城市数据，直接通过Java程序一次性导入
有效经纬度范围从-180到180，超出范围时会返回错误，
key由（纬度，经度，名称）构成

查看官网，一共有六个相关命令

add、dist、hash、pos、radius、rediusbymember

geodist 返回两个给定位置之间的距离

geohash 返回geohash对位置进行的编码，用于内部调试，一般用不到
geopos 返回指定member的经纬度信息

georadius ：根据半径查找，需要给定中心点数据

georadiusbymember ：也是根据半径查找，但是中心点是已经存在的member

zrange 遍历member
zrem 移除member
纬度经度，member名称，geoadd可以一次添加多个
可以使用geopos读取地理位置
geodist，输出两地距离，加上unit单位，设置输出距离单位
- m、km、mi 英里、ft 英尺
我附近的人功能，通过半径来查询，获取附近的人的定位地址
georadius命令来实现，longitude纬度、latitude经度、radius半径单位，输入查询位置的经纬度就能从key集合中找到在半径范围的元素
后面跟了几个参数，withdist、withcoord、withhash、asc、desc、count
- Withdist：返回元素位置的同时，把与中心之间相差的距离一同返回
- withcoord ：将元素经纬度一同返回
- withhash ：返回经过geohash编码的有序集合分值，主要用于底层调试，作用不大
- asc ：根据中心的位置，从近到远的方式返回位置元素
- desc：从远到近的方式返回元素
- count ：获取前n个匹配元素，对于提高效率是有效的

HyperLogLog

是一种概率数据结构，计数唯一事物，从技术上讲估计一个集合的基数，通常计数唯一项需要使用成比例的内存，因为需要记录使用过的元素，以免多次记录，但是hyperloglog的算法可以用内存换精度，虽然有误差，但是误差小于1%，算法的神奇之处在于只需要很小的内存，最大也不超过12k，类似集合的功能，能记录2^64的计数，从内存的角度来说，hyperloglog是首选

能用在网页的UV

传统方式，set保存用户的id，用户可能是uuid，这样可能占用巨大的内存
但是只是需要计数功能并不需要保存用户的id
pfadd
pfcount 计数
pfmarge 合并 //合并到第一个key

Bitmaps

统计用户信息，活跃与不活跃，登录未登录只有两种状态的数据，可以使用BitMaps

可以用作打卡功能实现，到达一定数目之后进行统计，判断预期数目与统计得出的数目是否达到预期

setbit 中的offset是偏移量，可以看作下标，value只能是0或1
getbit

bitcount 统计key offset 为1的个数 bitcount sign
bitpos 查看 key offset 为0或1的位置，并且可以设置range
bitop 对一个或多个保存二进制位的字符串key进行位元操作，将结果保存在deskkey上
- and、or、not、xor
- 除了not之外，其他都能加入多个key进行运算

事务transition

Redis事务的本质是一组命令的集合，一个事务中所有命令都被序列化，在事务执行过程中，会按照顺序执行！

一次性、顺序性、排他性，一次执行多个指令，其他客户端提交的命令请求不会插入到事务执行命令序列中

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

开启事务（multi）
命令入队（。。。）
执行事务（exec）

取消事务（discard）
监视、加锁（watch）
取消监视、解锁（unwatch）

锁

乐观锁应该适用于读多写少的情况，悲观锁应该适用于写多读少的情况

悲观锁

为了避免其他人同时修改，直接对数据进行加锁以防止并发，修改数据前锁定，修改的方式被称为悲观并发控制 Pessimistic Concurrency Control 悲观、并发、控制
独占性、排他性
在整个数据处理过程中，数据处于锁定状态
线程操作数据，对数据添加排他锁
假设最坏的情况，每次都默认其他线程更改数据
传统数据库使用的几种加锁机制，都是在操作之前上锁
- 行锁
- 表锁
- 读锁
- 写锁
在Java中同步用synchronized关键字实现
悲观锁住要分共享锁和排他锁
- 共享锁 shared locks
  - 读锁、S锁，多个事务对同一个数据可以共享一把锁，都能访问数据，只能读不能修改
- 排他锁 exclusive locks
  - 写锁、X锁、不能与其他锁并存，一个事务获取了数据行的排他锁，其他事物就不能再获得该行的其他锁，获取排他锁的事物可以对数据行读取和修改
悲观并发控制先取锁再访问的保守策略，开销大，还增加死锁的概率，降低并发性，其他事务必须等待

Jedis

官方推荐的操作Redis的中间件，SpringBoot已经有整合RedisTemplate

导入包
建立连接
操作
可关闭连接，或者直接就使用jedis连接池


    redis.clients
    jedis
    3.3.0

测试

package com.xc;

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

/**
 * 星晨
 */
public class TestPing {
	public static void main(String[] args) {
		//1.new Jedis对象即可
		Jedis jedis = new Jedis("127.0.0.1",6379);
		System.out.println(jedis.ping());//连接成功打印PONG

		jedis.flushDB();//清空当前数据

		JSONObject jsonObject = new JSONObject();
		jsonObject.put("hello","world");
		jsonObject.put("name","xingchen");

		//开启事务
		Transaction multi = jedis.multi();
		String result = jsonObject.toJSONString();

		try {
			multi.set("user1",result);
			multi.set("user2",result);
//			int i = 1/0;//代码抛出异常事务，执行失败！

			multi.exec();//执行事务
		} catch (Exception e){
			multi.discard();//放弃事务
			e.printStackTrace();
		} finally {
			System.out.println(jedis.get("user1"));
			System.out.println(jedis.get("user2"));
			jedis.close();//关闭连接
		}


	}
}

SpringBoot整合

SpringBoot操作数据：是封装在Spring-data中的，jpa、jdbc、mongodb、redis

在SpringBoot2.x以后与原来使用的jedis被替换成来看lettuce，底层已经不使用jedis了

jedis：采用的直连，多个线程操作的话，不安全，要提高安全性要使用jedis pool连接池 BIO
lettuce：采用netty，高性能网络框架，异步请求，实例在多线程中可以共享，不存在线程不安全的情况，dubbo底层也是用netty，可以减少线程数量，更像NIO模式


    org.springframework.boot
    spring-boot-starter-data-redis

原理讲解

SpringBoot所有配置类，都会有一个自动配置类

自动配置类都会绑定一个properties配置文件

RedisAutoConfiguation

启动配置类中有一个RedisProperties配置类

里面有很多以前缀spring.redis开头的配置，可以在application中配置

如host、password、、配置

RedisAutoConfiguation中封装了两个Bean

RedisTemplate

@Bean
@ConditionalOnMissingBean(name = "redisTemplate")
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)
      throws UnknownHostException {
   RedisTemplate template = new RedisTemplate<>();
   template.setConnectionFactory(redisConnectionFactory);
   return template;
}

没有过多的设置，Redis的对象都是需要序列化的
两个泛型都是object，后面使用需要强制转换
靠自己重写config来替换这个template

StringRedisTamplate
- 大部分情况下String类型是最常用的，就会多一个stringRedisTemplate

@ConditionalOnMissingBean(name = "redisTemplate")
//重写一个redisTemplate就能替换掉这个bean

整合实现

导入依赖


    org.springframework.boot
    spring-boot-starter-data-redis

配置连接

# 配置Redis
spring.redis.host=127.0.0.1
spring.redis.port=6379

测试

package com.xc;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class Redis02SpringBootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {

        //redisTemplate  操作不同的数据类型，api和我们的指令是一样的
        //opsForValue 操作字符串 类似String
        //opsForList  操作List  类似List
        //opsForSet
        //opsForHash
        //opsForZSet
        //opsForGeo
        //opsForHyperLogLog

        //除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务和基本的CRUD

        //获取redis的连接对象
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushDb();
//        connection.flushAll();

        redisTemplate.opsForValue().set("mykey","xingchen");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }

}

Redis工具类

package com.xc.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    // =============================common============================

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     */
    public boolean expire(String key, long time, TimeUnit timeUnit) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, timeUnit);
            }
            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((Collection) 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);
            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)
     */
    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)
     */
    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
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     */
    public boolean hmset(String key, Map 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 map, long time, TimeUnit timeUnit) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time, timeUnit);
            }
            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, TimeUnit timeUnit) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time, timeUnit);
            }
            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)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }


    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     */
    public Set