java使用redis

一、依赖 

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

 二、工具类

1、连接池

@Slf4j
public class MyJedisPool {
    private JedisPool pool;

    public MyJedisPool() {     //初始化连接池
        JedisPoolConfig config = new JedisPoolConfig();
        //控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；
        //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
        config.setMaxTotal(PropUtils.getInt("redis.maxTotal"));
        //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
        config.setMaxIdle(PropUtils.getInt("redis.maxIdle"));
        //表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
        config.setMaxWaitMillis(PropUtils.getInt("redis.maxWaitMillis"));
        //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
        config.setTestOnBorrow(PropUtils.getBoolean("redis.testOnBorrow"));
        pool = new JedisPool(config, PropUtils.getProperty("redis.host"), PropUtils.getInt("redis.port"), 100000);
    }

    public JedisUtil getJedis() {
        return new JedisUtil(this.pool.getResource()); //获取redis资源
    }

    public void close() {
        this.pool.close();
    }

	//释放redis资源
    public void returnResource(JedisUtil jedisUtil) {
        jedisUtil.close();
    } 
}

2、jedis工具类 

public class JedisUtil {

    private Jedis j;

    public JedisUtil(Jedis j) {
        this.j = j;
    }

    public PipelineUtil pipelined() {
        return new PipelineUtil(j);
    }

    public void close() {
        this.j.close();
    }

    public String set(String s, String s1) {
        return this.j.set(s, s1);
    }

    public String set(String s, String s1, String s2, String s3, long l) { 
        return j.set(s, s1, s2, s3, l);
    }

    public String set(String s, String s1, String s2) {
        return j.set(s, s1, s2);
    }

    public String get(String s) {
        return j.get(s);
    }

    public Boolean exists(String s) {
        return j.exists(s);
    }

    public Long expire(String s, int i) {
        return j.expire(s, i);
    }

    public Long pexpire(String s, long l) {
        return j.pexpire(s, l);
    }

    public Long expireAt(String s, long l) {
        return j.expireAt(s, l);
    }

    public Long pexpireAt(String s, long l) {
        return j.pexpireAt(s, l);
    }

    public Long ttl(String s) {
        return j.ttl(s);
    }

    public Long pttl(String s) {
        return j.pttl(s);
    }

    public Boolean setbit(String s, long l, boolean b) {
        return j.setbit(s, l, b);
    }

    public Boolean setbit(String s, long l, String s1) {
        return j.setbit(s, l, s1);
    }

    public Boolean getbit(String s, long l) {
        return j.getbit(s, l);
    }

    public Long setrange(String s, long l, String s1) {
        return j.setrange(s, l, s1);
    }

    public String getrange(String s, long l, long l1) {
        return j.getrange(s, l, l1);
    }

    public String getSet(String s, String s1) {
        return j.getSet(s, s1);
    }

    public Long setnx(String s, String s1) {
        return j.setnx(s, s1);
    }

    public String setex(String s, int i, String s1) {
        return j.setex(s, i, s1);
    }

    public String psetex(String s, long l, String s1) {
        return j.psetex(s, l, s1);
    }

    public Long decrBy(String s, long l) {
        return j.decrBy(s, l);
    }

    public Long decr(String s) {
        return j.decr(s);
    }

    public Long incrBy(String s, long l) {
        return j.incrBy(s, l);
    }

    public Double incrByFloat(String s, double v) {
        return j.incrByFloat(s, v);
    }

    public Long hincrByValue(String s, String s1, long s2) {
        return j.hincrBy(s, s1, s2);
    }

    public Double hincrByFloat(String s, String s1, long s2) {
        return j.hincrByFloat(s, s1, s2);
    }

    public Long incr(String s) {
        return j.incr(s);
    }

    public Long append(String s, String s1) {
        return j.append(s, s1);
    }

    public String substr(String s, int i, int i1) {
        return j.substr(s, i, i1);
    }

 	// 通过key给field设置指定的值,如果key不存在,则先创建
    public Long hset(String s, String s1, String s2) { 
        return j.hset(s, s1, s2);
    }

	//通过key 和 field 获取指定的 value
    public String hget(String s, String s1) { 
        return j.hget(s, s1);
    }

    public Long hsetnx(String s, String s1, String s2) {
        return j.hsetnx(s, s1, s2);
    }

    public String hmset(String s, Map<String, String> map) {
        return j.hmset(s, map);
    }

    public List<String> hmget(String s, String... strings) {
        return j.hmget(s, strings);
    }

    public Long hincrBy(String s, String s1, long l) {
        return j.hincrBy(s, s1, l);
    }

    public Double hincrByFloat(String s, String s1, double v) {
        return j.hincrByFloat(s, s1, v);
    }

	//通过key和field判断是否有指定的value存在
    public Boolean hexists(String s, String s1) {   
        return j.hexists(s, s1);
    }

	//通过key 删除指定的 field
    public Long hdel(String s, String... strings) {  
        return j.hdel(s, strings);
    }

    public Long hlen(String s) {
        return j.hlen(s);
    }

    public Set<String> hkeys(String s) {
        return j.hkeys(s);
    }

    public List<String> hvals(String s) {
        return j.hvals(s);
    }


    public Map<String, String> hgetAll(String s) {
        return j.hgetAll(s);
    }

    public String rpop(String s) {
        return j.rpop(s);
    }

    public Long scard(String s) {
        return j.scard(s);
    }

    public Long sadd(String s, String... strings) {
        return j.sadd(s, strings);
    }

    public Boolean sismember(String key, String member) {
        return j.sismember(key, member);
    }

    //移除
    public Long smove(String s, String s1, String s2) {
        return j.smove(s, s1, s2);
    }

    //交集
    public Long sinterstore(String s, String... strings) {
        return j.sinterstore(s, strings);
    }

    //差集
    public Long sdiffstore(String s, String... strings) {
        return j.sdiffstore(s, strings);
    }

    public Long lpush(String s, String... strings) {
        return j.lpush(s, strings);
    }

    public Set<String> sinter(String... s) {
        return j.sinter(s);
    }

	//通过key获取set中所有的value
    public Set<String> smembers(String s) {  
        return j.smembers(s);
    }


    public Long srem(String s, String... strings) {
        return j.srem(s, strings);
    }

    public List<String> sort(String s) {
        return j.sort(s);
    }

    public List<String> sort(String s, SortingParams sortingParams) {
        return j.sort(s, sortingParams);
    }

	//删除指定的key,也可以传入一个包含key的数组
    public Long del(String s) { 
        return j.del(s);
    }

    public Long zadd(String key, double score, String value) {
        return j.zadd(key, score, value);
    }

    public Double zincrby(String key, double score, String member) {
        return j.zincrby(key, score, member);
    }

    public Double zscore(String key, String member) {
        return j.zscore(key, member);
    }
}

3、管道工具类 

public class PipelineUtil {

    private Pipeline p;

    public PipelineUtil(Jedis j) {
        this.p = j.pipelined();
    }

    public Response<String> set(String s, String s1) {
        return this.p.set(s, s1);
    }

    public Response<Long> incrBy(String s, Long s1) {
        return this.p.incrBy(s, s1);
    }

    public Response<Long> incr(String s) {
        return this.p.incr(s);
    }

    public Response<Long> hset(String s, String s1, String s2) {
        return this.p.hset(s, s1, s2);
    }

    public Response<Long> hdel(String s, String s1) {
        return this.p.del(s, s1);
    }

    public Response<Long> sadd(String s, String... ss) {
        return p.sadd(s, ss);
    }

    public Response<Long> scard(String s) {
        return p.scard(s);
    }

    public Response<Long> lpush(String s, String... ss) {
        return p.lpush(s, ss);
    }

    public Response<Long> del(String s) {
        return p.del(s);
    }

    public Response<Long> expire(String s, int i) {
        return p.expire(s, i);
    }

    public Response<Long> srem(String s, String... ss) {
        return p.srem(s, ss);
    }

    public Response<Boolean> sismember(String s, String ss) {
        return p.sismember(s, ss);
    }

    public Response<Long> expireAt(String s, long l) {
        return p.expireAt(s, l);
    }

    public Response<Long> pexpireAt(String s, long millseconds) {
        return p.pexpireAt(s, millseconds);
    }

    public Response<Long> hincrBy(String var1, String var2, long var3) {
        return p.hincrBy(var1, var2, var3);
    }

    public Response<Long> incrBy(String var1, long var2) {
        return p.incrBy(var1, var2);
    }

    public void sync() {
        p.sync();
    }

    public void close() throws IOException {
        p.close();
    }

    public Pipeline getP() {
        return p;
    }

    public void setP(Pipeline p) {
        this.p = p;
    }
}

使用 

MyJedisPool jedisPool  = new MyJedisPool(); 
JedisUtil jedisUtil = jedisPool.getJedis(); 
Pipeline Pipeline hPipeline = jedisUtil.pipelined();

 参考：Java 使用Pipeline对Redis批量读写_harveybd的博客-CSDN博客_java redis批量写入数据

注：redis常用方法

1.incrby
同incr 类似，加指定值，key 不存在时候会设置 key，并认为原来的 value 是 0
2.decr
同decr，减指定值。decrby 完全是为了可读性，我们完全可以通过 incrby 一个负值来实现同样效果，反之一样。
3.append
给指定key的字符串值追加value,返回新字符串值的长度。
4.strlen
取指定key的value值的长度。
5.hsetnx
设置 hash field 为指定值，如果 key 不存在，则先创建。
如果 field 已经存在，返回 0， nx 是not exist 的意思。
第一次执行是成功的，但第二次执行相同的命令失败，原因是 field 已经存在了。
6.hmset
同时设置 hash 的多个 field。
hmset myhash field1 Hello field2 World
7.hmget
获取全部指定的 hash filed。
hmget myhash field1 field2 field3
1) "Hello"
2) "World"
3) (nil)
由于数据库没有 field3，所以取到的是一个空值 nil
8.hincrby
指定的 hash filed 加上给定值。
hincrby myhash field3 -8
9.hlen
返回指定 hash 的 field 数量。
10.hdel
命令用于从存储在键散列删除指定的字段。如果没有这个哈希中存在指定的字段将被忽略。如果键不存在，它将被视为一个空的哈希与此命令将返回0。
11.hkeys
返回 hash 的所有 field。
hkeys myhash
1) "field2"
2) "field"
3) "field3"
12.hvals
返回 hash 的所有 value。
redis 127.0.0.1:6379> hvals myhash
1) "World"
2) "Hello"
3) "12"
13.hgetall
获取某个 hash 中全部的 filed 及 value。
redis 127.0.0.1:6379> hgetall myhash
1) "field2"
2) "World"
3) "field"
4) "Hello"
5) "field3"
6) "12"