Redis-Jedis-String

Jedis客户端操作redis小例子

package com.redis.string;

import com.redis.util.RedisUtil;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;

import java.util.List;

public class StringTest {

    /**
     * get
     * 向redis中存放数据aaa
     * 返回：获取到aaa的值为：张三
     */
    @Test
    public void getString(){
        Jedis jedis = RedisUtil.getJedis();
        String aaa = jedis.get("aaa");
        System.out.println("获取到aaa的值为："+aaa);
    }

    /**
     * set
     * 从redis中获取数据aaa
     * 返回：保存aaa的返回值为：OK
     */
    @Test
    public void saveString(){
        Jedis jedis = RedisUtil.getJedis();
        String set = jedis.set("aaa", "张三");
        System.out.println("保存aaa的返回值为：" + set);
    }

    /**
     * delete
     * 从redis中删除数据aaa
     * 返回：删除aaa的返回值为：1
     */
    @Test
    public void deleteString(){
        Jedis jedis = RedisUtil.getJedis();
        Long aaa = jedis.del("aaa");
        System.out.println("删除aaa的返回值为：" + aaa);
    }

    /**
     * append
     * 向redis中已经存在的键追加数据
     * 返回：追加aaa的返回值为：15
     * 追加后的aaa的值为:张三爱李四
     */
    @Test
    public void appendString(){
        Jedis jedis = RedisUtil.getJedis();
        Long append = jedis.append("aaa", "爱李四");
        System.out.println("追加aaa的返回值为：" + append);
        String aaa = jedis.get("aaa");
        System.out.println("追加后的aaa的值为:"+aaa);
    }

    /**
     * decr
     * incr
     * 对数据减1，但是value必须是Integer类型的(api提供的只有String类型，但是需要时数字)
     * 与之对应的是incr方法，对数据加1。
     */
    @Test
    public void decrAndIncrInteger(){
        Jedis jedis = RedisUtil.getJedis();
        String a = jedis.set("a", "5");
        System.out.println("保存a的值为5,保存操作的返回值为：" + a);
        Long a1 = jedis.decr("a");
        System.out.println("对a减1后的返回值为:"+a1);
        Long a2 = jedis.incr("a");
        System.out.println("对a加1后的返回值为:"+a2);
    }

    /**
     * decrby
     * incrby
     * 和decr与incr不一样的是，decrby与incrby可以指定加减的数值
     */
    @Test
    public void decrByAndIncrByInteger(){
        Jedis jedis = RedisUtil.getJedis();
        String b = jedis.set("b", "5");
        System.out.println("保存b的值为5,保存操作的返回值为：" + b);
        Long b1 = jedis.decrBy("b",2);
        System.out.println("对b减2后的返回值为:"+b1);
        Long b2 = jedis.incrBy("b",1);
        System.out.println("对b加1后的返回值为:"+b2);
    }

    /**
     * getRange
     * 获取指定偏移量位置的字符串。也就是获取指定位置的子字符串
     * 保存c的值为i am hanmei,保存操作的返回值为：OK
     * 获取字符串的3-6位置的值:m ha
     */
    @Test
    public void getRange(){
        Jedis jedis = RedisUtil.getJedis();
        String c = jedis.set("c", "i am hanmei");
        System.out.println("保存c的值为i am hanmei,保存操作的返回值为：" + c);
        String c1 = jedis.getrange("c", 3, 6);
        System.out.println("获取字符串的3-6位置的值:"+c1);
        //-1表示字符串的末尾
        String c2 = jedis.getrange("c", 3, -1);
        System.out.println("获取字符串的3--1位置的值:"+c2);
    }

    /**
     * getset
     * 返回老值，设置新值
     * 相当于分两步进行，先进行get将结果返回，然后再进行set不返回结果
     */
    @Test
    public void getSet(){
        Jedis jedis = RedisUtil.getJedis();
        String d = jedis.set("d", "hello");
        System.out.println("保存d的值为hello,保存操作的返回值为：" + d);
        String d1 = jedis.getSet("d","world");
        System.out.println("获取字符串d值:"+d1+"，并设置新值为：world");
        String d2 = jedis.get("d");
        System.out.println("获取字符串d的值:"+d2);

        //如果不存在，直接返回null
        String set = jedis.getSet("e", "imnew");
        System.out.println("如果e为null，使用getset会是什么结果："+set);

        //如果是数字也没有问题
        String f = jedis.set("f", "10");
        System.out.println("设置f为10，返回结果为："+f);
        String f1 = jedis.getSet("f", "lisi");
        System.out.println("获取字符串d值:"+f1+"，并设置新值为：lisi");
        String f2 = jedis.get("f");
        System.out.println("获取字符串f的值:"+f2);
    }

    /**
     * mset mget
     * 批量保存数据和批量获取数据
     */
    @Test
    public void msetAndmget(){
        Jedis jedis = RedisUtil.getJedis();
        String mset = jedis.mset("a", "1", "b", "2", "c", "3", "d", "4");
        System.out.println("设置ABCD的值分别为1234");
        List<String> mget = jedis.mget("a", "b", "c", "d");
        for (String value:mget){
            System.out.println("获取到的值分别为："+value);
        }
        System.out.println("获取a的值为："+jedis.get("a"));
    }

    /**
     * 在设置值的时候，设置该值的过期时间。
     * 在设定的时间范围内是有效的，超过该时间后，在此获取该keyvalue返回null
     * @throws InterruptedException
     */
    @Test
    public void setex() throws InterruptedException {
        Jedis jedis = RedisUtil.getJedis();
        String setex = jedis.setex("ex", 10, "exvalue");
        System.out.println("设置ex的值为exvalue，过期时间为10s,返回结果："+setex);
        System.out.println("获取ex的值为："+jedis.get("ex"));
        Thread.sleep(10000);
        System.out.println("睡眠10s后获取该ex的值为："+jedis.get("ex"));
    }

    /**
     * 如果keyvalue已经存在，那么就不在进行重写。
     * 通过该方案，可以实现分布式锁的功能。在进行业务逻辑操作的时候，都需要先调用这个方法。
     * 但是该方法需要配合expire使用，如果不设置超时时间，如果业务出现问题，可能其他线程就永远无法获取到该分布式锁。
     * 那么问题又出现了：如果setnx操作完成后还未来得及设置expire，服务就挂掉了，那该怎么办呢？
     * 这个需要使用jedis的set方法，设置多个参数。具体操作详见下面的setnxAndexpire()方法，对各参数都有说明
     *
     * @throws InterruptedException
     * 设置nx的值为nxvalue1,返回结果：1
     * 对nx重新设置值.....
     * 设置nx的值为nxvalue2,返回结果：0
     * 获取nx的最新值为：nxvalue1
     */
    @Test
    public void setnx() throws InterruptedException {
        Jedis jedis = RedisUtil.getJedis();
        jedis.del("nx");

        Long setnx1 = jedis.setnx("nx", "nxvalue1");
        System.out.println("设置nx的值为nxvalue1,返回结果："+setnx1);
        System.out.println("对nx重新设置值..");
        Long setnx2 = jedis.setnx("nx", "nxvalue2");
        System.out.println("设置nx的值为nxvalue2,返回结果："+setnx2);
        System.out.println("获取nx的最新值为："+jedis.get("nx"));
    }

/**
     * key : 键
     * value : 值
     * nxxx : NX|XX
     * 说明：NX -- Only set the key if it does not already exist. XX -- Only set the key if it already exist.
     * expx : EX|PX
     * 说明：expire time units: EX = seconds; PX = milliseconds
     * time : 时间
     *
     * 该方法可以同时实现sexnx的功能，有实现expire的功能
     * 在setnx后忽然当即，未来得及设置expire时间，容易导致该值一直存在，并对后面的操作造成极大的影响。
     * 测试使用该方案可以有效的解决问题
     */
    @Test
    public void setnxAndexpire() throws InterruptedException {
        Jedis jedis = RedisUtil.getJedis();
        String set = jedis.set("nxe", "nxe", "NX", "EX", 8);
        System.out.println("返回值:"+set);
        String nxe = jedis.get("nxe");
        System.out.println(nxe);

        Thread.sleep(5000);
        System.out.println("=======");
        String nxx = jedis.get("nxe");
        System.out.println(nxx);

        Thread.sleep(5000);
        System.out.println("--------");
        String nxxx = jedis.get("nxe");
        System.out.println(nxxx);

    }

    /**
     * 将数据在指定的偏移量替换为新的值
     * range的值为:hello world
     * range的值为:hello redis
     * @throws InterruptedException
     */
    @Test
    public void setrange() throws InterruptedException {

        Jedis jedis = RedisUtil.getJedis();
        jedis.set("range","hello world");
        System.out.println("range的值为:"+jedis.get("range"));
        jedis.setrange("range",6,"redis");
        System.out.println("range的值为:"+jedis.get("range"));
    }

}

RedisUtil

package com.redis.util;

import org.apache.log4j.Logger;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisUtil {

    private static final Logger logger = Logger.getLogger(RedisUtil.class);

    //Redis服务器IP
    private static String ADDR = "192.168.72.129";
    //Redis的端口号
    private static int PORT = 6380;

    //可用连接实例的最大数目，默认值为8；
    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 1024;

    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 200;
    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static int MAX_WAIT = 10000;
    private static int TIMEOUT = 10000;

    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;

    private static JedisPool jedisPool = null;

    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取Jedis实例
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 释放jedis资源
     * @param jedis
     */
    public static void closeResource(final Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }


    /**
     * 删除key
     */
    public Long delkeyObject(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.del(key.getBytes());
        }catch(Exception e) {
            e.printStackTrace();
            return null;
        }finally{
            if(jedis != null)
            {
                jedis.close();
            }
        }
    }

    public Boolean existsObject(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.exists(key.getBytes());
        }catch(Exception e) {
            e.printStackTrace();
            return null;
        }finally{
            if(jedis != null)
            {
                jedis.close();
            }
        }
    }


}