FunTester框架Redis压测预备

叁歲伎倆 2023-10-08 13:34 9阅读 0赞

![在这里插入图片描述][20d9d3803e0c429288663512b48b1770.gif_pic_center]  
在超万字回顾FunTester的前世今生一文中我分享了FunTester测试框架一个优点：针对所有Java可实现的接口都能进行功能封装进而进行性能测试。

之前都已经分享过了HTTP协议、Socket协议以及MySQL的测试案例，最近要准备对Redis的接口进行测试，所以未雨绸缪，我提前将Redis的功能接口封装类重写了一下，不得不说之前对Redis的认知真是肤浅。

话不多说，首先我分享一下自己的思路：

*  Redis连接池管理类
 *  Redis资源回收
 *  Redis功能封装类

### 池化技术 ###

在开始正文之前，先分享一个技术名词叫做池化技术。池化技术的应用非常的广泛，比如我们经常说到的线程池、mysql数据库连接池，Http协议连接池以及我们今天要分享的Redis连接池。

池化技术 (Pool) 是一种很常见的编程技巧，在请求量大时能明显优化应用性能，降低系统频繁建连的资源开销。我们日常工作中常见的有数据库连接池、线程池、对象池等，它们的特点都是将 “昂贵的”、“费时的” 的资源维护在一个特定的 “池子” 中，规定其最小连接数、最大连接数、阻塞队列等配置，方便进行统一管理和复用，通常还会附带一些探活机制、强制回收、监控一类的配套功能。

在做性能测试的过程中，也是用到了很多实话的技术，我的一个基本思路就是拿协议的连接池和线程池做绑定，这样既能避免资源的共享导致的问题，也能够提升性能并发能力。

这里有一个非常重要的知识点，就是资源的回收复用。后面我会分享到。

### Redis连接池管理类 ###

这个连接池管理类的主要功能就是创建连接池，设置连接配置。本次我并没有做配置文件，如果大家有需求的话，可以进行配置文件，去把这些配置存起来。

package com.funtester.db.redis;
    
    import com.alibaba.fastjson.JSONObject;
    import com.funtester.frame.SourceCode;
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    /**
     * redis连接池
     */
    public class RedisPool extends SourceCode {
        
    
        static Logger logger = LogManager.getLogger(RedisPool.class);
    
        /**
         * 最大连接数
         */
        private static int MAX_TOTAL = 1000;
    
        /**
         * 在jedispool中最大的idle状态(空闲的)的jedis实例的个数
         */
        private static int MAX_IDLE = 300;
    
        /**
         * 在jedispool中最小的idle状态(空闲的)的jedis实例的个数
         */
        private static int MIN_IDLE = 10;
    
        /**
         * 获取实例的最大等待时间
         */
        private static long MAX_WAIT = 5000;
    
        /**
         * redis连接的超时时间
         */
        private static int TIMEOUT = 5000;
    
        /**
         * 在borrow一个jedis实例的时候，是否要进行验证操作，如果赋值true。则得到的jedis实例肯定是可以用的
         */
        private static boolean testOnBorrow = true;
    
        /**
         * 在return一个jedis实例的时候，是否要进行验证操作，如果赋值true。则放回jedispool的jedis实例肯定是可以用的。
         */
        private static boolean testOnReturn = true;
    
        /**
         * 连接耗尽的时候，是否阻塞，false会抛出异常，true阻塞直到超时。默认为true
         */
        private static boolean blockWhenExhausted = true;
    
        private static JedisPoolConfig config = getConfig();
    
        /**
         * 初始化连接池
         */
        public static JedisPool getPool(String host, int port) {
        
            logger.info("redis连接池IP：{}，端口：{}，超时设置：{}", host, port, TIMEOUT);
            return new JedisPool(config, host, port, TIMEOUT);
        }
    
        /**
         * 默认连接池配置
         *
         * @return
         */
        private static JedisPoolConfig getConfig() {
        
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_TOTAL);
            config.setMaxIdle(MAX_IDLE);
            config.setMinIdle(MIN_IDLE);
            config.setTestOnBorrow(testOnBorrow);
            config.setTestOnReturn(testOnReturn);
            config.setBlockWhenExhausted(blockWhenExhausted);
            config.setMaxWaitMillis(MAX_WAIT);
            logger.debug("连接redis配置：{}", JSONObject.toJSONString(config));
            return config;
        }
    
    }

### 资源回收知识 ###

这里的资源就是指Redis连接池的连接，在我们获取一个连接，进行一些操作之后，我们需要把这个连接重新放回到连接池里面，一共其他线程获取，已达到复用的目的。这里我们主要参考的是官方的实现案例。其实方法也是非常简单的，只需要我们在获取一个连接Jedis对象进行操作之后，调用close()方法即可。

这里我用到了Java中try-catch语法：

/**
         * 设置key的有效期，单位是秒
         *
         * @param key
         * @param exTime
         * @return
         */
        public boolean expire(String key, int exTime) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.expire(key, exTime) == 1;
            } catch (Exception e) {
        
                logger.error("expire key:{} error", key, e);
                return false;
            }
        }

这种写法等同于：

public boolean expire(String key, int exTime) {
        
            Jedis jedis = null;
            try {
        
                jedis = getJedis();
                return jedis.expire(key, exTime) == 1;
            } catch (Exception e) {
        
                logger.error("expire key:{} error", key, e);
                return false;
            } finally {
        
                if (jedis != null) jedis.close();
            }
        }

### 功能封装类 ###

在我开始看Redis操作常用api之前，我觉得这个api的数量会比较少，但是在我详细查完所有api的之后。我就发现自己真的是too young，too simple！这个功能封装类我写了一些非常常用的操作，对于一些不太常用的，这里并没有写出。如果大家有需要，可以通过继承这个com.funtester.db.redis.RedisBase类来添加方法的封装。

package com.funtester.db.redis;
    
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    import java.util.*;
    
    public class RedisBase {
        
    
        private static Logger logger = LogManager.getLogger(RedisBase.class);
    
        String host;
    
        int port;
    
        JedisPool pool;
    
        public int index;
    
        public RedisBase() {
        
        }
    
        public RedisBase(String host, int port) {
        
            this.host = host;
            this.port = port;
            pool = RedisPool.getPool(host, port);
        }
    
        /**
         * 获取jedis操作对象，回收资源方法close，3.0以后废弃了其他方法，默认连接第一个数据库
         * 默认使用0个index
         *
         * @return
         */
        public Jedis getJedis() {
        
            Jedis resource = pool.getResource();
            resource.select(index);
            return resource;
        }
    
        /**
         * 设置key的有效期，单位是秒
         *
         * @param key
         * @param exTime
         * @return
         */
        public boolean expire(String key, int exTime) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.expire(key, exTime) == 1;
            } catch (Exception e) {
        
                logger.error("expire key:{} error", key, e);
                return false;
            }
        }
    
        /**
         * 设置key-value，过期时间
         *
         * @param key
         * @param value
         * @param expiredTime 单位s
         * @return
         */
        public boolean set(String key, String value, int expiredTime) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.setex(key, expiredTime, value).equalsIgnoreCase("OK");
            } catch (Exception e) {
        
                logger.error("setex key:{} value:{} error", key, value, e);
                return false;
            }
        }
    
        /**
         * 设置redis内容
         *
         * @param key
         * @param value
         * @return
         */
        public boolean set(String key, String value) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.set(key, value).equalsIgnoreCase("OK");
            } catch (Exception e) {
        
                logger.error("set key:{} value:{} error", key, value, e);
                return false;
            }
        }
    
        /**
         * 获取value
         *
         * @param key
         * @return
         */
        public String get(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.get(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 设置redis list内容
         * Redis Lpush 命令将一个或多个值插入到列表头部。 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。 当 key 存在但不是列表类型时，返回一个错误
         *
         * @param key
         * @param list
         * @return list长度
         */
        public Long lpush(String key, String... list) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.lpush(key, list);
            } catch (Exception e) {
        
                return 0l;
            }
        }
    
    
        /**
         * 将一个或多个值插入到已存在的列表头部，列表不存在时操作无效
         *
         * @param key
         * @param list
         * @return
         */
        public Long lpushx(String key, String... list) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.lpushx(key, list);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return 0l;
            }
        }
    
        /**
         * 将一个或多个值插入到列表的尾部(最右边)。
         * <p>
         * 如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。 当列表存在但不是列表类型时，返回一个错误。
         *
         * @param key
         * @param list
         * @return
         */
        public Long rpush(String key, String... list) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.rpush(key, list);
            } catch (Exception e) {
        
                return 0l;
            }
        }
    
        /**
         * 用于将一个或多个值插入到已存在的列表尾部(最右边)。如果列表不存在，操作无效
         *
         * @param key
         * @param list
         * @return
         */
        public Long rpushx(String key, String... list) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.rpushx(key, list);
            } catch (Exception e) {
        
                return 0l;
            }
        }
    
        /**
         * 从数组中获取第一个值,并删除该值
         *
         * @param key
         * @return
         */
        public String lpop(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.lpop(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 用于移除并返回列表的最后一个元素
         *
         * @param key
         * @return
         */
        public String rpop(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.rpop(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 获取数组长度
         *
         * @param key
         * @return
         */
        public Long llen(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.llen(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return 0l;
            }
        }
    
        /**
         * 获取固定索引的值
         *
         * @param key
         * @param index 从0开始
         * @return
         */
        public String lindex(String key, long index) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.lindex(key, index);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 获取list某一段
         *
         * @param key
         * @param start
         * @param end
         * @return
         */
        public List<String> lrange(String key, long start, long end) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.lrange(key, start, end);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return new ArrayList<>();
            }
        }
    
        /**
         * 设置list中index的值
         *
         * @param key
         * @param index
         * @param value
         * @return
         */
        public String lset(String key, long index, String value) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.lset(key, index, value);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 将哈希表 key 中的域 field 的值设为 value
         *
         * @param key
         * @param hkey
         * @param value
         * @return 行数
         */
        public Long hset(String key, String hkey, String value) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.hset(key, hkey, value);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 返回哈希表 key 中给定域 field 的值
         *
         * @param key
         * @param hkey
         * @return
         */
        public String hget(String key, String hkey) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.hget(key, hkey);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略
         *
         * @param key
         * @param hkey
         * @return
         */
        public Long hdel(String key, String hkey) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.hdel(key, hkey);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 查看哈希表 key 中，给定域 field 是否存在
         *
         * @param key
         * @param hkey
         * @return
         */
        public Boolean hexists(String key, String hkey) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.hexists(key, hkey);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 返回哈希表 key 中的所有域
         *
         * @param key
         * @return
         */
        public Set<String> hkeys(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.hkeys(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 返回哈希表 key 中所有域的值
         *
         * @param key
         * @return
         */
        public List<String> hvals(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.hvals(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 返回哈希表 key 中域的数量
         *
         * @param key
         * @return
         */
        public Long hlen(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.hlen(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 返回哈希表 key 中，所有的域和值
         *
         * @param key
         * @return
         */
        public Map<String, String> hgetAll(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.hgetAll(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 为哈希表 key 中的域 field 的值加上增量 increment。如果域 field 不存在，域的值先被初始化为 0
         *
         * @param key
         * @param hkey
         * @param num
         * @return
         */
        public Long hincrBy(String key, String hkey, long num) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.hincrBy(key, hkey, num);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 为哈希表 key 中的域 field 的值加上增量 increment。如果域 field 不存在，域的值先被初始化为 0
         *
         * @param key
         * @param hkey
         * @param num
         * @return
         */
        public Double hincrByFloat(String key, String hkey, double num) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.hincrByFloat(key, hkey, num);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
    
        /**
         * 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略
         *
         * @param key
         * @param value
         * @return
         */
        public Long sadd(String key, String... value) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.sadd(key, value);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 返回集合 key 的基数(集合中元素的数量)
         *
         * @param key
         * @param value
         * @return
         */
        public Long scard(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.scard(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 返回集合 key 中的所有成员。 不存在的 key 被视为空集合
         *
         * @param key
         * @return
         */
        public Set<String> smembers(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.smembers(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 移除并返回集合中的一个随机元素
         *
         * @param key
         * @return
         */
        public String spop(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.spop(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
         * 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
         *
         * @param key
         * @param count
         * @return
         */
        public List<String> srandmember(String key, int count) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.srandmember(key, count);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 返回集合中的一个随机元素
         *
         * @param key
         * @return
         */
        public String srandmember(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.srandmember(key);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
    
        /**移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略
         * @param key
         * @param value
         * @return
         */
        public Long srem(String key,String... value) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.srem(key,value);
            } catch (Exception e) {
        
                logger.error("get key:{} error", key, e);
                return null;
            }
        }
        /**
         * 是否存在key
         *
         * @param key
         * @return
         */
        public boolean exists(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.exists(key);
            } catch (Exception e) {
        
                logger.error("exists key:{} error", key, e);
                return false;
            }
        }
    
        /**
         * 删除key
         * jedis返回值1表示成功，0表示失败，可能是不存在的key
         *
         * @param key
         * @return
         */
        public Long del(String... key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.del(key);
            } catch (Exception e) {
        
                logger.error("del key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 获取key对应value的类型
         *
         * @param key
         * @return
         */
        public String type(String key) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.type(key);
            } catch (Exception e) {
        
                logger.error("type key:{} error", key, e);
                return null;
            }
        }
    
        /**
         * 获取符合条件的key集合
         *
         * @param pattern
         * @return
         */
        public Set<String> getKeys(String pattern) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.keys(pattern);
            } catch (Exception e) {
        
                logger.error("type key:{} error", pattern, e);
                return new HashSet<String>();
            }
        }
    
        /**
         * 将 value 追加到 key 原来的值的末尾
         *
         * @param key
         * @param content
         * @return
         */
        public Long append(String key, String content) {
        
            try (Jedis jedis = getJedis()) {
        
                return jedis.append(key, content);
            } catch (Exception e) {
        
                logger.error("append key:{} ,content:{},error", key, content, e);
                return null;
            }
        }
    
        /**
         * 关闭连接池
         */
        public void close() {
        
            pool.close();
        }
    
    }

**最后：** 可以关注公众号：伤心的辣条 ！ 进去有许多资料共享！资料都是面试时面试官必问的知识点，也包括了很多测试行业常见知识，其中包括了有基础知识、Linux必备、Shell、互联网程序原理、Mysql数据库、抓包工具专题、接口测试工具、测试进阶-Python编程、Web自动化测试、APP自动化测试、接口自动化测试、测试高级持续集成、测试架构开发测试框架、性能测试、安全测试等。

**如果我的博客对你有帮助、如果你喜欢我的博客内容，请 “点赞” “评论” “收藏” 一键三连哦！**

--------------------

### 好文推荐 ###

[转行面试，跳槽面试，软件测试人员都必须知道的这几种面试技巧！][Link 1]

[面试经：一线城市搬砖！又面软件测试岗，5000就知足了…][5000]

[面试官：工作三年，还来面初级测试？恐怕你的软件测试工程师的头衔要加双引号…][Link 2]

[什么样的人适合从事软件测试工作？][Link 3]

[那个准点下班的人，比我先升职了…][Link 4]

[测试岗反复跳槽，跳着跳着就跳没了…][Link 5]

[20d9d3803e0c429288663512b48b1770.gif_pic_center]: https://img-blog.csdnimg.cn/20d9d3803e0c429288663512b48b1770.gif#pic_center
[Link 1]: https://blog.csdn.net/m0_56736369/article/details/117909132
[5000]: https://blog.csdn.net/m0_56736369/article/details/117915399
[Link 2]: https://blog.csdn.net/weixin_50829653/article/details/117422433
[Link 3]: https://blog.csdn.net/weixin_50271247/article/details/108421434
[Link 4]: https://blog.csdn.net/weixin_50829653/article/details/117856900
[Link 5]: https://blog.csdn.net/m0_56736369/article/details/117923266