原文：http://blog.csdn.net/centre10/article/details/50761815
http://my.oschina.net/u/866380/blog/521658 （切片方式的带密码、数据库方式的访问）
http://www.cnblogs.com/zr520/p/5062025.html （spring 使用redis集群配置）
要用redis ，则必须添加相关的包
jedis-2.7.2.jar
commons-pool2-2.0.jar
1、spring 和 redis 的非切片方式的配置
<!-- Jedis 连接池配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!-- 控制一个pool（池）可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制 -->
<property name="maxTotal" value="${jedis.pool.maxTotal}" />
<!-- 控制一个pool（池）最多有多少个状态为idle(空闲)的jedis实例 -->
<property name="maxIdle" value="${jedis.pool.maxIdle}" />
<!-- 表示当borrow（借用）一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException -->
<property name="maxWaitMillis" value="${jedis.pool.maxWaitMillis}" />
<!-- 在borrow（借用）一个jedis实例时，是否提前进行validate（验证）操作；如果为true，则得到的jedis实例均是可用的 -->
<property name="testOnBorrow" value="${jedis.pool.testOnBorrow}" />
<!-- 在return(返回)给pool（池）时，是否提前进行validate（验证）操作 -->
<property name="testOnReturn" value="${jedis.pool.testOnReturn}" />
</bean>
<!-- JedisPool(非切片链接池)配置 -->
<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
<constructor-arg ref="jedisPoolConfig" />
<constructor-arg value="${redis.hostName}" />
<constructor-arg value="${redis.port}" type="int" />
<constructor-arg value="${redis.timeout}" type="int" />
<constructor-arg value="${redis.password}" />
<constructor-arg value="${redis.database}" type="int"/>
</bean>
redis.properites配置如下：
redis.hostName=172.168.48.197
redis.port=6379
redis.timeout=3000
redis.password=chbigdata
redis.database=1
jedis.pool.maxTotal=300
jedis.pool.maxIdle=300
jedis.pool.maxWaitMillis=100000
jedis.pool.testOnBorrow=true
jedis.pool.testOnReturn=true
java 类中，jedis 2.7.2版本中的释放资源jedis与2.6之前的版本有区别，示例：
/**
*
* <p>说明：存入对象到缓存</p>
* <p>时间：2016-06-27 14:21:41</p>
* @param key
* 键
* @param object
* 对象
* @return boolean
*/
public boolean putObject(String key, Object object) {
boolean flag = false;
if (StringUtils.isBlank(key)) {
return flag;
}
if (object == null) {
return flag;
}
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
String result = jedis.set(key, JSONObject.toJSONString(object, SerializerFeature.WriteClassName));
if ("ok".equalsIgnoreCase(result)) {
flag = true;
}
} catch (Exception e) {
logger.error("Redis putObject error" + e.getMessage(), e);
}finally {
if (jedis != null) {
try {
jedis.close();
}catch (Exception e) {
logger.error("Jedis putObject method close error" + e.getMessage(), e);
}
}
}
return flag;
}
2、哨兵方式sentinels的集群配置方式请看文章：http://www.cnblogs.com/zr520/p/5062025.html
3、下边来说说spring 和 redis 集群的配置（高可用配置，配置2个实例，则spring默认是启用第1个实例，当第1个实例不可用时，再启用第2个实例；）
将以下XML配置引入spring
<!-- jedis 多个服务器配置-->
配置写法1：与下边配置写法2任意选一种即可，我选的此种方式
<bean id="jedisShardInfo1" class="redis.clients.jedis.JedisShardInfo">
<!-- URL方式要求 uri在redis.properies 中配置为：
redis.uri1=redis://:chbigdata@172.17.123.134:6379/9
即redis://:[密码]@[服务器地址]:[端口]/[db index]-->
<constructor-arg name="host" value="${redis.uri1}" />
</bean>
<bean id="jedisShardInfo2" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg name="host" value="${redis.uri2}" />
</bean>
<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool" scope="singleton">
<constructor-arg index="0" ref="jedisPoolConfig" />
<constructor-arg index="1">
<list>
<ref bean="jedisShardInfo1" />
<ref bean="jedisShardInfo2"/>
</list>
</constructor-arg>
</bean>
配置写法2：其实就是上边的一个变种
<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
<constructor-arg index="0" ref="jedisPoolConfig"/>
<constructor-arg index="1">
<list>
<bean name="slaver" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg name="host" value="${redis.uri1}" />
</bean>
<bean name="master" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg name="host" value="${redis.uri2}" />
</bean>
</list>
</constructor-arg>
</bean>
<!-- jedisPoolConfig 必须要-->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="2048" />
<property name="maxIdle" value="200" />
<property name="numTestsPerEvictionRun" value="1024"/>
<property name="timeBetweenEvictionRunsMillis" value="30000" />
<property name="minEvictableIdleTimeMillis" value="-1" />
<property name="softMinEvictableIdleTimeMillis" value="10000" />
<property name="maxWaitMillis" value="1500"/>
<property name="testOnBorrow" value="true" />
<property name="testWhileIdle" value="true"/>
<property name="testOnReturn" value="false"/>
<property name="jmxEnabled" value="true"/>
<property name="jmxNamePrefix" value="chbigdata"/>
<property name="blockWhenExhausted" value="false"/>
</bean>
properties配置文件：
#redis配置
redis.slaver.host=127.0.0.1
redis.slaver.port=6379
redis.master.host=127.0.0.2
redis.master.port=6379
将shardedJedisPool注入相关的工具类中即可使用
import java.util.ArraygeiList;ge
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Resource;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
/**
* <p>标题：</p>
* <p>描述：</p>
* <p>Copyright：Copyright(c) 2015 yjph83</p>
* <p>日期：2016年6月27日</p>
* @author yjph83
*/
public class JedisUtil {
private static Logger logger = LoggerFactory.getLogger(JedisUtil.class);
@Resource
private ShardedJedisPool shardedJedisPool;
/**
* 设置一个key的过期时间（单位：秒）
*
* @param key
* key值
* @param seconds
* 多少秒后过期
* @return 1：设置了过期时间 0：没有设置过期时间/不能设置过期时间
*/
public long expire(String key, int seconds) {
if (StringUtils.isBlank(key)) {
return 0;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.expire(key, seconds);
} catch (Exception ex) {
logger.error("shardedJedis expire error[key=" + key + " seconds=" + seconds + "]" + ex.getMessage(), ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis expire method close error" + e.getMessage(), e);
}
}
return 0;
}
/**
* 设置一个key在某个时间点过期
*
* @param key
* key值
* @param unixTimestamp
* unix时间戳，从1970-01-01 00:00:00开始到现在的秒数
* @return 1：设置了过期时间 0：没有设置过期时间/不能设置过期时间
*/
public long expireAt(String key, int unixTimestamp) {
if (StringUtils.isBlank(key)) {
return 0;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.expireAt(key, unixTimestamp);
} catch (Exception ex) {
logger.error("shardedJedis expireAt error[key=" + key + " unixTimestamp=" + unixTimestamp + "]" + ex.getMessage(), ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis expireAt method close error" + e.getMessage(), e);
}
}
return 0;
}
/**
* 截断一个List
*
* @param key
* 列表key
* @param start
* 开始位置 从0开始
* @param end
* 结束位置
* @return 状态码
*/
public String trimList(String key, long start, long end) {
if (StringUtils.isBlank(key)) {
return "-";
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.ltrim(key, start, end);
} catch (Exception ex) {
logger.error("shardedJedis trimList 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage(), ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis trimList method close error" + e.getMessage(), e);
}
}
return "-";
}
/**
* 检查Set长度
*
* @param key
* @return
*/
public long countSet(String key) {
if (StringUtils.isBlank(key)) {
return 0;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.scard(key);
} catch (Exception ex) {
logger.error("shardedJedis countSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis countSet method close error " + e.getMessage(), e);
}
}
return 0;
}
/**
* 添加到Set中（同时设置过期时间）
*
* @param key
* key值
* @param seconds
* 过期时间 单位s
* @param value
* @return
*/
public boolean addSet(String key, int seconds, String... value) {
boolean result = addSet(key, value);
if (result) {
long i = expire(key, seconds);
return i == 1;
}
return false;
}
/**
* 添加到Set中
*
* @param key
* @param value
* @return
*/
public boolean addSet(String key, String... value) {
if (StringUtils.isBlank(key)) {
return false;
}
if (value.length == 0 || value == null){
return false;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
shardedJedis.sadd(key, value);
return true;
} catch (Exception ex) {
logger.error("shardedJedis setList error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis addSet method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* @param key
* @param value
* @return 判断值是否包含在set中
*/
public boolean containsInSet(String key, String value) {
if (StringUtils.isBlank(key)) {
return false;
}
if (StringUtils.isBlank(value)){
return false;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.sismember(key, value);
} catch (Exception ex) {
logger.error("shardedJedis setList error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis containsInSet method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* 获取Set
*
* @param key
* @return
*/
public Set<String> getSet(String key) {
if (StringUtils.isBlank(key)) {
return null;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.smembers(key);
} catch (Exception ex) {
logger.error("shardedJedis getList error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis getSet method close error." + e.getMessage(), e);
}
}
return null;
}
/**
* 从set中删除value
*
* @param key
* @return
*/
public boolean removeSetValue(String key, String... value) {
if (StringUtils.isBlank(key)) {
return false;
}
if (value.length == 0 || value == null){
return false;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
shardedJedis.srem(key, value);
return true;
} catch (Exception ex) {
logger.error("getList error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis removeSetValue method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* 从list中删除value 默认count 1
*
* @param key
* @param values
* 值list
* @return
*/
public int removeListValue(String key, List<String> values) {
return removeListValue(key, 1, values);
}
/**
* 从list中删除value
*
* @param key
* @param count
* @param values
* 值list
* @return
*/
public int removeListValue(String key, long count, List<String> values) {
if (StringUtils.isBlank(key)) {
return 0;
}
if (values.size() == 0 || values == null){
return 0;
}
int result = 0;
if (values != null && values.size() > 0) {
for (String value : values) {
if (removeListValue(key, count, value)) {
result++;
}
}
}
return result;
}
/**
* 从list中删除value
*
* @param key
* @param count
* 要删除个数
* @param value
* @return
*/
public boolean removeListValue(String key, long count, String value) {
if (StringUtils.isBlank(key)) {
return false;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
shardedJedis.lrem(key, count, value);
return true;
} catch (Exception ex) {
logger.error("getList error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis removeListValue method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* 截取List
*
* @param key
* @param start
* 起始位置
* @param end
* 结束位置
* @return
*/
public List<String> rangeList(String key, long start, long end) {
if (StringUtils.isBlank(key)) {
return null;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.lrange(key, start, end);
} catch (Exception ex) {
logger.error("rangeList 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage(), ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis rangeList method close error." + e.getMessage(), e);
}
}
return null;
}
/**
* 检查List长度
*
* @param key
* @return
*/
public long countList(String key) {
if (StringUtils.isBlank(key)) {
return 0;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.llen(key);
} catch (Exception ex) {
logger.error("countList error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis countList method close error." + e.getMessage(), e);
}
}
return 0;
}
/**
* 添加到List中（同时设置过期时间）
*
* @param key
* key值
* @param seconds
* 过期时间 单位s
* @param ... value
* @return
*/
public boolean addList(String key, int seconds, String... value) {
boolean result = addList(key, value);
if (result) {
long i = expire(key, seconds);
return i == 1;
}
return false;
}
/**
* 添加到List
*
* @param key
* @param ... value
* @return
*/
public boolean addList(String key, String... value) {
if (key == null || value == null) {
return false;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
shardedJedis.lpush(key, value);
return true;
} catch (Exception ex) {
logger.error("shardedJedis setList error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis addList method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* 添加到List(只新增)
*
* @param key
* @param List values
* @return
*/
public boolean addList(String key, List<String> list) {
if (StringUtils.isBlank(key) || list == null || list.size() == 0) {
return false;
}
for (String value : list) {
addList(key, value);
}
return true;
}
/**
* 获取List
*
* @param key
* @return
*/
public List<String> getList(String key) {
if (StringUtils.isBlank(key)) {
return null;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.lrange(key, 0, -1);
} catch (Exception ex) {
logger.error("shardedJedis getList error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis getList method close error." + e.getMessage(), e);
}
}
return null;
}
/**
* 设置HashSet对象
*
* @param domain
* 域名
* @param key
* 键值
* @param value
* Json String or String value
* @return
*/
public boolean setHSet(String domain, String key, String value) {
if (StringUtils.isBlank(key)) {
return false;
}
if (value == null)
return false;
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
shardedJedis.hset(domain, key, value);
return true;
} catch (Exception ex) {
logger.error("shardedJedis setHSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis setHSet method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* 获得HashSet对象
*
* @param domain
* 域名
* @param key
* 键值
* @return Json String or String value
*/
public String getHSet(String domain, String key) {
if (StringUtils.isBlank(key))
return null;
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.hget(domain, key);
} catch (Exception ex) {
logger.error("shardedJedis getHSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis getHSet method close error." + e.getMessage(), e);
}
}
return null;
}
/**
* 删除HashSet对象
*
* @param domain
* 域名
* @param key
* 键值
* @return 删除的记录数
*/
public long delHSet(String domain, String key) {
long count = 0;
if (StringUtils.isBlank(key)) {
return count;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
count = shardedJedis.hdel(domain, key);
} catch (Exception ex) {
logger.error("shardedJedis delHSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis delHSet method close error." + e.getMessage(), e);
}
}
return count;
}
/**
* 删除HashSet对象
*
* @param domain
* 域名
* @param ... key
* 键值
* @return 删除的记录数
*/
public long delHSet(String domain, String... key) {
long count = 0;
if (key.length == 0 || key == null) {
return count;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
count = shardedJedis.hdel(domain, key);
} catch (Exception ex) {
logger.error("shardedJedis delHSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis delHSet method close error." + e.getMessage(), e);
}
}
return count;
}
/**
* 判断key是否存在
*
* @param domain
* 域名
* @param key
* 键值
* @return
*/
public boolean existsHSet(String domain, String key) {
boolean isExist = false;
if (StringUtils.isBlank(key)) {
return isExist;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
isExist = shardedJedis.hexists(domain, key);
} catch (Exception ex) {
logger.error("shardedJedis existsHSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis existsHSet method close error." + e.getMessage(), e);
}
}
return isExist;
}
/**
* 全局扫描hset
*
* @param match
* field匹配模式
* @return
*/
public List<Map.Entry<String, String>> scanHSet(String domain, String match) {
ShardedJedis shardedJedis = null;
try {
int cursor = 0;
shardedJedis = shardedJedisPool.getResource();
ScanParams scanParams = new ScanParams();
scanParams.match(match);
Jedis jedis = shardedJedis.getShard(domain);
ScanResult<Map.Entry<String, String>> scanResult;
List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>();
do {
scanResult = jedis.hscan(domain, String.valueOf(cursor),
scanParams);
list.addAll(scanResult.getResult());
cursor = Integer.parseInt(scanResult.getStringCursor());
} while (cursor > 0);
return list;
} catch (Exception ex) {
logger.error("shardedJedis scanHSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis scanHSet method close error." + e.getMessage(), e);
}
}
return null;
}
/**
* 返回 domain 指定的哈希集中所有字段的value值
*
* @param domain
* @return
*/
public List<String> hvals(String domain) {
ShardedJedis shardedJedis = null;
List<String> retList = null;
try {
shardedJedis = shardedJedisPool.getResource();
retList = shardedJedis.hvals(domain);
} catch (Exception ex) {
logger.error("shardedJedis hvals error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis hvals method close error." + e.getMessage(), e);
}
}
return retList;
}
/**
* 返回 domain 指定的哈希集中所有字段的key值
*
* @param domain
* @return
*/
public Set<String> hkeys(String domain) {
ShardedJedis shardedJedis = null;
Set<String> retList = null;
try {
shardedJedis = shardedJedisPool.getResource();
retList = shardedJedis.hkeys(domain);
} catch (Exception ex) {
logger.error("shardedJedis hkeys error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis hkeys method close error." + e.getMessage(), e);
}
}
return retList;
}
/**
* 返回 domain 指定的哈希key值总数
*
* @param domain
* @return
*/
public long lenHset(String domain) {
ShardedJedis shardedJedis = null;
long retList = 0;
try {
shardedJedis = shardedJedisPool.getResource();
retList = shardedJedis.hlen(domain);
} catch (Exception ex) {
logger.error("shardedJedis lenHset error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis lenHset method close error." + e.getMessage(), e);
}
}
return retList;
}
/**
* 设置指定位置的String类型的值排序集合
*
* @param key
* @param score
* @param value
* @return
*/
public boolean setSortedSet(String key, long score, String value) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
shardedJedis.zadd(key, score, value);
return true;
} catch (Exception ex) {
logger.error("shardedJedis setSortedSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis setSortedSet method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* 根据String类型的key，起始、结束记录位置获得排序集合
*
* @param key
* @param startScore
* @param endScore
* @param orderByDesc
* @return
*/
public Set<String> getSoredSet(String key, long startScore, long endScore, boolean orderByDesc) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
if (orderByDesc) {
return shardedJedis.zrevrangeByScore(key, endScore, startScore);
} else {
return shardedJedis.zrangeByScore(key, startScore, endScore);
}
} catch (Exception ex) {
logger.error("shardedJedis getSoredSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis getSoredSet method close error." + e.getMessage(), e);
}
}
return null;
}
/**
* 根据String类型的key，起始、结束记录位置计算排序长度
*
* @param key
* @param startScore
* @param endScore
* @return
*/
public long countSoredSet(String key, long startScore, long endScore) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
Long count = shardedJedis.zcount(key, startScore, endScore);
return count == null ? 0L : count;
} catch (Exception ex) {
logger.error("shardedJedis countSoredSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis countSoredSet method close error." + e.getMessage(), e);
}
}
return 0L;
}
/**
* 根据String类型的key和value删除排序集合
*
* @param key
* @param value
* @return
*/
public boolean delSortedSet(String key, String value) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
long count = shardedJedis.zrem(key, value);
return count > 0;
} catch (Exception ex) {
logger.error("shardedJedis delSortedSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis delSortedSet method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* 获得排序集合
*
* @param key
* @param startRange
* @param endRange
* @param orderByDesc
* @return
*/
public Set<String> getSoredSetByRange(String key, int startRange, int endRange, boolean orderByDesc) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
if (orderByDesc) {
return shardedJedis.zrevrange(key, startRange, endRange);
} else {
return shardedJedis.zrange(key, startRange, endRange);
}
} catch (Exception ex) {
logger.error("shardedJedis getSoredSetByRange error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis getSoredSetByRange method close error." + e.getMessage(), e);
}
}
return null;
}
/**
* 获得排序打分
*
* @param key
* @return
*/
public Double getScore(String key, String member) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.zscore(key, member);
} catch (Exception ex) {
logger.error("shardedJedis getSoredSet error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis getScore method close error." + e.getMessage(), e);
}
}
return null;
}
/**
* 存入String的值，并设置过期时间
* @param key
* @param value
* @param second 秒
* @return
*/
public boolean set(String key, String value, int second) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
shardedJedis.setex(key, second, value);
return true;
} catch (Exception ex) {
logger.error("shardedJedis set error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis set method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* 存入String 类型的值
* @param key
* @param value
* @return
*/
public boolean set(String key, String value) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
shardedJedis.set(key, value);
return true;
} catch (Exception ex) {
logger.error("shardedJedis set error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis set method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* 获取值，如果值为空，则可以指定返回值
* @param key
* @param defaultValue
* @return
*/
public String get(String key, String defaultValue) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.get(key) == null ? defaultValue : shardedJedis.get(key);
} catch (Exception ex) {
logger.error("shardedJedis get error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis get method close error." + e.getMessage(), e);
}
}
return defaultValue;
}
/**
* 根据key来删除值
* @param key
* @return
*/
public boolean del(String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
shardedJedis.del(key);
return true;
} catch (Exception ex) {
logger.error("shardedJedis del error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis del method close error." + e.getMessage(), e);
}
}
return false;
}
/**
* 名称为key的string加1操作
* @param key
* @return
*/
public long incr(String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.incr(key);
} catch (Exception ex) {
logger.error("shardedJedis incr error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis incr method close error." + e.getMessage(), e);
}
}
return 0;
}
/**
* 名称为key的string减1操作
* @param key
* @return
*/
public long decr(String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
return shardedJedis.decr(key);
} catch (Exception ex) {
logger.error("shardedJedis decr error.", ex);
} finally {
try{
if (shardedJedis != null ){
shardedJedis.close();
}
}catch (Exception e) {
logger.error("shardedJedis decr method close error." + e.getMessage(), e);
}
}
return 0;
}
}
相关推荐
综上所述，"spring-data-redis-1.6.0.RELEASE.jar + jedis-2.7.2.jar"组合提供了Spring应用程序与Redis交互的强大工具集，涵盖了从基本操作到复杂应用场景的各种功能。在实际开发中，你需要根据项目需求选择合适的...
<jedis.version>2.7.2</jedis.version> <solrj.version>4.10.3 <!-- 时间操作组件 --> <groupId>joda-time <artifactId>joda-time ${joda-time.version} <!-- Apache工具组件 --> ...
内容概要：本文详细介绍了基于TMS320F系列芯片的C2000串口读写方案及其编程器——FlashPro2000的功能特点和支持的接口模式。文中不仅涵盖了硬件连接的具体步骤，还提供了代码实例来展示Flash擦除操作，并对比了JTAG和SCI-BOOT两种模式的优缺点。此外，针对不同型号的C2000系列芯片，给出了详细的适配指导以及避免烧录过程中可能出现的问题的方法。 适合人群：从事DSP开发的技术人员，尤其是对TI公司C2000系列芯片有一定了解并希望深入了解其编程和烧录细节的人群。 使用场景及目标：适用于实验室环境下的程序调试阶段，以及生产线上的批量烧录任务。主要目的是帮助开发者选择合适的编程工具和技术手段，提高工作效率，减少因误操作导致设备损坏的风险。 其他说明：文中提供的代码片段和命令行指令可以直接用于实际项目中，同时附带了一些实用技巧，如防止芯片变砖的小贴士和自动化重试脚本，有助于解决常见的烧录难题。
汉字字库存储芯片扩展实验 # 汉字字库存储芯片扩展实验 ## 实验目的 1. 了解汉字字库的存储原理和结构 2. 掌握存储芯片扩展技术 3. 学习如何通过硬件扩展实现大容量汉字字库存储 ## 实验原理 ### 汉字字库存储基础 - 汉字通常采用点阵方式存储(如16×16、24×24、32×32点阵) - 每个汉字需要占用32字节(16×16)到128字节(32×32)不等的存储空间 - 国标GB2312-80包含6763个汉字，需要较大存储容量 ### 存储芯片扩展方法 1. **位扩展**：增加数据总线宽度 2. **字扩展**：增加存储单元数量 3. **混合扩展**：同时进行位扩展和字扩展 ## 实验设备 - 单片机开发板(如STC89C52) - 存储芯片(如27C256、29C040等) - 逻辑门电路芯片(如74HC138、74HC373等) - 示波器、万用表等测试设备 - 连接线若干 ## 实验步骤 ### 1. 单芯片汉字存储实验 1. 连接27C256 EPROM芯片到单片机系统 2. 将16×16点阵汉字字库写入芯片 3. 编写程序读取并显示汉字 ### 2. 存储芯片字扩展实验 1. 使用地址译码器(如74HC138)扩展多片27C256 2. 将完整GB2312字库分布到各芯片中 3. 编写程序实现跨芯片汉字读取 ### 3. 存储芯片位扩展实验 1. 连接两片27C256实现16位数据总线扩展 2. 优化字库存储结构，提高读取速度 3. 测试并比较扩展前后的性能差异 ## 实验代码示例(单片机部分) ```c #include <reg52.h> #include <intrins.h> // 定义存储芯片控制引脚 sbit CE = P2^7; // 片选 sbit OE = P2^6; // 输出使能 sbit
测控装备干扰源快速侦测系统设计研究.pdf
嵌入式八股文面试题库资料知识宝典-【开发】嵌入式开源项目&库&资料.zip
嵌入式八股文面试题库资料知识宝典-百度2022年嵌入式面试题.zip
少儿编程scratch项目源代码文件案例素材-空间站.zip
基于关联规则的商业银行个性化产品推荐.pdf
嵌入式八股文面试题库资料知识宝典-Linux基础使用.zip
内容概要：本文详细介绍了利用MATLAB进行轴棱锥生成贝塞尔高斯光束及环形光束光强图像的仿真研究。首先阐述了实验的背景与目标，强调了MATLAB在光学和计算科学领域的广泛应用。接着，具体描述了实验的方法与步骤，包括材料准备、仿真过程中的参数设定和光束生成代码编写。最后，对实验结果进行了深入分析，展示了贝塞尔高斯光束和环形光束的光强分布特点，验证了其光学性能的预期表现。文章还对未来的研究方向和技术改进提出了展望。 适合人群：从事光学、物理学及相关领域研究的专业人士，特别是对光束生成和光学性能分析感兴趣的科研工作者。 使用场景及目标：适用于需要进行光束生成和性能分析的实验室环境，旨在帮助研究人员更好地理解和优化光束特性和传播行为。 其他说明：本文不仅提供了详细的实验方法和步骤，还附有丰富的实验结果和数据分析，为后续研究提供了宝贵的参考资料。
内容概要：本文探讨了三电平NPC型有源电力滤波器（APF）的模型预测控制（MPC）中存在的开关频率过高问题及其解决方案。传统MPC方法会导致极高的开关频率，增加了系统的能耗和热量。通过引入滞环控制模块，可以在不大幅牺牲性能的情况下有效降低开关频率。具体来说，滞环控制通过在价值函数计算后增加一个判断条件，对状态切换进行惩罚，从而减少不必要的开关动作。实验结果显示，开关频率从4392Hz降至3242Hz，降幅达26.2%，虽然电流总谐波畸变率（THD）略有上升，但仍符合国家标准。此外，文中还提出了动态调整滞环宽度的方法，以进一步优化不同负载条件下的表现。 适合人群：从事电力电子、电力系统控制领域的研究人员和技术人员，特别是关注APF和MPC技术的人群。 使用场景及目标：适用于需要优化APF系统开关频率的研究和工程项目，旨在提高系统效率并降低成本。目标是在不影响系统性能的前提下，显著降低开关频率，减少能量损失和热管理难度。 其他说明：文章不仅提供了理论分析，还包括具体的实现代码片段，有助于读者理解和实践。同时，强调了在实际应用中需要注意的问题，如中点电位漂移等。
内容概要：本文介绍了三维POD DMD程序在处理原网格数据方面的独特优势和技术细节。首先阐述了该程序能读取结构化和非结构化网格数据及其拓扑关系，在生成模态数据过程中保持原始网格形态而不需要进行网格插值操作。接着展示了简化版本的Python代码片段，揭示了读取网格数据和生成模态数据的核心逻辑。最后提到提供的辅助学习资料如代码、视频教程、Word教程和实例数据，帮助用户深入理解并掌握该程序的应用。 适合人群：从事计算流体力学领域的研究人员和技术爱好者，尤其是那些希望提高数据处理效率的人群。 使用场景及目标：适用于需要处理复杂网格数据的研究项目，旨在简化数据处理流程，提升工作效率，同时保持数据的原始特性。 其他说明：文中不仅提供了理论性的讲解，还有具体的代码示例和丰富的学习资源，使读者可以边学边练，快速上手。
融合双向路由注意力的多尺度X光违禁品检测.pdf
嵌入式八股文面试题库资料知识宝典-Linux_Shell基础使用.zip
嵌入式八股文面试题库资料知识宝典-联发科2021武汉嵌入式软件开发.zip
基于有限体积法Godunov格式的管道泄漏检测模型研究.pdf
嵌入式八股文面试题库资料知识宝典-ARM常见面试题目.zip
基于LWR问题的无证书全同态加密方案.pdf
嵌入式八股文面试题库资料知识宝典-符坤面试经验.zip