使用jedis操作redis

1、引入jar

<redis.clients.version>2.9.0</redis.clients.version>
<!--redis缓存相关依赖-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.8.0.RC1</version>
        </dependency>
        <!-- redis客户端jar -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${redis.clients.version}</version>
        </dependency>

2、配置redis.properties

#访问地址
redis.host=127.0.0.1
#访问端口
redis.port=6379
#注意，如果没有password，此处不设置值，但这一项要保留，默认foobared
redis.password=foobared
#客户端超时时间单位是毫秒 默认是2000
redis.timeout=10000

#最大空闲数
redis.maxIdle=300
#连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal
redis.maxActive=300
#控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
redis.maxTotal=300
#当池内没有返回对象时，最大等待时间
redis.maxWait=10000
#当调用borrow Object方法时，是否进行有效性检查 ,如果为true，则得到的jedis实例均是可用的
redis.testOnBorrow=false
redis.testOnReturn=false
#在空闲时检查有效性, 默认false
redis.testWhileIdle=true
#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
redis.maxWaitMillis=1000
#连接的最小空闲时间 默认1800000毫秒(30分钟)
redis.minEvictableIdleTimeMillis=300000
#每次释放连接的最大数目,默认3
redis.numTestsPerEvictionRun=1024
#逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
redis.timeBetweenEvictionRunsMillis=30000
#连接耗尽是否阻塞,false代表抛异常,true代表阻塞直到超时,默认为true
redis.blockWhenExhausted=false

3、配置redis-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="maxTotal" value="${redis.maxTotal}"/>
        <property name="maxWaitMillis" value="${redis.maxWait}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
        <property name="testOnReturn" value="${redis.testOnReturn}"/>
        <property name="testWhileIdle" value="${redis.testWhileIdle}"/>
        <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"/>
        <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"/>
        <!--每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3-->
        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"/>
        <!--连接耗尽是否阻塞,false代表抛异常,true代表阻塞直到超时,默认为true -->
        <property name="blockWhenExhausted" value="${redis.blockWhenExhausted}"/>
    </bean>

    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg name="poolConfig" ref="poolConfig" />
        <constructor-arg name="host" value="${redis.host}" />
        <constructor-arg name="port" value="${redis.port}" type="int" />
        <constructor-arg name="timeout" value="${redis.maxWait}" type="int" />
        <constructor-arg name="password" value="${redis.password}" />
        <constructor-arg name="database" value="0" type="int" />
    </bean>

    <!--自定义redis工具类,在需要缓存的地方注入此类  -->
    <bean id="redisService" class="com.hikvision.common.cache.RedisService">
        <property name="jedisPool" ref="jedisPool" />
    </bean>
</beans>

4、工具类， RedisService.java

package com.hikvision.common.cache;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.hikvision.common.util.LogUtil;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * redis缓存服务service
 *
 * @author wanjiadong
 * @description
 * @date Create in 16:35 2018/5/10
 */
public class RedisService {

    private JedisPool jedisPool;

    public void setJedisPool(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /**
     * 获取Jedis实例
     *
     * @return
     */
    public synchronized Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                LogUtil.debug(RedisService.class, resource
                        + ",activeNum:"+ jedisPool.getNumActive()
                        + ",idleNum:" + jedisPool.getNumIdle()
                        + ",waiterNum:" + jedisPool.getNumWaiters());
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "Redis缓存获取Jedis实例 出错！", e);
            return null;
        }
    }

    /**
     * 释放jedis资源
     * 每次连接必须使用
     *
     * @param jedis
     */
    public void returnResource(final Jedis jedis) {
        if (jedis != null) {
            //jedis-2.9以上的版本已经使用了jedis.close()
            jedis.close();
//            jedisPool.returnResource(jedis);
//            jedis.quit();
        }
    }

    //=============================common============================

    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key,long time){
        boolean result = false;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (null != jedis && time > 0) {
                jedis.expire(key, (int) time);
            }
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "redis键过期设置出错--键值" + key, e);
        } finally {
            returnResource(jedis);
        }
        return result;
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key){
        Long time = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (jedis != null) {
                time = jedis.ttl(key);
            }
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "获取" + key + "的过期时间出错！", e);
        } finally {
            returnResource(jedis);
        }
        if(null == time) {
            return -2;
        }
        return time;
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (jedis != null) {
                return jedis.exists(key);
            }
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "获取" + key + "的过期时间出错！", e);
        } finally {
            returnResource(jedis);
        }
        return false;
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String ... key){
        if(null == key) {
            return;
        }
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if(null == jedis) {
                return;
            }
            jedis.del(key);
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "删除" + key + "出错！", e);
        } finally {
            returnResource(jedis);
        }
    }

    //============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        Jedis jedis = null;
        Object obj = null;
        try {
            jedis = jedisPool.getResource();
            String str = jedis.get(key);
            obj = JSONObject.parse(str);
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "获取" + key + "出错！", e);
        } finally {
            returnResource(jedis);
        }
        return obj;
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key,Object value) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (jedis != null) {
                jedis.set(key, JSONObject.toJSONString(value));
            }
            return true;
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "Redis缓存设置" + key + "-" + value + "出错！", e);
            return false;
        } finally {
            returnResource(jedis);
        }
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key,Object value,long time){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (jedis != null) {
                jedis.set(key, JSONObject.toJSONString(value));
                jedis.expire(key, (int) time);
            }
            return true;
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "Redis缓存设置" + key + "-" + value + "出错！", e);
            return false;
        } finally {
            returnResource(jedis);
        }
    }

    //============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key){
        Jedis jedis = null;
        Set<Object> set = null;
        try {
            jedis = jedisPool.getResource();
            Set<String> strSet = jedis.smembers(key);
            if (strSet !=null && !strSet.isEmpty()) {
                set = new HashSet<Object>();
                for (String str : strSet) {
                    Object obj = JSONObject.parse(str);
                    set.add(obj);
                }
            }
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "获取" + key + "出错！", e);
        } finally {
            returnResource(jedis);
        }
        return set;
    }

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key,long time,Object...values) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            if (values != null && values.length>0) {
                String[] strarrays = new String[values.length];
                for (int i = 0; i < values.length; i++) {
                    strarrays[i] = JSONObject.toJSONString(values[i]);
                }
                Long count = jedis.sadd(key, strarrays);
                if(time>0) expire(key, time);
                return count;
            }
        } catch (Exception e) {
            return 0;
        } finally {
            returnResource(jedis);
        }
        return 0;
    }

    //================================zSet================================

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param value 值
     * @param score 排序分数
     */
    public <T> boolean zSet(String key, T value ,double score) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (jedis != null) {
                jedis.zadd(key, score, JSONObject.toJSONString(value));
            }
            return true;
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "Redis缓存设置" + key + "-" + value + "出错！", e);
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    /**
     *
    * 返回键k的从start-end之间的数据。（从大到小排序从0开始）
    * @param
    * @return
    * @auther yaotenghui
    * @date 2018/5/17 15:22
    */
    public <T> Set<T> reverseRange(String key, long start, long end, Class<T> resultType){
        Jedis jedis = null;
        Set<T> set = null;
        try {
            jedis = jedisPool.getResource();
            Set<String> strSet = jedis.zrevrange(key,start,end);
            if (strSet !=null && !strSet.isEmpty()) {
                set = new HashSet<T>();
                for (String str : strSet) {
                    set.add(JSON.toJavaObject(JSON.parseObject(str), resultType));
                }
            }
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "获取" + key + "出错！", e);
        } finally {
            returnResource(jedis);
        }
        return set;
    }

    /**
     *
     * 返回键k的从start-end之间的数据。（从大到小排序从0开始）
     * @param
     * @return
     * @auther wanjiadong
     * @date 2018/6/23 15:22
     */
    public <T> List<T> reverseRangeToList(String key, long start, long end, Class<T> resultType){
        Jedis jedis = null;
        List<T> list = null;
        try {
            jedis = jedisPool.getResource();
            Set<String> strSet = jedis.zrevrange(key,start,end);
            if (strSet !=null && !strSet.isEmpty()) {
                list = new ArrayList<T>(strSet.size());
                for (String str : strSet) {
                    list.add(JSON.toJavaObject(JSON.parseObject(str), resultType));
                }
            }
        } catch (Exception e) {
            LogUtil.exception(RedisService.class, "获取" + key + "出错！", e);
        } finally {
            returnResource(jedis);
        }
        return list;
    }
}