技术标签： java jedis 分布式存储 web架构 分布式开发 分布式缓存 redis
最近公司用到redis ， 参考了一些帖子以及github上的代码 ，自己整理出的一些简单的封装，如果有更好的想法，希望大家互相交流，谢谢！
源文件目录有redis.properties 文件
#最大分配的对象数
redis.pool.maxTotal=1024
#最大能够保持idel状态的对象数
redis.pool.maxIdle=200
#当池内没有返回对象时，最大等待时间
redis.pool.maxWaitMillis=1000
#当调用borrow Object方法时，是否进行有效性检查
redis.pool.testOnBorrow=true
#当调用return Object方法时，是否进行有效性检查
redis.pool.testOnReturn=true
#测试机IP
#redis.ip=192.168.0.250
redis.ip=localhost
#Port
redis.port=6379直接上代码
public interface RedisCallback<T> {
public T call(Jedis jedis,Object params);
}@Component
public class RedisClient {
private static Logger logger = LoggerFactory.getLogger("RedisManager");
private static JedisPool pool = null;
private static String IP_ADDRESS = null;
@PostConstruct
public void initRedisCOnfig() {
try {
logger.info("------------- redis pool init start------------- ");
Properties props = new Properties();
props.load(RedisClient.class.getClassLoader().getResourceAsStream("redis.properties"));
IP_ADDRESS = props.getProperty("redis.ip");
// 创建jedis池配置实例
JedisPoolConfig config = new JedisPoolConfig();
// 设置池配置项值
config.setTestWhileIdle(false);
config.setMaxTotal(Integer.valueOf(props.getProperty("redis.pool.maxTotal")));
config.setMaxIdle(Integer.valueOf(props.getProperty("redis.pool.maxIdle")));
config.setMaxWaitMillis(Long.valueOf(props.getProperty("redis.pool.maxWaitMillis")));
config.setTestOnBorrow(Boolean.valueOf(props.getProperty("redis.pool.testOnBorrow")));
config.setTestOnReturn(Boolean.valueOf(props.getProperty("redis.pool.testOnReturn")));
pool = new JedisPool(config, IP_ADDRESS, Integer.valueOf(props.getProperty("redis.port")));
boolean connected = isConnected();
if(!connected){
logger.error("redis 初始化出错 缓存服务器连接不上！ ");
throw new Exception("IP:"+IP_ADDRESS+", redis服务器不可以连接~~~，请检查配置 与redis 服务器");
}
logger.info("------------- redis pool init end------------- ");
} catch (Exception e) {
logger.error(e.getMessage(), e);
throw new Error("IP:" + IP_ADDRESS + ",设置redis服务器出错", e);
}
}
public boolean isConnected() {
return getRedis().isConnected();
}
public void destory() {
pool.destroy();
}
public Jedis getRedis() {
Jedis jedis = pool.getResource();
jedis.select(0);
return jedis;
}
public Jedis getRedis(int index) {
Jedis jedis = pool.getResource();
jedis.select(index);
return jedis;
}
public void returnRedis(Jedis jedis) {
pool.returnResource(jedis);
}
public void returnBrokeRedis(Jedis jedis) {
pool.returnBrokenResource(jedis);
}
}
public class RedisKVPO {
private String k;
private String v;
public RedisKVPO(){}
public RedisKVPO(String k, String v) {
this.k = k;
this.v = v;
}
public String getK() {
return k;
}
public void setK(String k) {
this.k = k;
}
public String getV() {
return v;
}
public void setV(String v) {
this.v = v;
}
}
@Component
public class RedisTempalte {
private static Logger logger = LoggerFactory.getLogger("RedisSimpleTempalte");
@Autowired
private RedisClient client;
protected <T> T execute(RedisCallback<T> callback, Object... args) {
Jedis jedis = null;
try {
Object index = ((Object[]) args)[0];
System.err.println("-------------------index ------------"+index);
if(null!=index&&Integer.parseInt(index.toString())>0&&Integer.parseInt(index.toString())<16){
jedis = client.getRedis(Integer.parseInt(index.toString()));
}else{
jedis = client.getRedis();
}
return callback.call(jedis, args);
} catch (JedisConnectionException e) {
if (jedis != null)
client.returnBrokeRedis(jedis);
jedis = client.getRedis();
logger.error(e.getMessage(),e);
} catch (Exception e) {
logger.error(e.getMessage(),e);
} finally {
if (jedis != null) {
client.returnRedis(jedis);
}
}
return null;
}
/**
* @Description:选择DB实例
* @author Wanglei
* Date: 2015-8-12 上午9:28:34
* @param index 实例index
* @version [版本号1.0.0]
*/
public void select(int index) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
int index = Integer.parseInt(((Object[]) parms)[0].toString());
return jedis.select(index);
}
}, index);
}
public Boolean isConnected(int index){
return execute(new RedisCallback<Boolean>() {
@Override
public Boolean call(Jedis jedis, Object params) {
return jedis.isConnected();
}
},index);
}
public Boolean exists(int index,String key){
return execute(new RedisCallback<Boolean>() {
@Override
public Boolean call(Jedis jedis, Object params) {
String key = ((Object[]) params)[1].toString();
return jedis.exists(key);
}
}, index,key);
}
public Boolean hexists(int index,String mapKey, String attributeKey){
return execute(new RedisCallback<Boolean>() {
@Override
public Boolean call(Jedis jedis, Object params) {
String key = ((Object[]) params)[1].toString();
String field = ((Object[]) params)[2].toString();
return jedis.hexists(key, field);
}
}, index,mapKey,attributeKey);
}
/**
* @Description: 获取Hash（哈希）
* @author Wanglei
* Date: 2015-8-12 上午9:29:38
* @param key
* @param field
* @return
* @version [版本号1.0.0]
*/
public String hget(int index,String key, String field) {
return execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
String field = ((Object[]) parms)[2].toString();
return jedis.hget(key, field);
}
},index, key, field);
}
public Map<String, String> hgetAll(int index,String key) {
return execute(new RedisCallback<Map<String, String>>() {
@Override
public Map<String, String> call(Jedis jedis, Object params) {
String key = ((Object[]) params)[1].toString();
return jedis.hgetAll(key);
}
}, index,key);
}
public Long hdel(int index,String mapKey, String attributeKey){
return execute(new RedisCallback<Long>() {
@Override
public Long call(Jedis jedis, Object params) {
String key = ((Object[]) params)[1].toString();
String field = ((Object[]) params)[2].toString();
return jedis.hdel(key, field);
}
},index, mapKey,attributeKey);
}
/**
* @Description: Hash（哈希）
* @author Wanglei
* Date: 2015-8-12 上午9:30:29
* @param key
* @param field
* @param value
* @version [版本号1.0.0]
*/
public void hset(int index,String key, String field, String value) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
String field = ((Object[]) parms)[2].toString();
String value = ((Object[]) parms)[3].toString();
jedis.hset(key, field, value);
return null;
}
}, key, field, value);
}
/**
* @Description:String（字符串）获取
* @author Wanglei
* Date: 2015-8-12 上午9:30:58
* @param key
* @return value
* @version [版本号1.0.0]
*/
public String get(int index,String key) {
return execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
return jedis.get(key);
}
},index, key);
}
public byte[] getByte(int index,String key) {
return execute(new RedisCallback<byte[]>() {
public byte[] call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
try {
return jedis.get(key.getBytes("UTF-8"));
} catch (UnsupportedEncodingException e) {
logger.error(e.getMessage(),e);
}
return null;
}
}, index,key);
}
/**
* @Description: String（字符串）赋值
* @author Wanglei
* Date: 2015-8-12 上午9:31:32
* @param key
* @param value
* @version [版本号1.0.0]
*/
public void set(int index,String key, String value) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
String value = ((Object[]) parms)[2].toString();
jedis.set(key, value);
return null;
}
}, index,key, value);
}
public void set(int index,String key, byte[] value) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
byte[] value = (byte[]) ((Object[]) parms)[2];
try {
jedis.set(key.getBytes("UTF-8"), value);
} catch (UnsupportedEncodingException e) {
logger.error(e.getMessage(),e);
}
return null;
}
},index, key, value);
}
/**
* @Description:seconds:过期时间（单位：秒）
* @author Wanglei
* Date: 2015-8-12 上午9:32:09
* @param key
* @param value
* @param seconds
* @version [版本号1.0.0]
*/
public void set(int index,String key, String value, int seconds) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
String value = ((Object[]) parms)[2].toString();
String seconds = ((Object[]) parms)[3].toString();
jedis.setex(key, Integer.parseInt(seconds), value);
return null;
}
},index,key, value, seconds);
}
public void set(int index,String key, byte[] value, int seconds) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
byte[] value = (byte[]) ((Object[]) parms)[2];
String seconds = ((Object[]) parms)[3].toString();
try {
jedis.setex(key.getBytes("UTF-8"), Integer.parseInt(seconds), value);
} catch (UnsupportedEncodingException e) {
logger.error(e.getMessage(),e);
}
return null;
}
}, index,key, value, seconds);
}
/**
* @Description: 批量Set
* @author Wanglei
* Date: 2015-8-12 上午9:31:58
* @param list
* @version [版本号1.0.0]
*/
public void setPipeLine(int index,List<RedisKVPO> list) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
Pipeline p = jedis.pipelined();
@SuppressWarnings("unchecked")
List<RedisKVPO> values = (List<RedisKVPO>) ((Object[]) parms)[1];
for (RedisKVPO po : values) {
p.set(po.getK(), po.getV());
}
p.sync();
return null;
}
},index, list);
}
/**
* @Description: 根据key删除
* @author Wanglei
* Date: 2015-8-12 上午9:32:33
* @param key
* @version [版本号1.0.0]
*/
public void del(int index,String key) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
jedis.del(key);
return null;
}
},index, key);
}
public String llen(int index,String key) {
return execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
return jedis.llen(key) + "";
}
},index, key);
}
public void lpush(int index,String key, String value) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
String value = ((Object[]) parms)[2].toString();
jedis.lpush(key, value);
return null;
}
}, index,key, value);
}
public void lpushPipeLine(int index,String key, List<String> values) {
execute(new RedisCallback<String>() {
@SuppressWarnings("unchecked")
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
List<String> values = (List<String>) ((Object[]) parms)[2];
Pipeline p = jedis.pipelined();
for (String value : values) {
p.lpush(key, value);
}
p.sync();
return null;
}
},index, key, values);
}
public List<String> lrange(int index,String key, long start, long end) {
return execute(new RedisCallback<List<String>>() {
public List<String> call(Jedis jedis, Object parms) {
Object[] ps = ((Object[]) parms);
String key = ps[1].toString();
long start = Long.parseLong(ps[2].toString());
long end = Long.parseLong(ps[3].toString());
return jedis.lrange(key, start, end);
}
}, index,key, start, end);
}
public void incr(int index,String key) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
jedis.incr(key);
return null;
}
},index, key);
}
public void sadd(int index,String key, String value) {
execute(new RedisCallback<String>() {
public String call(Jedis jedis, Object parms) {
String key = ((Object[]) parms)[1].toString();
String value = ((Object[]) parms)[2].toString();
jedis.sadd(key, value);
return null;
}
}, index,key, value);
}
public Set<String> smembers(int index,String key) {
return execute(new RedisCallback<Set<String>>() {
public Set<String> call(Jedis jedis, Object parms) {
Object[] ps = ((Object[]) parms);
String key = ps[1].toString();
return jedis.smembers(key);
}
}, index,key);
}
public List<String> brpop(int index,String key) {
return execute(new RedisCallback<List<String>>() {
public List<String> call(Jedis jedis, Object parms) {
Object[] ps = ((Object[]) parms);
String key = ps[1].toString();
return jedis.brpop(0, key);
}
},index, key);
}
}
public class CacheSessionProvider implements SessionProvider{
@Autowired
private RedisTempalte redisTempalte;
@Override
public void logout(HttpServletRequest request,HttpServletResponse response) {
//cache 缓存del
String sessionKey = generatorSessionKey(getSessionId(request,response));
if(redisTempalte.exists(redisSessionIndex, sessionKey)){
redisTempalte.del(redisSessionIndex, sessionKey);
}
//清理Cookie
}
}http://blog.csdn.net/leezy_2000/article/details/36512487 转载于:https://my.oschina.net/u/554222/b...
每个word文件中有几百个带底纹的图片，需要将这些图片格式设置成的亮度为50，对比度为100，这样能去除底纹。请问如何批量处理？还是让我帮你来出点子吧，怎么前面的都答非所问呢。 新建一个宏，将如下代码原样复制粘贴进入后按F5执行即可。'Sub Macro1() For i = 1 To ActiveDocument.InlineShapes.Count ActiveD...
概念用户体验（UserExperience，简称UX或UE）是一种纯主观的在用户使用一个产品（服务）的过程中建立起来的心理感受。因为它是纯主观的，就带有一定的不确定因素。个体差异也决定了每个用户的真实体验是无法通过其他途径来完全模拟或再现的。但是对于一个界定明确的用户群体来讲，其用户体验的共性是能够经由良好设计的实验来认识到。计算机技术和互联网的发展，使技术创新形态...
1.首先要修改hosts文件：1.点击桌面上的我的电脑，访问C:\Windows\System32\drivers\etc下的hosts文件2.要在hosts文件中加入下列代码：# GitHub Start 192.30.253.112 github.com 192.30.253.119 gist.github.com# GitHub Start 192.30.253.112 git...
在Redis中，哈希表不但是我们可以使用的几种基础数据结构之一，同时还是整个Redis数据存储结构的核心。 究其根本，Redis是一种基于Key-Value的内存数据库，所有的用户数据，Redis在底层都是使用哈希表进行保存的。 可以说，了解Redis中哈希表的实现方式，是了解Redis存储的一个关键。Redis哈希表概述基于链表的哈希表是实现哈希表的一个主流方式，除了Redis中的哈希表实现，g...
一、MySQL数据库安装博主用的是CentOS7.8版本，MySQL是8.01.首先检查Linux主机MySQL的安装情况rpm -qa|grep mysql没有反应是正常的，CentOS7系统默认没有安装MySQL数据库，要自己安装。2.安装方式有以下三种（1）通过yum命令在线下载安装（2）下载离线rpm安装包安装（3）下载源码编译安装其中第二种和第三种安装成功率都不高，因此，推荐使用yum在线安装3.获取MySQL数据库安装源https://dev.mysql.com/do
首先引入依赖，版本可以自行选择，（官网有各版本和各种配置方式的文档)。 <dependency> <groupId>io.shardingsphere</groupId> <artifactId>sharding-jdbc-spring-boot-starter</artifactId> <version>3.0.0</version&
戳蓝字“CSDN云计算”关注我们哦！技术头条：干货、简洁、多维全面。更多云计算精华知识尽在眼前，get要点、solve难题，统统不在话下！作为云计算的当红明星Docker...
安装完SQL server2017之后，选择SQL 身份验证登录，可以先用windows身份验证登录把密码更改好了，然后服务器右键重新启动 ，再断开连接 ，选择SQL身份验证登录验证，关闭SQL server2017选择SQL server2017配置管理器如果这里找不到的话，就在我的电脑右键-&gt;管理找到选择你正在使用的协议，要是不知道是哪个的话就都改了吧（就是这么暴力/笑哭） 状态都改成...
Description 殷犇有很多队员。他们都认为自己是最强的，于是，一场比赛开始了~ 于是安叔主办了一场比赛，比赛有n个题目，每个题目都有一个价值Pi和相对能力消耗Wi，但是有些题目因为太坑不能同时做出来，并且坑题具有传递性。（a和b一起做会坑、b和c会坑则a和c也会坑） ACM队员们想知道，于是他们想知道在能力范围内，它们最多可以作出多少价值的题目。 聪明的你
先建个钉钉群，并加好机器人此时，机器人已经添加完毕，接下来编写我们连接机器人小哥的代码import com.alibaba.fastjson.JSON;import com.google.common.collect.Lists;import com.google.common.collect.Maps;import java.util.List;import java.util.Map;/***...
什么是web服务 什么是Web服务？ (What are Web Services?)Web Services are client and server applications that communicate over the World Wide Web's (WWW) Hypertext Transfer Protocol (HTTP). As described by the Wo...