jedis客户端，取redis服务的值

package com.common.util;

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

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

/**
 * @ClassName: SerializeUtil
 * @Desc: 序列化、反序列化
 * @date 2014-8-20下午2:21:41
 */
public class SerializeUtil {
    /** 写日志文件 */
    public final static Logger logger = LoggerFactory.getLogger(SerializeUtil.class);

    /**
     * @Description: 序列化
     * @date 2013-9-14上午10:22:12
     * @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) {
            logger.error("【异常提示信息】" + e);
        }
        return null;
    }

    /**
     * @Description: 反序列化
     * @date 2013-9-14上午10:22:25
     * @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) {
        }
        return null;
    }
}

package com.common.util.cache;

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

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

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
import redis.clients.util.Hashing;
import redis.clients.util.Sharded;

import com.common.util.SerializeUtil;

/**
 * @ClassName: JedisUtil
 * @Desc: jedis客户端，取redis服务的值
 * @date 2014-8-20下午2:16:06
 */
public class JedisUtil {
    // 写日志
    private static final Logger log = LoggerFactory.getLogger(JedisUtil.class);
    // 实例-单例模式
    private static JedisUtil dbClient;

    // ShardedJedisPool池
    private static ShardedJedisPool pool;

    // 初始化连接对象
    static {
        // 创建jedis池配置实例
        JedisPoolConfig config = new JedisPoolConfig();

        // 设置池配置项值
        // #jedis的最大分配对象#
        // config.setMaxActive(Integer.valueOf(ResourceProperty.createResourceProperty().getValue("jedis_pool_maxActive").trim()));
        // #jedis最大保存idel状态对象数 #
        config.setMaxIdle(Integer.valueOf(JedisProperty.newInstance().getValue(
                "jedis_pool_maxIdle")));
        // #jedis池没有对象返回时，最大等待时间 #
        config.setMaxWaitMillis(Long.valueOf(JedisProperty.newInstance()
                .getValue("jedis_pool_maxWait")));
        // #jedis调用borrowObject方法时，是否进行有效检查#
        config.setTestOnBorrow(Boolean.valueOf(true));
        // #jedis调用returnObject方法时，是否进行有效检查 #
        config.setTestOnReturn(Boolean.valueOf(true));
        // 根据配置实例化jedis池

        List<JedisShardInfo> jdsInfoList = new ArrayList<JedisShardInfo>(2);
        JedisShardInfo jedisShardInfo = new JedisShardInfo(JedisProperty
                .newInstance().getValue("redis.host"),
                Integer.valueOf(JedisProperty.newInstance().getValue(
                        "redis.port")));
        jdsInfoList.add(jedisShardInfo);
        pool = new ShardedJedisPool(config, jdsInfoList, Hashing.MURMUR_HASH,
                Sharded.DEFAULT_KEY_TAG_PATTERN);

    }

    /**
     *
     * 获取客户端实例
     *
     * @return dbClient instance
     */
    public synchronized static JedisUtil getInstance() {
        if (dbClient == null) {
            dbClient = new JedisUtil();
        }
        return dbClient;
    }

    /**
     * @Description: 保存对象(序列化)
     * @date 2014-8-10下午04:38:40
     * @param key
     * @param value
     */
    public void setObject(String key, Object value) {
        ShardedJedis jedis = null;
        if (key == null || value == null) {
            return;
        }
        byte[] val = SerializeUtil.serialize(value);
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            jedis.set(key.getBytes(), val);
        } catch (Exception e) {
            log.error("【异常提示信息】" + e);
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null)
                pool.returnResource(jedis);
        }
    }

    /**
     * @Desc: 保存对象(序列化)
     * @date 2014-8-20下午4:33:03
     * @param key
     * @param value
     * @param expire
     */
    public void setObject(String key, Object value, int expire) {
        ShardedJedis jedis = null;
        if (key == null || value == null) {
            return;
        }
        byte[] val = SerializeUtil.serialize(value);
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            jedis.set(key.getBytes(), val);
            jedis.expire(key, expire);
        } catch (Exception e) {
            log.error("【异常提示信息】" + e);
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null)
                pool.returnResource(jedis);
        }
    }

    /**
     * @Description: 获取对象(序列化)
     * @date 2014-8-10下午04:38:44
     * @param key
     * @return
     */
    public Object getObject(String key) {
        ShardedJedis jedis = null;

        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            // 获取jedis实例后可以对redis服务进行一系列的操作
            byte[] value = jedis.get(key.getBytes());
            Object data = SerializeUtil.unSerialize(value);
            return data;
        } catch (Exception e) {
            log.error("【异常提示信息】" + e);
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null)
                pool.returnResource(jedis);
        }
        return null;
    }

    /**
     * @Description: 获取String对象类型值
     * @date 2014-2-13上午10:00:44
     * @param key
     * @return
     */
    public String getString(String key) {
        ShardedJedis jedis = null;
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            // 获取jedis实例后可以对redis服务进行一系列的操作
            String value = jedis.get(key);
            return value;
        } catch (Exception e) {
            log.error("【异常提示信息】" + e);
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null)
                pool.returnResource(jedis);
        }
        return null;
    }

    /**
     * @Description: 存入String对象值
     * @date 2014-8-13上午10:03:31
     * @param key
     * @param value
     */
    public void setString(String key, String value) {
        ShardedJedis jedis = null;
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            jedis.set(key, value);
        } catch (Exception e) {
            log.error("【异常提示信息】" + e);
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null)
                pool.returnResource(jedis);
        }
    }

    /**
     * @Desc: 存入String对象值
     * @date 2014-8-20下午4:33:28
     * @param key
     * @param value
     * @param expire
     */
    public void setString(String key, String value, int expire) {
        ShardedJedis jedis = null;
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            jedis.set(key, value);
            jedis.expire(key, expire);
        } catch (Exception e) {
            log.error("【异常提示信息】" + e);
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null)
                pool.returnResource(jedis);
        }
    }

    /**
     * @Desc: 删除缓存数据
     * @date 2014-8-20下午3:58:41
     * @param key
     * @return
     */
    public Integer deleteByKey(String key) {
        ShardedJedis jedis = null;
        try {
            jedis = pool.getResource();
            jedis.del(key);
            return 1;
        } catch (Exception e) {
            log.error("");
        } finally {
            if (jedis != null)
                pool.returnResource(jedis);
        }
        return 0;
    }

    /**
     *
     * 描述：pop
     * @date 2015年6月24日下午6:26:37
     * @param key
     * @param isLeft
     * @return
     */
    private byte[] pop(String key, boolean isLeft) {
        ShardedJedis jedis = pool.getResource();
        boolean flag = false;
        byte[] values = null;
        try {
            if (isLeft) {
                values = jedis.lpop(key.getBytes());
            } else {
                values = jedis.rpop(key.getBytes());
            }
            flag = true;
        } catch (Exception e) {
            flag = false;
            log.error(e.getMessage(), e);
        } finally {
            release(flag, jedis);
        }
        return values;
    }

    /**
     *
     * 描述：lpop
     * @date 2015年6月24日下午6:25:14
     * @param key
     * @return
     */
    public byte[] lpop(String key) {
        return pop(key, true);
    }

    /**
     *
     * 描述：rpop
     * @date 2015年6月24日下午6:24:56
     * @param key
     * @return
     */
    public byte[] rpop(String key) {
        return pop(key, false);
    }

    /**
     *
     * 描述：push
     * @date 2015年6月24日下午6:26:37
     * @param key
     * @param isLeft
     * @return
     */
    private Long push(boolean isLeft, String key, String... values) {
        ShardedJedis jedis = pool.getResource();
        boolean flag = false;
        Long len = null;
        try {
            if (isLeft) {
                len = jedis.lpush(key, values);
            } else {
                len = jedis.rpush(key, values);
            }
            flag = true;
        } catch (Exception e) {
            flag = false;
            log.error(e.getMessage(), e);
        } finally {
            release(flag, jedis);
        }
        return len;
    }

    /**
     *
     * 描述：lpop
     * @date 2015年6月24日下午6:25:14
     * @param key
     * @return
     */
    public Long lpush(String key, String... values) {
        return push(true, key, values);
    }

    /**
     *
     * 描述：rpop
     * @date 2015年6月24日下午6:24:56
     * @param key
     * @return
     */
    public Long rpush(String key, String... values) {
        return push(false, key, values);
    }

    /**
     *
     * 描述：回收jedis客户端
     * @date 2015年6月24日下午6:24:15
     * @param isNormal
     *            是否正常
     * @param jedis
     *            jedis
     */
    private void release(boolean isNormal, ShardedJedis jedis) {
        if (isNormal)
            pool.returnResource(jedis);
        else {
            pool.returnBrokenResource(jedis);
        }
    }

    /**
     *
     * 描述：rpop lpush
     * @date 2015年6月24日下午6:28:21
     * @param scrKey
     * @param dstKey
     * @return
     */
    public byte[] rpoplpush(String scrKey, String dstKey) {
        ShardedJedis jedis = pool.getResource();
        boolean flag = false;
        byte[] ret = null;
        try {
            Jedis j = jedis.getShard(scrKey + dstKey);
            ret = j.rpoplpush(scrKey.getBytes(), dstKey.getBytes());
            flag = true;
        } catch (Exception e) {
            flag = false;
            log.error(e.getMessage(), e);
        } finally {
            release(flag, jedis);
        }
        return ret;
    }

    /**
     *
     * 描述：length
     * @date 2015年6月24日下午6:58:37
     * @param key
     * @param value
     * @return
     */
    public Long length(String key) {
        ShardedJedis jedis = null;
        boolean flag = false;
        Long result = 0l;
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            result = jedis.llen(key);
            flag = true;
        } catch (Exception e) {
            flag = false;
            log.error("【异常提示信息】" + e);
        } finally {
            release(flag, jedis);
        }

        return result;
    }

    /**
     *
     * 描述：存入MAP集合数据（专用）
     * @date 2016年12月6日上午11:54:04
     * @param key
     * @param map
     */
    public void hmset(String key,Map<String,String> map){
        ShardedJedis jedis = null;
        boolean flag = false;
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            jedis.hmset(key, map);
            // 24小时失效
            jedis.expire(key, 24*60*60);
            flag = true;
        } catch (Exception e) {
            flag = false;
            log.error("【异常提示信息】",e);
        } finally {
            release(flag, jedis);
        }
    }

    /**
     *
     * 描述：获取map中的值
     * @date 2016年12月6日下午12:02:01
     * @param key,redis key
     * @param fields,map key
     * @return map value
     */
    public List<String> hmget(String key, String... fields){
        ShardedJedis jedis = null;
        List<String> data = null;
        boolean flag = false;
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            data = jedis.hmget(key, fields);
            flag = true;
        } catch (Exception e) {
            flag = false;
            log.error("【异常提示信息】",e);
        } finally {
            release(flag, jedis);
        }
        return data;
    }

}

==================================================

    public void init() {
        if (status.compareAndSet(false, true)) {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxIdle(poolMaxIdle);
            config.setMaxWaitMillis(poolMaxWait);
            // #jedis调用borrowObject方法时，是否进行有效检查#
            config.setTestOnBorrow(Boolean.valueOf(true));
            // #jedis调用returnObject方法时，是否进行有效检查 #
            config.setTestOnReturn(Boolean.valueOf(true));
            List<JedisShardInfo> jdsInfoList = new ArrayList<JedisShardInfo>(clusterAddress.size());
            Iterator<HostAndPort> it = clusterAddress.iterator();
            while (it.hasNext()) {
                HostAndPort home = it.next();
                it.remove();
                JedisShardInfo info = new JedisShardInfo(home.getHost(), home.getPort());
                jdsInfoList.add(info);
            }
            shardeJedisPool = new ShardedJedisPool(config, jdsInfoList, Hashing.MURMUR_HASH,
                    Sharded.DEFAULT_KEY_TAG_PATTERN);
            if (asyncLoad) {
                template = new SimpleJedisTemplate(shardeJedisPool, status);
            } else {
                template = new SimpleJedisTemplate(shardeJedisPool);
            }
            LOGGER.info("init jedsHolder finished ...!");
        }
    }

    <bean class="com.busp.common.util.cache.redis.JedisHolder"
        init-method="init" destroy-method="dispose" factory-method="custom">
        <property name="poolMaxIdle" value="${jedis_pool_maxIdle}" />
        <property name="poolMaxWait" value="${jedis_pool_maxWait}" />
        <property name="asyncLoad" value="true" />
        <property name="clusterAddress">
            <list>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg index="0" value="${redis.host}" />
                    <constructor-arg index="1" value="${redis.port}" />
                </bean>
            </list>
        </property>
    </bean>