封装Redis部分基本操作(键值都封装为对象类型)

一.序列化工具类（因为Jedis的键是区分String，byte类型的，所以使用序列化成byte，再使用反序列化显示）

package com.yk;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerialoizebleUtil {

/**
* 将对象序列化:要求对象要实现序列化接口
*/
public static byte[] serialize(Object obj ){
ObjectOutputStream oos = null; //对象输出流
ByteArrayOutputStream baos = null;//字节数组输出流

byte[] bt=null;

try {
baos = new ByteArrayOutputStream();
oos=new ObjectOutputStream(baos);
<
4000
span style="color:#cc7832;">         oos.writeObject(obj);
bt=baos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
}finally{
if(baos!=null){
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return bt;
}

//反序列化，将byte字节转换为对象
public static Object unSerialize(byte[] bt){
ByteArrayInputStream bais = null;
Object object =null;

try {
bais = new ByteArrayInputStream(bt);
ObjectInputStream ois = new ObjectInputStream(bais);
object  = ois .readObject();
} catch (Exception e) {
e.printStackTrace();
}finally{
if(bais!=null){
try {
bais.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return object;
}

}

二.redis连接池类(读取配置文件，创建redis连接池，获取redis连接)

package com.yk;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.util.ResourceBundle;

public class RedisPool {
private static JedisPool pool =null;
/*使用静态代码块，优先加载顺序在static方法之前
* 初始化redis连接配置
*/
static {
//得到redis.properties 中的配置信息
ResourceBundle bundle = ResourceBundle.getBundle("redis");
if(bundle==null){
throw new IllegalArgumentException("[redis.properties] is not found");
}
//配置信息对象config
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(Integer.valueOf(bundle.getString("redis.pool.maxActive")));
config.setMaxIdle(Integer.valueOf(bundle.getString("redis.pool.maxIdle")));
config.setMaxWaitMillis(Long.valueOf(bundle.getString("redis.pool.maxWait")));
config.setTestOnBorrow(Boolean.valueOf(bundle.getString("redis.pool.testOnBorrow")));
config.setTestOnReturn(Boolean.valueOf(bundle.getString("redis.pool.testOnReturn")));
//创建redis连接池
pool =  new JedisPool( config,bundle.getString("redis.ip"),Integer.valueOf(bundle.getString("redis.port")));
}
/**
* 获取jedis实例
* 在获取jedis实例方法前，加上序列化
* @return
*/
public synchronized static Jedis getJedis(){
if(pool!=null){
return pool.getResource();
}else{
return null;
}
}
/**
* 释放jedis实例资源
*/
public static void returnResource(Jedis jedis){
if(jedis!=null){
jedis.close();
}
}
}

三.redis配置文件(详细配置可以自己百度，这里只写出最基本的配置)

redis.pool.maxActive=1024
redis.pool.maxIdle=200
redis.pool.maxWait=100
redis.pool.testOnBorrow=true
redis.pool.testOnReturn=true
redis.ip=127.0.0.1
redis.port=6379

四.封装Redis的基本操作的接口

package com.yk;

import java.util.List;

public interface RedisDo {

public boolean RedisExist(Object key);

public void RedisSet(Object key, Object value);

public Object RedisGet(Object key);

public Object RedisGetSet(Object key, Object value);

public void RedisMset(Object... keysvalues);

public List<Object> RedisMget(Object... keys);

public void RedisSetex(Object key, int seconds, Object value);

public void RedisExpire(Object key, int seconds);

public void RedisPersist(Object key);

public Long RedisTTL(Object key);

public void RedisDel(Object... keys);

public void RedisRename(Object key, Object newkey);

}

五.接口实现

package com.yk;

import redis.clients.jedis.Jedis;

import java.util.LinkedList;
import java.util.List;

public class RedisDaoImpl implements RedisDo{

/**
* 从连接池中获取实例
* @return
*/
public static Jedis GetJedis(){
return RedisPool.getJedis();
}
/**
* 序列化
* @param object
* @return
*/
public byte[] serializeObj(Object object){
return SerialoizebleUtil.serialize(object);
}
/**
* 反序列化
* @param bt
* @return
*/
public Object unSerializeByte(byte[] bt){
return SerialoizebleUtil.unSerialize(bt);
}
/**
* 判断键是否存在
* @param key
* @return
*/
public boolean RedisExist(Object key) {
return GetJedis().exists(serializeObj(key));
}
/**
* set
* @param key
* @param value
*/
public void RedisSet(Object key, Object value) {
GetJedis().set(serializeObj(key),serializeObj(value));
}
/**
* get
* @param key
* @return
*/
public Object RedisGet(Object key) {
return unSerializeByte(GetJedis().get(serializeObj(key)));
}
/**
* 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
* @param key
* @param value
* @return
*/
public Object RedisGetSet(Object key, Object value) {
return unSerializeByte(GetJedis().getSet(serializeObj(key),serializeObj(value)));
}
/**
* 存入多个键值对 自己封装
* @param keysvalues
*/
public void RedisMset(Object... keysvalues){
List<Object> list = new LinkedList<Object>();
int i =0;
if(keysvalues!=null){
for (Object object :keysvalues){
list.add(i,object);
i++;
}
}
for (i=0;i<list.size();i++){
GetJedis().set(serializeObj(list.get(i)),serializeObj(list.get(i+1)));
i=i+1;
}
}
/**
* 输入多个键得到List<>值
* @param keys
* @return
*/
public List<Object> RedisMget(Object...keys){
List<byte[]> keyslist = new LinkedList<byte[]>();
int i =0;
if(keys!=null){
for(Object object :keys){
keyslist.add(i,serializeObj(object));
i++;
}
}
List<Object> listObj = new LinkedList<Object>();
for (i=0;i<keyslist.size();i++){
listObj.add(i,unSerializeByte(GetJedis().get(keyslist.get(i))));
}
return listObj;
}
/**
* 设置一个有过期时间的key-value对
* @param key
* @param seconds
* @param value
*/
public void RedisSetex(Object key, int seconds,Object value) {
GetJedis().setex(serializeObj(key),seconds,serializeObj(value));
}
/**
* 单独设置键的过期时间
* @param key
* @param seconds
*/
public void RedisExpire(Object key, int seconds) {
GetJedis().expire(serializeObj(key),seconds);
}
/**
* 移除键的过期时间，键保持持久
* @param key
*/
public void RedisPersist(Object key) {
GetJedis().persist(serializeObj(key));
}
/**
* 查看键的剩余过期时间
* @param key
* @return
*/
public Long RedisTTL(Object key) {
return GetJedis().ttl(serializeObj(key));
}
/**
* 删除一个或者多个键
* @param keys
*/
public void RedisDel(Object... keys) {
List<Object> list = new LinkedList<Object>();
int i =0;
if(keys!=null){
for (Object object :keys){
list.add(i,object);
i++;
}
}
for (i=0;i<list.size();i++){
GetJedis().del(serializeObj(list.get(i)));
}
}
/**
* 重命名key
* @param key
* @param newkey
*/
public void RedisRename(Object key, Object newkey) {
GetJedis().rename(serializeObj(key),serializeObj(newkey));
}
}

六.上面使用的是IDEA，代码可以直接生产Jar文件使用，需要更多的操作可以自己封装Jedis！

To be continue......