Redis最全详解（二）——客户端底层Jedis
Redis缓存与数据库一致性
一、实时同步
对强一致要求比较高的，应采用实时同步方案，即查询缓存查询不到再从DB查询，保存到缓存；更新缓存时，先更 新数据库，再将缓存的设置过期(建议不要去更新缓存内容，直接设置缓存过期)。 @Cacheable：查询时使用，注意 Long类型需转换为Sting类型，否则会抛异常 @CachePut：更新时使用，使用此注解，一定会从DB上查询数据@CacheEvict：删除时使用； @Caching：组合用法
二、异步队列
对于并发程度较高的，可采用异步队列的方式同步，可采用kafka等消息中间件处理消息生产和消费。
三、使用阿里的同步工具canal
四、采用UDF自定义函数的方式
面对mysql的API进行编程，利用触发器进行缓存同步，但UDF主要是c/c++语言实现，学习成本高。
Redis底层Jedis
Jedis淘汰了，但redis底层还是Jedis，原理是运用socket发送Resp协议的redis命令给redis服务器。
SpringBoot2.x以后使用了lettuce替代了Jedis
lettuce是高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，sentinel，管道和编辑器。
优点：
- Jedis：比较全面提供了Redis的操作特性
- Redission：促使使用者对Redis的关注分离，提供很多分布式相关操作服务，例如，分布式锁、分布式集合、可通过Redis支持延迟队列。
- Lettuce：基于Netty框架的事件驱动的通行层，其方法调用是异步的。Lettuce的API是线程安全的，所以可以操作单个Lettuce连接来完成各种操作。
优先使用Lettuce，如果需要分布式锁，分布式集合等分布式的高级特性，添加Redisson即可。
<dependency>
<groupId>redis.clientsgroupId
> jedisartifactId>
dependency>
spring:
redis:
port: 6379
password: 123456
host: 192.168.169.135
jedis:
pool:
max-idle: 6 #最大空闲数
max-active: 10 #最大连接数
min-idle: 2 #最小空闲数 timeout: 2000 #连接超时
JedisConfig:
package com.config.jedis;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
* @ClassName JedisConfig
* @Description TODO
* @Author wzq
* @Version 1.0
*/
@Configuration
public class JedisConfig {
private Logger logger = LoggerFactory.getLogger(JedisConfig.class);
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.timeout}")
private int timeout;
@Value("${spring.redis.jedis.pool.max-active}")
private int maxActive;
@Value("${spring.redis.jedis.pool.max-idle}")
private int maxIdle;
@Value("${spring.redis.jedis.pool.min-idle}")
private int minIdle;
@Bean
public JedisPool jedisPool(){
JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(maxIdle);
jedisPoolConfig.setMinIdle(minIdle);
jedisPoolConfig.setMaxTotal(maxActive);
JedisPool jedisPool=new JedisPool(jedisPoolConfig,host,port,timeout,password);
logger.info("JedisPool连接成功:"+host+"\t"+port);
return jedisPool;
}
}
测试配置：
@SpringBootTest
public class JedisApplicationTests {
@Autowired private JedisPool jedisPool;
@Test
public void contextLoads() {
System.out.println(jedisPool); //在连接池中得到Jedis连接 Jedis
jedis=jedisPool.getResource();
jedis.set("haha","你好"); jedis.set("name","123456"); //关闭当前连接 jedis.close();
}
}
工具类
package com..config.jedis;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
/**
* @ClassName JedisUtils
* @Description redis客户端的命令这里都有方法
* @Author wzq
* @Version 1.0
*/
@Component
public class JedisUtils {
@Autowired
private JedisPool jedisPool;
/*** 获取Jedis资源 */
public Jedis getJedis(){
return jedisPool.getResource();
}
/*** 释放Jedis连接 */
public void close(Jedis jedis){
if(jedis!=null){
jedis.close();
}
}
//。。。。。。
}
redis客户端的命令这里都有方法，使用：
/**
* @ClassName JedisServiceImpl
* @Description TODO
* @Author wzq
* @Version 1.0
*/
@Service
@Log //日志的处理,日志不是打印
public class JedisServiceImpl {
@Autowired
private JedisUtils jedisUtils;
/*** 测试String类型
* 根据key 查询value值
*/
public String getString(String key){
Jedis jedis=jedisUtils.getJedis();
String val=null;
if(!jedis.exists(key)){
val="千锋南京"; log.info(key+"在MYSQL数据库中进行查询的结果是："+val);
jedis.set(key,val);
log.info(key+"存入Redis中。值是："+val);
}else{
val=jedis.get(key);
log.info(key+"是在Redis中查询的数据。值是："+val);
}
jedisUtils.close(jedis); //释放资源 return val;
}
/**
* 测试 jedis 操作hash类型
* 根据用户ID查询用户信息
* 先判断Redis中是否存在，
* 如果不存在，数据库中查询。并存到Redis中
* 如果存在，直接查询Redis 并返回
*/
public User selectBy(String id){
String key="user:id"; //根据规则生成相同规范的key
User user=new User();
Jedis jedis=jedisUtils.getJedis();
if(!jedis.exists(key)){ //数据库中查询，并进行存
user.setId(id);
user.setName("千锋南京JAVA");
user.setAge(20);
log.info("数据库中查询的用户信息是："+user);
Map<String,String> map=new HashMap();
map.put("id",user.getId());
map.put("name",user.getName());
jedis.hset(key,map);
log.info(key+"成功存入Redis:"+user);
}else{
Map<String,String> map= jedis.hgetAll(key);
user.setId(map.get("id"));
user.setName(map.get("name"));
log.info(key+"Redis中查询出来的是:"+map);
}
jedisUtils.close(jedis);
return user;
}
}
其它的工具类，基本不用，看情况。
//Jedis工具类
package com.commons;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
/**
* Redis通用工具类
* @author 【享学课堂】 James老师 qq ：1076258117
* @author 【享学课堂】 架构技术QQ群 ：684504192
* @author 【享学课堂】 往期视频依娜老师 ：2470523467
*/
@Component
public class JedisUtils {
private JedisPool pool = null;
private String ip = "192.168.169.131";
private int port = 6379;
private String auth = "123456";
/**
* 传入ip和端口号构建redis 连接
*/
public JedisUtils() {
if (pool == null) {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(500);
config.setMaxIdle(5);
config.setMaxWaitMillis(100);
config.setTestOnBorrow(true);
pool = new JedisPool(config, this.ip, this.port, 100000, this.auth);
}
}
/**
* 通过key获取储存在redis中的value 并释放连
*
* @param key
* @return 成功返回value 失败返回null
*/
public String get(String key) {
Jedis jedis = null;
String value = null;
try {
jedis = pool.getResource();
value = jedis.get(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return value;
}
/**
* 向redis存入key和value,并释放连接资 如果key已经存在 则覆
*
* @param key
* @param value
* @return 成功 返回OK 失败返回 0
*/
public String set(String key, String value) {
Jedis jedis = null;
try {
jedis = pool.getResource();//每次操作时向pool借用个jedis对象，用完即还?
return jedis.set(key, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
return "0";
} finally {
returnResource(pool, jedis);
}
}
/**
* 向redis存入序列化的key和value,并释放连接资 如果key已经存在 则覆
*
* @param key
* @param value
* @return 成功 返回OK 失败返回 0
*/
public String setSerializer(byte[] keyBytes, byte[] valueBytes) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.set(keyBytes, valueBytes);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
return "0";
} finally {
returnResource(pool, jedis);
}
}
/**
* 通过序列化key获取储存在redis中的序列化value 并释放连
*
* @param key
* @return 成功返回value 失败返回null
*/
public byte[] getSerializer(byte[] key) {
Jedis jedis = null;
byte[] value = null;
try {
jedis = pool.getResource();
value = jedis.get(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return value;
}
/**
* 删除指定的key,也可以传入一个包含key的数
*
* @param keys
* 个key 也可以使 string 数组
* @return 返回删除成功的个
*/
public Long del(String... keys) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.del(keys);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
return 0L;
} finally {
returnResource(pool, jedis);
}
}
/**
* 通过key向指定的value值追加?
*
* @param key
* @param str
* @return 成功返回 添加后value的长 失败 返回 添加 value 的长 异常返回0L
*/
public Long append(String key, String str) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.append(key, str);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
return 0L;
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 判断key是否存在
*
* @param key
* @return true OR false
*/
public Boolean exists(String key) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.exists(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
return false;
} finally {
returnResource(pool, jedis);
}
}
/**
* 设置key value,如果key已经存在则返0,nx==> not exist
*
* @param key
* @param value
* @return 成功返回1 如果存在 发生异常 返回 0
*/
public Long setnx(String key, String value) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.setnx(key, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
return 0L;
} finally {
returnResource(pool, jedis);
}
}
/**
* 设置key value并制定这个键值的有效
*
* @param key
* @param value
* @param seconds
* 单位:
* @return 成功返回OK 失败和异常返回null
*/
public String setex(String key, String value, int seconds) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.setex(key, seconds, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key 和offset 从指定的位置始将原先value替换 下标0,offset表示从offset下标始替
* 如果替换的字符串长度过小则会这样 example: value : [email protected] str : abc 从下7始替 则结果为
* RES : bigsea.abc.cn
*
* @param key
* @param str
* @param offset
* 下标位置
* @return 返回替换 value 的长
*/
public Long setrange(String key, String str, int offset) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.setrange(key, offset, str);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
return 0L;
} finally {
returnResource(pool, jedis);
}
}
/**
* 通过批量的key获取批量的value
*
* @param keys
* string数组 也可以是个key
* @return 成功返回value的集, 失败返回null的集 ,异常返回
*/
public List<String> mget(String... keys) {
Jedis jedis = null;
List<String> values = null;
try {
jedis = pool.getResource();
values = jedis.mget(keys);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return values;
}
/**
* 批量的设置key:value,可以 example: obj.mset(new
* String[]{"key2","value1","key2","value2"})
*
* @param keysvalues
* @return 成功返回OK 失败 异常 返回 null
*
*/
public String mset(String... keysvalues) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.mset(keysvalues);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 删除多个字符串key 并释放连
*
* @param key*
* @return 成功返回value 失败返回null
*/
public boolean mdel(List<String> keys) {
Jedis jedis = null;
boolean flag = false;
try {
jedis = pool.getResource();//从连接�用Jedis对象
Pipeline pipe = jedis.pipelined();//获取jedis对象的pipeline对象
for(String key:keys){
pipe.del(key); //将多个key放入pipe删除指令
}
pipe.sync(); //执行命令，完全此时pipeline对象的远程调
flag = true;
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return flag;
}
/**
* 批量的设置key:value,可以,如果key已经存在则会失败,操作会回 example: obj.msetnx(new
* String[]{"key2","value1","key2","value2"})
*
* @param keysvalues
* @return 成功返回1 失败返回0
*/
public Long msetnx(String... keysvalues) {
Jedis jedis = null;
Long res = 0L;
try {
jedis = pool.getResource();
res = jedis.msetnx(keysvalues);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 设置key的?,并返回一个旧
*
* @param key
* @param value
* @return 旧? 如果key不存 则返回null
*/
public String getset(String key, String value) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.getSet(key, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过下标 和key 获取指定下标位置 value
*
* @param key
* @param startOffset
* 始位 0 负数表示从右边开始截
* @param endOffset
* @return 如果没有返回null
*/
public String getrange(String key, int startOffset, int endOffset) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.getrange(key, startOffset, endOffset);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key 对value进行加?+1操作,当value不是int类型时会返回错误,当key不存在是则value1
*
* @param key
* @return 加�后的结
*/
public Long incr(String key) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.incr(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key给指定的value加?,如果key不存,则这是value为该
*
* @param key
* @param integer
* @return
*/
public Long incrBy(String key, Long integer) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.incrBy(key, integer);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 对key的�做减减操作,如果key不存,则设置key-1
*
* @param key
* @return
*/
public Long decr(String key) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.decr(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 减去指定的?
*
* @param key
* @param integer
* @return
*/
public Long decrBy(String key, Long integer) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.decrBy(key, integer);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key获取value值的长度
*
* @param key
* @return 失败返回null
*/
public Long serlen(String key) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.strlen(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key给field设置指定的?,如果key不存,则先创建
*
* @param key
* @param field
* 字段
* @param value
* @return 如果存在返回0 异常返回null
*/
public Long hset(String key, String field, String value) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.hset(key, field, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key给field设置指定的?,如果key不存在则先创,如果field已经存在,返回0
*
* @param key
* @param field
* @param value
* @return
*/
public Long hsetnx(String key, String field, String value) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.hsetnx(key, field, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key同时设置 hash的多个field
*
* @param key
* @param hash
* @return 返回OK 异常返回null
*/
public String hmset(String key, Map<String, String> hash) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.hmset(key, hash);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key field 获取指定 value
*
* @param key
* @param field
* @return 没有返回null
*/
public String hget(String key, String field) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.hget(key, field);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key fields 获取指定的value 如果没有对应的value则返回null
*
* @param key
* @param fields
* 可以 个String 也可以是 String数组
* @return
*/
public List<String> hmget(String key, String... fields) {
Jedis jedis = null;
List<String> res = null;
try {
jedis = pool.getResource();
res = jedis.hmget(key, fields);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key给指定的field的value加上给定的?
*
* @param key
* @param field
* @param value
* @return
*/
public Long hincrby(String key, String field, Long value) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.hincrBy(key, field, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key和field判断是否有指定的value存在
*
* @param key
* @param field
* @return
*/
public Boolean hexists(String key, String field) {
Jedis jedis = null;
Boolean res = false;
try {
jedis = pool.getResource();
res = jedis.hexists(key, field);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key返回field的数
*
* @param key
* @return
*/
public Long hlen(String key) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.hlen(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
public Map<String,String> hgetAll(String key) {
Jedis jedis = null;
Map<String,String> res = null;
try {
jedis = pool.getResource();
res = jedis.hgetAll(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key 删除指定 field
*
* @param key
* @param fields
* 可以 field 也可以是 个数
* @return
*/
public Long hdel(String key, String... fields) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.hdel(key, fields);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
public Set<String> zrange(String key, Long start, Long end) {
Jedis jedis = null;
Set<String> res = null;
try {
jedis = pool.getResource();
res = jedis.zrange(key, start, end);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key返回有的field
*
* @param key
* @return
*/
public Set<String> hkeys(String key) {
Jedis jedis = null;
Set<String> res = null;
try {
jedis = pool.getResource();
res = jedis.hkeys(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key返回有和key有关的value
*
* @param key
* @return
*/
public List<String> hvals(String key) {
Jedis jedis = null;
List<String> res = null;
try {
jedis = pool.getResource();
res = jedis.hvals(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key获取有的field和value
*
* @param key
* @return
*/
public Map<String, String> hgetall(String key) {
Jedis jedis = null;
Map<String, String> res = null;
try {
jedis = pool.getResource();
res = jedis.hgetAll(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key向list头部添加字符
*
*
* @param key
* @param strs
* 可以使一个string 也可以使string数组
* @return 返回list的value个数
*/
public Long lpush(String key, String... strs) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.lpush(key, strs);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key向list尾部添加字符
*
*
* @param key
* @param strs
* 可以使一个string 也可以使string数组
* @return 返回list的value个数
*/
public Long rpush(String key, String... strs) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.rpush(key, strs);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key在list指定的位置之前或者之 添加字符串元
*
*
* @param key
* @param where
* LIST_POSITION枚举类型
* @param pivot
* list里面的value
* @param value
* 添加的value
* @return
*/
public Long linsert(String key, LIST_POSITION where, String pivot, String value) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.linsert(key, where, pivot, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key设置list指定下标位置的value
*
*
* 如果下标超过list里面value的个数则报错
*
*
* @param key
* @param index
* 0
* @param value
* @return 成功返回OK
*/
public String lset(String key, Long index, String value) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.lset(key, index, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key从对应的list中删除指定的count value相同的元
*
*
* @param key
* @param count
* 当count0时删除全
* @param value
* @return 返回被删除的个数
*/
public Long lrem(String key, long count, String value) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.lrem(key, count, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key保留list中从strat下标始到end下标结束的value
*
*
* @param key
* @param start
* @param end
* @return 成功返回OK
*/
public String ltrim(String key, long start, long end) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.ltrim(key, start, end);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key从list的头部删除一个value,并返回该value
*
*
* @param key
* @return
*/
public String lpop(String key) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.lpop(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key从list尾部删除个value,并返回该元素
*
*
* @param key
* @return
*/
public String rpop(String key) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.rpop(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key从一个list的尾部删除一个value并添加到另一个list的头,并返回该value
*
*
* 如果第一个list为空或�不存在则返回null
*
*
* @param srckey
* @param dstkey
* @return
*/
public String rpoplpush(String srckey, String dstkey) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.rpoplpush(srckey, dstkey);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key获取list中指定下标位置的value
*
*
* @param key
* @param index
* @return 如果没有返回null
*/
public String lindex(String key, long index) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.lindex(key, index);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key返回list的长
*
*
* @param key
* @return
*/
public Long llen(String key) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.llen(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key获取list指定下标位置的value
*
*
* 如果start 0 end -1 则返回全部的list中的value
*
*
* @param key
* @param start
* @param end
* @return
*/
public List<String> lrange(String key, long start, long end) {
Jedis jedis = null;
List<String> res = null;
try {
jedis = pool.getResource();
res = jedis.lrange(key, start, end);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key向指定的set中添加value
*
*
* @param key
* @param members
* 可以是一个String 也可以是个String数组
* @return 添加成功的个
*/
public Long sadd(String key, String... members) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.sadd(key, members);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
public void expire(String key, int times) {
Jedis jedis = null;
try {
jedis = pool.getResource();
jedis.expire(key, times);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
}
/**
*
* 通过key删除set中对应的value
*
*
* @param key
* @param members
* 可以是一个String 也可以是个String数组
* @return 删除的个
*/
public Long srem(String key, String... members) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.srem(key, members);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key随机删除个set中的value并返回该
*
*
* @param key
* @return
*/
public String spop(String key) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.spop(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key获取set中的差集
*
*
* 以第个set为标
*
*
* @param keys
* 可以使一个string 则返回set中所有的value 也可以是string数组
* @return
*/
public Set<String> sdiff(String... keys) {
Jedis jedis = null;
Set<String> res = null;
try {
jedis = pool.getResource();
res = jedis.sdiff(keys);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key获取set中的差集并存入到另一个key
*
*
* 以第个set为标
*
*
* @param dstkey
* 差集存入的key
* @param keys
* 可以使一个string 则返回set中所有的value 也可以是string数组
* @return
*/
public Long sdiffstore(String dstkey, String... keys) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.sdiffstore(dstkey, keys);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key获取指定set中的交集
*
*
* @param keys
* 可以使一个string 也可以是个string数组
* @return
*/
public Set<String> sinter(String... keys) {
Jedis jedis = null;
Set<String> res = null;
try {
jedis = pool.getResource();
res = jedis.sinter(keys);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key获取指定set中的交集 并将结果存入新的set
*
*
* @param dstkey
* @param keys
* 可以使一个string 也可以是个string数组
* @return
*/
public Long sinterstore(String dstkey, String... keys) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.sinterstore(dstkey, keys);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key返回有set的并
*
*
* @param keys
* 可以使一个string 也可以是个string数组
* @return
*/
public Set<String> sunion(String... keys) {
Jedis jedis = null;
Set<String> res = null;
try {
jedis = pool.getResource();
res = jedis.sunion(keys);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key返回有set的并,并存入到新的set
*
*
* @param dstkey
* @param keys
* 可以使一个string 也可以是个string数组
* @return
*/
public Long sunionstore(String dstkey, String... keys) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.sunionstore(dstkey, keys);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key将set中的value移除并添加到第二个set
*
*
* @param srckey
* 要移除的
* @param dstkey
* 添加
* @param member
* set中的value
* @return
*/
public Long smove(String srckey, String dstkey, String member) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.smove(srckey, dstkey, member);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key获取set中value的个
*
*
* @param key
* @return
*/
public Long scard(String key) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.scard(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key判断value是否是set中的元素
*
*
* @param key
* @param member
* @return
*/
public Boolean sismember(String key, String member) {
Jedis jedis = null;
Boolean res = null;
try {
jedis = pool.getResource();
res = jedis.sismember(key, member);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key获取set中随机的value,不删除元
*
*
* @param key
* @return
*/
public String srandmember(String key) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.srandmember(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
*
* 通过key获取set中所有的value
*
*
* @param key
* @return
*/
public Set<String> smembers(String key) {
Jedis jedis = null;
Set<String> res = null;
try {
jedis = pool.getResource();
res = jedis.smembers(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key向zset中添加value,score,其中score就是用来排序 如果该value已经存在则根据score更新元素
*
* @param key
* @param scoreMembers
* @return
*/
public Long zadd(String key, Map<String,Double> scoreMembers) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.zadd(key, scoreMembers);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key向zset中添加value,score,其中score就是用来排序 如果该value已经存在则根据score更新元素
*
* @param key
* @param score
* @param member
* @return
*/
public Long zadd(String key, double score, String member) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.zadd(key, score, member);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key删除在zset中指定的value
*
* @param key
* @param members
* 可以使一个string 也可以是个string数组
* @return
*/
public Long zrem(String key, String... members) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.zrem(key, members);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key增加该zset中value的score的?
*
* @param key
* @param score
* @param member
* @return
*/
public Double zincrby(String key, double score, String member) {
Jedis jedis = null;
Double res = null;
try {
jedis = pool.getResource();
res = jedis.zincrby(key, score, member);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
public long hincrBy(String key, String field, long value) {
Jedis jedis = null;
long res = 0l;
try {
jedis = pool.getResource();
res = jedis.hincrBy(key, field, value);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key返回zset中value的排 下标从小到大排序
*
* @param key
* @param member
* @return
*/
public Long zrank(String key, String member) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.zrank(key, member);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key返回zset中value的排 下标从大到小排序
*
* @param key
* @param member
* @return
*/
public Long zrevrank(String key, String member) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.zrevrank(key, member);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key将获取score从start到end中zset的value socre从大到小排序 当start0 end-1时返回全
*
* @param key
* @param start
* @param end
* @return
*/
public Set<String> zrevrange(String key, long start, long end) {
Jedis jedis = null;
Set<String> res = null;
try {
jedis = pool.getResource();
res = jedis.zrevrange(key, start, end);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key返回指定score内zset中的value
*
* @param key
* @param max
* @param min
* @return
*/
public Set<String> zrangebyscore(String key, String max, String min) {
Jedis jedis = null;
Set<String> res = null;
try {
jedis = pool.getResource();
res = jedis.zrevrangeByScore(key, max, min);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key返回指定score内zset中的value
*
* @param key
* @param max
* @param min
* @return
*/
public Set<String> zrangeByScore(String key, double max, double min) {
Jedis jedis = null;
Set<String> res = null;
try {
jedis = pool.getResource();
res = jedis.zrevrangeByScore(key, max, min);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 返回指定区间内zset中value的数
*
* @param key
* @param min
* @param max
* @return
*/
public Long zcount(String key, String min, String max) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.zcount(key, min, max);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key返回zset中的value个数
*
* @param key
* @return
*/
public Long zcard(String key) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.zcard(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key获取zset中value的score
*
* @param key
* @param member
* @return
*/
public Double zscore(String key, String member) {
Jedis jedis = null;
Double res = null;
try {
jedis = pool.getResource();
res = jedis.zscore(key, member);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key删除给定区间内的元素
*
* @param key
* @param start
* @param end
* @return
*/
public Long zremrangeByRank(String key, long start, long end) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.zremrangeByRank(key, start, end);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key删除指定score内的元素
*
* @param key
* @param start
* @param end
* @return
*/
public Long zremrangeByScore(String key, double start, double end) {
Jedis jedis = null;
Long res = null;
try {
jedis = pool.getResource();
res = jedis.zremrangeByScore(key, start, end);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 返回满足pattern表达式的有key keys(*) 返回有的key
*
* @param pattern
* @return
*/
public Set<String> keys(String pattern) {
Jedis jedis = null;
Set<String> res = null;
try {
jedis = pool.getResource();
res = jedis.keys(pattern);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 通过key判断值得类型
*
* @param key
* @return
*/
public String type(String key) {
Jedis jedis = null;
String res = null;
try {
jedis = pool.getResource();
res = jedis.type(key);
} catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
returnResource(pool, jedis);
}
return res;
}
/**
* 返还到连接池
*
* @param pool
* @param redis
*/
public static void returnResource(JedisPool pool, Jedis jedis) {
if (jedis != null) {
pool.returnResource(jedis);
}
}
}
Redis模糊查询
方法一：keys 命令
// 通配符*
Set keys = redisTemplate.keys("*message:*");
Iterator<String> iterator = list.iterator();
List<MsgLike> msgLikes=new ArrayList<>(256);
while (iterator.hasNext()){
//遍历操作；
}
模糊查询：返回所有符合key的集合；
命令优点是简单，初学者拿来即用。(但通常运维大神会在redis服务端禁用该命令)，缺点是可能会直接导致redis服务宕机。由于redis服务是单线程工作，每一条到达的指令都是串行执行，而Keys 命令会全量遍历缓存中的所有key，直到结束，如果redis中的key数量太多、所需要的时间就很长，此刻请求redis服务的其它指令都将被阻塞，后台服务可能会因为超时而报错；
方法二：scan命令
SCAN cursor [MATCH pattern] [COUNT count] [TYPE type]
- cursor：游标；默认为0；
- pattern: 需要进行模糊查询的字符串；与keys的pattern相同；可省略；
- count:返回多少条符合的key; 可省略
- Type: 模糊查询返回的key的类型；可为String,Hash,List,Set,Zset; 可省略
public class RedisUtils {
public static Logger log= LoggerFactory.getLogger(RedisUtils.class);
/**
* 获取 指定格式的所有key
* 迭代执行 SCAN 0 MATCH {pattern} COUNT 10000
*
* @param redisTemplate redisTemplate
* @param pattern 匹配规则，带通配符*pattern*
* @return 指定格式的所有key
*/
public static List<String> scanKeys(RedisTemplate redisTemplate, String pattern) {
//SCAN 0 MATCH {pattern} COUNT 10000
return (List<String>) redisTemplate.execute(connection -> {
//scan 迭代遍历键，返回的结果可能会有重复，需要客户端去重复
Set<String> redisKeys = new HashSet<>();
//lettuce 原生api
RedisAsyncCommands conn = (RedisAsyncCommands) connection.getNativeConnection();
//游标
ScanCursor curs = ScanCursor.INITIAL;
try {
//采用 SCAN 命令，迭代遍历所有key
while (!curs.isFinished()) {
long count = 10000L;
ScanArgs args = ScanArgs.Builder.matches(pattern).limit(count);
log.info("SCAN {} MATCH {} COUNT {}", curs.getCursor(), pattern, count);
RedisFuture<KeyScanCursor<byte[]>> future = conn.scan(curs, args);
KeyScanCursor<byte[]> keyCurs = future.get();
List<byte[]> ks = keyCurs.getKeys();
Set<String> set = ks.stream().map(bytes -> new String(bytes, StandardCharsets.UTF_8)).collect(Collectors.toSet());
log.info("return size:{}", set.size());
redisKeys.addAll(set);
curs = keyCurs;
}
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
return new ArrayList<>(redisKeys);
}, true);
}
}
核心是采用 lettuce 原生api。
io.lettuce.core.api.async.RedisAsyncCommands#scan()
/**
* Incrementally iterate the keys space.
*
* @param scanCursor cursor to resume from a previous scan, must not be {@literal null}
* @param scanArgs scan arguments
* @return KeyScanCursor<K> scan cursor.
*/
RedisFuture<KeyScanCursor<K>> scan(ScanCursor scanCursor, ScanArgs scanArgs);
io.lettuce.core.ScanCursor 是迭代遍历的游标
io.lettuce.core.ScanArgs 是Scan的参数，包括count和pattern字符串。
io.lettuce.core.KeyScanCursor 是每次迭代后的返回数据，包含下次迭代的游标和此次迭代返回的keys列表。
原生api可以获取到每次迭代后下次迭代的游标，便于采用轮询的方式实现真正的迭代遍历。
采用scan 迭代遍历键，返回的结果可能会有重复，需要客户端去重复。代码中用 Set，存储每次迭代的key列表，可实现去重。