jedis工具類

 

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

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 工具類
 * @Author mufeng
 * @Date 2019-5-22 15:34
 */
public class RedisUtils {
    private Jedis jedis;
    public RedisUtils(){
        JedisPool pool = getPool();
        jedis=pool.getResource();
    }
    public JedisPool getPool(){
        JedisPool pool=null;
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxIdle(Integer.parseInt("50"));
        config.setMaxTotal(Integer.parseInt("1000"));
        config.setMaxWaitMillis((long)Integer.parseInt("3000"));
        config.setTestOnBorrow(Boolean.parseBoolean("true"));
        config.setTestOnReturn(Boolean.parseBoolean("true"));
        config.setTimeBetweenEvictionRunsMillis(-1L);
        String ip="10.20.24.113";
        int port=6379;
        String password="redispass";
        pool=new JedisPool(config,ip,port,2000,password);
        return pool;
    }
    public String get(String key){
        return jedis.get(key);
    }
    public String set(String key,String value){
        return jedis.set(key,value);
    }
    public Long del(String... keys){
        return jedis.del(keys);
    }

    /**
     * 通過key向指定的value追加值
     * @param key
     * @param str
     * @return
     */
    public Long append(String key,String str){
        return jedis.append(key,str);
    }
    public Boolean exist(String key){
        return jedis.exists(key);
    }

    /**
     * 設置key-value，若key已存在返回0 則返回1
     * @param key
     * @param value
     * @return
     */
    public Long setnx(String key,String value){
        return jedis.setnx(key,value);
    }

    /**
     *  設置key-value並指定鍵值的有效期
     * @param key
     * @param seconds 以秒為單位
     * @param value
     * @return
     */
    public String setex(String key,int seconds,String value){
        return jedis.setex(key,seconds,value);
    }

    /**
     * 從指定的位置替換原先value  aa 1 tt ->atta
     * 值不存在也會有空格   ee 1 uu->" uu"
     * @param key
     * @param offset
     * @param str
     * @return
     */
    public Long setrange(String key,int offset,String str){
        return jedis.setrange(key,offset,str);
    }

    /**
     * 通過批量keys獲取批量values
     * @param keys
     * @return
     */
    public List<String> mget(String... keys){
        return jedis.mget(keys);
    }

    /**
     * 批量設置keyvalues，也可以一個 "key","value",..
     * @param keyvalues
     * @return
     */
    public String mset(String... keyvalues){
        return jedis.mset(keyvalues);
    }

    /**
     * 批量設置keyvalues，也可以一個 如果key存在則會失敗，操作回滾
     * @param keyvalues
     * @return
     */
    public Long msetnx(String... keyvalues){
        return jedis.msetnx(keyvalues);
    }

    /**
     * 設置key的值，返回一個舊值，key不存在，也會設置
     * @param key
     * @param value
     * @return
     */
    public String getSet(String key,String value){
        return jedis.getSet(key,value);
    }

    /**
     * 通過key和指定下標獲取指定下標的值
     * @param key
     * @param startOffset
     * @param endOffset
     * @return
     */
    public String getrange(String key,int startOffset,int endOffset){
        return jedis.getrange(key,startOffset,endOffset);
    }

    /**
     * 通過key對value加1操作，如果value不是int類型會返回錯誤，如果key不存在，value為1
     * @param key
     * @return
     */
    public Long incr(String key){
        return jedis.incr(key);
    }

    /**
     * 通過key對value加指定的值，如果value不是int類型會返回錯誤，若key不存在，value為該值
     * @param key
     * @param integer
     * @return
     */
    public Long incrBy(String key,int integer){
        return jedis.incrBy(key,integer);
    }
    /**
     * 通過key對value減去1操作，如果value不是int類型會返回錯誤，如果key不存在，value為-1
     * @param key
     * @return
     */
    public Long decr(String key){
        return jedis.decr(key);
    }

    /**
     * 通過key對value減去指定的值，如果value不是int類型會返回錯誤，若key不存在，value為該值
     * @param key
     * @param integer
     * @return
     */
    public Long decrBy(String key,int integer){
        return jedis.decrBy(key,integer);
    }

    /**
     * 通過key獲取value的長度
     * @param key
     * @return
     */
    public Long StrLen(String key){
        return jedis.strlen(key);
    }

    /**
     * 通過key給field設置指定的值，若key不存在則先創建，若field已存在，返回0
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Long hsetnx(String key,String field,String value){
        return jedis.hsetnx(key,field,value);
    }

    /**
     * 通過key給field設置指定的值，若key不存在則先創建
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Long hset(String key,String field,String value){
        return jedis.hset(key,field,value);
    }

    /**
     * 通過key同時設置多個field
     * @param key
     * @param hash
     * @return
     */
    public String hmset(String key, Map<String,String>hash){
        return jedis.hmset(key,hash);
    }

    /**
     * 通過key和field獲取指定的值
     * @param key
     * @param field
     * @return
     */
    public String hget(String key,String field){
        return jedis.hget(key,field);
    }

    /**
     * 設置key的過期時間秒
     * @param key
     * @param seconds
     * @return
     */
    public Long expirt(String key,int seconds){
        return jedis.expire(key,seconds);
    }

    /**
     * 通過key和fields獲取指定的value，如果沒有value，返回null
     * @param key
     * @param field
     * @return
     */
    public List<String> hmget(String key,String... field){
        return jedis.hmget(key,field);
    }

    /**
     * 通過key給指定的field加指定的值
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Long hincBy(String key,String field,Long value){
        return jedis.hincrBy(key,field,value);
    }

    /**
     * 通過key和field判斷指定的value是否存在
     * @param key
     * @param field
     * @return
     */
    public Boolean hexist(String key,String field){
        return jedis.hexists(key,field);
    }

    /**
     * 通過key返回field數量
     * @param key
     * @return
     */
    public Long hlen(String key){
        return jedis.hlen(key);
    }
    /**
     * 通過key刪除指定field
     * @param key
     * @param field 一個 也可以是數組
     * @return
     */
    public Long hdel(String key,String... field){
        return jedis.hdel(key,field);
    }

    /**
     * 通過field獲取所有field
     * @param key
     * @return
     */
    public Set<String> hkeys(String key){
        return jedis.hkeys(key);
    }

    /**
     * 通過key獲取和key有關的value
     * @param key
     * @return
     */
    public List<String> hvals(String key){
        return jedis.hvals(key);
    }

    /**
     * 通過key獲取有關的field和value
     * @param key
     * @return
     */
    public Map<String,String> hgetall(String key){
        return jedis.hgetAll(key);
    }

    /**
     * 通過key向list頭部添加字符串
     * @param key
     * @param strs
     * @return
     */
    public Long lpush(String key,String... strs){
        return jedis.lpush(key,strs);
    }

    /**
     * 通過key向list尾部添加字符串
     * @param key
     * @param strs
     * @return
     */
    public Long rpush(String key,String... strs){
        return jedis.rpush(key,strs);
    }

    /**
     * 通過key向list指定位置添加字符串
     * @param key
     * @param where LIST_POSITION 枚舉類型
     * @param pivot list內的value
     * @param value
     * @return
     */
    public Long linsert(String key, BinaryClient.LIST_POSITION where,String pivot,String value){
        return jedis.linsert(key,where,pivot,value);
    }

    /**
     * 通過key設置list指定下標位置value，越界報錯
     * @param key
     * @param index
     * @param value
     * @return
     */
    public String lset(String key,Long index,String value){
        return jedis.lset(key,index,value);
    }

    /**
     * 通過key刪除count個與value相同的元素
     * @param key
     * @param count
     * @param value
     * @return
     */
    public Long lrem(String key,long count,String value){
        return jedis.lrem(key,count,value);
    }

    /**
     * 通過key保留下標start到end的value
     * @param key
     * @param start
     * @param end
     * @return
     */
    public String ltrim(String key,long start,long end){
        return jedis.ltrim(key,start,end);
    }

    /**
     * 通過key刪除頭部一個value，返回value
     * @param key
     * @return
     */
    public String lpop(String key){
        return jedis.lpop(key);
    }
    /**
     * 通過key刪除尾部一個value，返回value
     * @param key
     * @return
     */
    public String rpop(String key){
        return jedis.rpop(key);
    }

    /**
     * 通過key刪除list尾部一個value，添加到另一個list的頭部，返回該value
     * list為空或不存在返回null
     * @param srckey
     * @param dstkey
     * @return
     */
    public String rpoplpush(String srckey,String dstkey){
        return jedis.rpoplpush(srckey,dstkey);
    }

    /**
     * 通過key獲取list指定下標的value
     * @param key
     * @param index
     * @return
     */
    public String lindex(String key,long index){
        return jedis.lindex(key,index);
    }

    /**
     * 通過key獲取list的長度
     * @param key
     * @return
     */
    public Long llen(String key){
        return jedis.llen(key);
    }

    /**
     * 通過key獲取指定下標位置的value
     * 若start為0，end為-1，返回所有value
     * @param key
     * @param start
     * @param end
     * @return
     */
    public List<String> lrange(String key,long start,long end){
        return jedis.lrange(key,start,end);
    }

    /**
     * 通過key向set添加value
     * @param key
     * @param members
     * @return
     */
    public Long sadd(String key,String... members){
        return jedis.sadd(key,members);
    }

    /**
     * 通過key刪除set對應的value值
     * @param key
     * @param members
     * @return
     */
    public Long srem(String key,String... members){
        return jedis.srem(key,members);
    }

    /**
     * 通過key隨機刪除set一個value
     * @param key
     * @return
     */
    public String spop(String key){
        return jedis.spop(key);
    }

    /**
     * 通過key獲取set中的差集
     * 以第一個為標准
     * @param keys
     * @return
     */
    public Set<String> sdiff(String... keys){
        return jedis.sdiff(keys);
    }

    /**
     * 通過key獲取set中差集並存入另一set中
     * @param dstkey
     * @param keys
     * @return
     */
    public Long sdiffstore(String dstkey,String... keys){
        return jedis.sdiffstore(dstkey,keys);
    }

    /**
     * 通過key獲取set中交集
     * @param keys
     * @return
     */
    public Set<String> sinter(String... keys){
        return jedis.sinter(keys);
    }
    /**
     * 通過key獲取set中交集並存入另一set中
     * @param dstkey
     * @param keys
     * @return
     */
    public Long sinterstore(String dstkey,String... keys){
        return jedis.sinterstore(dstkey,keys);
    }
    /**
     * 通過key獲取set中並集
     * @param keys
     * @return
     */
    public Set<String> sunion(String... keys){
        return jedis.sunion(keys);
    }
    /**
     * 通過key獲取set中並集並存入另一set中
     * @param dstkey
     * @param keys
     * @return
     */
    public Long sunionstore(String dstkey,String... keys){
        return jedis.sunionstore(dstkey,keys);
    }

    /**
     * 通過key將set中的value移除並把該value值添加到第二個set中
     * @param srckey
     * @param dstkey
     * @param member
     * @return
     */
    public Long smove(String srckey,String dstkey,String member){
        return jedis.smove(srckey,dstkey,member);
    }

    /**
     * 通過key獲取set中value個數
     * @param key
     * @return
     */
    public Long scard(String key){
        return jedis.scard(key);
    }

    /**
     * 通過key判斷value是否是set中元素
     * @param key
     * @param member
     * @return
     */
    public Boolean sismember(String key,String member){
        return jedis.sismember(key,member);
    }

    /**
     * 通過key隨機獲取set中的值
     * @param key
     * @return
     */
    public String srandmember(String key){
        return jedis.srandmember(key);
    }

    /**
     * 通過key獲取set所有元素
     * @param key
     * @return
     */
    public Set<String> smembers(String key){
        return jedis.smembers(key);
    }

    /**
     * 通過key的zset中添加value，score，其中score是用來排序的
     * 若該value已存在則根據score更新元素
     * @param key
     * @param score
     * @param member
     * @return
     */
    public Long zadd(String key,double score,String member){
        return jedis.zadd(key,score,member);
    }

    /**
     * 通過key刪除在zset中指定的value
     * @param key
     * @param member
     * @return
     */
    public Long zrem(String key,String... member){
        return jedis.zrem(key,member);
    }

    /**
     * 通過key增加該value中score值
     * @param key
     * @param score
     * @param member
     * @return
     */
    public Double zincrby(String key,double score,String member){
        return jedis.zincrby(key,score,member);
    }

    /**
     * 通過key返回zset中的排名
     * 下標從小到大排序
     * @param key
     * @param member
     * @return
     */
    public Long zrank(String key,String member){
        return jedis.zrank(key,member);
    }

    /**
     * 通過key返回zset中的排名
     *  下標從大道小排序
     * @param key
     * @param member
     * @return
     */
    public Long zrevrank(String key,String member){
        return jedis.zrevrank(key,member);
    }
    /**
     * 通過key獲取zset中start到end的value，score從大到小排序
     *  start為0 end為-1返回全部
     * @param key
     * @param start
     * @return
     */
    public Set<String> zrevrange(String key,long start,long end){
        return jedis.zrevrange(key,start,end);
    }
    /**
     * 通過key獲取zset中指定score內的value
     * @param key
     * @param max
     * @return
     */
    public Set<String> zrangeByScore(String key,String max,String min){
        return jedis.zrangeByScore(key,max,min);
    }
    /**
     * 通過key獲取zset中指定score內的value
     * @param key
     * @param max
     * @return
     */
    public Set<String> zrangeByScore(String key,double max,double min){
        return jedis.zrangeByScore(key,max,min);
    }
    /**
     * 通過key獲取zset中指定區間內的value數量
     * @param key
     * @param max
     * @return
     */
    public Long zcount(String key,String max,String min){
        return jedis.zcount(key,max,min);
    }
    /**
     * 通過key獲取zset中value數量
     * @param key
     * @return
     */
    public Long zcard(String key){
        return jedis.zcard(key);
    }

    /**
     * 通過key獲取zset中value的score值
     * @param key
     * @param member
     * @return
     */
    public Double zscore(String key,String member){
        return jedis.zscore(key,member);
    }
    /**
     * 通過key刪除指定區間的元素
     * @param key
     * @param start
     * @return
     */
    public Long zremrangeByRank(String key,long start,long end){
        return jedis.zremrangeByRank(key,start,end);
    }
    /**
     * 通過key刪除指定score的元素
     * @param key
     * @param start
     * @return
     */
    public Long zremrangeByScore(String key,double start,double end){
        return jedis.zremrangeByScore(key,start,end);
    }

    /**
     * 通過key存儲是什么類型
     * @param key
     * @return
     */
    public String type(String key){
        return jedis.type(key);
    }
    /**
     * 返回滿足pattern表達式的所有key
     * keys("*") 返回所有的key
     * @param pattern
     * @return
     */
    public Set<String> keys(String pattern){
        return jedis.keys(pattern);
    }
}

導入maven依賴

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>