- 浏览: 92089 次
- 性别:
- 来自: 深圳
最新评论
-
skyhan:
Jquery获取某行某列的值 -
pangbo535:
谢谢咯 简单容易理解
java 用二进制的方法实现权限的管理 -
xudong_wuchen:
哥们,写完了也得稍微解释一下啊!看得人真眼晕。
Java定时调用 -
qkjava:
过年时间都在调程序
选择IT工作,就等于选择了租个女友回家过年各位IT同行 -
aa00aa00:
楼主是说做IT的就相当于租来的女朋友,看到,摸到,就是玩不到。 ...
选择IT工作,就等于选择了租个女友回家过年各位IT同行
ApplicationContent-reids.xml配置:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
<context:property-placeholder location="classpath:redis.properties" />
<context:component-scan base-package="com.sc.ew.redis" />
<bean id="shardedJedisPools" 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 index="0" value="${redis.slaver.host}" />
<constructor-arg index="1" value="${redis.slaver.port}" type="int" />
</bean> -->
<bean name="master" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="192.168.1.250" />
<constructor-arg index="1" value="6379" type="int" />
<constructor-arg index="2" value="10000" type="int" />
</bean>
</list>
</constructor-arg>
</bean>
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="5000" />
<property name="maxIdle" value="1000" />
<property name="minIdle" value="50" />
<property name="numTestsPerEvictionRun" value="1024" />
<property name="timeBetweenEvictionRunsMillis" value="30000" />
<property name="minEvictableIdleTimeMillis" value="-1" />
<property name="softMinEvictableIdleTimeMillis" value="10000" />
<property name="maxWaitMillis" value="10000" />
<property name="testOnBorrow" value="true" />
<property name="testWhileIdle" value="true" />
<property name="testOnReturn" value="false" />
<property name="jmxEnabled" value="true" />
<property name="jmxNamePrefix" value="youyuan" />
<property name="blockWhenExhausted" value="false" />
</bean>
</beans>
package com.sc.ew.redis.dao.source;
import redis.clients.jedis.ShardedJedis;
public interface RedisDataSource {
/**
* 取得redis的客户端,可以执行命令了。
* @return
*/
public abstract ShardedJedis getRedisClient();
public void returnResource(ShardedJedis shardedJedis);// 将资源返还给pool
public void returnResource(ShardedJedis shardedJedis, boolean broken);// 出现异常后,将资源返还给pool (其实不需要第二个方法)
}
package com.sc.ew.redis.dao.source.impl;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Repository;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
import com.sc.ew.redis.dao.source.RedisDataSource;
@Repository
public class RedisDataSourceImpl implements RedisDataSource {
private static final Logger logger = Logger
.getLogger(RedisDataSourceImpl.class);
@Resource
private ShardedJedisPool shardedJedisPool;
public ShardedJedis getRedisClient() {
try {
ShardedJedis shardJedis = shardedJedisPool.getResource();
return shardJedis;
} catch (Exception e) {
logger.error("getRedisClent error", e);
}
return null;
}
public void returnResource(ShardedJedis shardedJedis) {
shardedJedisPool.returnResource(shardedJedis);
}
public void returnResource(ShardedJedis shardedJedis, boolean broken) {
if (broken) {
shardedJedisPool.returnBrokenResource(shardedJedis);
} else {
shardedJedisPool.returnResource(shardedJedis);
}
}
}
package com.sc.ew.redis.template;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.sc.ew.redis.dao.source.RedisDataSource;
import com.sc.ew.redis.util.SerializationUtils;
import redis.clients.jedis.ShardedJedis;
@Repository
public class RedisHashTemplate {
private static final Logger logger = Logger
.getLogger(RedisHashTemplate.class);
@Autowired
private RedisDataSource redisDataSource;
public void disconnect() {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
shardedJedis.disconnect();
}
/**
* 将哈希表 key 中的域 field 的值设为 value 。 如果 key 不存在,一个新的哈希表被创建并进行 HSET 操作。 如果域
* field 已经存在于哈希表中,旧值将被覆盖。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hset(String key, String field, String value) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hset(key, field, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 将哈希表 key 中的域 field 的值设为 value 。 如果 key 不存在,一个新的哈希表被创建并进行 HSET 操作。 如果域
* field 已经存在于哈希表中,旧值将被覆盖。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hsetObject(String key, String field, Object object) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hset(key.getBytes(), field.getBytes(),
SerializationUtils.serialize(object));
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中给定域 field 的值。
*
* @param key
* @param field
* @return
*/
public String hget(String key, String field) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hget(key, field);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中给定域 field 的值。
*
* @param key
* @param field
* @return
*/
public Object hgetObject(String key, String field) {
Object result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = SerializationUtils.deserialize(shardedJedis.hget(
key.getBytes(), field.getBytes()));
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 将哈希表 key 中的域 field 的值设置为 value ,当且仅当域 field 不存在。 若域 field 已经存在,该操作无效。 如果
* key 不存在,一个新哈希表被创建并执行 HSETNX 命令。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hsetnx(String key, String field, String value) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hsetnx(key, field, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。
*
* @param key
* @param hash
* @return
*/
public String hmset(String key, Map<String, String> hash) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hmset(key, hash);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。
*
* @param key
* @param hash
* @return
*/
public String hmsetObject(String key, Map<String, Object> hashs) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Map<byte[], byte[]> byteHash = new HashMap<byte[], byte[]>();
for (Map.Entry<String, Object> setMap : hashs.entrySet()) {
String keyMap = setMap.getKey();
Object valMap = setMap.getValue();
byteHash.put(keyMap.getBytes(),
SerializationUtils.serialize(valMap));
}
result = shardedJedis.hmset(key.getBytes(), byteHash);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。
*
* @param key
* @param hash
* @return
*/
public String hmsetMapObject(String key, Map<String, Map<String, Object>> hashs) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Map<byte[], byte[]> byteHash = new HashMap<byte[], byte[]>();
for (Map.Entry<String, Map<String, Object>> setMap : hashs.entrySet()) {
String keyMap = setMap.getKey();
Object valMap = setMap.getValue();
byteHash.put(keyMap.getBytes(),
SerializationUtils.serialize(valMap));
}
result = shardedJedis.hmset(key.getBytes(), byteHash);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中,一个或多个给定域的值。 如果给定的域不存在于哈希表,那么返回一个 nil 值。
*
* @param key
* @param fields
* @return
*/
public List<String> hmget(String key, String... fields) {
List<String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hmget(key, fields);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中,一个或多个给定域的值。 如果给定的域不存在于哈希表,那么返回一个 nil 值。
*
* @param key
* @param fields
* @return
*/
public List<Object> hmgetObject(String key, String... fields) {
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
byte[][] bytes = new byte[fields.length][];
for (int i = 0; i < fields.length; i++) {
bytes[i] = fields[i].getBytes();
}
List<byte[]> resultList = shardedJedis.hmget(key.getBytes(), bytes);
List<Object> resultObject = new ArrayList<Object>();
for (byte[] byteList : resultList) {
resultObject.add(SerializationUtils.deserialize(byteList));
}
return resultObject;
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return null;
}
/**
* 为哈希表 key 中的域 field 的值加上增量 increment 。 增量也可以为负数,相当于对给定域进行减法操作。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hincrBy(String key, String field, long value) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hincrBy(key, field, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 查看哈希表 key 中,给定域 field 是否存在。
*
* @param key
* @param field
* @return
*/
public Boolean hexists(String key, String field) {
Boolean result = false;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hexists(key, field);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 删除哈希表 key 中的一个或多个指定域,不存在的域将被忽略。
*
* @param key
* @param field
* @return
*/
public Long hdelAll(String key) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Set<String> keys = hkeys(key);
if(keys.size() > 0){
String[] arr = new String[keys.size()];
keys.toArray(arr);
result = hdel(key, arr);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 删除哈希表 key 中的一个或多个指定域,不存在的域将被忽略。
*
* @param key
* @param field
* @return
*/
public Long hdel(String key, String... field) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hdel(key, field);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中域的数量。
*
* @param key
* @return
*/
public Long hlen(String key) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hlen(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中的所有域。
*
* @param key
* @return
*/
public Set<String> hkeys(String key) {
Set<String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hkeys(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中所有域的值。
*
* @param key
* @return
*/
public List<String> hvals(String key) {
List<String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hvals(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中,所有的域和值。 在返回值里,紧跟每个域名(field
* name)之后是域的值(value),所以返回值的长度是哈希表大小的两倍。
*
* @param key
* @return
*/
public Map<String, String> hgetAll(String key) {
Map<String, String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hgetAll(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中,所有的域和值。 在返回值里,紧跟每个域名(field
* name)之后是域的值(value),所以返回值的长度是哈希表大小的两倍。
*
* @param key
* @return
*/
public Map<String, Object> hgetAllObject(String key) {
Map<String, Object> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Map<byte[], byte[]> resultByteMap = shardedJedis.hgetAll(key
.getBytes());
result = new HashMap<String, Object>();
for (Map.Entry<byte[], byte[]> entrySet : resultByteMap.entrySet()) {
byte[] keyMap = entrySet.getKey();
byte[] valMap = entrySet.getValue();
result.put(new String(keyMap),
SerializationUtils.deserialize(valMap));
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
<context:property-placeholder location="classpath:redis.properties" />
<context:component-scan base-package="com.sc.ew.redis" />
<bean id="shardedJedisPools" 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 index="0" value="${redis.slaver.host}" />
<constructor-arg index="1" value="${redis.slaver.port}" type="int" />
</bean> -->
<bean name="master" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="192.168.1.250" />
<constructor-arg index="1" value="6379" type="int" />
<constructor-arg index="2" value="10000" type="int" />
</bean>
</list>
</constructor-arg>
</bean>
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="5000" />
<property name="maxIdle" value="1000" />
<property name="minIdle" value="50" />
<property name="numTestsPerEvictionRun" value="1024" />
<property name="timeBetweenEvictionRunsMillis" value="30000" />
<property name="minEvictableIdleTimeMillis" value="-1" />
<property name="softMinEvictableIdleTimeMillis" value="10000" />
<property name="maxWaitMillis" value="10000" />
<property name="testOnBorrow" value="true" />
<property name="testWhileIdle" value="true" />
<property name="testOnReturn" value="false" />
<property name="jmxEnabled" value="true" />
<property name="jmxNamePrefix" value="youyuan" />
<property name="blockWhenExhausted" value="false" />
</bean>
</beans>
package com.sc.ew.redis.dao.source;
import redis.clients.jedis.ShardedJedis;
public interface RedisDataSource {
/**
* 取得redis的客户端,可以执行命令了。
* @return
*/
public abstract ShardedJedis getRedisClient();
public void returnResource(ShardedJedis shardedJedis);// 将资源返还给pool
public void returnResource(ShardedJedis shardedJedis, boolean broken);// 出现异常后,将资源返还给pool (其实不需要第二个方法)
}
package com.sc.ew.redis.dao.source.impl;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Repository;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
import com.sc.ew.redis.dao.source.RedisDataSource;
@Repository
public class RedisDataSourceImpl implements RedisDataSource {
private static final Logger logger = Logger
.getLogger(RedisDataSourceImpl.class);
@Resource
private ShardedJedisPool shardedJedisPool;
public ShardedJedis getRedisClient() {
try {
ShardedJedis shardJedis = shardedJedisPool.getResource();
return shardJedis;
} catch (Exception e) {
logger.error("getRedisClent error", e);
}
return null;
}
public void returnResource(ShardedJedis shardedJedis) {
shardedJedisPool.returnResource(shardedJedis);
}
public void returnResource(ShardedJedis shardedJedis, boolean broken) {
if (broken) {
shardedJedisPool.returnBrokenResource(shardedJedis);
} else {
shardedJedisPool.returnResource(shardedJedis);
}
}
}
package com.sc.ew.redis.template;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.sc.ew.redis.dao.source.RedisDataSource;
import com.sc.ew.redis.util.SerializationUtils;
import redis.clients.jedis.ShardedJedis;
@Repository
public class RedisHashTemplate {
private static final Logger logger = Logger
.getLogger(RedisHashTemplate.class);
@Autowired
private RedisDataSource redisDataSource;
public void disconnect() {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
shardedJedis.disconnect();
}
/**
* 将哈希表 key 中的域 field 的值设为 value 。 如果 key 不存在,一个新的哈希表被创建并进行 HSET 操作。 如果域
* field 已经存在于哈希表中,旧值将被覆盖。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hset(String key, String field, String value) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hset(key, field, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 将哈希表 key 中的域 field 的值设为 value 。 如果 key 不存在,一个新的哈希表被创建并进行 HSET 操作。 如果域
* field 已经存在于哈希表中,旧值将被覆盖。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hsetObject(String key, String field, Object object) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hset(key.getBytes(), field.getBytes(),
SerializationUtils.serialize(object));
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中给定域 field 的值。
*
* @param key
* @param field
* @return
*/
public String hget(String key, String field) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hget(key, field);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中给定域 field 的值。
*
* @param key
* @param field
* @return
*/
public Object hgetObject(String key, String field) {
Object result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = SerializationUtils.deserialize(shardedJedis.hget(
key.getBytes(), field.getBytes()));
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 将哈希表 key 中的域 field 的值设置为 value ,当且仅当域 field 不存在。 若域 field 已经存在,该操作无效。 如果
* key 不存在,一个新哈希表被创建并执行 HSETNX 命令。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hsetnx(String key, String field, String value) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hsetnx(key, field, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。
*
* @param key
* @param hash
* @return
*/
public String hmset(String key, Map<String, String> hash) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hmset(key, hash);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。
*
* @param key
* @param hash
* @return
*/
public String hmsetObject(String key, Map<String, Object> hashs) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Map<byte[], byte[]> byteHash = new HashMap<byte[], byte[]>();
for (Map.Entry<String, Object> setMap : hashs.entrySet()) {
String keyMap = setMap.getKey();
Object valMap = setMap.getValue();
byteHash.put(keyMap.getBytes(),
SerializationUtils.serialize(valMap));
}
result = shardedJedis.hmset(key.getBytes(), byteHash);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。
*
* @param key
* @param hash
* @return
*/
public String hmsetMapObject(String key, Map<String, Map<String, Object>> hashs) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Map<byte[], byte[]> byteHash = new HashMap<byte[], byte[]>();
for (Map.Entry<String, Map<String, Object>> setMap : hashs.entrySet()) {
String keyMap = setMap.getKey();
Object valMap = setMap.getValue();
byteHash.put(keyMap.getBytes(),
SerializationUtils.serialize(valMap));
}
result = shardedJedis.hmset(key.getBytes(), byteHash);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中,一个或多个给定域的值。 如果给定的域不存在于哈希表,那么返回一个 nil 值。
*
* @param key
* @param fields
* @return
*/
public List<String> hmget(String key, String... fields) {
List<String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hmget(key, fields);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中,一个或多个给定域的值。 如果给定的域不存在于哈希表,那么返回一个 nil 值。
*
* @param key
* @param fields
* @return
*/
public List<Object> hmgetObject(String key, String... fields) {
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
byte[][] bytes = new byte[fields.length][];
for (int i = 0; i < fields.length; i++) {
bytes[i] = fields[i].getBytes();
}
List<byte[]> resultList = shardedJedis.hmget(key.getBytes(), bytes);
List<Object> resultObject = new ArrayList<Object>();
for (byte[] byteList : resultList) {
resultObject.add(SerializationUtils.deserialize(byteList));
}
return resultObject;
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return null;
}
/**
* 为哈希表 key 中的域 field 的值加上增量 increment 。 增量也可以为负数,相当于对给定域进行减法操作。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hincrBy(String key, String field, long value) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hincrBy(key, field, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 查看哈希表 key 中,给定域 field 是否存在。
*
* @param key
* @param field
* @return
*/
public Boolean hexists(String key, String field) {
Boolean result = false;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hexists(key, field);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 删除哈希表 key 中的一个或多个指定域,不存在的域将被忽略。
*
* @param key
* @param field
* @return
*/
public Long hdelAll(String key) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Set<String> keys = hkeys(key);
if(keys.size() > 0){
String[] arr = new String[keys.size()];
keys.toArray(arr);
result = hdel(key, arr);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 删除哈希表 key 中的一个或多个指定域,不存在的域将被忽略。
*
* @param key
* @param field
* @return
*/
public Long hdel(String key, String... field) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hdel(key, field);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中域的数量。
*
* @param key
* @return
*/
public Long hlen(String key) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hlen(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中的所有域。
*
* @param key
* @return
*/
public Set<String> hkeys(String key) {
Set<String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hkeys(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中所有域的值。
*
* @param key
* @return
*/
public List<String> hvals(String key) {
List<String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hvals(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中,所有的域和值。 在返回值里,紧跟每个域名(field
* name)之后是域的值(value),所以返回值的长度是哈希表大小的两倍。
*
* @param key
* @return
*/
public Map<String, String> hgetAll(String key) {
Map<String, String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hgetAll(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
/**
* 返回哈希表 key 中,所有的域和值。 在返回值里,紧跟每个域名(field
* name)之后是域的值(value),所以返回值的长度是哈希表大小的两倍。
*
* @param key
* @return
*/
public Map<String, Object> hgetAllObject(String key) {
Map<String, Object> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Map<byte[], byte[]> resultByteMap = shardedJedis.hgetAll(key
.getBytes());
result = new HashMap<String, Object>();
for (Map.Entry<byte[], byte[]> entrySet : resultByteMap.entrySet()) {
byte[] keyMap = entrySet.getKey();
byte[] valMap = entrySet.getValue();
result.put(new String(keyMap),
SerializationUtils.deserialize(valMap));
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}
}
- commons-pool2-2.4.2.jar (109.3 KB)
- 下载次数: 0
- jedis-2.8.1.jar (526.2 KB)
- 下载次数: 0
相关推荐
将Redis与Spring集成,可以充分利用Redis的强大功能,同时利用Spring的便捷性。 集成Redis与Spring主要通过Spring Data Redis模块实现。Spring Data Redis提供了对Redis的高级抽象,包括模板类、Repository支持以及...
【Redis与Spring集成】 Redis,一个高性能的键值对存储系统,常被用作数据库、缓存和消息中间件。其高效性能得益于内存存储和基于键值的数据结构。Spring Data Redis是Spring框架的一个模块,目的是简化Redis在Java...
这样,我们便完成了Redis与Spring的集成,能够方便地使用Java代码对Redis进行各种操作。记住,合理利用Redis的特性(如批量操作、订阅发布等)可以显著提高应用的性能和响应速度。在实际项目中,根据业务需求进行...
SpringCloud整合Redis缓存;版本:SpringCloud :Dalston.SR4;SpringBoot:1.5.14.RELEASE;Redis:3.2.0;Maven :3.5.3.代码下载下来即可用
spring集成redis,spring mvc实现session共享以及redis排行榜春季会议Redis这一系列项目,将会有多个spring相关的简单的例子,包括session-with-redis、spring整合redis等1、在springmvc项目session存储到redis中...
Spring 3.0虽然相对较老,但在当时是广泛使用的版本,因此了解其与Redis的集成方式对维护旧项目或理解历史背景很有帮助。 首先,我们需要引入Redis的相关jar包。在"redis必须jar"中,通常包括以下组件: 1. `jedis....
spring-data-redis-1.6.2.RELEASE.jar spring与redis集成包 commons-pool2-2.4.2.jar 与redis连接池 spring-data-commons-2.0.0.RC2.jar spring数据包 redis-context.xml redis和spring配置,需要引用到自己项目的...
将Redis与Spring整合,可以充分利用Redis的高速存储优势,提升应用程序的性能。本文将深入探讨如何进行Redis与Spring的整合,并详细解析整合过程中的关键步骤。 首先,我们要理解Spring对数据源的支持。Spring提供...
我们将深入探讨如何在Spring框架中集成Redis,并通过注解方式实现数据的存取。 首先,Redis作为缓存系统,可以大大提高应用程序的响应速度,减少对数据库的直接访问,从而降低系统负载。在Spring中整合Redis,我们...
总的来说,集成Redis与Spring Cache可以简化缓存的管理和使用,通过合理配置和使用,能够有效地提升系统的响应速度和效率。在实际开发中,应根据业务需求调整缓存策略,例如设置合适的缓存过期时间,以及处理缓存和...
Spring框架提供了多种方式来集成Redis,其中最常用的是通过`Spring-data-redis`模块。这个模块提供了对Redis操作的高级抽象,使得在Spring应用中使用Redis变得简单。 **一、集成步骤** 1. **依赖添加**:首先,在...
`redis-spring-boot-starter`是Spring Boot生态中的一个启动器(Starter),它简化了Redis与Spring Boot集成的过程,使得开发者无需手动配置复杂的Redis连接参数,就能快速地在应用中启用Redis服务。这个启动器通常...
spring和redis集成有很多方式,看到网上很多都是使用redistemplate自己去做redis 的一些操作,但是对于我们开发来说,肯定是使用越方便越好,于是乎就有了spring的对redis或者memcahe这些换成框架的封装,只需要引入...
将Redis与Spring集成,可以轻松地在应用中实现缓存功能,提高系统的响应速度和数据一致性。 在这个"spring+springmvc+mybatis+redis框架"的示例中,开发者可能已经创建了一个完整的Web应用,其中: 1. Spring作为...
**Spring集成Redis集群详解** 在现代的Web应用程序开发中,数据缓存扮演着至关重要的角色,而Redis作为一款高性能的键值数据存储系统,被广泛应用于缓存、消息队列等多个场景。当业务规模扩大,单机Redis可能无法...
本文将详细介绍如何在Spring应用中集成Redis,以及如何操作String、list、set、map四种基本数据类型。 一、整合步骤 1. **环境配置**:首先确保本地安装了Redis服务器,并且能够在应用中访问。同时,添加Redis的...
在IT行业中,Spring Boot是一个非常流行的微服务框架,它简化了Spring应用的初始搭建...通过这样的集成,我们可以利用Spring Boot的便利性,结合Redis的高速缓存能力与MyBatis的数据库操作,构建出高效稳定的Web应用。
标题中的“Spring-session2整合spring5+redis”指的是在Spring框架的第五个主要版本(Spring 5)中,集成Spring Session 2与Redis数据库来管理Web应用的会话(Session)。Spring Session是一个开源项目,旨在提供一...
在这个项目中,Spring负责整体架构的管理,包括依赖注入、AOP(面向切面编程)以及与Shiro和Redis的集成。 **Shiro与Spring的集成** 将Shiro与Spring结合,可以利用Spring的IOC容器管理Shiro的组件,如Realm(领域...
当我们谈论"redis集成spring实现aop"时,我们指的是如何将Redis缓存系统与Spring框架结合,并利用Spring的面向切面编程(AOP)功能来优化应用程序的性能。 首先,让我们深入了解Redis。Redis是一种内存数据结构存储...