Jedis实战02

（1）Jedis配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="  
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd  
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd  
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.1.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd  
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd"
default-lazy-init="true">

<context:component-scan base-package="com.crm.redis" />

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!--最大连接数 -->
<!--不同的Common Pool 这个属性不一样 -->
<property name="maxTotal" value="50" />
<!--最大空闲数 -->
<property name="maxIdle" value="10" />
<property name="minIdle" value="1" />
<!--最大等待时间ms -->
<property name="maxWaitMillis" value="30000" />
<property name="testOnBorrow" value="true" />
<property name="testOnReturn" value="true" />
<property name="testWhileIdle" value="true" />
</bean>

<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool"
destroy-method="destroy">
<constructor-arg ref="jedisPoolConfig" />
<constructor-arg>
<list>
<bean class="redis.clients.jedis.JedisShardInfo">
<constructor-arg value="202.102.83.169" />
<constructor-arg type="int" value="6379" />
<constructor-arg value="instance:01" />
</bean>
<!-- 
<bean class="redis.clients.jedis.JedisShardInfo">
<constructor-arg value="localhost" />
<constructor-arg type="int" value="6379" />
<constructor-arg value="instance:02" />
</bean>
 -->
</list>
</constructor-arg>
</bean>

</beans>

 

（2）抽象Jedis公共DAO

 

package com.crm.redis;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.crm.redis.util.JedisSerializeUtil;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
@Repository("RedisDao")
public class RedisDao {
 @Autowired
 private ShardedJedisPool shardedJedisPool;
 // ------------------------------String------------------------------
 public void setString(String key, String value) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  jedis.set(key, value);
  shardedJedisPool.returnResource(jedis);
 }
 public String getString(String key) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  String str = jedis.get(key);
  shardedJedisPool.returnResource(jedis);
  return str;
 }
 public void delString(String key) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  jedis.del(key);
  shardedJedisPool.returnResource(jedis);
 }
 /**
  * 根据KEY追加值 （1）如果KEY存在的话，在原有值的基础上追加 （2）如果KEY不存在的话，则新增值KEY-VALUE
  */
 public void valueAppend(String key, String appendValue) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  jedis.append(key, appendValue);
  shardedJedisPool.returnResource(jedis);
 }
 // ------------------------------HashMap------------------------------
 /**
  * 根据key设置HashMap
  */
 public void hmset(String key, Map hashMap) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  jedis.hmset(key, hashMap);
  shardedJedisPool.returnResource(jedis);
 }
 /**
  * 根据key获取Map的所有Key
  */
 public Set<String> hkeys(String key) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  Set<String> r = jedis.hkeys(key);
  shardedJedisPool.returnResource(jedis);
  return r;
 }
 /**
  * 根据key获取Map的所有Value
  */
 public List<String> hvals(String key) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  List<String> r = jedis.hvals(key);
  shardedJedisPool.returnResource(jedis);
  return r;
 }
 /**
  * 根据key和HashMap的key获取值
  */
 public List<String> hmget(String key, String hashMapKey) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  List<String> r = jedis.hmget(key, hashMapKey);
  shardedJedisPool.returnResource(jedis);
  return r;
 }
 // ------------------------------List------------------------------
 /**
  * 根据key设置List
  */
 public void lpush(String key, List<String> list) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  for (String listVal : list) {
   jedis.lpush(key, listVal);
  }
  shardedJedisPool.returnResource(jedis);
 }
 /**
  * 根据key获取list中的值【起始值~终止值】 end:-1表示取得所有
  */
 public List<String> lrange(String key, long start, long end) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  List<String> r = jedis.lrange(key, start, end);
  shardedJedisPool.returnResource(jedis);
  return r;
 }
 // // 添加数据
 // jedis.lpush("lists", "vector");
 // jedis.lpush("lists", "ArrayList");
 // jedis.lpush("lists", "LinkedList");
 // // 数组长度
 // System.out.println(jedis.llen("lists"));
 // // 排序
 // System.out.println(jedis.sort("lists"));
 // // 字串
 // System.out.println(jedis.lrange("lists", 0, 3));
 // // 修改列表中单个值
 // jedis.lset("lists", 0, "hello list!");
 // // 获取列表指定下标的值
 // System.out.println(jedis.lindex("lists", 1));
 // // 删除列表指定下标的值
 // System.out.println(jedis.lrem("lists", 1, "vector"));
 // // 删除区间以外的数据
 // System.out.println(jedis.ltrim("lists", 0, 1));
 // // 列表出栈
 // System.out.println(jedis.lpop("lists"));
 // // 整个列表值
 // System.out.println(jedis.lrange("lists", 0, -1));
 
 // ------------------------------Object------------------------------
 
 /**
  * 设置对象
  */
 public void setObject(String key, Serializable object) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  jedis.set(key.getBytes(), JedisSerializeUtil.serialize(object));
  shardedJedisPool.returnResource(jedis);
 }
 
 /**
  * 获取对象
  */
 public Object getObject(String key) {
  ShardedJedis jedis = shardedJedisPool.getResource();
  return JedisSerializeUtil.unserialize(jedis.get(key.getBytes()));
 }
 
}

 

（3）Jedis Util

 

package com.crm.redis.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
 *  序列化就是将一个对象转换为二进制的数据流。
 *  这样就可以进行传输，或者保存到文件中。如果一个类的对象要想实现序列化，就必须实现serializable接口。
 *  在此接口中没有任何的方法，此接口只是作为一个标识，表示本类的对象具备了序列化的能力而已。
 *  
 *  反序列化:将二进制数据流转换成相应的对象。
 *  如果想要完成对象的序列化，则还要依靠ObjectOutputStream和ObjectInputStream,前者属于序列化操作，而后者属于反序列化操作。
 *  
 */
public class JedisSerializeUtil {
 
 private static Log log = LogFactory.getLog(JedisSerializeUtil.class);
 
 /**
  * 序列化
  *
  * @param object
  * @return
  */
 public static byte[] serialize(Object object) {
  ObjectOutputStream oos = null;
  ByteArrayOutputStream baos = null;
  try {
   // 序列化
   baos = new ByteArrayOutputStream();
   oos = new ObjectOutputStream(baos);
   oos.writeObject(object);
   byte[] bytes = baos.toByteArray();
   return bytes;
  } catch (Exception e) {
   log.error("Jedis执行序列化异常："+e.getMessage());
  }
  return null;
 }
 /**
  * 反序列化
  *
  * @param bytes
  * @return
  */
 public static Object unserialize(byte[] bytes) {
  ByteArrayInputStream bais = null;
  try {
   // 反序列化
   bais = new ByteArrayInputStream(bytes);
   ObjectInputStream ois = new ObjectInputStream(bais);
   return ois.readObject();
  } catch (Exception e) {
   log.error("Jedis执行反序列化异常："+e.getMessage());
  }
  return null;
 }
}

 

 

（4）测试代码

package com.crm.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.crm.model.operator.BOCrmOperator;
import com.crm.redis.RedisDao;
public class TestRedis {
 public static void main(String[] args) {
  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext-redis.xml");
  RedisDao RedisDao = (RedisDao) ac.getBean("RedisDao");
 
  //--------------------String--------------------
  RedisDao.setString("hello", "world");
  System.out.println(RedisDao.getString("hello"));
  RedisDao.valueAppend("hello", "-----append");
  System.out.println(RedisDao.getString("hello"));
  RedisDao.valueAppend("NOT_EXIST", "NOT_EXIST_VALUE");
  System.out.println(RedisDao.getString("NOT_EXIST"));
 
  //--------------------Map--------------------
  Map h = new HashMap();
  h.put("name", "zhuyinbai");
  h.put("age", "28");
  RedisDao.hmset("user", h);
  System.out.println(RedisDao.hkeys("user"));
  System.out.println(RedisDao.hvals("user"));
  System.out.println(RedisDao.hmget("user","name"));
  System.out.println(RedisDao.hmget("user","age"));
 
  //--------------------List--------------------
  List _list = new ArrayList();
  _list.add("A1");
  _list.add("A2");
  _list.add("A3");
  RedisDao.lpush("list", _list);
  System.out.println(RedisDao.lrange("list", 0, -1));
 
  //--------------------Object--------------------
  BOCrmOperator _o = new BOCrmOperator();
  _o.setId(1l);
  _o.setCode("code");
  _o.setName("name");
  RedisDao.setObject("o:1", _o);
  System.out.println(((BOCrmOperator)RedisDao.getObject("o:1")).toString());
 
 }
 
}