java 使用redis的工具类

最近游戏把数据库换成了redis，写了redis存储工具类与大伙分享。

import java.util.ArrayList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;



import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

public class RedisUtil {


    private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);
        private Jedis jedis;//非切片额客户端连接
        private JedisPool jedisPool;//非切片连接池
        private ShardedJedis shardedJedis;//切片额客户端连接
        private ShardedJedisPool shardedJedisPool;//切片连接池
        private static String PASSWORD = null;
        private String ip ="127.0.0.1";
        private int port = 6397;

        public RedisUtil() 
        { 

            initialPool(); 
            initialShardedPool(); 
            shardedJedis = shardedJedisPool.getResource(); 
            jedis = jedisPool.getResource(); 


        } 

        /**
         * 初始化非切片池
         */
        private void initialPool() 
        { 
            // 池基本配置 
             JedisPoolConfig config = new JedisPoolConfig(); 
             config.setMaxActive(20); 
             config.setMaxIdle(5); 
             config.setMaxWait(1000l); 
             config.setTestOnBorrow(false); 

             //jedisPool = new JedisPool(config,"123.207.229.148",6379);
            config.setTestWhileIdle(true);
            config.setMinEvictableIdleTimeMillis(60000L);
            config.setNumTestsPerEvictionRun(1);
            config.setTimeBetweenEvictionRunsMillis(30000L);

            if(PASSWORD!=null){
                jedisPool = new JedisPool(config,ip,port,10000,PASSWORD);
            }else{
                jedisPool = new JedisPool(config,ip,port);
            }
        }

        private static RedisUtil Singleton = new RedisUtil();

        public  static RedisUtil getSingleton() {
            return Singleton;
        }

        private  Jedis getJedis() {
            if (jedisPool == null)
                initialPool();
            return jedisPool.getResource();
        }

        private  void returnJedis(Jedis jedis) {
            if (jedis != null)
                jedisPool.returnResource(jedis);
        }

         /**
         * 获取数据
         * 
         * @param key
         * @return
         */
        public  void setString(String key,String value){
            Jedis jedis = null;
            try {
                jedis = getJedis();
                value = jedis.set(key,value);
            } catch (Exception e) {
                //释放redis对象
                logger.info(""+e);
                returnJedis(jedis);
            } finally {
                //返还到连接池
                returnResource(jedisPool, jedis);
            }

        }

        /**
         * 获取数据
         * 
         * @param key
         * @return
         */
        public  void setObject(byte[] key,byte[] value){
            Jedis jedis = null;
            try {
                jedis = getJedis();
                jedis.set(key,value);
            } catch (Exception e) {
                //释放redis对象
                logger.info(""+e);
                returnJedis(jedis);
            } finally {
                //返还到连接池
                returnResource(jedisPool, jedis);
            }

        }

        /**
         * 获取数据
         * 
         * @param key
         * @return
         */
        public  String getString(String key){
            String value = null;

            Jedis jedis = null;
            try {
                jedis = getJedis();
                value = jedis.get(key);
            } catch (Exception e) {
                //释放redis对象
                logger.info(""+e);
                returnJedis(jedis);
            } finally {
                //返还到连接池
                returnResource(jedisPool, jedis);
            }

            return value;
        }


        /**
         * 获取数据
         * 
         * @param key
         * @return
         */
        public  Object getObject(byte[] key){
            byte[] value = null;

            Jedis jedis = null;
            try {
                jedis = getJedis();
                value = jedis.get(key);
                return SerializeUtil.unSerialize(value);
            } catch (Exception e) {
                //释放redis对象
                logger.info(""+e);
                returnJedis(jedis);
            } finally {
                //返还到连接池
                returnResource(jedisPool, jedis);
            }

            return value;
        }

        /** 
         * 初始化切片池 
         */ 
        private void initialShardedPool() 
        { 
            // 池基本配置 
            JedisPoolConfig config = new JedisPoolConfig(); 
            config.setMaxActive(20); 
            config.setMaxIdle(5); 
            config.setMaxWait(1000l); 
            config.setTestOnBorrow(false); 
            // slave链接 
            List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); 


                logger.info("ip="+ip+"----"+"port="+port);
                shards.add(new JedisShardInfo(ip,port, "master")); 

            // 构造池 

            shardedJedisPool = new ShardedJedisPool(config, shards); 

        } 

        /**
         * 返还到连接池
         * 
         * @param pool 
         * @param redis
         */
        public  void returnResource(JedisPool pool, Jedis redis) {
            if (redis != null) {
                pool.returnResourceObject(redis);
            }
        }

        public void show() {     

            jedisPool.returnResource(jedis);
            shardedJedisPool.returnResource(shardedJedis);

        } 

    }

序列化工具类

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SerializeUtil {
    private static final Logger logger = LoggerFactory.getLogger(SerializeUtil.class);
    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) {
            logger.info("",e);
        }
        return null;
        }

        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) {
           logger.info("",e);
        }
        return null;
        }
}