两种连接方式：（写了一半，未测试）
spring xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-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/aop http://www.springframework.org/schema/aop/spring-aop-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/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <!-- 加载配置文件 -->
<!-- <context:property-placeholder location="classpath:redis-config/*.properties" /> --> <!-- jedis客户端单机版 id是我们随便起的名字,后面全限定名要复制对，这种方式不能配置密码，如果有密码，用下面的jedisPool配置
然后还有个属性 poolConfig可以配也开不配置，不配置时会有默认配置-->
<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
<constructor-arg name="host" value="127.0.0.1"></constructor-arg>
<constructor-arg name="port" value="6379"></constructor-arg>
</bean> <!-- 如果要配置连接密码需要用下面这种单机配置 -->
<!-- <bean id="jedisPool" class="redis.clients.jedis.JedisPool" >
<constructor-arg name="host" value="${redis.host}"></constructor-arg>
<constructor-arg name="port" value="${redis.port}"></constructor-arg>
<constructor-arg name="password" value="${redis.password}"></constructor-arg>
<constructor-arg name="timeout" value="${redis.timeout}"></constructor-arg>
<constructor-arg name="database" value="${redis.database}"></constructor-arg> <constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
</bean> --> <!-- 单机和集群都可能用到的配置 -->
<!-- <bean class="redis.clients.jedis.JedisPoolConfig" id="jedisPoolConfig">
<property name="maxIdle" value="${maxIdle}" />
<property name="maxTotal" value="${maxActive}" />
<property name="maxWaitMillis" value="${maxWait}" />
<property name="testOnBorrow" value="${testOnBorrow}" />
<property name="blockWhenExhausted" value="${blockWhenExhausted}" />
</bean> --> <!-- 单机redisClient实现类 -->
<bean id="jedisClientSingle" class="com.tydic.jtcrm.redis.util.JedisClientSingle">
<property name="jedisPool" ref="jedisPool" />
</bean> <!-- 集群相关 -->
<!-- <bean id="jedisCluster" class="redis.clients.jedis.JedisCluster">
多节点配置
<constructor-arg name="jedisClusterNode">
<set>
<bean class="redis.clients.jedis.HostAndPort">
<constructor-arg index="0" value="${redis.host}"></constructor-arg>
<constructor-arg index="1" value="${redis.port}"></constructor-arg>
</bean>
<bean class="redis.clients.jedis.HostAndPort">
<constructor-arg index="0" value="192.168.101.3"></constructor-arg>
<constructor-arg index="1" value="7002"></constructor-arg>
</bean>
</set>
</constructor-arg> 其他参数配置
<constructor-arg name="connectionTimeout" value="2000"/> <constructor-arg name="soTimeout" value="2000"/> <constructor-arg name="maxAttempts" value="3"/> <constructor-arg name="password" value="${redis.password}"/> 连接池配置，可以和带密码的单机版公用一个
<constructor-arg name="poolConfig" ref="jedisPoolConfig"/> </bean> --> <!-- 集群redisClient实现类 -->
<!-- <bean id="jedisClientCluster" class="com.tydic.jtcrm.redis.util.JedisClientCluster">
<property name="jedisCluster" ref="jedisCluster" />
</bean> --> <!-- 配置我们自定义的jedisClient实现类 -->
<!-- <bean id="jedisClient" class="com.tydic.jtcrm.redis.service.JedisClient">
</bean> --> </beans>
代码：
单机版，使用jedispool：
package com.tydic.jtcrm.redis.util; import java.util.List;
import java.util.Set; import javax.annotation.Resource; import com.tydic.xxcrm.redis.service.JedisClient; import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool; public class JedisClientSingle implements JedisClient{
//单机版需要注入在 application-jedis.xml中配置的bean
private JedisPool jedisPool; /**
* 必须有set方法，否则无法属性注入
*/
public void setJedisPool(JedisPool jedisPool) {
this.jedisPool = jedisPool;
} public String get(String key) {
Jedis jedis = jedisPool.getResource();
String result = jedis.get(key);
jedis.close();
return result;
} public String set(String key, String value) {
Jedis jedis = jedisPool.getResource();
String result = jedis.set(key, value);
jedis.close();
return result;
} public Boolean exists(String key){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
return jedis.exists(key);
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return false;
} public String hget(String hkey, String key) {
Jedis jedis = jedisPool.getResource();
String result = jedis.hget(hkey, key);
jedis.close();
return result;
} public Long hset(String hkey, String key, String value) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.hset(hkey, key, value);
jedis.close();
return result;
} public Long incr(String key) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.incr(key);
jedis.close();
return result;
} public Long expire(String key, int second) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.expire(key, second);
jedis.close();
return result;
} public Long ttl(String key) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.ttl(key);
jedis.close();
return result;
} public Long del(String key) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.del(key);
jedis.close();
return result;
} public Long hdel(String hkey, String key) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.hdel(hkey,key);
jedis.close();
return result;
} /**************************** redis 列表List start***************************/ /**
* 将一个值插入到列表头部，value可以重复，返回列表的长度
* @param key
* @param value String
* @return 返回List的长度
*/
public Long lpush(String key, String value){
Jedis jedis = jedisPool.getResource();
Long length = jedis.lpush(key, value);
jedis.close();
return length;
} /**
* 将多个值插入到列表头部，value可以重复
* @param key
* @param values String[]
* @return 返回List的数量size
*/
public Long lpush(String key, String[] values){
Jedis jedis = jedisPool.getResource();
Long size = jedis.lpush(key, values);
jedis.close();
//System.out.println(result);
return size;
} /**
* 获取List列表
* @param key
* @param start Long，开始索引
* @param end Long， 结束索引
* @return List<String>
*/
public List<String> lrange(String key, int start, int end){
Jedis jedis = jedisPool.getResource();
List<String> list = jedis.lrange(key, start, end);
jedis.close();
return list;
} /**
* 通过索引获取列表中的元素
* @param key
* @param index，索引，0表示最新的一个元素
* @return String
*/
public String lindex(String key, Long index){
Jedis jedis = jedisPool.getResource();
String str = jedis.lindex(key, index);
jedis.close();
return str;
} /**
* 获取列表长度，key为空时返回0
* @param key
* @return Long
*/
public Long llen(String key){
Jedis jedis = jedisPool.getResource();
Long length = jedis.llen(key);
jedis.close();
return length;
} /**
* 在列表的元素前或者后插入元素，返回List的长度
* @param key
* @param where LIST_POSITION
* @param pivot 以该元素作为参照物，是在它之前，还是之后（pivot：枢轴;中心点，中枢;[物]支点，支枢;[体]回转运动。）
* @param value
* @return Long
*/
public Long linsert(String key, LIST_POSITION where, String pivot, String value){
Jedis jedis = jedisPool.getResource();
Long length = jedis.linsert(key, where, pivot, value);
jedis.close();
return length;
} /**
* 将一个或多个值插入到已存在的列表头部，当成功时，返回List的长度；当不成功（即key不存在时，返回0）
* @param key
* @param value String
* @return Long
*/
public Long lpushx(String key, String value){
Jedis jedis = jedisPool.getResource();
Long length = jedis.lpushx(key, value);
jedis.close();
return length;
} /**
* 将一个或多个值插入到已存在的列表头部，当成功时，返回List的长度；当不成功（即key不存在时，返回0）
* @param key
* @param values String[]
* @return Long
*/
public Long lpushx(String key, String[] values){
Jedis jedis = jedisPool.getResource();
Long length = jedis.lpushx(key, values);
jedis.close();
return length;
} /**
* 移除列表元素，返回移除的元素数量
* @param key
* @param count，标识，表示动作或者查找方向
* <li>当count=0时，移除所有匹配的元素；</li>
* <li>当count为负数时，移除方向是从尾到头；</li>
* <li>当count为正数时，移除方向是从头到尾；</li>
* @param value 匹配的元素
* @return Long
*/
public Long lrem(String key, Long count, String value){
Jedis jedis = jedisPool.getResource();
Long length = jedis.lrem(key, count, value);
jedis.close();
return length;
} /**
* 通过索引设置列表元素的值，当超出索引时会抛错。成功设置返回true
* @param key
* @param index 索引
* @param value
* @return Boolean
*/
public Boolean lset(String key, Long index, String value){
Jedis jedis = jedisPool.getResource();
String statusCode = jedis.lset(key, index, value);
jedis.close();
if("OK".equalsIgnoreCase(statusCode)){
return true;
}else{
return false;
}
} /**
* 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
* @param key
* @param start
* <li>可以为负数（-1是列表的最后一个元素，-2是列表倒数第二的元素。）</li>
* <li>如果start大于end，则返回一个空的列表，即列表被清空</li>
* @param end
* <li>可以为负数（-1是列表的最后一个元素，-2是列表倒数第二的元素。）</li>
* <li>可以超出索引，不影响结果</li>
* @return Boolean
*/
public Boolean ltrim(String key, Long start, Long end){
Jedis jedis = jedisPool.getResource();
String statusCode = jedis.ltrim(key, start, end);
jedis.close();
if("OK".equalsIgnoreCase(statusCode)){
return true;
}else{
return false;
}
} /**
* 移出并获取列表的第一个元素，当列表不存在或者为空时，返回Null
* @param key
* @return String
*/
public String lpop(String key){
Jedis jedis = jedisPool.getResource();
String value = jedis.lpop(key);
jedis.close();
return value;
} /**
* 移除并获取列表最后一个元素，当列表不存在或者为空时，返回Null
* @param key
* @return String
*/
public String rpop(String key){
Jedis jedis = jedisPool.getResource();
String value = jedis.rpop(key);
jedis.close();
return value;
} /**
* 在列表中的尾部添加一个个值，返回列表的长度
* @param key
* @param value
* @return Long
*/
public Long rpush(String key, String value){
Jedis jedis = jedisPool.getResource();
Long length = jedis.rpush(key, value);
jedis.close();
return length;
} /**
* 在列表中的尾部添加多个值，返回列表的长度
* @param key
* @param values
* @return Long
*/
public Long rpush(String key, String[] values){
Jedis jedis = jedisPool.getResource();
Long length = jedis.rpush(key, values);
jedis.close();
return length;
} /**
* 仅当列表存在时，才会向列表中的尾部添加一个值，返回列表的长度
* @param key
* @param value
* @return Long
*/
public Long rpushx(String key, String value){
Jedis jedis = jedisPool.getResource();
Long length = jedis.rpushx(key, value);
jedis.close();
return length;
} /**
* 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
* @param sourceKey 源列表的key，当源key不存在时，结果返回Null
* @param targetKey 目标列表的key，当目标key不存在时，会自动创建新的
* @return String
*/
public String rpopLpush(String sourceKey, String targetKey){
Jedis jedis = jedisPool.getResource();
String value = jedis.rpoplpush(sourceKey, targetKey);
jedis.close();
return value;
} /**
* 移出并获取列表的【第一个元素】， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
* @param timeout 单位为秒
* @param keys
* <li>当有多个key时，只要某个key值的列表有内容，即马上返回，不再阻塞。</li>
* <li>当所有key都没有内容或不存在时，则会阻塞，直到有值返回或者超时。</li>
* <li>当超期时间到达时，keys列表仍然没有内容，则返回Null</li>
* @return List<String>
*/
public List<String> blpop(int timeout, String... keys){
Jedis jedis = jedisPool.getResource();
List<String> values = jedis.blpop(timeout, keys);
jedis.close();
return values;
} /**
* 移出并获取列表的【最后一个元素】， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
* @param timeout 单位为秒
* @param keys
* <li>当有多个key时，只要某个key值的列表有内容，即马上返回，不再阻塞。</li>
* <li>当所有key都没有内容或不存在时，则会阻塞，直到有值返回或者超时。</li>
* <li>当超期时间到达时，keys列表仍然没有内容，则返回Null</li>
* @return List<String>
*/
public List<String> brpop(int timeout, String... keys){
Jedis jedis = jedisPool.getResource();
List<String> values = jedis.brpop(timeout, keys);
jedis.close();
return values;
} /**
* 从列表中弹出列表最后一个值，将弹出的元素插入到另外一个列表中并返回它；
* 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
* @param sourceKey 源列表的key，当源key不存在时，则会进行阻塞
* @param targetKey 目标列表的key，当目标key不存在时，会自动创建新的
* @param timeout 单位为秒
* @return String
*/
public String brpopLpush(String sourceKey, String targetKey, int timeout){
Jedis jedis = jedisPool.getResource();
String value = jedis.brpoplpush(sourceKey, targetKey, timeout);
jedis.close();
return value;
} /**************************** redis 列表List end***************************/ /**************************** redis 集合Set start***************************/
/**Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。**/ /**
* 向集合添加一个或多个成员，返回添加成功的数量
* @param key
* @param members
* @return Long
*/
public Long sadd(String key, String... members){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
return jedis.sadd(key, members);
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return null;
} /**
* 获取集合的成员数
* @param key
* @return
*/
public Long scard(String key){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
return jedis.scard(key);
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return null;
} /**
* 返回集合中的所有成员
* @param key
* @return Set<String>
*/
public Set<String> smembers(String key){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
return jedis.smembers(key);
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return null;
} /**
* 判断 member 元素是否是集合 key 的成员，在集合中返回True
* @param key
* @param member
* @return Boolean
*/
public Boolean sIsMember(String key, String member){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
return jedis.sismember(key, member);
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return null;
} /**
* 返回给定所有集合的差集（获取第一个key中与其它key不相同的值，当只有一个key时，就返回这个key的所有值）
* @param keys
* @return Set<String>
*/
public Set<String> sdiff(String... keys){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
return jedis.sdiff(keys);
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return null;
} /**
* 返回给定所有集合的差集并存储在 targetKey中，类似sdiff，只是该方法把返回的差集保存到targetKey中
* <li>当有差集时，返回true</li>
* <li>当没有差集时，返回false</li>
* @param targetKey
* @param keys
* @return
*/
public Boolean sdiffStore(String targetKey, String... keys){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
Long statusCode = jedis.sdiffstore(targetKey, keys);
if(1L == statusCode){
return true;
}
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return false;
} /**
* 返回给定所有集合的交集（获取第一个key中与其它key相同的值，要求所有key都要有相同的值，如果没有相同，返回Null。当只有一个key时，就返回这个key的所有值）
* @param keys
* @return Set<String>
*/
public Set<String> sinter(String... keys){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
return jedis.sinter(keys);
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return null;
} /**
* 返回给定所有集合的交集并存储在 targetKey中，类似sinter
* @param targetKey
* @param keys
* @return Boolean
*/
public Boolean sinterStore(String targetKey, String... keys){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
Long statusCode = jedis.sinterstore(targetKey, keys);
if(1L == statusCode){
return true;
}
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return false;
} /**
* 将 member 元素从 sourceKey 集合移动到 targetKey 集合
* <li>成功返回true</li>
* <li>当member不存在于sourceKey时，返回false</li>
* <li>当sourceKey不存在时，也返回false</li>
* @param sourceKey
* @param targetKey
* @param member
* @return Boolean
*/
public Boolean smove(String sourceKey, String targetKey, String member){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
Long value = jedis.smove(sourceKey, targetKey, member);
if(value > 0){
return true;
}
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return false;
} /**
* 移除并返回集合中的一个随机元素
* <li>当set为空或者不存在时，返回Null</li>
* @param key
* @return String
*/
public String spop(String key){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
return jedis.spop(key);
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return null;
} /**
* 返回集合中一个或多个随机数
* <li>当count大于set的长度时，set所有值返回，不会抛错。</li>
* <li>当count等于0时，返回[]</li>
* <li>当count小于0时，也能返回。如-1返回一个，-2返回两个</li>
* @param key
* @param count
* @return List<String>
*/
public List<String> srandMember(String key, int count){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
return jedis.srandmember(key, count);
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return null;
} /**
* 移除集合中一个或多个成员
* @param key
* @param members
* @return
*/
public Boolean srem(String key, String... members){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
//Integer reply, specifically: 1 if the new element was removed
//0 if the new element was not a member of the set
Long value = jedis.srem(key, members);
if(value > 0){
return true;
}
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return false;
} /**
* 返回所有给定集合的并集，相同的只会返回一个
* @param keys
* @return
*/
public Set<String> sunion(String... keys){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
return jedis.sunion(keys);
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return null;
} /**
* 所有给定集合的并集存储在targetKey集合中
* <li>注：合并时，只会把keys中的集合返回，不包括targetKey本身</li>
* <li>如果targetKey本身是有值的，合并后原来的值是没有的，因为把keys的集合重新赋值给targetKey</li>
* <li>要想保留targetKey本身的值，keys要包含原来的targetKey</li>
* @param targetKey
* @param keys
* @return
*/
public Boolean sunionStore(String targetKey, String... keys){
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
//返回合并后的长度
Long statusCode = jedis.sunionstore(targetKey, keys);
if(statusCode > 0){
return true;
}
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return false;
} /**************************** redis 集合Set end***************************/ }
集群版，使用jedisCluster：
package com.txxxc.jtcrm.redis.util; import java.util.List; import com.tydic.jtcrm.redis.service.JedisClient; import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster; public class JedisClientCluster implements JedisClient { private JedisCluster jedisCluster; public JedisCluster getJedisCluster() {
return jedisCluster;
} public void setJedisCluster(JedisCluster jedisCluster) {
this.jedisCluster = jedisCluster;
} @Override
public String set(String key, String value) {
return jedisCluster.set(key, value);
} @Override
public String get(String key) {
return jedisCluster.get(key);
} @Override
public Boolean exists(String key) {
return jedisCluster.exists(key);
} @Override
public Long expire(String key, int seconds) {
return jedisCluster.expire(key, seconds);
} // @Override
public Long ttl(String key) {
return jedisCluster.ttl(key);
} // @Override
public Long incr(String key) {
return jedisCluster.incr(key);
} // @Override
public Long hset(String key, String field, String value) {
return jedisCluster.hset(key, field, value);
} // @Override
public String hget(String key, String field) {
return jedisCluster.hget(key, field);
} // @Override
public Long hdel(String key, String field) {
return jedisCluster.hdel(key, field);
} // @Override
public Boolean hexists(String key, String field) {
return jedisCluster.hexists(key, field);
} // @Override
public List<String> hvals(String key) {
return jedisCluster.hvals(key);
} @Override
public Long del(String key) {
return jedisCluster.del(key);
} @Override
public Long rpush(String key, String value){
Long length = jedisCluster.rpush(key, value);
return length;
} @Override
public String lpop(String key){
return jedisCluster.lpop(key);
} @Override
public Long llen(String key){
return jedisCluster.llen(key);
} @Override
public List<String> lrange(String key, int start, int end){
List<String> list = jedisCluster.lrange(key, start, end);
return list;
} // @Override
public Long lrem(String key, Long count, String value){
Long length = jedisCluster.lrem(key, count, value);
return length;
} }
接口：
package com.txxxc.jtcrm.redis.service;
import java.util.List;
public interface JedisClient {
//获取值
String get(String key);
//设置值
String set(String key,String value);
/*//获取hash类型的值
String hget(String hkey,String key);
//设置hash类型的值
Long hset(String hkey,String key,String value);
//使某个值自增1
Long incr(String key);*/
//设置某个值的有效期，单位是秒
Long expire(String key,int second);
//获取某个值的有效期（返回-1为永久有效，返回-2为已经失效，返回其他正整数为剩余有效期毫秒值）
// Long ttl(String key);
//删除缓存数据
Long del(String key);
//删除hash类型数据
// Long hdel(String hkey,String key);
Boolean exists(String key);
Long rpush(String key, String value);
String lpop(String key);
Long llen(String key);
List<String> lrange(String key, int start, int end);
// Long lrem(String key, Long count, String value);
}
测试：
package com.txxxc.xxcrm.redis; import java.util.ArrayList;
import java.util.List; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import com.ctg.ixxxc.cache.pool.CtgJedisPool;
import com.ctg.ixxxc.cache.pool.CtgJedisPoolConfig;
import com.ctg.ixxxc.cache.pool.CtgJedisPoolException;
import com.ctg.ixxxc.cache.pool.ProxyJedis;
import com.txxxc.xxcrm.redis.util.JedisClientSingle;
import com.txxxc.xxcrm.redis.util.JedisClientSingle2; import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig; /**
* @Package com.tydic.jtcrm.redis
* @ClassName RedisTest.java
* @author libin
* @date 2019年4月13日 上午10:01:01
* @version V1.0
*/
public class RedisTest { public static void main1(String[] args) {
//创建一个jedis对象
Jedis jedis = new Jedis("127.0.0.1", 6379);
//调用jedis对象的方法，方法名和redis命令一致
jedis.set("key1", "jedistest1");
String s1 = jedis.get("key1");
System.out.println(s1);
// Set<String> keys = jedis.keys("*");
// System.out.println(keys);
//关闭jedis连接
jedis.close(); }
public static void main2(String[] args) {
//创建连接池对象
JedisPool jedisPool = new JedisPool("127.0.0.1", 6379);
//从连接池中获取一个jedis对象
Jedis jedis = jedisPool.getResource();
jedis.set("key2", "jedisPool2");
String string = jedis.get("key2");
System.out.println(string);
//关闭jedis对象
jedis.close();
//关闭连接池
jedisPool.close(); } public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:redis-config/applicationContext-jedis.xml");
JedisClientSingle j = (JedisClientSingle) applicationContext.getBean(JedisClientSingle.class);
j.set("b", "6u");
String s = j.get("b");
System.out.println(s);
} public static void main3(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:redis-config/applicationContext-jedis2.xml");
JedisClientSingle2 j = (JedisClientSingle2) applicationContext.getBean(JedisClientSingle2.class);
j.set("b", "5k");
String s = j.get("b");
System.out.println("----------------------------------"+s); } public static void main4(String[] args) throws CtgJedisPoolException { JedisPoolConfig poolConfig = new JedisPoolConfig(); // 线程池配置
poolConfig.setMaxIdle(3); // 最大空闲连接数
poolConfig.setMaxTotal(10); // 最大连接数（空闲+使用中）
poolConfig.setMinIdle(3); // 保持的最小空闲连接数
poolConfig.setMaxWaitMillis(3000); // 借出连接时最大的等待时间 List<HostAndPort> nodes = new ArrayList<HostAndPort>(); String[] hostArr = "172.16.1.249:10051".split(",");
for (String host : hostArr) {
String[] hostPort = host.split(":");
nodes.add(new HostAndPort(hostPort[0], Integer.parseInt(hostPort[1])));
} CtgJedisPoolConfig ctgJedisPoolConfig = new CtgJedisPoolConfig(nodes);
ctgJedisPoolConfig.setDatabase(21) // 分组对应的桶位
.setPassword("cust_center_all#Tydic123") // “用户#密码”
.setPoolConfig(poolConfig) // 线程池配置
.setPeriod(3000) // 后台监控执行周期，毫秒
.setMonitorTimeout(2000); // 后台监控ping命令超时时间,毫秒 CtgJedisPool ctgJedisPool = new CtgJedisPool(ctgJedisPoolConfig);
ProxyJedis jedis = ctgJedisPool.getResource(); jedis.set("a", "7777777");
System.out.println("-----------: "+jedis.get("a"));
if(jedis!=null){
jedis.close();
}
} }