redis管道技术pipeline二——api
package spring.redis; import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service; import java.io.UnsupportedEncodingException;
import java.util.*;
import java.util.stream.Collectors; @Service
public class SpringRedisHandler implements InitializingBean { //redis编码
private static final String redisCode = "utf-8";
private static final String EmptyString = ""; @Autowired
private RedisTemplate<String, String> jtRedis; /**
* 设置key-value【不含超时时间】
*
* @param key
* @param value
*/
public void set(String key, Object value) {
this.set(key, String.valueOf(value), 0L);
} /**
* 设置key-value【含超时时间】
*
* @param key
* @param value
* @param liveTime
*/
public void set(String key, Object value, long liveTime) {
this.set(key.getBytes(), String.valueOf(value).getBytes(), liveTime);
} @SuppressWarnings({"unchecked", "rawtypes"})
private void set(final byte[] key, final byte[] value, final long liveTime) {
jtRedis.execute(new RedisCallback() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
connection.set(key, value);
if (liveTime > 0) {
connection.expire(key, liveTime);
}
return 1L;
}
});
} /**
* get key的值
*
* @param key
* @return
*/
public String get(final String key) {
return jtRedis.execute(new RedisCallback<String>() {
@Override
public String doInRedis(RedisConnection connection) throws DataAccessException {
try {
return new String(connection.get(key.getBytes()), redisCode);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
return "";
}
}
});
} /**
* 是否存在key
*
* @param key
* @return
*/
public boolean exists(final String key) {
return jtRedis.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
return connection.exists(key.getBytes());
}
});
} /**
* 某数据中所有key的总数
*
* @return
*/
public long dbSize() {
return jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.dbSize();
}
});
} /**
* 检测redis服务器是否能平通
*/
public String ping() {
return jtRedis.execute(new RedisCallback<String>() {
@Override
public String doInRedis(RedisConnection connection) throws DataAccessException {
return connection.ping();
}
});
} /**
* value增加某个值
*
* @param key
* @param value
* @return
*/
public Long incr(String key, long value) {
return incr(key.getBytes(), value);
} private Long incr(byte[] key, long value) {
return jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.incrBy(key, value);
}
});
} /**
* 自增
*
* @param key
* @return
*/
public Long incr(String key) {
return incr(key.getBytes(), 1);
} /**
* 自减
*
* @param key
* @return
*/
public Long decr(String key) {
return decr(key.getBytes(), 1);
} /**
* value减少某个值
*
* @param key
* @param value
* @return
*/
public Long decr(String key, long value) {
return decr(key.getBytes(), value);
} private Long decr(byte[] key, long value) {
return jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.decrBy(key, value);
}
});
} /**
* 删除key
*
* @param key
* @return
*/
public Long del(String key) {
return del(key.getBytes());
} private Long del(byte[] key) {
return jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.del(key);
}
});
} /**
* flushdb：删除db下的所有数据
*/
@SuppressWarnings({"rawtypes", "unchecked"})
public void flushDb() {
jtRedis.execute(new RedisCallback() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
connection.flushDb();
return 1L;
}
});
} /**
* 设置hash
*
* @param key
* @param field
* @param value
* @return
*/
public Boolean hSet(String key, String field, String value) {
return jtRedis.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.hSet(key.getBytes(), field.getBytes(), value.getBytes());
}
});
} /**
* 获取hash的属性值
*
* @param key
* @param field
* @return
*/
public String hGet(String key, String field) {
return jtRedis.execute(new RedisCallback<String>() {
@Override
public String doInRedis(RedisConnection redisConnection) throws DataAccessException {
return new String(redisConnection.hGet(key.getBytes(), field.getBytes()));
}
});
} /**
* 批量设置hash
*
* @param key
* @param values
*/
public void hMSet(String key, Map<String, Object> values) {
jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
redisConnection.hMSet(key.getBytes(), stringObjectMapToBytes(values));
return null;
}
});
} /**
* 批量获取hash的多个属性
*
* @param key
* @param fields
* @return
*/
public List<String> hMGet(String key, String... fields) {
return jtRedis.execute(new RedisCallback<List<String>>() {
@Override
public List<String> doInRedis(RedisConnection redisConnection) throws DataAccessException {
List<String> listFileds = new ArrayList<>();
for (int i = 0; i < fields.length; i++) {
listFileds.add(fields[i]);
} List<byte[]> byteFileds = stringListToByte(listFileds);
return bytesListToString(redisConnection.hMGet(key.getBytes(), byteFileds.toArray(new byte[byteFileds.size()][byteFileds.size()])));
}
});
} /**
* 获取hash的所有属性
*
* @param key
* @return
*/
public Map<String, String> hGetAll(String key) {
return jtRedis.execute(new RedisCallback<Map<String, String>>() {
@Override
public Map<String, String> doInRedis(RedisConnection redisConnection) throws DataAccessException {
return bytesMapToString(redisConnection.hGetAll(key.getBytes()));
}
});
} /**
* 针对hash中某个属性增加指定的值
*
* @param key
* @param field
* @param value
* @return
*/
public Double hIncrBy(String key, String field, double value) {
return jtRedis.execute(new RedisCallback<Double>() {
@Override
public Double doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.hIncrBy(key.getBytes(), field.getBytes(), value);
}
});
} /**
* hash是存在某属性
*
* @param key
* @param field
* @return
*/
public Boolean hExists(String key, String field) {
return jtRedis.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.hExists(key.getBytes(), field.getBytes());
}
});
} /**
* 删除hash的某属性
*
* @param key
* @param field
* @return
*/
public Long hDel(String key, String field) {
return jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.hDel(key.getBytes(), field.getBytes());
}
});
} /**
* 向zset中的某个key添加一个属性几分数（可以根据分数排序）
*
* @param key
* @param score
* @param field
* @return
*/
public Boolean zAdd(String key, double score, String field) {
return jtRedis.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.zAdd(key.getBytes(), score, field.getBytes());
}
});
} /**
* 给zset中的某个key中的某个属性增加指定分数
*
* @param key
* @param score
* @param field
* @return
*/
public Double zIncrBy(String key, double score, String field) {
return jtRedis.execute(new RedisCallback<Double>() {
@Override
public Double doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.zIncrBy(key.getBytes(), score, field.getBytes());
}
});
} /**
* 从list左侧插入一个元素
*
* @param key
* @param values
* @return
*/
public Long lPush(String key, String value) {
return jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.lPush(key.getBytes(), value.getBytes());
}
});
} /**
* 从list左侧插入多个元素
*
* @param key
* @param values
* @return
*/
public Long lPush(String key, List<String> values) {
return jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
List<byte[]> bytes = stringListToByte(values);
return connection.lPush(key.getBytes(), bytes.toArray(new byte[bytes.size()][bytes.size()]));
}
});
} /**
* 从list的左侧取出一个元素
*
* @param key
* @return
*/
public String lPop(String key) {
return jtRedis.execute(new RedisCallback<String>() {
@Override
public String doInRedis(RedisConnection connection) throws DataAccessException {
if (connection.lLen(key.getBytes()) > 0) {
return new String(connection.lPop(key.getBytes()));
} else {
return EmptyString;
}
}
});
} /**
* 向list的右侧插入一个元素
*
* @param key
* @param value
* @return
*/
public Long rPush(String key, String value) {
return jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.rPush(key.getBytes(), value.getBytes());
}
});
} /**
* list的rpush，从右侧插入多个元素
*
* @param key
* @param values
* @return
*/
public Long rPush(String key, List<String> values) {
return jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
List<byte[]> bytes = stringListToByte(values);
return connection.rPush(key.getBytes(), bytes.toArray(new byte[bytes.size()][bytes.size()]));
}
});
} /**
* 从list的右侧取出一个元素
*
* @param key
* @return
*/
public String rPop(String key) {
return jtRedis.execute(new RedisCallback<String>() {
@Override
public String doInRedis(RedisConnection connection) throws DataAccessException {
if (connection.lLen(key.getBytes()) > 0) {
return new String(connection.rPop(key.getBytes()));
} else {
return EmptyString;
}
}
});
} /**
* 给set中添加元素
*
* @param key
* @param values
* @return
*/
public Long sadd(String key, List<String> values) {
return jtRedis.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
List<byte[]> bytes = stringListToByte(values);
return connection.sAdd(key.getBytes(), bytes.toArray(new byte[bytes.size()][bytes.size()]));
}
});
} /**
* 获取set中的所有元素
*
* @param key
* @return
*/
public List<String> smembers(String key) {
return jtRedis.execute(new RedisCallback<List<String>>() {
@Override
public List<String> doInRedis(RedisConnection connection) throws DataAccessException {
return bytesListToString(connection.sMembers(key.getBytes()));
}
});
} /**
* set中是否包含某元素
*
* @param key
* @param value
* @return
*/
public Boolean sIsMember(String key, String value) {
return jtRedis.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
return connection.sIsMember(key.getBytes(), value.getBytes());
}
});
} private byte[][] change(List<byte[]> values) {
byte[][] result = {};
return result;
} private List<byte[]> stringListToByte(List<String> values) {
return values
.stream()
.map(p -> p.getBytes())
.collect(
Collectors.toList()
);
} private List<String> bytesListToString(Collection<byte[]> values) {
return values
.stream()
.map(p -> new String(p))
.collect(
Collectors.toList()
);
} private Map<String, String> bytesMapToString(Map<byte[], byte[]> values) {
Map<String, String> result = new HashMap<>();
values.forEach((k, v) -> result.put(new String(k), new String(v)));
return result;
} private Map<byte[], byte[]> stringObjectMapToBytes(Map<String, Object> values) {
Map<byte[], byte[]> result = new HashMap<>();
values.forEach((k, v) -> result.put(k.getBytes(), String.valueOf(v).getBytes()));
return result;
} /**
* 正则表达式获取值
*
* @param pattern
* @return
*/
public Set<String> keys(String pattern) {
return jtRedis.keys(pattern);
} @Override
public void afterPropertiesSet() throws Exception {
RedisSerializer<String> stringSerializer = new StringRedisSerializer();
jtRedis.setKeySerializer(stringSerializer);
jtRedis.setValueSerializer(stringSerializer);
jtRedis.setHashKeySerializer(stringSerializer);
jtRedis.setHashValueSerializer(stringSerializer);
}
}
相关文章：https://my.oschina.net/u/3266761/blog/3023454
https://www.cnblogs.com/sxdcgaq8080/p/10949727.html
或者api2：
public String tsetRedis(){
2 Long time = System.currentTimeMillis();
3 for (int i = 0; i < 10000; i++) {
4 stringRedisTemplate.opsForValue().set("yi" + i, "wo" + i);
5 }
6 Long time1 = System.currentTimeMillis();
7 System.out.println("耗时：" + (time1 - time));
8 long time4 = System.currentTimeMillis();
9 stringRedisTemplate.executePipelined(new SessionCallback<Object>() {
10 @Override
11 public <K, V> Object execute(RedisOperations<K, V> redisOperations) throws DataAccessException {
12 for (int i = 0; i < 10000; i++) {
13 stringRedisTemplate.opsForValue().set("qiang" + i, "wo" + i);
14 }
15 return null; //RedisTemplate执行executePipelined方法是有返回值的
16 }
17 });
18 Long time2 = System.currentTimeMillis();
19 System.out.println("耗时：" + (time2 - time4));
20 return "redis正常耗时：" + (time1 - time) + "<br/>" + "redis管道耗时：" + (time2 - time4);
21 }
redis管道技术pipeline二——api的更多相关文章
- redis 管道技术 pipeline 简介
redis数据库的主要瓶颈是网络速度,其次是内存与cpu.在应用允许的情况下,优先使用pipeline批量操作.pipeline批量发出请求/一次性获取响应:不是发出多个请求,每个请求都阻塞等待响应, ...
- Redis 管道技术
Redis是一种基于客户端-服务端模型以及请求/响应协议的TCP服务.这意味着通常情况下一个请求会遵循以下步骤: 客户端向服务端发送一个查询请求,并监听Socket返回,通常是以阻塞模式,等待服务端响 ...
- redis管道技术
1.redis管道pipeline解决的问题: 由于redis通信是通过tcp协议基础,并且是堵塞的处理方式,在第一个请求没有执行并返回前,无法处理第二个请求.所以事件浪费在了网络传输和堵塞请求中. ...
- Redis 管道（pipeline）
- Redis 管道pipeline
Redis是一个cs模式的tcp server,使用和http类似的请求响应协议. 一个client可以通过一个socket连接发起多个请求命令. 每个请求命令发出后client通常会阻塞并等待red ...
- Redis 数据备份与恢复，安全，性能测试，客户端连接，管道技术，分区（四）
Redis 数据备份与恢复 Redis SAVE 命令用于创建当前数据库的备份. 语法 redis Save 命令基本语法如下: redis 127.0.0.1:6379> SAVE 实例 re ...
- 缓存数据库-redis(管道)
一:Redis 管道技术 Redis是一种基于客户端-服务端模型以及请求/响应协议的TCP服务.这意味着通常情况下一个请求会遵循以下步骤: 客户端向服务端发送一个查询请求,并监听Socket返回,通常 ...
- Redis学习篇（十二）之管道技术
通过管道技术降低往返时延 当后一条命令不依赖于前一条命令的返回结果时,可以使用管道技术将多条命令一起 发送给redis服务器,服务器执行结束之后,一起返回结果,降低了通信频度.
- .NET客户端实现Redis中的管道（PipeLine）与事物（Transactions）
序言 Redis中的管道(PipeLine)特性:简述一下就是,Redis如何从客户端一次发送多个命令,服务端到客户端如何一次性响应多个命令. Redis使用的是客户端-服务器模型和请求/响应协议的T ...
- Redis 新特性---pipeline（管道）
转载自http://weipengfei.blog.51cto.com/1511707/1215042 Redis本身是一个cs模式的tcp server, client可以通过一个socket连续发 ...
随机推荐
- Unity学习笔记--数据持久化XML文件（2）
IXmlSerializable接口: 使用该接口可以帮助处理不能被序列化和反序列化的特殊类得到处理, 使特殊类继承IXmlSerializable接口 ,实现其中的读写方法,检测到读写方法被重写之后 ...
- 数据分析工具 Datainside、Power BI、帆软(FineReport)怎么选？
Datainside.Power BI和帆软(FineReport)都是数据分析领域常用的工具,它们各自有不同的特点和适用场景.下面将会详细介绍每个工具的功能和优势,以便您进行选择. Datainsi ...
- Snipaste安装与使用教程
一.下载 1.官网 下载地址 2.下载 可以直接在官网下载,也可以跳转微软仓库下载增强版的.如果是其他系统,mac在最下面,而Linux现在没有需要等待. 二.开始安装 1.下载完毕,是一压缩包绿色版 ...
- 利用Jdk动态代理模拟MyBatis的Mapper功能
本文将先介绍jdk动态代理的基本用法,并对其原理和注意事项予以说明.之后将以两个最常见的应用场景为例,进行代码实操.这两个应用场景分别是拦截器和声明性接口,它们在许多开发框架中广泛使用.比如在spri ...
- Tampermonkey(油猴)的获取方法
介绍: Tampermonkey中有大量的脚本,可以方便我们在日常的上网使用. 有那么一句话说:没有了Tampermonkey(油猴)我都不知道该如何上网. 获取Tampermonkey的步骤: 1. ...
- 【笔记整理】忽略https证书校验
import requests url = "https://sam.huat.edu.cn:8443/selfservice/" # 默认不忽略ssl证书,如果有证书问题的网站会 ...
- 聊聊流式数据湖Paimon(一)
翻译自 Apache Paimon官方文档 概览 概述 Apache Paimon (incubating) 是一项流式数据湖存储技术,可以为用户提供高吞吐.低延迟的数据摄入.流式订阅以及实时查询能力 ...
- Python——第四章：推导式（Comprehensions）
推导式: 推导式是为了简化代码. 语法: 列表推导式:[数据 for循环 if判断] 集合推导式:{数据 for循环 if判断} 字典推导式:{k:v for循环 if判断} 元组推导式:不存在(因为 ...
- JavaFx之使用高版本JDK（二十八）
JavaFx之使用高版本JDK(二十八) 如何使用高版本的jfx? 根据官网的需要手动引入jfx模块(运行参数:–module-path) 要知道高版本jfx已经集成了丰富的主流功能,例如视频编码,大 ...
- Docker 使用及常见问题总结
一.使用 1.docker run -it 命令中的 it 参数是什么含义 在Docker中,-it是两个选项的组合,用于在交互式模式下运行容器.让我解释一下它们的含义: -i 或 --interac ...