Redis操作
Redis事物操作
redis对事务的支持目前还比较简单。redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。 由于redis是单线程来处理所有client的请求的所以做到这点是很容易的。一般情况下redis在接受到一个client发来的命令后会立即处理并 返回处理结果，但是当一个client在一个连接中发出multi命令有，这个连接会进入一个事务上下文，该连接后续的命令并不是立即执行，而是先放到一 个队列中。当从此连接受到exec命令后，redis会顺序的执行队列中的所有命令。并将所有命令的运行结果打包到一起返回给client，然后结束事务上下文。
Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：
- 批量操作在发送 EXEC 命令前被放入队列缓存。
- 收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
- 在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。
Redis 事务特性
数据ACID特性满足了几条？
为了保持简单，redis事务保证了其中的一致性和隔离性；
不满足原子性和持久性；
原子性
redis事务在执行的中途遇到错误，不会回滚所有的命令，而是继续执行后续命令；（违反原子性）
事务可以理解为一个打包的批量执行脚本，但批量指令并非原子化的操作；
中间某条指令的失败不会导致前面已做指令的回滚，也不会造成后续的指令不做；
一个事务从开始到执行会经历以下三个阶段：
- 开始事务(multi)
- 命令入队(.....)
- 执行事务(exec)
正常的提交事务
127. 0.0.1:6379> FLUSHDB
OK
127. 0.0.1:6379> multi #开启事物
OK
#命令入队
127. 0.0.1:6379(TX)> set k1 v1
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)> set k3 v3
QUEUED
127. 0.0.1:6379(TX)> exec #执行事物
1) OK
2) OK
3) "v2"
4) OK
127. 0.0.1:6379>
放弃事物
127. 0.0.1:6379> multi #开启事物
OK
127. 0.0.1:6379(TX)> set k1 v1
QUEUED
127. 0.0.1:6379(TX)> set k2 v2
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 k4 #事物列队命令都不会执行
(nil)
127. 0.0.1:6379>
编译型异常（代码有问题!命令有错!)，事务中所有的命令都不会被执行!
127. 0.0.1:6379> multi
OK
127. 0.0.1:6379(TX)> set k6 v6
QUEUED
127. 0.0.1:6379(TX)> set k7 v7
QUEUED
127. 0.0.1:6379(TX)> getset k8 v8
QUEUED
127. 0.0.1:6379(TX)> getset k9 #错误的命令
(error) ERR wrong number of arguments for 'getset' command
127. 0.0.1:6379(TX)> exec #执行的事物报错
(error) EXECABORT Transaction discarded because of previous errors.
127. 0.0.1:6379> get k6 所有的命令都不会被执行
(nil)
127. 0.0.1:6379>
运行时异常(1/0)，如果事务队列中存在语法性，那么执行命令的时候，其他命令是可以正常执行的，错误命令抛出异常!
127. 0.0.1:6379> FLUSHDB
OK
127. 0.0.1:6379> set k1 "v1"
OK
127. 0.0.1:6379> multi
OK
127. 0.0.1:6379(TX)> incr k1 #运行时会执行失败
QUEUED
127. 0.0.1:6379(TX)> set k2 v2
QUEUED
127. 0.0.1:6379(TX)> set k3 v3
QUEUED
127. 0.0.1:6379(TX)> get k3
QUEUED
127. 0.0.1:6379(TX)> exec
1) (error) ERR value is not an integer or out of range #虽然第一条执行失败，其他的都会依旧执行成功
2) OK
3) OK
4) "v3"
127. 0.0.1:6379> get k2
"v2"
127. 0.0.1:6379>
Redis实现乐关锁
监控 ! Watch
悲观锁：
·很悲观，认为什么时候都会出问题，无论做什么都会加锁!
乐观锁:
·很乐观，认为什么时候都不会出问题，所以不会上锁!更新数据的时候去判断一下，在此期间是否有人修改过这个数据，
Redis测监视测试
127. 0.0.1:6379> FLUSHDB
OK
127. 0.0.1:6379> set money 100
OK
127. 0.0.1:6379> set out 0
OK
127. 0.0.1:6379> watch money #监视money对象
OK
127. 0.0.1:6379> multi #事物正常结束，数据期间没有发生变动，这个时候久正常执行成功
OK
127. 0.0.1:6379(TX)> decrby money 20 #余额减少20
QUEUED
127. 0.0.1:6379(TX)> incrby out 20
QUEUED
127. 0.0.1:6379(TX)> exec
1) (integer) 80
2) (integer) 20
127. 0.0.1:6379> get money
"80"
127. 0.0.1:6379> get out
"20"
测试多线程修改值，使用watch可以当做redis的乐观锁操作!
如何多线程修改失败可以使用
127. 0.0.1:6379> unwatch #1、如里发砚事务执行美败，就先解锁
OK
127. 0.0.1:6379> watch money #获得最新的值，再次监视
OK
127. 0.0.1:6379> multi
OK
127. 0.0.1:6379(TX)> decrby money 10
QUEUED
127. 0.0.1:6379(TX)> incrby out 10
QUEUED
127. 0.0.1:6379(TX)> exec #3.对监视的值是否发生了变化，姆果没有变化,那么可以执行成功,如津要量就执行失败|
1) (integer) 50
2) (integer) 50
127. 0.0.1:6379>
Jedis
什么是edis是Redis官方推荐的java连接开发工具!使用]ava 操作Redis 中间件!如果你要使用java操作redis，
那么一定要对Jedis十分的熟悉生
测试
1,导入对应的依赖
<dependencies>
<!--jedis-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.3.0</version>
</dependency>
<!--fastjson-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.78</version>
</dependency>
<!--配置连接池-->
<dependency>
<groupId>commons-pool</groupId>
<artifactId>commons-pool</artifactId>
<version>1.5.6</version>
</dependency>
</dependencies>
2,编码测试
连接数据库
操作命令
#启动redis服务端即可 cmd：c
public class Test {
public static void main(String[] args) {
Jedis jedis = new Jedis("127.0.0.1",6379);
System.out.println(jedis.ping());
}
}
输出 PING
Jedis配置连接池
public final class RedisPool {
//服务器IP地址
private static String ADDR = "192.168.126.144";
//端口
private static int PORT = 6379;
//密码
private static String AUTH = "";
//连接实例的最大连接数默认值为8 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;
//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
private static int MAX_IDLE = 200;
//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
private static int MAX_WAIT = 10000;
//连接超时的时间
private static int TIMEOUT = 10000;
// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
private static boolean TEST_ON_BORROW = true;
private static JedisPool jedisPool = null;
//数据库模式是16个数据库 0~15
public static final int DEFAULT_DATABASE = 0;
/**
* 初始化Redis连接池
*/
static {
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, null, DEFAULT_DATABASE);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取Jedis实例
*/
public synchronized static Jedis getJedis() {
try {
if (jedisPool != null) {
Jedis resource = jedisPool.getResource();
System.out.println("redis--服务正在运行: " + resource.ping());
return resource;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/***
*
* 释放资源
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedis.close();
}
}
}
}
Jedis工具类
package com.springbootreids.utils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 工具类
*/
public class JedisUtils {
private Jedis jedis;
public JedisUtils(){
JedisPool pool = getPool();
jedis=pool.getResource();
}
public JedisPool getPool(){
JedisPool pool=null;
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxIdle(Integer.parseInt("50"));
config.setMaxTotal(Integer.parseInt("1000"));
config.setMaxWaitMillis((long)Integer.parseInt("3000"));
config.setTestOnBorrow(Boolean.parseBoolean("true"));
config.setTestOnReturn(Boolean.parseBoolean("true"));
config.setTimeBetweenEvictionRunsMillis(-1L);
String ip="127.0.0.1";
int port=6379;
String password="redispass";
pool=new JedisPool(config,ip,port,2000,password);
return pool;
}
public String get(String key){
return jedis.get(key);
}
public String set(String key,String value){
return jedis.set(key,value);
}
public Long del(String... keys){
return jedis.del(keys);
}
/**
* 通过key向指定的value追加值
* @param key
* @param str
* @return
*/
public Long append(String key,String str){
return jedis.append(key,str);
}
public Boolean exist(String key){
return jedis.exists(key);
}
/**
* 设置key-value，若key已存在返回0 则返回1
* @param key
* @param value
* @return
*/
public Long setnx(String key,String value){
return jedis.setnx(key,value);
}
/**
* 设置key-value并指定键值的有效期
* @param key
* @param seconds 以秒为单位
* @param value
* @return
*/
public String setex(String key,int seconds,String value){
return jedis.setex(key,seconds,value);
}
/**
* 从指定的位置替换原先value aa 1 tt ->atta
* 值不存在也会有空格 ee 1 uu->" uu"
* @param key
* @param offset
* @param str
* @return
*/
public Long setrange(String key,int offset,String str){
return jedis.setrange(key,offset,str);
}
/**
* 通过批量keys获取批量values
* @param keys
* @return
*/
public List<String> mget(String... keys){
return jedis.mget(keys);
}
/**
* 批量设置keyvalues，也可以一个 "key","value",..
* @param keyvalues
* @return
*/
public String mset(String... keyvalues){
return jedis.mset(keyvalues);
}
/**
* 批量设置keyvalues，也可以一个 如果key存在则会失败，操作回滚
* @param keyvalues
* @return
*/
public Long msetnx(String... keyvalues){
return jedis.msetnx(keyvalues);
}
/**
* 设置key的值，返回一个旧值，key不存在，也会设置
* @param key
* @param value
* @return
*/
public String getSet(String key,String value){
return jedis.getSet(key,value);
}
/**
* 通过key和指定下标获取指定下标的值
* @param key
* @param startOffset
* @param endOffset
* @return
*/
public String getrange(String key,int startOffset,int endOffset){
return jedis.getrange(key,startOffset,endOffset);
}
/**
* 通过key对value加1操作，如果value不是int类型会返回错误，如果key不存在，value为1
* @param key
* @return
*/
public Long incr(String key){
return jedis.incr(key);
}
/**
* 通过key对value加指定的值，如果value不是int类型会返回错误，若key不存在，value为该值
* @param key
* @param integer
* @return
*/
public Long incrBy(String key,int integer){
return jedis.incrBy(key,integer);
}
/**
* 通过key对value减去1操作，如果value不是int类型会返回错误，如果key不存在，value为-1
* @param key
* @return
*/
public Long decr(String key){
return jedis.decr(key);
}
/**
* 通过key对value减去指定的值，如果value不是int类型会返回错误，若key不存在，value为该值
* @param key
* @param integer
* @return
*/
public Long decrBy(String key,int integer){
return jedis.decrBy(key,integer);
}
/**
* 通过key获取value的长度
* @param key
* @return
*/
public Long StrLen(String key){
return jedis.strlen(key);
}
/**
* 通过key给field设置指定的值，若key不存在则先创建，若field已存在，返回0
* @param key
* @param field
* @param value
* @return
*/
public Long hsetnx(String key,String field,String value){
return jedis.hsetnx(key,field,value);
}
/**
* 通过key给field设置指定的值，若key不存在则先创建
* @param key
* @param field
* @param value
* @return
*/
public Long hset(String key,String field,String value){
return jedis.hset(key,field,value);
}
/**
* 通过key同时设置多个field
* @param key
* @param hash
* @return
*/
public String hmset(String key, Map<String,String>hash){
return jedis.hmset(key,hash);
}
/**
* 通过key和field获取指定的值
* @param key
* @param field
* @return
*/
public String hget(String key,String field){
return jedis.hget(key,field);
}
/**
* 设置key的过期时间秒
* @param key
* @param seconds
* @return
*/
public Long expirt(String key,int seconds){
return jedis.expire(key,seconds);
}
/**
* 通过key和fields获取指定的value，如果没有value，返回null
* @param key
* @param field
* @return
*/
public List<String> hmget(String key,String... field){
return jedis.hmget(key,field);
}
/**
* 通过key给指定的field加指定的值
* @param key
* @param field
* @param value
* @return
*/
public Long hincBy(String key,String field,Long value){
return jedis.hincrBy(key,field,value);
}
/**
* 通过key和field判断指定的value是否存在
* @param key
* @param field
* @return
*/
public Boolean hexist(String key,String field){
return jedis.hexists(key,field);
}
/**
* 通过key返回field数量
* @param key
* @return
*/
public Long hlen(String key){
return jedis.hlen(key);
}
/**
* 通过key删除指定field
* @param key
* @param field 一个 也可以是数组
* @return
*/
public Long hdel(String key,String... field){
return jedis.hdel(key,field);
}
/**
* 通过field获取所有field
* @param key
* @return
*/
public Set<String> hkeys(String key){
return jedis.hkeys(key);
}
/**
* 通过key获取和key有关的value
* @param key
* @return
*/
public List<String> hvals(String key){
return jedis.hvals(key);
}
/**
* 通过key获取有关的field和value
* @param key
* @return
*/
public Map<String,String> hgetall(String key){
return jedis.hgetAll(key);
}
/**
* 通过key向list头部添加字符串
* @param key
* @param strs
* @return
*/
public Long lpush(String key,String... strs){
return jedis.lpush(key,strs);
}
/**
* 通过key向list尾部添加字符串
* @param key
* @param strs
* @return
*/
public Long rpush(String key,String... strs){
return jedis.rpush(key,strs);
}
// /**
// * 通过key向list指定位置添加字符串
// * @param key
// * @param where LIST_POSITION 枚举类型
// * @param pivot list内的value
// * @param value
// * @return
// */
// public Long linsert(String key, BinaryClient.LIST_POSITION where, String pivot, String value){
// return jedis.linsert(key,where,pivot,value);
// }
/**
* 通过key设置list指定下标位置value，越界报错
* @param key
* @param index
* @param value
* @return
*/
public String lset(String key,Long index,String value){
return jedis.lset(key,index,value);
}
/**
* 通过key删除count个与value相同的元素
* @param key
* @param count
* @param value
* @return
*/
public Long lrem(String key,long count,String value){
return jedis.lrem(key,count,value);
}
/**
* 通过key保留下标start到end的value
* @param key
* @param start
* @param end
* @return
*/
public String ltrim(String key,long start,long end){
return jedis.ltrim(key,start,end);
}
/**
* 通过key删除头部一个value，返回value
* @param key
* @return
*/
public String lpop(String key){
return jedis.lpop(key);
}
/**
* 通过key删除尾部一个value，返回value
* @param key
* @return
*/
public String rpop(String key){
return jedis.rpop(key);
}
/**
* 通过key删除list尾部一个value，添加到另一个list的头部，返回该value
* list为空或不存在返回null
* @param srckey
* @param dstkey
* @return
*/
public String rpoplpush(String srckey,String dstkey){
return jedis.rpoplpush(srckey,dstkey);
}
/**
* 通过key获取list指定下标的value
* @param key
* @param index
* @return
*/
public String lindex(String key,long index){
return jedis.lindex(key,index);
}
/**
* 通过key获取list的长度
* @param key
* @return
*/
public Long llen(String key){
return jedis.llen(key);
}
/**
* 通过key获取指定下标位置的value
* 若start为0，end为-1，返回所有value
* @param key
* @param start
* @param end
* @return
*/
public List<String> lrange(String key,long start,long end){
return jedis.lrange(key,start,end);
}
/**
* 通过key向set添加value
* @param key
* @param members
* @return
*/
public Long sadd(String key,String... members){
return jedis.sadd(key,members);
}
/**
* 通过key删除set对应的value值
* @param key
* @param members
* @return
*/
public Long srem(String key,String... members){
return jedis.srem(key,members);
}
/**
* 通过key随机删除set一个value
* @param key
* @return
*/
public String spop(String key){
return jedis.spop(key);
}
/**
* 通过key获取set中的差集
* 以第一个为标准
* @param keys
* @return
*/
public Set<String> sdiff(String... keys){
return jedis.sdiff(keys);
}
/**
* 通过key获取set中差集并存入另一set中
* @param dstkey
* @param keys
* @return
*/
public Long sdiffstore(String dstkey,String... keys){
return jedis.sdiffstore(dstkey,keys);
}
/**
* 通过key获取set中交集
* @param keys
* @return
*/
public Set<String> sinter(String... keys){
return jedis.sinter(keys);
}
/**
* 通过key获取set中交集并存入另一set中
* @param dstkey
* @param keys
* @return
*/
public Long sinterstore(String dstkey,String... keys){
return jedis.sinterstore(dstkey,keys);
}
/**
* 通过key获取set中并集
* @param keys
* @return
*/
public Set<String> sunion(String... keys){
return jedis.sunion(keys);
}
/**
* 通过key获取set中并集并存入另一set中
* @param dstkey
* @param keys
* @return
*/
public Long sunionstore(String dstkey,String... keys){
return jedis.sunionstore(dstkey,keys);
}
/**
* 通过key将set中的value移除并把该value值添加到第二个set中
* @param srckey
* @param dstkey
* @param member
* @return
*/
public Long smove(String srckey,String dstkey,String member){
return jedis.smove(srckey,dstkey,member);
}
/**
* 通过key获取set中value个数
* @param key
* @return
*/
public Long scard(String key){
return jedis.scard(key);
}
/**
* 通过key判断value是否是set中元素
* @param key
* @param member
* @return
*/
public Boolean sismember(String key,String member){
return jedis.sismember(key,member);
}
/**
* 通过key随机获取set中的值
* @param key
* @return
*/
public String srandmember(String key){
return jedis.srandmember(key);
}
/**
* 通过key获取set所有元素
* @param key
* @return
*/
public Set<String> smembers(String key){
return jedis.smembers(key);
}
/**
* 通过key的zset中添加value，score，其中score是用来排序的
* 若该value已存在则根据score更新元素
* @param key
* @param score
* @param member
* @return
*/
public Long zadd(String key,double score,String member){
return jedis.zadd(key,score,member);
}
/**
* 通过key删除在zset中指定的value
* @param key
* @param member
* @return
*/
public Long zrem(String key,String... member){
return jedis.zrem(key,member);
}
/**
* 通过key增加该value中score值
* @param key
* @param score
* @param member
* @return
*/
public Double zincrby(String key,double score,String member){
return jedis.zincrby(key,score,member);
}
/**
* 通过key返回zset中的排名
* 下标从小到大排序
* @param key
* @param member
* @return
*/
public Long zrank(String key,String member){
return jedis.zrank(key,member);
}
/**
* 通过key返回zset中的排名
* 下标从大道小排序
* @param key
* @param member
* @return
*/
public Long zrevrank(String key,String member){
return jedis.zrevrank(key,member);
}
/**
* 通过key获取zset中start到end的value，score从大到小排序
* start为0 end为-1返回全部
* @param key
* @param start
* @return
*/
public Set<String> zrevrange(String key,long start,long end){
return jedis.zrevrange(key,start,end);
}
/**
* 通过key获取zset中指定score内的value
* @param key
* @param max
* @return
*/
public Set<String> zrangeByScore(String key,String max,String min){
return jedis.zrangeByScore(key,max,min);
}
/**
* 通过key获取zset中指定score内的value
* @param key
* @param max
* @return
*/
public Set<String> zrangeByScore(String key,double max,double min){
return jedis.zrangeByScore(key,max,min);
}
/**
* 通过key获取zset中指定区间内的value数量
* @param key
* @param max
* @return
*/
public Long zcount(String key,String max,String min){
return jedis.zcount(key,max,min);
}
/**
* 通过key获取zset中value数量
* @param key
* @return
*/
public Long zcard(String key){
return jedis.zcard(key);
}
/**
* 通过key获取zset中value的score值
* @param key
* @param member
* @return
*/
public Double zscore(String key,String member){
return jedis.zscore(key,member);
}
/**
* 通过key删除指定区间的元素
* @param key
* @param start
* @return
*/
public Long zremrangeByRank(String key,long start,long end){
return jedis.zremrangeByRank(key,start,end);
}
/**
* 通过key删除指定score的元素
* @param key
* @param start
* @return
*/
public Long zremrangeByScore(String key,double start,double end){
return jedis.zremrangeByScore(key,start,end);
}
/**
* 通过key存储是什么类型
* @param key
* @return
*/
public String type(String key){
return jedis.type(key);
}
/**
* 返回满足pattern表达式的所有key
* keys("*") 返回所有的key
* @param pattern
* @return
*/
public Set<String> keys(String pattern){
return jedis.keys(pattern);
}
}
断开连接!
Jedis工具类2
public class RedisUtil {
/**
* 设置key的有效期，单位是秒
* @param key
* @param exTime
* @return
*/
public static Long expire(String key,int exTime){
Jedis jedis = null;
Long result = null;
try {
//从Redis连接池中获得Jedis对象
jedis = RedisPool.getJedis();
//设置成功则返回Jedis对象
result = jedis.expire(key,exTime);
} catch (Exception e) {
e.printStackTrace();
return result;
}finally {
RedisPool.returnResource(jedis);
}
return result;
}
//exTime的单位是秒
//设置key-value并且设置超时时间
public static String setEx(String key,String value,int exTime){
Jedis jedis = null;
String result = null;
try {
jedis = RedisPool.getJedis();
result = jedis.setex(key,exTime,value);
} catch (Exception e) {
e.printStackTrace();
return result;
}finally {
RedisPool.returnResource(jedis);
}
return result;
}
public static String set(String key,String value){
Jedis jedis = null;
String result = null;
try {
jedis = RedisPool.getJedis();
result = jedis.set(key,value);
} catch (Exception e) {
e.printStackTrace();
return result;
}finally {
RedisPool.returnResource(jedis);
}
return result;
}
public static String get(String key){
Jedis jedis = null;
String result = null;
try {
jedis = RedisPool.getJedis();
result = jedis.get(key);
} catch (Exception e) {
e.printStackTrace();
return result;
}finally {
RedisPool.returnResource(jedis);
}
return result;
}
public static Long del(String key) {
Jedis jedis = null;
Long result = null;
try {
jedis = RedisPool.getJedis();
result = jedis.del(key);
} catch (Exception e) {
e.printStackTrace();
return result;
}finally {
RedisPool.returnResource(jedis);
}
return result;
}
//////////////////////list////////////////////
/**
* 从头部添加
* @return 返回添加后元素个数
*/
public static Long lpush(String key,String...vals){
Jedis jedis = null;
Long result = null;
try{
jedis = RedisPool.getJedis();
result = jedis.lpush(key,vals);
}catch (Exception e){
e.printStackTrace();
result = null;
}finally {
RedisPool.returnResource(jedis);
}
return result;
}
/**
* 从尾部添加
* @return 返回添加后元素个数
*/
public static Long rpush(String key,String...vals){
Jedis jedis = null;
Long result = null;
try{
jedis = RedisPool.getJedis();
result = jedis.rpush(key,vals);
}catch (Exception e){
e.printStackTrace();
result = null;
}finally {
RedisPool.returnResource(jedis);
}
return result;
}
/**
* 移除头部元素
* @return 返回移除的元素
*/
public static String lpop(String key){
Jedis jedis = null;
String result = null;
try{
jedis = RedisPool.getJedis();
result = jedis.lpop(key);
}catch (Exception e){
e.printStackTrace();
result = null;
}finally {
RedisPool.returnResource(jedis);
}
return result;
}
/**
* 尾部添加
* @return
*/
public static String rpop(String key){
Jedis jedis = null;
String result = null;
try{
jedis = RedisPool.getJedis();
result = jedis.rpop(key);
}catch (Exception e){
e.printStackTrace();
result = null;
}finally {
RedisPool.returnResource(jedis);
}
return result;
}
/**
* 获取区间元素
*/
public static List<String> lrange(String key,long start,long end){
Jedis jedis = null;
List<String> result = null;
try{
jedis = RedisPool.getJedis();
result = jedis.lrange(key,start,end);
}catch (Exception e){
e.printStackTrace();
result = null;
}finally {
RedisPool.returnResource(jedis);
}
return result;
}
//////////////////////set////////////////////
//////////////////////zset////////////////////
}
Spring Boot集成Redis
springBoot操作数据︰spring-data jpa jdbc mongodb redis !
SpringData也是和SpringBoot齐名的项目!
说明︰在SpringBoot2.x之后，原来使用的jedis被替换为了lettuce?
jedis :采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用jedis pool连接池!更像BIO模式
lettuce :采用netty，实例可以再多个线程中进行共享，不存在线程不安全的情况!可以减少线程数据了，更像NIO模式
我们在学习SpringBoot自动配置的原理时，整合一个组件并进行配置一定会有一个自动配置类xxxAutoConfiguration,并且在spring.factories中也一定能找到这个类的完全限定名。Redis也不例外。
那么就一定还存在一个RedisProperties类
SpringBoot2.x后默认使用Lettuce来替换Jedis，现在我们就能来验证
先看Jedis:
@ConditionalOnClass注解中有两个类是默认不存在的，所以Jedis是无法生效的
然后再看Lettuce：
完美生效。
导入依赖
<!--导入redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
配置文件
#配置redis
#设置连接本机地址
spring.redis.host=127.0.0.1
#设置redis端口号
spring.redis.port=6379
#设置密码
#spring.redis.password=
#连接池配置
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=100
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.lettuce.pool.max-wait=10000
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=5
# 连接超时时间（毫秒）
spring.redis.timeout=1000000
测试
package com.yuan;
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.core.RedisTemplate;
@SpringBootTest
class RedisSpringboot02ApplicationTests {
@Autowired
private RedisTemplate<String, String> redisTemplate;
@Test
void contextLoads() {
// redisTemplate 操作不同的数据类型，api和我们的指令是一样的
// opsForValue 操作字符串 类似String
// opsForList 操作List 类似List
// opsForHash 操作hash 类似于hash
//opsForSet 操作Set 类似于Set
//opsForZSet 操作ZSet 类似于ZSet
// 除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务和基本的CRUD
// 获取连接对象
//RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//connection.flushDb();
//connection.flushAll();
redisTemplate.opsForValue().set("key1","yuan");
System.out.println(redisTemplate.opsForValue().get("key1"));
}
}
Redis自定义Template
默认的是使用的jdk序列化
而默认的RedisTemplate中的所有序列化器都是使用这个序列化器：
我们转到看那个默认的RedisTemplate内部的样子：
RedisSerializer提供了多种序列化方案：
直接调用RedisSerializer的静态方法来返回序列化器，然后set
自己new 相应的实现类，然后set
定制RedisTemplate的模板：
User.java
@Component
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
private String name;
private Integer age;
}
RedisTemplateConfig.java
package com.yuan.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* 自定义RedisTemplate
* @author 111
*/
@Configuration
public class RedisTemplateConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory){
//为了自己开发的方便一般直接使用<String,Object>
RedisTemplate<String, Object> template=new RedisTemplate<String, Object>();
template.setConnectionFactory(factory);
//Json序列化配置
Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
// 如果不想json序列化用GenericJackson2JsonRedisSerializer直接把objectJackson2JsonRedisSerializer替换即可，通用
GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
objectJackson2JsonRedisSerializer.setObjectMapper(om);
//String 序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//key采用string的序列化方式
template.setKeySerializer(stringRedisSerializer);
//设置value采用spring值序列化
template.setValueSerializer(objectJackson2JsonRedisSerializer);
//hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
//value序列化方式采用jackson
template.setValueSerializer(objectJackson2JsonRedisSerializer);
//hash的value序列化采用jackson
template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
测试
@Test
void contextLoads2() {
//真实开发一般使用json传递对象
User user = new User("啊啊啊",12);
//String json = new ObjectMapper().writeValueAsString(user);
redisTemplate.opsForValue().set("user",user);
System.out.println(redisTemplate.opsForValue().get("user"));
}
乱码问题得到解决
工具类参考博客：
https://www.cnblogs.com/zeng1994/p/03303c805731afc9aa9c60dbbd32a323.html
https://www.cnblogs.com/zhzhlong/p/11434284.html
Redis工具类
package com.yuan.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
import org.springframework.stereotype.Component;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* Redis工具类*/
@Component
public class RedisUtil {
@Autowired
private StringRedisTemplate redisTemplate;
/** -------------------key相关操作--------------------- */
/**
* 删除key
*
* @param key
*/
public void delete(String key) {
redisTemplate.delete(key);
}
/**
* 批量删除key
*
* @param keys
*/
public void delete(Collection<String> keys) {
redisTemplate.delete(keys);
}
/**
* 序列化key
*
* @param key
* @return
*/
public byte[] dump(String key) {
return redisTemplate.dump(key);
}
/**
* 是否存在key
*
* @param key
* @return
*/
public Boolean hasKey(String key) {
return redisTemplate.hasKey(key);
}
/**
* 设置过期时间
*
* @param key
* @param timeout
* @param unit
* @return
*/
public Boolean expire(String key, long timeout, TimeUnit unit) {
return redisTemplate.expire(key, timeout, unit);
}
/**
* 设置过期时间
*
* @param key
* @param date
* @return
*/
public Boolean expireAt(String key, Date date) {
return redisTemplate.expireAt(key, date);
}
/**
* 查找匹配的key
*
* @param pattern
* @return
*/
public Set<String> keys(String pattern) {
return redisTemplate.keys(pattern);
}
/**
* 将当前数据库的 key 移动到给定的数据库 db 当中
*
* @param key
* @param dbIndex
* @return
*/
public Boolean move(String key, int dbIndex) {
return redisTemplate.move(key, dbIndex);
}
/**
* 移除 key 的过期时间，key 将持久保持
*
* @param key
* @return
*/
public Boolean persist(String key) {
return redisTemplate.persist(key);
}
/**
* 返回 key 的剩余的过期时间
*
* @param key
* @param unit
* @return
*/
public Long getExpire(String key, TimeUnit unit) {
return redisTemplate.getExpire(key, unit);
}
/**
* 返回 key 的剩余的过期时间
*
* @param key
* @return
*/
public Long getExpire(String key) {
return redisTemplate.getExpire(key);
}
/**
* 从当前数据库中随机返回一个 key
*
* @return
*/
public String randomKey() {
return redisTemplate.randomKey();
}
/**
* 修改 key 的名称
*
* @param oldKey
* @param newKey
*/
public void rename(String oldKey, String newKey) {
redisTemplate.rename(oldKey, newKey);
}
/**
* 仅当 newkey 不存在时，将 oldKey 改名为 newkey
*
* @param oldKey
* @param newKey
* @return
*/
public Boolean renameIfAbsent(String oldKey, String newKey) {
return redisTemplate.renameIfAbsent(oldKey, newKey);
}
/**
* 返回 key 所储存的值的类型
*
* @param key
* @return
*/
public DataType type(String key) {
return redisTemplate.type(key);
}
/** -------------------string相关操作--------------------- */
/**
* 设置指定 key 的值
* @param key
* @param value
*/
public void set(String key, String value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* 获取指定 key 的值
* @param key
* @return
*/
public String get(String key) {
return redisTemplate.opsForValue().get(key);
}
/**
* 返回 key 中字符串值的子字符
* @param key
* @param start
* @param end
* @return
*/
public String getRange(String key, long start, long end) {
return redisTemplate.opsForValue().get(key, start, end);
}
/**
* 将给定 key 的值设为 value ，并返回 key 的旧值(old value)
*
* @param key
* @param value
* @return
*/
public String getAndSet(String key, String value) {
return redisTemplate.opsForValue().getAndSet(key, value);
}
/**
* 对 key 所储存的字符串值，获取指定偏移量上的位(bit)
*
* @param key
* @param offset
* @return
*/
public Boolean getBit(String key, long offset) {
return redisTemplate.opsForValue().getBit(key, offset);
}
/**
* 批量获取
*
* @param keys
* @return
*/
public List<String> multiGet(Collection<String> keys) {
return redisTemplate.opsForValue().multiGet(keys);
}
/**
* 设置ASCII码, 字符串'a'的ASCII码是97, 转为二进制是'01100001', 此方法是将二进制第offset位值变为value
*
* @param key 位置
* @param value
* 值,true为1, false为0
* @return
*/
public boolean setBit(String key, long offset, boolean value) {
return redisTemplate.opsForValue().setBit(key, offset, value);
}
/**
* 将值 value 关联到 key ，并将 key 的过期时间设为 timeout
*
* @param key
* @param value
* @param timeout
* 过期时间
* @param unit
* 时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES
* 秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
*/
public void setEx(String key, String value, long timeout, TimeUnit unit) {
redisTemplate.opsForValue().set(key, value, timeout, unit);
}
/**
* 只有在 key 不存在时设置 key 的值
*
* @param key
* @param value
* @return 之前已经存在返回false,不存在返回true
*/
public boolean setIfAbsent(String key, String value) {
return redisTemplate.opsForValue().setIfAbsent(key, value);
}
/**
* 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
*
* @param key
* @param value
* @param offset
* 从指定位置开始覆写
*/
public void setRange(String key, String value, long offset) {
redisTemplate.opsForValue().set(key, value, offset);
}
/**
* 获取字符串的长度
*
* @param key
* @return
*/
public Long size(String key) {
return redisTemplate.opsForValue().size(key);
}
/**
* 批量添加
*
* @param maps
*/
public void multiSet(Map<String, String> maps) {
redisTemplate.opsForValue().multiSet(maps);
}
/**
* 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
*
* @param maps
* @return 之前已经存在返回false,不存在返回true
*/
public boolean multiSetIfAbsent(Map<String, String> maps) {
return redisTemplate.opsForValue().multiSetIfAbsent(maps);
}
/**
* 增加(自增长), 负数则为自减
*
* @param key
* @return
*/
public Long incrBy(String key, long increment) {
return redisTemplate.opsForValue().increment(key, increment);
}
/**
*
* @param key
* @return
*/
public Double incrByFloat(String key, double increment) {
return redisTemplate.opsForValue().increment(key, increment);
}
/**
* 追加到末尾
*
* @param key
* @param value
* @return
*/
public Integer append(String key, String value) {
return redisTemplate.opsForValue().append(key, value);
}
/** -------------------hash相关操作------------------------- */
/**
* 获取存储在哈希表中指定字段的值
*
* @param key
* @param field
* @return
*/
public Object hGet(String key, String field) {
return redisTemplate.opsForHash().get(key, field);
}
/**
* 获取所有给定字段的值
*
* @param key
* @return
*/
public Map<Object, Object> hGetAll(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* 获取所有给定字段的值
*
* @param key
* @param fields
* @return
*/
public List<Object> hMultiGet(String key, Collection<Object> fields) {
return redisTemplate.opsForHash().multiGet(key, fields);
}
public void hPut(String key, String hashKey, String value) {
redisTemplate.opsForHash().put(key, hashKey, value);
}
public void hPutAll(String key, Map<String, String> maps) {
redisTemplate.opsForHash().putAll(key, maps);
}
/**
* 仅当hashKey不存在时才设置
*
* @param key
* @param hashKey
* @param value
* @return
*/
public Boolean hPutIfAbsent(String key, String hashKey, String value) {
return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
}
/**
* 删除一个或多个哈希表字段
*
* @param key
* @param fields
* @return
*/
public Long hDelete(String key, Object... fields) {
return redisTemplate.opsForHash().delete(key, fields);
}
/**
* 查看哈希表 key 中，指定的字段是否存在
*
* @param key
* @param field
* @return
*/
public boolean hExists(String key, String field) {
return redisTemplate.opsForHash().hasKey(key, field);
}
/**
* 为哈希表 key 中的指定字段的整数值加上增量 increment
*
* @param key
* @param field
* @param increment
* @return
*/
public Long hIncrBy(String key, Object field, long increment) {
return redisTemplate.opsForHash().increment(key, field, increment);
}
/**
* 为哈希表 key 中的指定字段的整数值加上增量 increment
*
* @param key
* @param field
* @param delta
* @return
*/
public Double hIncrByFloat(String key, Object field, double delta) {
return redisTemplate.opsForHash().increment(key, field, delta);
}
/**
* 获取所有哈希表中的字段
*
* @param key
* @return
*/
public Set<Object> hKeys(String key) {
return redisTemplate.opsForHash().keys(key);
}
/**
* 获取哈希表中字段的数量
*
* @param key
* @return
*/
public Long hSize(String key) {
return redisTemplate.opsForHash().size(key);
}
/**
* 获取哈希表中所有值
*
* @param key
* @return
*/
public List<Object> hValues(String key) {
return redisTemplate.opsForHash().values(key);
}
/**
* 迭代哈希表中的键值对
*
* @param key
* @param options
* @return
*/
public Cursor<Entry<Object, Object>> hScan(String key, ScanOptions options) {
return redisTemplate.opsForHash().scan(key, options);
}
/** ------------------------list相关操作---------------------------- */
/**
* 通过索引获取列表中的元素
*
* @param key
* @param index
* @return
*/
public String lIndex(String key, long index) {
return redisTemplate.opsForList().index(key, index);
}
/**
* 获取列表指定范围内的元素
*
* @param key
* @param start
* 开始位置, 0是开始位置
* @param end
* 结束位置, -1返回所有
* @return
*/
public List<String> lRange(String key, long start, long end) {
return redisTemplate.opsForList().range(key, start, end);
}
/**
* 存储在list头部
*
* @param key
* @param value
* @return
*/
public Long lLeftPush(String key, String value) {
return redisTemplate.opsForList().leftPush(key, value);
}
/**
*
* @param key
* @param value
* @return
*/
public Long lLeftPushAll(String key, String... value) {
return redisTemplate.opsForList().leftPushAll(key, value);
}
/**
*
* @param key
* @param value
* @return
*/
public Long lLeftPushAll(String key, Collection<String> value) {
return redisTemplate.opsForList().leftPushAll(key, value);
}
/**
* 当list存在的时候才加入
*
* @param key
* @param value
* @return
*/
public Long lLeftPushIfPresent(String key, String value) {
return redisTemplate.opsForList().leftPushIfPresent(key, value);
}
/**
* 如果pivot存在,再pivot前面添加
*
* @param key
* @param pivot
* @param value
* @return
*/
public Long lLeftPush(String key, String pivot, String value) {
return redisTemplate.opsForList().leftPush(key, pivot, value);
}
/**
*
* @param key
* @param value
* @return
*/
public Long lRightPush(String key, String value) {
return redisTemplate.opsForList().rightPush(key, value);
}
/**
*
* @param key
* @param value
* @return
*/
public Long lRightPushAll(String key, String... value) {
return redisTemplate.opsForList().rightPushAll(key, value);
}
/**
*
* @param key
* @param value
* @return
*/
public Long lRightPushAll(String key, Collection<String> value) {
return redisTemplate.opsForList().rightPushAll(key, value);
}
/**
* 为已存在的列表添加值
*
* @param key
* @param value
* @return
*/
public Long lRightPushIfPresent(String key, String value) {
return redisTemplate.opsForList().rightPushIfPresent(key, value);
}
/**
* 在pivot元素的右边添加值
*
* @param key
* @param pivot
* @param value
* @return
*/
public Long lRightPush(String key, String pivot, String value) {
return redisTemplate.opsForList().rightPush(key, pivot, value);
}
/**
* 通过索引设置列表元素的值
*
* @param key
* @param index
* 位置
* @param value
*/
public void lSet(String key, long index, String value) {
redisTemplate.opsForList().set(key, index, value);
}
/**
* 移出并获取列表的第一个元素
*
* @param key
* @return 删除的元素
*/
public String lLeftPop(String key) {
return redisTemplate.opsForList().leftPop(key);
}
/**
* 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
*
* @param key
* @param timeout
* 等待时间
* @param unit
* 时间单位
* @return
*/
public String lBLeftPop(String key, long timeout, TimeUnit unit) {
return redisTemplate.opsForList().leftPop(key, timeout, unit);
}
/**
* 移除并获取列表最后一个元素
*
* @param key
* @return 删除的元素
*/
public String lRightPop(String key) {
return redisTemplate.opsForList().rightPop(key);
}
/**
* 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
*
* @param key
* @param timeout
* 等待时间
* @param unit
* 时间单位
* @return
*/
public String lBRightPop(String key, long timeout, TimeUnit unit) {
return redisTemplate.opsForList().rightPop(key, timeout, unit);
}
/**
* 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
*
* @param sourceKey
* @param destinationKey
* @return
*/
public String lRightPopAndLeftPush(String sourceKey, String destinationKey) {
return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey,
destinationKey);
}
/**
* 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
*
* @param sourceKey
* @param destinationKey
* @param timeout
* @param unit
* @return
*/
public String lBRightPopAndLeftPush(String sourceKey, String destinationKey,
long timeout, TimeUnit unit) {
return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey,
destinationKey, timeout, unit);
}
/**
* 删除集合中值等于value得元素
*
* @param key
* @param index
* index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素;
* index<0, 从尾部开始删除第一个值等于value的元素;
* @param value
* @return
*/
public Long lRemove(String key, long index, String value) {
return redisTemplate.opsForList().remove(key, index, value);
}
/**
* 裁剪list
*
* @param key
* @param start
* @param end
*/
public void lTrim(String key, long start, long end) {
redisTemplate.opsForList().trim(key, start, end);
}
/**
* 获取列表长度
*
* @param key
* @return
*/
public Long lLen(String key) {
return redisTemplate.opsForList().size(key);
}
/** --------------------set相关操作-------------------------- */
/**
* set添加元素
*
* @param key
* @param values
* @return
*/
public Long sAdd(String key, String... values) {
return redisTemplate.opsForSet().add(key, values);
}
/**
* set移除元素
*
* @param key
* @param values
* @return
*/
public Long sRemove(String key, Object... values) {
return redisTemplate.opsForSet().remove(key, values);
}
/**
* 移除并返回集合的一个随机元素
*
* @param key
* @return
*/
public String sPop(String key) {
return redisTemplate.opsForSet().pop(key);
}
/**
* 将元素value从一个集合移到另一个集合
*
* @param key
* @param value
* @param destKey
* @return
*/
public Boolean sMove(String key, String value, String destKey) {
return redisTemplate.opsForSet().move(key, value, destKey);
}
/**
* 获取集合的大小
*
* @param key
* @return
*/
public Long sSize(String key) {
return redisTemplate.opsForSet().size(key);
}
/**
* 判断集合是否包含value
*
* @param key
* @param value
* @return
*/
public Boolean sIsMember(String key, Object value) {
return redisTemplate.opsForSet().isMember(key, value);
}
/**
* 获取两个集合的交集
*
* @param key
* @param otherKey
* @return
*/
public Set<String> sIntersect(String key, String otherKey) {
return redisTemplate.opsForSet().intersect(key, otherKey);
}
/**
* 获取key集合与多个集合的交集
*
* @param key
* @param otherKeys
* @return
*/
public Set<String> sIntersect(String key, Collection<String> otherKeys) {
return redisTemplate.opsForSet().intersect(key, otherKeys);
}
/**
* key集合与otherKey集合的交集存储到destKey集合中
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public Long sIntersectAndStore(String key, String otherKey, String destKey) {
return redisTemplate.opsForSet().intersectAndStore(key, otherKey,
destKey);
}
/**
* key集合与多个集合的交集存储到destKey集合中
*
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public Long sIntersectAndStore(String key, Collection<String> otherKeys,
String destKey) {
return redisTemplate.opsForSet().intersectAndStore(key, otherKeys,
destKey);
}
/**
* 获取两个集合的并集
*
* @param key
* @param otherKeys
* @return
*/
public Set<String> sUnion(String key, String otherKeys) {
return redisTemplate.opsForSet().union(key, otherKeys);
}
/**
* 获取key集合与多个集合的并集
*
* @param key
* @param otherKeys
* @return
*/
public Set<String> sUnion(String key, Collection<String> otherKeys) {
return redisTemplate.opsForSet().union(key, otherKeys);
}
/**
* key集合与otherKey集合的并集存储到destKey中
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public Long sUnionAndStore(String key, String otherKey, String destKey) {
return redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey);
}
/**
* key集合与多个集合的并集存储到destKey中
*
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public Long sUnionAndStore(String key, Collection<String> otherKeys,
String destKey) {
return redisTemplate.opsForSet().unionAndStore(key, otherKeys, destKey);
}
/**
* 获取两个集合的差集
*
* @param key
* @param otherKey
* @return
*/
public Set<String> sDifference(String key, String otherKey) {
return redisTemplate.opsForSet().difference(key, otherKey);
}
/**
* 获取key集合与多个集合的差集
*
* @param key
* @param otherKeys
* @return
*/
public Set<String> sDifference(String key, Collection<String> otherKeys) {
return redisTemplate.opsForSet().difference(key, otherKeys);
}
/**
* key集合与otherKey集合的差集存储到destKey中
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public Long sDifference(String key, String otherKey, String destKey) {
return redisTemplate.opsForSet().differenceAndStore(key, otherKey,
destKey);
}
/**
* key集合与多个集合的差集存储到destKey中
*
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public Long sDifference(String key, Collection<String> otherKeys,
String destKey) {
return redisTemplate.opsForSet().differenceAndStore(key, otherKeys,
destKey);
}
/**
* 获取集合所有元素
*
* @param key
* @return
*/
public Set<String> setMembers(String key) {
return redisTemplate.opsForSet().members(key);
}
/**
* 随机获取集合中的一个元素
*
* @param key
* @return
*/
public String sRandomMember(String key) {
return redisTemplate.opsForSet().randomMember(key);
}
/**
* 随机获取集合中count个元素
*
* @param key
* @param count
* @return
*/
public List<String> sRandomMembers(String key, long count) {
return redisTemplate.opsForSet().randomMembers(key, count);
}
/**
* 随机获取集合中count个元素并且去除重复的
*
* @param key
* @param count
* @return
*/
public Set<String> sDistinctRandomMembers(String key, long count) {
return redisTemplate.opsForSet().distinctRandomMembers(key, count);
}
/**
*
* @param key
* @param options
* @return
*/
public Cursor<String> sScan(String key, ScanOptions options) {
return redisTemplate.opsForSet().scan(key, options);
}
/**------------------zSet相关操作--------------------------------*/
/**
* 添加元素,有序集合是按照元素的score值由小到大排列
*
* @param key
* @param value
* @param score
* @return
*/
public Boolean zAdd(String key, String value, double score) {
return redisTemplate.opsForZSet().add(key, value, score);
}
/**
*
* @param key
* @param values
* @return
*/
public Long zAdd(String key, Set<TypedTuple<String>> values) {
return redisTemplate.opsForZSet().add(key, values);
}
/**
*
* @param key
* @param values
* @return
*/
public Long zRemove(String key, Object... values) {
return redisTemplate.opsForZSet().remove(key, values);
}
/**
* 增加元素的score值，并返回增加后的值
*
* @param key
* @param value
* @param delta
* @return
*/
public Double zIncrementScore(String key, String value, double delta) {
return redisTemplate.opsForZSet().incrementScore(key, value, delta);
}
/**
* 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
*
* @param key
* @param value
* @return 0表示第一位
*/
public Long zRank(String key, Object value) {
return redisTemplate.opsForZSet().rank(key, value);
}
/**
* 返回元素在集合的排名,按元素的score值由大到小排列
*
* @param key
* @param value
* @return
*/
public Long zReverseRank(String key, Object value) {
return redisTemplate.opsForZSet().reverseRank(key, value);
}
/**
* 获取集合的元素, 从小到大排序
*
* @param key
* @param start
* 开始位置
* @param end
* 结束位置, -1查询所有
* @return
*/
public Set<String> zRange(String key, long start, long end) {
return redisTemplate.opsForZSet().range(key, start, end);
}
/**
* 获取集合元素, 并且把score值也获取
*
* @param key
* @param start
* @param end
* @return
*/
public Set<TypedTuple<String>> zRangeWithScores(String key, long start,
long end) {
return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
}
/**
* 根据Score值查询集合元素
*
* @param key
* @param min
* 最小值
* @param max
* 最大值
* @return
*/
public Set<String> zRangeByScore(String key, double min, double max) {
return redisTemplate.opsForZSet().rangeByScore(key, min, max);
}
/**
* 根据Score值查询集合元素, 从小到大排序
*
* @param key
* @param min
* 最小值
* @param max
* 最大值
* @return
*/
public Set<TypedTuple<String>> zRangeByScoreWithScores(String key,
double min, double max) {
return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
}
/**
*
* @param key
* @param min
* @param max
* @param start
* @param end
* @return
*/
public Set<TypedTuple<String>> zRangeByScoreWithScores(String key,
double min, double max, long start, long end) {
return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max,
start, end);
}
/**
* 获取集合的元素, 从大到小排序
*
* @param key
* @param start
* @param end
* @return
*/
public Set<String> zReverseRange(String key, long start, long end) {
return redisTemplate.opsForZSet().reverseRange(key, start, end);
}
/**
* 获取集合的元素, 从大到小排序, 并返回score值
*
* @param key
* @param start
* @param end
* @return
*/
public Set<TypedTuple<String>> zReverseRangeWithScores(String key,
long start, long end) {
return redisTemplate.opsForZSet().reverseRangeWithScores(key, start,
end);
}
/**
* 根据Score值查询集合元素, 从大到小排序
*
* @param key
* @param min
* @param max
* @return
*/
public Set<String> zReverseRangeByScore(String key, double min,
double max) {
return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
}
/**
* 根据Score值查询集合元素, 从大到小排序
*
* @param key
* @param min
* @param max
* @return
*/
public Set<TypedTuple<String>> zReverseRangeByScoreWithScores(
String key, double min, double max) {
return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,
min, max);
}
/**
*
* @param key
* @param min
* @param max
* @param start
* @param end
* @return
*/
public Set<String> zReverseRangeByScore(String key, double min,
double max, long start, long end) {
return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max,
start, end);
}
/**
* 根据score值获取集合元素数量
*
* @param key
* @param min
* @param max
* @return
*/
public Long zCount(String key, double min, double max) {
return redisTemplate.opsForZSet().count(key, min, max);
}
/**
* 获取集合大小
*
* @param key
* @return
*/
public Long zSize(String key) {
return redisTemplate.opsForZSet().size(key);
}
/**
* 获取集合大小
*
* @param key
* @return
*/
public Long zZCard(String key) {
return redisTemplate.opsForZSet().zCard(key);
}
/**
* 获取集合中value元素的score值
*
* @param key
* @param value
* @return
*/
public Double zScore(String key, Object value) {
return redisTemplate.opsForZSet().score(key, value);
}
/**
* 移除指定索引位置的成员
*
* @param key
* @param start
* @param end
* @return
*/
public Long zRemoveRange(String key, long start, long end) {
return redisTemplate.opsForZSet().removeRange(key, start, end);
}
/**
* 根据指定的score值的范围来移除成员
*
* @param key
* @param min
* @param max
* @return
*/
public Long zRemoveRangeByScore(String key, double min, double max) {
return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
}
/**
* 获取key和otherKey的并集并存储在destKey中
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public Long zUnionAndStore(String key, String otherKey, String destKey) {
return redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
}
/**
*
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public Long zUnionAndStore(String key, Collection<String> otherKeys,
String destKey) {
return redisTemplate.opsForZSet()
.unionAndStore(key, otherKeys, destKey);
}
/**
* 交集
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public Long zIntersectAndStore(String key, String otherKey,
String destKey) {
return redisTemplate.opsForZSet().intersectAndStore(key, otherKey,
destKey);
}
/**
* 交集
*
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public Long zIntersectAndStore(String key, Collection<String> otherKeys,
String destKey) {
return redisTemplate.opsForZSet().intersectAndStore(key, otherKeys,
destKey);
}
/**
*
* @param key
* @param options
* @return
*/
public Cursor<TypedTuple<String>> zScan(String key, ScanOptions options) {
return redisTemplate.opsForZSet().scan(key, options);
}
/**
* 获取列表指定范围内的元素
*
* @param key
* @param start
* 开始位置, 0是开始位置
* @param end
* 结束位置, -1返回所有
* @return
*/
public <T> List<T> lGet(final String key, final long start, final long end) {
return (List<T>) redisTemplate.opsForList().range(key,start,end);
}
}
测试
@Test
void test1(){
redisUtil.set("name","yuan");
System.out.println(redisUtil.get("name"));
}
Redis工具类2
package com.springbootreidslettuce.utils;
import com.springbootreidslettuce.pojo.Product;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
import org.springframework.stereotype.Component;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* Redis工具类*/
@Component
public class RedisUtil<T> {
private static RedisTemplate redisTemplate;
@Autowired
public void setRedisTemplate(RedisTemplate redisTemplate) {
RedisUtil.redisTemplate = redisTemplate;
}
/**
* 是否存在key
* @param key
* @return
*/
public static Boolean hasKey(String key) {
return redisTemplate.hasKey(key);
}
/**
* 设置有效时间
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功；false=设置失败
*/
public static boolean expire(final String key, final long timeout) {
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功；false=设置失败
*/
public static boolean expire(final String key, final long timeout, final TimeUnit unit) {
Boolean ret = redisTemplate.expire(key, timeout, unit);
return ret != null && ret;
}
/**
* 删除单个key
*
* @param key 键
* @return true=删除成功；false=删除失败
*/
public static boolean del(final String key) {
Boolean ret = redisTemplate.delete(key);
return ret != null && ret;
}
/**
* 删除多个key
*
* @param keys 键集合
* @return 成功删除的个数
*/
public static long del(final Collection<String> keys) {
Long ret = redisTemplate.delete(keys);
return ret == null ? 0 : ret;
}
/**
* 存入普通对象
*
* @param key Redis键
* @param value 值
*/
public static void set(final String key, final Object value) {
redisTemplate.opsForValue().set(key, value, 1, TimeUnit.MINUTES);
}
// 存储普通对象操作
/**
* 存入普通对象
*
* @param key 键
* @param value 值
* @param timeout 有效期，单位秒
*/
public static void set(final String key, final Object value, final long timeout) {
redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
}
/**
* 获取普通对象
*
* @param key 键
* @return 对象
*/
public static Object get(final String key) {
return redisTemplate.opsForValue().get(key);
}
// 存储Hash操作
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public static void hPut(final String key, final String hKey, final Object value) {
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 往Hash中存入多个数据
*
* @param key Redis键
* @param values Hash键值对
*/
public static void hPutAll(final String key, final Map<String, Object> values) {
redisTemplate.opsForHash().putAll(key, values);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public static Object hGet(final String key, final String hKey) {
return redisTemplate.opsForHash().get(key, hKey);
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public static List<Object> hMultiGet(final String key, final Collection<Object> hKeys) {
return redisTemplate.opsForHash().multiGet(key, hKeys);
}
// 存储Set相关操作
/**
* 往Set中存入数据
*
* @param key Redis键
* @param values 值
* @return 存入的个数
*/
public static long sSet(final String key, final Object... values) {
Long count = redisTemplate.opsForSet().add(key, values);
return count == null ? 0 : count;
}
/**
* 删除Set中的数据
*
* @param key Redis键
* @param values 值
* @return 移除的个数
*/
public static long sDel(final String key, final Object... values) {
Long count = redisTemplate.opsForSet().remove(key, values);
return count == null ? 0 : count;
}
// 存储List相关操作
/**
* 往List中存入数据
*
* @param key Redis键
* @param value 数据
* @return 存入的个数
*/
public static long lPush(final String key, final Object value) {
Long count = redisTemplate.opsForList().rightPush(key, value);
return count == null ? 0 : count;
}
/**
* 往List中存入数据
* xi
* @param key Redis键
* @param value 数据
* @return 存入的个数
*/
public static long lPushLeft(final String key, final Object value) {
Long count = redisTemplate.opsForList().leftPush(key, value);
return count == null ? 0 : count;
}
/**
* 往List中存入多个数据
*
* @param key Redis键
* @param values 多个数据
* @return 存入的个数
*/
public static long lPushAll(final String key, final Collection<Object> values) {
Long count = redisTemplate.opsForList().rightPushAll(key, values);
return count == null ? 0 : count;
}
/**
* 往List中存入多个数据
*
* @param key Redis键
* @param values 多个数据
* @return 存入的个数
*/
public static long lPushAll(final String key, final Object... values) {
Long count = redisTemplate.opsForList().rightPushAll(key, values);
return count == null ? 0 : count;
}
/**
* 从List中获取begin到end之间的元素
*
* @param key Redis键
* @param start 开始位置
* @param end 结束位置（start=0，end=-1表示获取全部元素）
* @return List对象
*/
public static <T> List<T> lGet(final String key, final long start, final long end) {
return redisTemplate.opsForList().range(key,start,end);
}
/**
* 获取列表长度
* @param key
* @return
*/
public static Long lLen(String key) {
return redisTemplate.opsForList().size(key);
}
}
Redis.conf详解
使用vim编辑器打开redsi.conf
单位
可以使用 include 组合多个配置问题
网络
bind 127.0.0.1#绑定的ip
---------------
protected-mode yes #保护模式
---------------
port 6379# 端口设置
通用GENERAL
daemonize yes #以守护进程的方式运行，默认是no，我们需要自己开启为yes!
---------------
pidfile /var/run/redis_6379.pid # 如果以后台的方式运行，我们就需要指定一个 pid文件!
---------------
#日志
# specify the server verbosity leve1.
# This can be one of:
# debug (a lot of information，usefu7 for deve1opment/testing)
# verbose (many rarely usefu7 info，but not a mess like the debug leve1)
# notice (moderately verbose，what you want in production probably)生产环境
# warning (only very important / critica1 messages are logged)
logleve1 notice
---------------
logfile "" #日志的文件位置名
---------------
databases 16 #教据库的数量，默认是16个数据库! l
---------------
always-show- 7ogo yes#是否总是显示LOGO
快照
持久化，在规定的时间内，执行了多少次操作，则会持久化到文件.rdb.aof
redis是内存数据库，如果没有持久化，那么数据断电及失!
#如果300s内，如果至少10 key进行了修改，我们及进行持久化操作
save 300 10
#如果300s内，如果至少10 key进行了修改，我们及进行持久化操作
save 300 10
#如果60s内，如果至少10000 key进行了修改，我们及进行持久化操作
save 60 10000
---------------
stop-writes-on-bgsave-error yes # 持久化如果出错，是否还需要继续工作!
---------------
rdbcompression yes #是否压缩 rdb 文件，需要消耗一些cpu资源!
---------------
rdbchecksum yes # 保存rdb文件的时候，进行错误的检查校验!
---------------
dir ./# rdb文件保存的目录!
SECURITY 安全
可以在这里设置redis的密码，默认是没有密码!
127. 0.0.1:6379> ping
PONG
127. 0.0.1:6379> config get requirepass #获取redis的密码
1) "requirepass"
2) ""
127. 0.0.1:6379>config set requirepass "123456"# 设置redis的密码
oK
127. 0.0.1:6379> config get requirepass #发现所有的命令都没有权限了
(error)NOAUTH Authentication required.
127. 0.0.1:6379> ping
(error) NOAUTH Authentication required.
127. 0.0.1:6379> auth 123456 #使用密码进行登录!
oK
127. 0.0.1:6379> config get requirepass
1) "requirepass"
2) "123456"
限制CLIENTS
maxclients 10000 #设置能连接上redis的最大客户端的数量
---------------
maxmemory bytes> # redis 配置最大的内存容量
---------------
1. maxmemory-policy noeviction #内存到达上限之后的处理策略
2. volatile-lru：只对设置了过期时间的key进行LRU（默认值）
3. allkeys-lru ： 删除lru算法的key
4. volatile-random：随机删除即将过期key
5. allkeys-random：随机删除
6. volatile-ttl ： 删除即将过期的
7. noeviction ： 永不过期，返回错误
APPEND ONLY 模式aof配置
appendon1y no#默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分所有的情况下，rdb完全够用!
---------------
appendfi1ename "appendon1y.aof"#持久化的文件的名字
---------------
# appendfsync always #每次修改都会 sync。消耗性能
appendfsync everysec #每秒执行一次 sync，可能会丢失这1s的数据!
#appendfsync no #不执行sync，这个时候操作系统自己同步数据，速度最快!
持久化RDB操作
什么是RDB
在指定时间间隔后，将内存中的数据集快照写入数据库 ；在恢复时候，直接读取快照文件，进行数据的恢复
Redis是内存数据库，如果不将内存中的数据库状态保存到磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失。所以Redis提供了持久化功能!
默认情况下， Redis 将数据库快照保存在名字为 dump.rdb的二进制文件中。文件名可以在配置文件中进行自定义。
RDB ( Redis DataBase )
在主从复制中，rdb就是备用了!从机上面!|
在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里。
工作原理
在进行 RDB 的时候，redis 的主线程是不会做 io 操作的，主线程会 fork 一个子线程来完成该操作；
-
Redis 调用forks。同时拥有父进程和子进程。
-
子进程将数据集写入到一个临时 RDB 文件中。
-
当子进程完成对新 RDB 文件的写入时，Redis 用新 RDB 文件替换原来的 RDB 文件，并删除旧的 RDB 文件。
这种工作方式使得 Redis 可以从写时复制（copy-on-write）机制中获益(因为是使用子进程进行写操作，而父进程依然可以接收来自客户端的请求。)
Redis会单独创建 ( fork )一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。我们默认的就是RDB，一般情况下不需要修改这个配置!
有时候在生产环境我们会将这个文件进行备份!
rdb保存的文件是dump.rdb都是在我们的配置文件中快照中进行配置的!
触发机制
1、save的规则满足的情况下，会自动触发rdb规则
2、执行flushall命令，也会触发我们的rdb规则!
3、退出redis，也会产生rdb文件!
备份就自动生成一个dump.rdb
如果恢复rdb文件!
1、只需要将rdb文件放在我们redis启动目录就可以，redis启动的时候会自动检查dump.rdb恢复其中的数据!
2、查看需要存在的位置
127. 0.0.1:6379> config get dir
1)"dir"
2) "/usr/loca1/bin" #如果在这个目录下存在 dump .rdb 文件，启动就会自动恢复其中的数据
save
使用 save 命令，会立刻对当前内存中的数据进行持久化 ,但是会阻塞，也就是不接受其他操作了；
由于
save命令是同步命令，会占用Redis的主进程。若Redis数据非常多时，save命令执行速度会非常慢，阻塞所有客户端的请求。
flushall命令
flushall 命令也会触发持久化 ；
触发持久化规则
满足配置条件中的触发条件 ；
可以通过配置文件对 Redis 进行设置， 让它在“ N 秒内数据集至少有 M 个改动”这一条件被满足时， 自动进行数据集保存操作。
bgsave和save对比
| 命令 | save | bgsave |
|---|---|---|
| IO类型 | 同步 | 异步 |
| 阻塞？ | 是 | 是（阻塞发生在fock()，通常非常快） |
| 复杂度 | O(n) | O(n) |
| 优点 | 不会消耗额外的内存 | 不阻塞客户端命令 |
| 缺点 | 阻塞客户端命令 | 需要fock子进程，消耗内存 |
优点︰
1、适合大规模的数据恢复!
2、对数据的完整性要不高!
缺点∶
1、需要一定的时间间隔进程操作!如果redis意外宕机了，这个最后一次修改数据就没有的了!
2、fork进程的时候，会占用一定的内容空间!!
持久化AOF
RDB ( Redis DataBase )
将我们的所有命令都记录下来，history，恢复的时候就把这个文件全部在执行一遍!
以日志的形式来记录每个写操作，将Redis执行过的所有指令记录下来(读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作
Aof保存的是appendonly.aof文件
append
默认是不开启的，我们需要手动进行配置!我们只需要将appendonly改为yes就开启了aof !
重启，redis 就可以生效了!
如果这个aof文件有错位，这时候redis是启动不起来的吗，我们需要修复这个aof文件
redis给我们提供了一个工具redis-check-aof --fix
如果文件正常，重启就可以直接恢复了!
重写规则说明
aof默认就是文件的无限追加，文件会越来越大!|
如果aof文件大于64m，太大了! fork一个新的进程来将我们的文件进行重写!
优点和缺点!
appendon1y no #默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分所有的情况下，rdb完全够用!
appendfilename "appendon1y.aof" #持久化的文件的名字
# appendfsync always #每次修改都会sync。消耗性能
appendfsync everysec #每秒执行一次 sync，可能会丢失这1s的数据!
#appendfsync no #不执行sync，这个时候操作系统自己同步数据，速度最快!
优点︰
1、每一次修改都同步，文件的完整会更加好!
2、每秒同步一次，可能会丢失一秒的数据
3、从不同步，效率最高的!
缺点︰
1、相对于数据文件来说，aof远远大于rdb，修复的速度也比rdb慢!
2、Aof运行效率也要比 rdb 慢，所以我们redis默认的配置就是rdb持久化!
拓展
1、RDB持久化方式能够在指定的时间间隔内对你的数据进行快照存储
2、AOF持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据，AOF命令以Redis 协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不至于过大。
3、只做缓存，如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何持久化
4、同时开启两种持久化方式
·在这种情况下，当redis重启的时候会优先载入AOF文件来恢复原始的数据，因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整。
·RDB的数据不实时，同时使用两者时服务器重启也只会找AOF文件，那要不要只使用AOF呢?作者建议不要，因为RDB更适合用于备份数据库（AOF在不断变化不好备份），快速重启，而且不会有AOF可能潜在的Bug，留着作为一个万一的手段。
5、性能建议
·因为RDB文件只用作后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟备份一次就够了，只保留save 9001这条规则。
·如果Enable AOF，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持续的lO，二是AOF rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值。
·如果不Enable AOF，仅靠Master-Slave Repllcation实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果Master/Slave同时倒掉，会丢失十几分钟的数据，启动脚本也要比较两个Master/Slave中的RDB文件，载入较新的那个，微博就是这种架构。
Redis发布订阅
Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。
下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：
当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：
命令
- PSUBSCRIBE pattern [pattern..] 订阅一个或多个符合给定模式的频道。
- PUNSUBSCRIBE pattern [pattern..] 退订一个或多个符合给定模式的频道。
- PUBSUB subcommand [argument[argument]] 查看订阅与发布系统状态。
- PUBLISH channel message 向指定频道发布消息
- SUBSCRIBE channel [channel..] 订阅给定的一个或多个频道。
- SUBSCRIBE channel [channel..] 退订一个或多个频道
测试
-------------------订阅端----------------------
127. 0.0.1:6379> subscribe yuanshuo # 订阅yuanshuo频道
Reading messages... (press Ctrl-C to quit) # 等待接收消息
1) "subscribe" # 订阅成功的消息
2) "yuanshuo"
3) (integer) 1
1) "message" # 接收到来自sakura频道的消息 "hello world"
2) "yuanshuo"
3) "hello whord"
1) "message" # 接收到来自sakura频道的消息 "hello redis"
2) "yuanshuo"
3) "hello redis"
--------------消息发布端-------------------
#新开一个redis服务器
127. 0.0.1:6379> publish yuanshuo "hello whord" # 发布消息到yuanshuo频道
(integer) 1
127. 0.0.1:6379> publish yuanshuo "hello redis" # 发布消息
(integer) 1
127. 0.0.1:6379>
原理 每个 Redis 服务器进程都维持着一个表示服务器状态的 redis.h/redisServer 结构， 结构的 pubsub_channels 属性是一个字典， 这个字典就用于保存订阅频道的信息，其中，字典的键为正在被订阅的频道， 而字典的值则是一个链表， 链表中保存了所有订阅这个频道的客户端。
客户端订阅，就被链接到对应频道的链表的尾部，退订则就是将客户端节点从链表中移除。
缺点
- 如果一个客户端订阅了频道，但自己读取消息的速度却不够快的话，那么不断积压的消息会使redis输出缓冲区的体积变得越来越大，这可能使得redis本身的速度变慢，甚至直接崩溃。
- 这和数据传输可靠性有关，如果在订阅方断线，那么他将会丢失所有在短线期间发布者发布的消息。
应用
- 消息订阅：公众号订阅，微博关注等等（起始更多是使用消息队列来进行实现）
- 多人在线聊天室。
稍微复杂的场景，我们就会使用消息中间件MQ处理
Redis主从复制
概念
主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为(master/leader)，后者称为从节点(slave/follower);数据的复制是单向的，只能由主节点到从节点。Master以写为主，Slave以读为主。
默认情况下，每台Redis服务器都是主节点;且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。主从复制的作用主要包括:
1、数据冗余︰主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
2、故障恢复︰当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复;实际上是一种服务的冗余。
3、负载均衡∶在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载;尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。
4、高可用基石:除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是Redis高可用的基础。
一般来说，要将Redis运用于工程项目中，只使用一台Redis是万万不能的，原因如下︰
1、从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大;
2、从容量上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有内存用作Redis存储内存，一般来说，单台Redis最大使用内存不应该超过20G。
电商网站上的商品，一般都是一次上传，无数次浏览的，说专业点也就是"多读少写"。
对于区种场景，我们可以使如下这种架构:
主从复制，读写分离!80%的情况下都是在进行读操作!减缓服务器的压力!架构中经常使用!一主二从!
只要在公司中，主从复制就是必须要使用的，因为在真实的项目中不可能单机使用Redis !
环境配置
127. 0.0.1:6379> info replication #查看当前库的信息
# Replication
role:master #角色 master
connected_slaves:0 #没用从机
master_failover_state:no-failover
master_replid:34537d410e9e9b27317df929bf36414385bb801f
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
127. 0.0.1:6379>
开启4个reids服务
复制3个redis.conf
[root@yuan bin]# cd yconfig
[root@yuan yconfig]# cp redis.conf redis79.conf
[root@yuan yconfig]# cp redis.conf redis80.conf
[root@yuan yconfig]# cp redis.conf redis81.conf
[root@yuan yconfig]# ls -a
. .. redis79.conf redis80.conf redis81.conf redis.conf
既然需要启动多个服务，就需要多个配置文件。每个配置文件对应修改以下信息：
- 端口号
- pid文件名
- 日志文件名
- rdb文件名
redis79.conf
port 6379
pidfile /var/run/redis_6379.pid
logfile "redis6379.log"
dbfilename dump6379.rdb
redis80.conf
port 6380
pidfile /var/run/redis_6380.pid
logfile "redis6380.log"
dbfilename dump6380.rdb
redis81.conf
port 6381
pidfile /var/run/redis_6381.pid
logfile "redis6381.log"
生成3个配置日志文件
启动单机多服务集群：
一主二从配置
默认情况下，每台Redis服务器都是主节点;我们一般情况下只用配置从机就好了!
127. 0.0.1:6380> slaveof 127.0.0.1 6379 #slaveof host 6379 #主机的端口号,配置主机
OK
127. 0.0.1:6380> info replication
# Replication
role:slave #当前角色是从机
master_host:127.0.0.1 #主机信息
master_port:6379
master_link_status:up
master_last_io_seconds_ago:2
master_sync_in_progress:0
slave_read_repl_offset:0
slave_repl_offset:0
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:bd70d408c3a8e86ce556a8807d6a520896d9d77d
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:0
#在主机查看从机的信息
127. 0.0.1:6379> info replication
# Replication
role:master
connected_slaves:2 #从机的配置
slave0:ip=127.0.0.1,port=6380,state=online,offset=434,lag=1 #从机的信息 2台从机
slave1:ip=127.0.0.1,port=6381,state=online,offset=434,lag=1 #第二台从机的信息
master_failover_state:no-failover
master_replid:bd70d408c3a8e86ce556a8807d6a520896d9d77d
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:434
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:434
这是使用命令的方式，暂时的，如果想永久生效，可以在配置文件中配置
测试
主机可以设置设置值
从机只能读，不能set值
测试∶
主机断开连接，从机依旧连接到主机的，但是没有写操作，这个时候，主机如果回来了，从机依旧可以直接获取到主机写的信息!
如果是使用命令行，来配置的主从，这个时候如果重启了，就会变回主机!只要变为从机，立马就会从主机中获取值!
复制原理
Slave启动成功连接到 master后会发送一个sync同步命令
Master接到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slave，并完成一次完全同步。
全量复制︰而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。
增量复制:Master继续将新的所有收集到的修改命令依次传给slave，完成同步
但是只要是重新连接master，一次完全同步（全量复制)将被自动执行!我们的数据一定可以在从机中看到!
层层链路
上一个连接下一个 79为主机，80即为主机也为从机，81为从机
如果主机断开了可以使用SLAVEOF no one让自己变成主机!
哨兵模式
主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。
谋朝篡位的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。
哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。
这里的哨兵有两个作用
·通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
·当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。
然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。
假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象成为主观下线.当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover[故障转移]操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。
测试
1，配置哨兵模式配置文件 vim sentinel.conf
[root@yuan yconfig]# vim sentinel.conf
sentinel monitor 被监控的名称 ip地址 端口号 1
sentinel monitor myredis 127.0.0.1 6379 1
后面的这个数字1，代表主机挂了，slave投票看让谁接替成为主机，票数最多的，就会成为主机!
2，启动哨兵
[root@yuan bin]# redis-sentinel yconfig/sentinel.conf
成功启动哨兵模式
此时哨兵监视着我们的主机6379，当我们断开主机后：
哨兵模式优缺点
优点：
- 哨兵集群，基于主从复制模式，所有主从复制的优点，它都有
- 主从可以切换，故障可以转移，系统的可用性更好
- 哨兵模式是主从模式的升级，手动到自动，更加健壮
缺点：
- Redis不好在线扩容，集群容量一旦达到上限，在线扩容就十分麻烦
- 实现哨兵模式的配置其实是很麻烦的，里面有很多配置项
哨兵模式的全部配置
完整的哨兵模式配置文件 sentinel.conf
# Example sentinel.conf
# 哨兵sentinel实例运行的端口 默认26379
port 26379
# 哨兵sentinel的工作目录
dir /tmp
# 哨兵sentinel监控的redis主节点的 ip port
# master-name 可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。
# quorum 当这些quorum个数sentinel哨兵认为master主节点失联 那么这时 客观上认为主节点失联了
# sentinel monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor mymaster 127.0.0.1 6379 1
# 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供密码
# 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
# 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒
# sentinel down-after-milliseconds <master-name> <milliseconds>
sentinel down-after-milliseconds mymaster 30000
# 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同步，
这个数字越小，完成failover所需的时间就越长，
但是如果这个数字越大，就意味着越 多的slave因为replication而不可用。
可以通过将这个值设为 1 来保证每次只有一个slave 处于不能处理命令请求的状态。
# sentinel parallel-syncs <master-name> <numslaves>
sentinel parallel-syncs mymaster 1
# 故障转移的超时时间 failover-timeout 可以用在以下这些方面：
#1. 同一个sentinel对同一个master两次failover之间的间隔时间。
#2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的failover所需要的时间。
#4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了
# 默认三分钟
# sentinel failover-timeout <master-name> <milliseconds>
sentinel failover-timeout mymaster 180000
# SCRIPTS EXECUTION
#配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
#对于脚本的运行结果有以下规则：
#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
#若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
#一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
#通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本，
#这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，
#一个是事件的类型，
#一个是事件的描述。
#如果sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无法正常启动成功。
#通知脚本
# sentinel notification-script <master-name> <script-path>
sentinel notification-script mymaster /var/redis/notify.sh
# 客户端重新配置主节点参数脚本
# 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。
# 以下参数将会在调用脚本时传给脚本:
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
# 目前<state>总是“failover”,
# <role>是“leader”或者“observer”中的一个。
# 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
# 这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentinel client-reconfig-script <master-name> <script-path>
sentinel client-reconfig-script mymaster /var/redis/reconfig.sh
缓存穿透与雪崩
Redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。但同时，它也带来了一些问题。其中，最要害的问题，就是数据的一致性问题，从严格意义上讲，这个问题无解。如果对数据的一致性要求很高，那么就不能使用缓存。
另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前，业界也都有比较流行的解决方案。
缓存穿透（查不到）
概念
在默认情况下，用户请求数据时，会先在缓存(Redis)中查找，若没找到即缓存未命中，再在数据库中进行查找，数量少可能问题不大，可是一旦大量的请求数据（例如秒杀场景）缓存都没有命中的话，就会全部转移到数据库上，造成数据库极大的压力，就有可能导致数据库崩溃。网络安全中也有人恶意使用这种手段进行攻击被称为洪水攻击。
解决方案
布隆过滤器
布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力﹔
缓存空对象
当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源;
但是这种方法会存在两个问题:
1、如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键;
2、即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响
缓存击穿（量太大，缓存过期）
概念
相较于缓存穿透，缓存击穿的目的性更强，一个存在的key，在缓存过期的一刻，同时有大量的请求，这些请求都会击穿到DB，造成瞬时DB请求量大、压力骤增。这就是缓存被击穿，只是针对其中某个key的缓存不可用而导致击穿，但是其他的key依然可以使用缓存响应。
比如热搜排行上，一个热点新闻被同时大量访问就可能导致缓存击穿。
解决方案
- 设置热点数据永不过期
这样就不会出现热点数据过期的情况，但是当Redis内存空间满的时候也会清理部分数据，而且此种方案会占用空间，一旦热点数据多了起来，就会占用部分空间。
- 加互斥锁(分布式锁)
分布式锁∶使用分布式锁，保证对于每个key同时只有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大。
缓存雪崩
概念
缓存雪崩，是指在某一个时间段，缓存集中过期失效。Redis宕机!
产生雪崩的原因之一，比如在写本文的时候，马上就要到双十二零点，很快就会迎来一波抢购，这波商品时间比较集中的放入了缓存，假设缓存一个小时。那么到了凌晨一点钟的时候，这批商品的缓存就都过期了。而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压力波峰。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。
其实集中过期，倒不是非常致命，比较致命的缓存雪崩，是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压垮。
双十一:停掉一些服务，(保证主要的服务可用!)
解决方案
redis高可用
这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。（异地多活!)
限流降级
这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。
数据预热
数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即
将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。