Redis-Jedis-String

淩亂°似流年 2022-05-22 08:56 178阅读 0赞

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();
                }
            }
        }
    
    
    }

Redis-Jedis-String

发表评论取消回复

还没有评论，来说两句吧...

相关阅读