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连续发 ...
随机推荐
- Codeforces Round #691 (Div. 2) D - Glass Half Spilled（DP）
题目 补下因实验漏掉的CF(还以为是晚上,没想到是下午开始).前三题过的很顺利,到D题时想了会发现数据很小爆搜貌似能过,就以为是道水题,交了一发T了,胡乱加了点剪枝还是T.逐渐意识到事情的严重性.考虑 ...
- 用Python编写 2048 命令行小游戏
本篇博文围绕使用Python开发热门游戏2048 GAME(命令行版本) 代码未做任何优化(原生且随意).全程以面向过程.MVC的设计思想为主.开发环境是Ubuntu系统下的Pycharm 2048是 ...
- [编程] AI助力软件项目正向生成,注释编写的革命
引言 软件项目质量直接影响着用户体验和企业效益.随着软件的应用范围不断扩大,提高软件质量的重要性也日益凸显.传统上,软件工程师通常采用自下而上的开发模式,自行设计实现代码并进行测试,这给质量把控带来一 ...
- easycom自动导入自定义组件
使用时要先创建一个这样的结构 相当于定义一个方法,所有的页面引用就可以了
- 【已解决】nrm -g安装成功后不是全局应用（command not found: nrm）
本机情况: 服务器系统:CentOS 8.1 nodejs版本:20 问题描述: 在命令行执行命令,npm install -g nrm,全局安装nrm. 安装之后,执行nrm ls 报command ...
- 华企盾防泄密软件关于U盘无法注册问题
1.以管理员权限运行控制台注册 2.如果是非加密注册可在USB拔插日志中右键日志远程注册 3.检查USB的驱动程序注册表是否都有 4.换一台电脑安装控制台注册 5.检查是否有与驱动有关的程序卸载试试 ...
- 韩国国民搜索 NAVER：为 AI 平台引入存储方案 JuiceFS
NAVER 是一家多元化的互联网公司,拥有韩国最大的搜索引擎并在人工智能.自动驾驶等高科技领域积极投入. 在搭建 AI 平台时,NAVER 评估了公有云平台的存储产品.Alluxio 以及高性能专用存 ...
- Sliver 二开准备
cs被杀麻了,最近打算看看一下sliver的源码进行一下二开,这篇是记录遇到的一些问题 编译sliver Windows下 官方说用MingW,但是我自己用他带的make不行, 下载make ...
- Spring 七种事务传播性介绍
作者:vivo 互联网服务器团队 - Zhou Shaobin 本文主要介绍了Spring事务传播性的相关知识. Spring中定义了7种事务传播性: PROPAGATION_REQUIRED PRO ...
- 让 sdk 包静默升级的 SAO 操作，你见过几种？
拓展阅读 让 sdk 包静默升级的 SAO 操作,你见过几种? 业务背景 有时候为业务方提供了基础的 sdk 包,为了保证稳定性,一般都是 release 包. 但是每一次升级都非常痛苦,也不可能写一 ...