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,fi
99f5
elds);
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();
}
}
}
}