redis 缓存简单使用01

上个项目使用了redis 在这里现做个简单的记录

关于redis的简介这里不做闲聊，有需要了解的可以百度下
demo地址 http://download.csdn.net/detail/tets_java/9902917
1、本地windows系统测试redis环境搭建
http://pan.baidu.com/s/1dE1B6ut
下载压缩包
解压后 查看redis Windows下部署.txt 根据提示操作就可
2、java代码书写
这里使用的redis依赖包是 jedis-2.7.2.jar 由于jedis的低版本和高版本的jar地层代码区别很大，所以使用低版本的请不要参考本文。
基于redis这里使用了两个依赖包
jedis-2.7.2.jar
commons-pool2-2.2.jar

下面是redisUtil的代码
package com.founder.utmp.util;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.google.gson.Gson;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
* add by lk 2016-9-1 16:46:57
* @author Administrator
*
*/
public class RedisUtil {
private static Log LOG = LogFactory.getLog(RedisUtil.class);
//Redis服务器IP
private static String ADDR = “localhost”; // redis地址
//Redis的端口号
private static int PORT = 6379;
//可用连接实例的最大数目，默认值为8；
//如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;
//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
private static int MAX_IDLE = 200;
//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
private static int MAX_WAIT = 10000;

//在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；  
private static boolean TEST_ON_BORROW = true;  
private static JedisPool jedisPool = null;  
/** 
 * 初始化Redis连接池 
 */  
 static {  
     try {  
          JedisPoolConfig config = new JedisPoolConfig();  
          config.setMaxTotal(MAX_ACTIVE);  
          config.setMaxIdle(MAX_IDLE);  
          config.setMaxWaitMillis(MAX_WAIT);  
          config.setTestOnBorrow(TEST_ON_BORROW);  
          jedisPool = new JedisPool(config, ADDR, PORT);  
     } catch (Exception e) {  
          e.printStackTrace();  
     }  
 }  


 /** 
  * 释放jedis资源 
  * @param jedis 
  */  
  public static void returnResource(final Jedis jedis) {  
      if (jedis != null) {  
           jedisPool.returnResourceObject(jedis);  
      }  
  }  


  public static void main(String[] args) {
      Jedis jedis = connectJedis();
      jedis.set("56345", "09843");
      returnResource(jedis);
      Jedis jedis2 = connectJedis();
      System.out.println(jedis2.get("56"));
      returnResource(jedis2);

}

  /**
 *  redis 连接服务器
 * @return Jedis
 */
public static Jedis connectJedis(){
     try {  
         if (jedisPool != null) {  
             Jedis resource = jedisPool.getResource();  
             return resource;  
         } else {  
             return null;  
         }  
     } catch (Exception e) {  
         e.printStackTrace(); 
         LOG.debug(e);
         return null;  
     } 
}



/**
   * redis 添加Object对象
   * @param key
   * @param obj
   */
  public static void setObject(String key ,Object obj){
      Jedis jedis = null;
    try {
        obj = obj == null ? new Object():obj;
        jedis = connectJedis();
        jedis.set(key.getBytes(), SerializeUtil.serialize(obj));
    } catch (Exception e) {
        e.printStackTrace();
        LOG.debug(e);
    }finally{
        returnResource(jedis);
    }

}

  /**
   *  redis 获取object获取对象
   * @param key
   * @return Object
   */
public static Object getObject(String key){
    Jedis jedis = connectJedis();
    if(jedis == null || !jedis.exists(key)){
        return null;
    }
    byte[] data = jedis.get(key.getBytes());
    returnResource(jedis);
    return (Object)SerializeUtil.unserialize(data);
}

/**
   *  redis 添加 List集合
   * @param key
   * @param list
   */
  public static void setList(String key ,List<?> list){
      Jedis jedis = null;
    try {
        jedis = connectJedis();
        if(!list.isEmpty()){
            jedis.set(key.getBytes(), SerializeUtil.serializeList(list));
        }else{//如果list为空,则设置一个空
            jedis.set(key.getBytes(), "".getBytes());
        }
    } catch (Exception e) {
        e.printStackTrace();
        LOG.debug(e);
    }finally{
        returnResource(jedis);
    }

}

  /**
   *  redis 获取List集合
   * @param key
   * @return
   */
public static List<?> getList(String key){
    Jedis jedis = connectJedis();
    if(jedis == null || !jedis.exists(key)){
        return null;
    }
    byte[] data = connectJedis().get(key.getBytes());
    returnResource(jedis);
    return SerializeUtil.unserializeList(data);
}


/**
 * redis 保存map<String,String> 方法
 * @param kew
 * @param map
 */
public static void setMap(String key,Map<String,String> map){
    Jedis jedis = connectJedis();
    jedis.hmset(key,map);
    returnResource(jedis);
}

/**
 *  redis 获取Map<String,String>
 * @param key
 * @return Map<String,String>
 */
public static List<String> getMap(String key,String... fields ){
    Jedis jedis = connectJedis();
    List<String>  list=  jedis.hmget(key,fields);
    returnResource(jedis);
    return list;
}

/**
 * redis 删除Map中的某个键值对
 * @param key
 * @param mapValue
 */
public static void delMap(String key,String mapValue){
    Jedis jedis = connectJedis();
    jedis.hdel(key,mapValue);
    returnResource(jedis);
}


/**
 *  redis 删除redis中的元素
 * @param key
 */
public static void delete(String key){
    Jedis jedis = connectJedis();
    jedis.del(key);
    returnResource(jedis);
}

/**
 *  根据rediskey 与mapKey 将redis中Map对应的value值取出来 并将其转换为javaBean
 * @param redisKey redis 的 key
 * @param MapKey  map 的 key
 * @param beanClass 转换的javaBean.class
 * @return javaBean
 */
public static <T> T getMapToBean(String redisKey,String MapKey,Class<T> beanClass){
    List<String> list= RedisUtil.getMap(redisKey,MapKey);
    Gson gson=new Gson(); 
    T javaBean = gson.fromJson(list.get(0), beanClass);
    return javaBean;
};

其中 setList、getList、setObject、getObject使用了序列化和反序列化 必须依靠下面的类

package com.founder.utmp.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
/**
 * 序列化工具类
 * @author Administrator
 *
 */
public class SerializeUtil {
/**
 * 序列化
 * @param object
 * @return
 */
public static byte[] serialize(Object object) {
    if (object == null) {
        return null;
    }
    ObjectOutputStream oos = null;
    ByteArrayOutputStream baos = null;
    byte[] bytes = null;
    try {
        // 序列化
        baos = new ByteArrayOutputStream();
        oos = new ObjectOutputStream(baos);
        oos.writeObject(object);
        bytes = baos.toByteArray();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        close(oos);
        close(baos);
    }
    return bytes;
}
/**
 * 反序列化
 * 
 * @param bytes
 * @return
 */
public static Object unserialize(byte[] bytes) {
    if (bytes == null) {
        return null;
    }
    ByteArrayInputStream bais = null;
    ObjectInputStream ois = null;
    try {
        // 反序列化
        bais = new ByteArrayInputStream(bytes);
        ois = new ObjectInputStream(bais);
        return ois.readObject();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        close(bais);
        close(ois);
    }
    return null;
}

/**
 * 序列化 list 集合
 * 
 * @param list
 * @return
 */
public static byte[] serializeList(List<?> list) {

    if (list.isEmpty()) {
        return null;
    }
    ObjectOutputStream oos = null;
    ByteArrayOutputStream baos = null;
    byte[] bytes = null;
    try {
        baos = new ByteArrayOutputStream();
        oos = new ObjectOutputStream(baos);
        for (Object obj : list) {
            oos.writeObject(obj);
        }
        bytes = baos.toByteArray();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        close(oos);
        close(baos);
    }
    return bytes;
}

/**
 * 反序列化 list 集合
 * 
 * @param lb
 * @return
 */
public static List<?> unserializeList(byte[] bytes) {
    if (bytes == null) {
        return null;
    }

    List<Object> list = new ArrayList<Object>();
    ByteArrayInputStream bais = null;
    ObjectInputStream ois = null;
    try {
        // 反序列化
        bais = new ByteArrayInputStream(bytes);
        ois = new ObjectInputStream(bais);
        while (bais.available() > 0) {
            Object obj = (Object) ois.readObject();
            if (obj == null) {
                break;
            }
            list.add(obj);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        close(bais);
        close(ois);
    }
    return list;
}

/**
 * 关闭io流对象
 * 
 * @param closeable
 */
public static void close(Closeable closeable) {
    if (closeable != null) {
        try {
            closeable.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
}