发布新日志

  • 彻底解决 Jedis 连接池 获取不到连接，连接放回连接池错误的问题

    2018-02-11 16:17:58

    1. public class CacheKit {  
    2.     private static Logger logger = LoggerFactory.getLogger(CacheKit.class);  
    3.     private List<JSONObject> resultList;  
    4.     private static JedisPool pool;  
    5.   
    6.     /** 
    7.      * 初始化Redis连接池 
    8.      */  
    9.     private static void initializePool() {  
    10.         //redisURL 与 redisPort 的配置文件  
    11.         String configFile = "production.properties";  
    12.         if (PropKit.getBoolean("devMode")) {  
    13.             configFile = "dev.properties";  
    14.         }  
    15.   
    16.         JedisPoolConfig config = new JedisPoolConfig();  
    17.         //设置最大连接数（100个足够用了，没必要设置太大）  
    18.         config.setMaxTotal(100);  
    19.         //最大空闲连接数  
    20.         config.setMaxIdle(10);  
    21.         //获取Jedis连接的最大等待时间（50秒）   
    22.         config.setMaxWaitMillis(50 * 1000);  
    23.         //在获取Jedis连接时，自动检验连接是否可用  
    24.         config.setTestOnBorrow(true);  
    25.         //在将连接放回池中前，自动检验连接是否有效  
    26.         config.setTestOnReturn(true);  
    27.         //自动测试池中的空闲连接是否都是可用连接  
    28.         config.setTestWhileIdle(true);  
    29.         //创建连接池  
    30.         pool = new JedisPool(config, PropKit.use(configFile).get("redisURL"),  
    31.                     PropKit.use(configFile).getInt("redisPort"));  
    32.     }  
    33.   
    34.     /** 
    35.      * 多线程环境同步初始化（保证项目中有且仅有一个连接池） 
    36.      */  
    37.     private static synchronized void poolInit() {  
    38.         if (null == pool) {  
    39.             initializePool();  
    40.         }  
    41.     }  
    42.   
    43.     /** 
    44.      * 获取Jedis实例 
    45.      */  
    46.     private static Jedis getJedis() {  
    47.         if (null == pool) {  
    48.             poolInit();  
    49.         }  
    50.   
    51.         int timeoutCount = 0;  
    52.         while (true) {  
    53.             try {  
    54.                 if (null != pool) {  
    55.                     return pool.getResource();  
    56.                 }  
    57.             } catch (Exception e) {  
    58.                 if (e instanceof JedisConnectionException) {  
    59.                     timeoutCount++;  
    60.                     logger.warn("getJedis timeoutCount={}", timeoutCount);  
    61.                     if (timeoutCount > 3) {  
    62.                         break;  
    63.                     }  
    64.                 } else {  
    65.                     logger.warn("jedisInfo ... NumActive=" + pool.getNumActive()  
    66.                             + ", NumIdle=" + pool.getNumIdle()  
    67.                             + ", NumWaiters=" + pool.getNumWaiters()  
    68.                             + ", isClosed=" + pool.isClosed());  
    69.                     logger.error("GetJedis error,", e);  
    70.                     break;  
    71.                 }  
    72.             }  
    73.             break;  
    74.         }  
    75.         return null;  
    76.     }  
    77.   
    78.     /** 
    79.      * 释放Jedis资源 
    80.      * 
    81.      * @param jedis 
    82.      */  
    83.     public static void returnResource(Jedis jedis) {  
    84.         if (null != jedis) {  
    85.             pool.returnResourceObject(jedis);  
    86.         }  
    87.     }  
    88.   
    89.     /** 
    90.      * 绝对获取方法（保证一定能够使用可用的连接获取到 目标数据） 
    91.      * Jedis连接使用后放回  
    92.      * @param key 
    93.      * @return 
    94.      */  
    95.     private String safeGet(String key) {  
    96.         Jedis jedis = getJedis();  
    97.         while (true) {  
    98.             if (null != jedis) {  
    99.                 break;  
    100.             } else {  
    101.                 jedis = getJedis();  
    102.             }  
    103.         }  
    104.         String value = jedis.get(key);  
    105.         returnResource(jedis);  
    106.         return value;  
    107.     }  
    108.   
    109.     /** 
    110.      * 绝对设置方法（保证一定能够使用可用的链接设置 数据） 
    111.      * Jedis连接使用后返回连接池 
    112.      * @param key 
    113.      * @param time 
    114.      * @param value 
    115.      */  
    116.     private void safeSet(String key, int time, String value) {  
    117.         Jedis jedis = getJedis();  
    118.         while (true) {  
    119.             if (null != jedis) {  
    120.                 break;  
    121.             } else {  
    122.                 jedis = getJedis();  
    123.             }  
    124.         }  
    125.         jedis.setex(key, time, value);  
    126.         returnResource(jedis);  
    127.     }  
    128.   
    129.     /** 
    130.      * 绝对删除方法（保证删除绝对有效） 
    131.      * Jedis连接使用后返回连接池</span> 
    132.      * @param key 
    133.      */  
    134.     private void safeDel(String key) {  
    135.         Jedis jedis = getJedis();  
    136.         while (true) {  
    137.             if (null != jedis) {  
    138.                 break;  
    139.             } else {  
    140.                 jedis = getJedis();  
    141.             }  
    142.         }  
    143.         jedis.del(key);  
    144.         returnResource(jedis);  
    145.     }  
    146.   
    147.     /**自定义的一些 get set del 方法，方便使用**/  
    148.     public JSONObject getByCache(String key) {  
    149.         String result = safeGet(key);  
    150.         if (result != null) {  
    151.             return (JSONObject) JSONObject.parse(result);  
    152.         }  
    153.         return null;  
    154.   
    155.     }  
    156.   
    157.     public String getByCacheToString(String key) {  
    158.         String result = safeGet(key);  
    159.         if (result != null) {  
    160.             return result;  
    161.         }  
    162.         return null;  
    163.   
    164.     }  
    165.   
    166.     public List<JSONObject> getArrayByCache(String key) {  
    167.         String result = safeGet(key);  
    168.         if (result != null) {  
    169.             resultList = JSONArray.parseArray(result, JSONObject.class);  
    170.             return resultList;  
    171.         }  
    172.         return null;  
    173.     }  
    174.   
    175.     public JSONArray getJSONArrayByCache(String key) {  
    176.         String result = safeGet(key);  
    177.         if (result != null) {  
    178.             return JSONArray.parseArray(result);  
    179.         }  
    180.         return null;  
    181.     }  
    182.   
    183.     public void setByCache(String key, String s) {  
    184.         safeSet(key, 86400, s);  
    185.     }  
    186.   
    187.     public void setByCacheOneHour(String key, String s) {  
    188.         safeSet(key, 3600, s);  
    189.     }  
    190.   
    191.     public void setByCacheOneHour(String key, List<JSONObject> json) {  
    192.         safeSet(key, 86400, JSONObject.toJSONString(json));  
    193.         resultList = json;  
    194.     }  
    195.   
    196.     public void setByCache(String key, JSONObject json) {  
    197.         safeSet(key, 86400, JSONObject.toJSONString(json));  
    198.     }  
    199.   
    200.     public void setByCache(String key, List<JSONObject> list) {  
    201.         safeSet(key, 86400, JSONObject.toJSONString(list));  
    202.         resultList = list;  
    203.     }  
    204.   
    205.     public void setByCache(String key, JSONArray array) {  
    206.         safeSet(key, 86400, JSONArray.toJSONString(array));  
    207.     }  
    208.   
    209.     public void setByCacheCusTime(String key, String s, int time) {  
    210.         safeSet(key, time, s);  
    211.     }  
    212.   
    213.   
    214.     public void delByCache(String key) {  
    215.         if (null != safeGet(key)) {  
    216.             safeDel(key);  
    217.         }  
    218.     }  
    219.   
    220.     public JSONObject toJSON(DBObject db) {  
    221.         return (JSONObject) JSONObject.toJSON(db);  
    222.     }  
    223.   
    224.     public List<JSONObject> toJSON(List<DBObject> list) {  
    225.         List<JSONObject> json = new ArrayList<>();  
    226.         for (DBObject aList : list) {  
    227.             json.add((JSONObject) JSONObject.toJSON(aList));  
    228.         }  
    229.         return json;  
    230.     }  
    231.   
    232.     public boolean notNull() {  
    233.         return resultList != null && resultList.size() > 0;  
    234.     }  
    235.   
    236.     public List<JSONObject> getResult() {  
    237.         return resultList;  
    238.     }  
    239.   
    240. }

    查看(1711) 评论(0) 收藏 分享 管理

  • jedispool 连 redis 高并发卡死

    2018-02-11 16:12:06

    https://www.2cto.com/kf/201504/395403.html


    java端在使用jedispool 连接redis的时候，在高并发的时候经常卡死，或报连接异常，JedisConnectionException，或者getResource 异常等各种问题

    在使用jedispool 的时候一定要注意两点

    1。 在获取 jedisPool和jedis的时候加上线程同步，保证不要创建过多的jedispool 和 jedis

    2。 用完Jedis实例后需要返还给JedisPool

    整理了一下redis工具类，通过大量测试和高并发测试的

    package com.caspar.util;
     
    import org.apache.log4j.Logger;
     
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
     
    /**
     * Redis 工具类
     * @author caspar
     * https://blog.csdn.net/tuposky
     */
    public class RedisUtil {
         
        protected static Logger logger = Logger.getLogger(RedisUtil.class);
         
        //Redis服务器IP
        private static String ADDR_ARRAY = FileUtil.getPropertyValue("/properties/redis.properties", "server");
         
        //Redis的端口号
        private static int PORT = FileUtil.getPropertyValueInt("/properties/redis.properties", "port");
         
        //访问密码
    //    private static String AUTH = FileUtil.getPropertyValue("/properties/redis.properties", "auth");
         
        //可用连接实例的最大数目，默认值为8；
        //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
        private static int MAX_ACTIVE = FileUtil.getPropertyValueInt("/properties/redis.properties", "max_active");;
         
        //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
        private static int MAX_IDLE = FileUtil.getPropertyValueInt("/properties/redis.properties", "max_idle");;
         
        //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
        private static int MAX_WAIT = FileUtil.getPropertyValueInt("/properties/redis.properties", "max_wait");;
     
        //超时时间
        private static int TIMEOUT = FileUtil.getPropertyValueInt("/properties/redis.properties", "timeout");;
         
        //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
        private static boolean TEST_ON_BORROW = FileUtil.getPropertyValueBoolean("/properties/redis.properties", "test_on_borrow");;
         
        private static JedisPool jedisPool = null;
         
        /**
         * redis过期时间,以秒为单位
         */
        public final static int EXRP_HOUR = 60*60;          //一小时
        public final static int EXRP_DAY = 60*60*24;        //一天
        public final static int EXRP_MONTH = 60*60*24*30;   //一个月
         
        /**
         * 初始化Redis连接池
         */
        private static void initialPool(){
            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_ARRAY.split(",")[0], PORT, TIMEOUT);
            } catch (Exception e) {
                logger.error("First create JedisPool error : "+e);
                try{
                    //如果第一个IP异常，则访问第二个IP
                    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_ARRAY.split(",")[1], PORT, TIMEOUT);
                }catch(Exception e2){
                    logger.error("Second create JedisPool error : "+e2);
                }
            }
        }
         
         
        /**
         * 在多线程环境同步初始化
         */
        private static synchronized void poolInit() {
            if (jedisPool == null) { 
                initialPool();
            }
        }
     
         
        /**
         * 同步获取Jedis实例
         * @return Jedis
         */
        public synchronized static Jedis getJedis() { 
            if (jedisPool == null) { 
                poolInit();
            }
            Jedis jedis = null;
            try { 
                if (jedisPool != null) { 
                    jedis = jedisPool.getResource();
                }
            } catch (Exception e) { 
                logger.error("Get jedis error : "+e);
            }finally{
                returnResource(jedis);
            }
            return jedis;
        } 
         
         
        /**
         * 释放jedis资源
         * @param jedis
         */
        public static void returnResource(final Jedis jedis) {
            if (jedis != null && jedisPool !=null) {
                jedisPool.returnResource(jedis);
            }
        }
         
         
        /**
         * 设置 String
         * @param key
         * @param value
         */
        public static void setString(String key ,String value){
            try {
                value = StringUtil.isEmpty(value) ? "" : value;
                getJedis().set(key,value);
            } catch (Exception e) {
                logger.error("Set key error : "+e);
            }
        }
         
        /**
         * 设置 过期时间
         * @param key
         * @param seconds 以秒为单位
         * @param value
         */
        public static void setString(String key ,int seconds,String value){
            try {
                value = StringUtil.isEmpty(value) ? "" : value;
                getJedis().setex(key, seconds, value);
            } catch (Exception e) {
                logger.error("Set keyex error : "+e);
            }
        }
         
        /**
         * 获取String值
         * @param key
         * @return value
         */
        public static String getString(String key){
            if(getJedis() == null || !getJedis().exists(key)){
                return null;
            }
            return getJedis().get(key);
        }
         
    }


    查看(917) 评论(0) 收藏 分享 管理

  • Ant将Jmeter的jtl文件转为html文件报“前言中不允许有内容”

    2018-02-07 09:58:49

    1. 在JMeter的bin目录中找到jmeter.properties;
    2. 将文件中#jmeter.save.saveservice.output_format=csv改为jmeter.save.saveservice.output_format=xml
      注意：去掉前面的#号，后面的xml要小写

    查看(684) 评论(0) 收藏 分享 管理

  • Jmeter Random Variable配置项可以为每个线程生成随机变量

    2018-02-05 11:35:44

    配置元件Random Variable可以配置生成随机数，自定义输出格式，最大最小值，以及是否为每个线程单独生成：

    复制代码
    Variable Name:     uuid
Output Format:     12345678-1234-4444-a123-000000000000
Minimum Value:     111111111111
Maximum Value:     999999999999
    Seed for Random function：${__Random(1,10,)} //如果指定为一个固定值，则每次迭代，各个线程得到的随机值都会相同
    
Per Thread (User): True　　//每个线程生成一个随机数
    复制代码
    复制代码
    iteration: 1
    thread: 1
        sampler 1: VALUE_1-1
        sampler 2: VALUE_1-1
        ...
    thread: 2
        sampler 1: VALUE_2-1
        sampler 2: VALUE_2-1
        ...
    ...
iteration: 2
    thread: 1
        sampler 1: VALUE_1-2
        sampler 2: VALUE_1-2
        ...
    thread: 2
        sampler 1: VALUE_2-2
        sampler 2: VALUE_2-2
        ...
    ...
    复制代码

    查看(1908) 评论(0) 收藏 分享 管理

  • （JMeter/Ant/Jenkins）自动化接口测试的部署 及 部署过程中的坑

    2018-02-01 10:43:07

    查看(678) 评论(0) 收藏 分享 管理

Open Toolbar