• Redis客户端之Spring整合Jedis

     

    1.下载相关jar包，并引入工程：

    jedis-2.4.2.jar

    commons-pool2-2.0.jar

    2.将以下XML配置引入spring

    Xml代码  收藏代码
    1. <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">  
    2.        <constructor-arg index="0" ref="jedisPoolConfig"/>  
    3.        <constructor-arg index="1">  
    4.            <list>  
    5.                 <bean name="slaver" class="redis.clients.jedis.JedisShardInfo">  
    6.                    <constructor-arg index="0" value="${redis.slaver.host}"/>  
    7.                    <constructor-arg index="1" value="${redis.slaver.port}" type="int"/>  
    8.                </bean>  
    9.                 <bean name="master" class="redis.clients.jedis.JedisShardInfo">  
    10.                    <constructor-arg index="0" value="${redis.master.host}"/>  
    11.                    <constructor-arg index="1" value="${redis.master.port}" type="int"/>  
    12.                </bean>  
    13.            </list>  
    14.        </constructor-arg>  
    15.    </bean>  
    16.   
    17.    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
    18.        <property name="maxTotal" value="2048" />  
    19.        <property name="maxIdle" value="200" />  
    20.        <property name="numTestsPerEvictionRun" value="1024"/>  
    21.        <property name="timeBetweenEvictionRunsMillis" value="30000" />  
    22.        <property name="minEvictableIdleTimeMillis" value="-1" />  
    23.        <property name="softMinEvictableIdleTimeMillis" value="10000" />  
    24.        <property name="maxWaitMillis" value="1500"/>  
    25.        <property name="testOnBorrow" value="true" />  
    26.        <property name="testWhileIdle" value="true"/>  
    27.        <property name="testOnReturn" value="false"/>  
    28.        <property name="jmxEnabled" value="true"/>  
    29.        <property name="jmxNamePrefix" value="youyuan"/>  
    30.        <property name="blockWhenExhausted" value="false"/>  
    31.    </bean>  

    3.将shardedJedisPool注入相关的类中即可使用

    Java代码  收藏代码
    1. @Resource  
    2.     private ShardedJedisPool shardedJedisPool;  
    3.   
    4.   
    5.     /** 
    6.      * 设置一个key的过期时间（单位：秒） 
    7.      * @param key key值 
    8.      * @param seconds 多少秒后过期 
    9.      * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间 
    10.      */  
    11.     public long expire(String key, int seconds) {  
    12.         if (key==null || key.equals("")) {  
    13.             return 0;  
    14.         }  
    15.   
    16.         ShardedJedis shardedJedis = null;  
    17.         try {  
    18.             shardedJedis = shardedJedisPool.getResource();  
    19.             return shardedJedis.expire(key, seconds);  
    20.         } catch (Exception ex) {  
    21.             logger.error("EXPIRE error[key=" + key + " seconds=" + seconds + "]" + ex.getMessage(), ex);  
    22.             returnBrokenResource(shardedJedis);  
    23.         } finally {  
    24.             returnResource(shardedJedis);  
    25.         }  
    26.         return 0;  
    27.     }  
    28.   
    29.     /** 
    30.      * 设置一个key在某个时间点过期 
    31.      * @param key key值 
    32.      * @param unixTimestamp unix时间戳，从1970-01-01 00:00:00开始到现在的秒数 
    33.      * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间 
    34.      */  
    35.     public long expireAt(String key, int unixTimestamp) {  
    36.         if (key==null || key.equals("")) {  
    37.             return 0;  
    38.         }  
    39.   
    40.         ShardedJedis shardedJedis = null;  
    41.         try {  
    42.             shardedJedis = shardedJedisPool.getResource();  
    43.             return shardedJedis.expireAt(key, unixTimestamp);  
    44.         } catch (Exception ex) {  
    45.             logger.error("EXPIRE error[key=" + key + " unixTimestamp=" + unixTimestamp + "]" + ex.getMessage(), ex);  
    46.             returnBrokenResource(shardedJedis);  
    47.         } finally {  
    48.             returnResource(shardedJedis);  
    49.         }  
    50.         return 0;  
    51.     }  
    52.   
    53.     /** 
    54.      * 截断一个List 
    55.      * @param key 列表key 
    56.      * @param start 开始位置 从0开始 
    57.      * @param end 结束位置 
    58.      * @return 状态码 
    59.      */  
    60.     public String trimList(String key, long start, long end) {  
    61.         if (key == null || key.equals("")) {  
    62.             return "-";  
    63.         }  
    64.         ShardedJedis shardedJedis = null;  
    65.         try {  
    66.             shardedJedis = shardedJedisPool.getResource();  
    67.             return shardedJedis.ltrim(key, start, end);  
    68.         } catch (Exception ex) {  
    69.             logger.error("LTRIM 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);  
    70.             returnBrokenResource(shardedJedis);  
    71.         } finally {  
    72.             returnResource(shardedJedis);  
    73.         }  
    74.         return "-";  
    75.     }  
    76.     /** 
    77.      * 检查Set长度 
    78.      * @param key 
    79.      * @return 
    80.      */  
    81.     public long countSet(String key){  
    82.         if(key == null ){  
    83.             return 0;  
    84.         }  
    85.         ShardedJedis shardedJedis = null;  
    86.         try {  
    87.             shardedJedis = shardedJedisPool.getResource();  
    88.             return shardedJedis.scard(key);  
    89.         } catch (Exception ex) {  
    90.             logger.error("countSet error.", ex);  
    91.             returnBrokenResource(shardedJedis);  
    92.         } finally {  
    93.             returnResource(shardedJedis);  
    94.         }  
    95.         return 0;  
    96.     }  
    97.     /** 
    98.      * 添加到Set中（同时设置过期时间） 
    99.      * @param key key值 
    100.      * @param seconds 过期时间 单位s 
    101.      * @param value 
    102.      * @return 
    103.      */  
    104.     public boolean addSet(String key,int seconds, String... value) {  
    105.         boolean result = addSet(key, value);  
    106.         if(result){  
    107.             long i = expire(key, seconds);  
    108.             return i==1;  
    109.         }  
    110.         return false;  
    111.     }  
    112.     /** 
    113.      * 添加到Set中 
    114.      * @param key 
    115.      * @param value 
    116.      * @return 
    117.      */  
    118.     public boolean addSet(String key, String... value) {  
    119.         if(key == null || value == null){  
    120.             return false;  
    121.         }  
    122.         ShardedJedis shardedJedis = null;  
    123.         try {  
    124.             shardedJedis = shardedJedisPool.getResource();  
    125.             shardedJedis.sadd(key, value);  
    126.             return true;  
    127.         } catch (Exception ex) {  
    128.             logger.error("setList error.", ex);  
    129.             returnBrokenResource(shardedJedis);  
    130.         } finally {  
    131.             returnResource(shardedJedis);  
    132.         }  
    133.         return false;  
    134.     }  
    135.   
    136.       
    137.     /** 
    138.      * @param key 
    139.      * @param value 
    140.      * @return 判断值是否包含在set中 
    141.      */  
    142.     public boolean containsInSet(String key, String value) {  
    143.         if(key == null || value == null){  
    144.             return false;  
    145.         }  
    146.         ShardedJedis shardedJedis = null;  
    147.         try {  
    148.             shardedJedis = shardedJedisPool.getResource();  
    149.             return shardedJedis.sismember(key, value);  
    150.         } catch (Exception ex) {  
    151.             logger.error("setList error.", ex);  
    152.             returnBrokenResource(shardedJedis);  
    153.         } finally {  
    154.             returnResource(shardedJedis);  
    155.         }  
    156.         return false;  
    157.     }  
    158.     /** 
    159.      * 获取Set 
    160.      * @param key 
    161.      * @return 
    162.      */  
    163.     public  Set<String> getSet(String key){  
    164.         ShardedJedis shardedJedis = null;  
    165.         try {  
    166.             shardedJedis = shardedJedisPool.getResource();  
    167.             return shardedJedis.smembers(key);  
    168.         } catch (Exception ex) {  
    169.             logger.error("getList error.", ex);  
    170.             returnBrokenResource(shardedJedis);  
    171.         } finally {  
    172.             returnResource(shardedJedis);  
    173.         }  
    174.         return null;  
    175.     }  
    176.   
    177.     /** 
    178.      * 从set中删除value 
    179.      * @param key 
    180.      * @return 
    181.      */  
    182.     public  boolean removeSetValue(String key,String... value){  
    183.         ShardedJedis shardedJedis = null;  
    184.         try {  
    185.             shardedJedis = shardedJedisPool.getResource();  
    186.             shardedJedis.srem(key, value);  
    187.             return true;  
    188.         } catch (Exception ex) {  
    189.             logger.error("getList error.", ex);  
    190.             returnBrokenResource(shardedJedis);  
    191.         } finally {  
    192.             returnResource(shardedJedis);  
    193.         }  
    194.         return false;  
    195.     }  
    196.       
    197.       
    198.       
    199.     /** 
    200.      * 从list中删除value 默认count 1 
    201.      * @param key 
    202.      * @param values 值list 
    203.      * @return 
    204.      */  
    205.     public  int removeListValue(String key,List<String> values){  
    206.         return removeListValue(key, 1, values);  
    207.     }  
    208.     /** 
    209.      * 从list中删除value 
    210.      * @param key 
    211.      * @param count  
    212.      * @param values 值list 
    213.      * @return 
    214.      */  
    215.     public  int removeListValue(String key,long count,List<String> values){  
    216.         int result = 0;  
    217.         if(values != null && values.size()>0){  
    218.             for(String value : values){  
    219.                 if(removeListValue(key, count, value)){  
    220.                     result++;  
    221.                 }  
    222.             }  
    223.         }  
    224.         return result;  
    225.     }  
    226.     /** 
    227.      *  从list中删除value 
    228.      * @param key 
    229.      * @param count 要删除个数 
    230.      * @param value 
    231.      * @return 
    232.      */  
    233.     public  boolean removeListValue(String key,long count,String value){  
    234.         ShardedJedis shardedJedis = null;  
    235.         try {  
    236.             shardedJedis = shardedJedisPool.getResource();  
    237.             shardedJedis.lrem(key, count, value);  
    238.             return true;  
    239.         } catch (Exception ex) {  
    240.             logger.error("getList error.", ex);  
    241.             returnBrokenResource(shardedJedis);  
    242.         } finally {  
    243.             returnResource(shardedJedis);  
    244.         }  
    245.         return false;  
    246.     }  
    247.       
    248.     /** 
    249.      * 截取List 
    250.      * @param key  
    251.      * @param start 起始位置 
    252.      * @param end 结束位置 
    253.      * @return 
    254.      */  
    255.     public List<String> rangeList(String key, long start, long end) {  
    256.         if (key == null || key.equals("")) {  
    257.             return null;  
    258.         }  
    259.         ShardedJedis shardedJedis = null;  
    260.         try {  
    261.             shardedJedis = shardedJedisPool.getResource();  
    262.             return shardedJedis.lrange(key, start, end);  
    263.         } catch (Exception ex) {  
    264.             logger.error("rangeList 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);  
    265.             returnBrokenResource(shardedJedis);  
    266.         } finally {  
    267.             returnResource(shardedJedis);  
    268.         }  
    269.         return null;  
    270.     }  
    271.       
    272.     /** 
    273.      * 检查List长度 
    274.      * @param key 
    275.      * @return 
    276.      */  
    277.     public long countList(String key){  
    278.         if(key == null ){  
    279.             return 0;  
    280.         }  
    281.         ShardedJedis shardedJedis = null;  
    282.         try {  
    283.             shardedJedis = shardedJedisPool.getResource();  
    284.             return shardedJedis.llen(key);  
    285.         } catch (Exception ex) {  
    286.             logger.error("countList error.", ex);  
    287.             returnBrokenResource(shardedJedis);  
    288.         } finally {  
    289.             returnResource(shardedJedis);  
    290.         }  
    291.         return 0;  
    292.     }  
    293.       
    294.     /** 
    295.      * 添加到List中（同时设置过期时间） 
    296.      * @param key key值 
    297.      * @param seconds 过期时间 单位s 
    298.      * @param value  
    299.      * @return  
    300.      */  
    301.     public boolean addList(String key,int seconds, String... value){  
    302.         boolean result = addList(key, value);  
    303.         if(result){  
    304.             long i = expire(key, seconds);  
    305.             return i==1;  
    306.         }  
    307.         return false;  
    308.     }  
    309.     /** 
    310.      * 添加到List 
    311.      * @param key 
    312.      * @param value 
    313.      * @return 
    314.      */  
    315.     public boolean addList(String key, String... value) {  
    316.         if(key == null || value == null){  
    317.             return false;  
    318.         }  
    319.         ShardedJedis shardedJedis = null;  
    320.         try {  
    321.             shardedJedis = shardedJedisPool.getResource();  
    322.             shardedJedis.lpush(key, value);  
    323.             return true;  
    324.         } catch (Exception ex) {  
    325.             logger.error("setList error.", ex);  
    326.             returnBrokenResource(shardedJedis);  
    327.         } finally {  
    328.             returnResource(shardedJedis);  
    329.         }  
    330.         return false;  
    331.     }  
    332.     /** 
    333.      * 添加到List(只新增) 
    334.      * @param key 
    335.      * @param value 
    336.      * @return 
    337.      */  
    338.     public boolean addList(String key, List<String> list) {  
    339.         if(key == null || list == null || list.size() == 0){  
    340.             return false;  
    341.         }  
    342.         for(String value : list){  
    343.             addList(key, value);  
    344.         }  
    345.         return true;  
    346.     }  
    347.       
    348.     /** 
    349.      * 获取List 
    350.      * @param key 
    351.      * @return 
    352.      */  
    353.     public  List<String> getList(String key){  
    354.         ShardedJedis shardedJedis = null;  
    355.         try {  
    356.             shardedJedis = shardedJedisPool.getResource();  
    357.             return shardedJedis.lrange(key, 0, -1);  
    358.         } catch (Exception ex) {  
    359.             logger.error("getList error.", ex);  
    360.             returnBrokenResource(shardedJedis);  
    361.         } finally {  
    362.             returnResource(shardedJedis);  
    363.         }  
    364.         return null;  
    365.     }  
    366.     /** 
    367.      * 设置HashSet对象 
    368.      * 
    369.      * @param domain 域名 
    370.      * @param key    键值 
    371.      * @param value  Json String or String value 
    372.      * @return 
    373.      */  
    374.     public boolean setHSet(String domain, String key, String value) {  
    375.         if (value == null) return false;  
    376.         ShardedJedis shardedJedis = null;  
    377.         try {  
    378.             shardedJedis = shardedJedisPool.getResource();  
    379.             shardedJedis.hset(domain, key, value);  
    380.             return true;  
    381.         } catch (Exception ex) {  
    382.             logger.error("setHSet error.", ex);  
    383.             returnBrokenResource(shardedJedis);  
    384.         } finally {  
    385.             returnResource(shardedJedis);  
    386.         }  
    387.         return false;  
    388.     }  
    389.   
    390.     /** 
    391.      * 获得HashSet对象 
    392.      * 
    393.      * @param domain 域名 
    394.      * @param key    键值 
    395.      * @return Json String or String value 
    396.      */  
    397.     public String getHSet(String domain, String key) {  
    398.         ShardedJedis shardedJedis = null;  
    399.         try {  
    400.             shardedJedis = shardedJedisPool.getResource();  
    401.             return shardedJedis.hget(domain, key);  
    402.         } catch (Exception ex) {  
    403.             logger.error("getHSet error.", ex);  
    404.             returnBrokenResource(shardedJedis);  
    405.         } finally {  
    406.             returnResource(shardedJedis);  
    407.         }  
    408.         return null;  
    409.     }  
    410.   
    411.     /** 
    412.      * 删除HashSet对象 
    413.      * 
    414.      * @param domain 域名 
    415.      * @param key    键值 
    416.      * @return 删除的记录数 
    417.      */  
    418.     public long delHSet(String domain, String key) {  
    419.         ShardedJedis shardedJedis = null;  
    420.         long count = 0;  
    421.         try {  
    422.             shardedJedis = shardedJedisPool.getResource();  
    423.             count = shardedJedis.hdel(domain, key);  
    424.         } catch (Exception ex) {  
    425.             logger.error("delHSet error.", ex);  
    426.             returnBrokenResource(shardedJedis);  
    427.         } finally {  
    428.             returnResource(shardedJedis);  
    429.         }  
    430.         return count;  
    431.     }  
    432.   
    433.     /** 
    434.      * 删除HashSet对象 
    435.      * 
    436.      * @param domain 域名 
    437.      * @param key    键值 
    438.      * @return 删除的记录数 
    439.      */  
    440.     public long delHSet(String domain, String... key) {  
    441.         ShardedJedis shardedJedis = null;  
    442.         long count = 0;  
    443.         try {  
    444.             shardedJedis = shardedJedisPool.getResource();  
    445.             count = shardedJedis.hdel(domain, key);  
    446.         } catch (Exception ex) {  
    447.             logger.error("delHSet error.", ex);  
    448.             returnBrokenResource(shardedJedis);  
    449.         } finally {  
    450.             returnResource(shardedJedis);  
    451.         }  
    452.         return count;  
    453.     }  
    454.   
    455.     /** 
    456.      * 判断key是否存在 
    457.      * 
    458.      * @param domain 域名 
    459.      * @param key    键值 
    460.      * @return 
    461.      */  
    462.     public boolean existsHSet(String domain, String key) {  
    463.         ShardedJedis shardedJedis = null;  
    464.         boolean isExist = false;  
    465.         try {  
    466.             shardedJedis = shardedJedisPool.getResource();  
    467.             isExist = shardedJedis.hexists(domain, key);  
    468.         } catch (Exception ex) {  
    469.             logger.error("existsHSet error.", ex);  
    470.             returnBrokenResource(shardedJedis);  
    471.         } finally {  
    472.             returnResource(shardedJedis);  
    473.         }  
    474.         return isExist;  
    475.     }  
    476.   
    477.     /** 
    478.      * 全局扫描hset 
    479.      * 
    480.      * @param match field匹配模式 
    481.      * @return 
    482.      */  
    483.     public List<Map.Entry<String, String>> scanHSet(String domain, String match) {  
    484.         ShardedJedis shardedJedis = null;  
    485.         try {  
    486.             int cursor = 0;  
    487.             shardedJedis = shardedJedisPool.getResource();  
    488.             ScanParams scanParams = new ScanParams();  
    489.             scanParams.match(match);  
    490.             Jedis jedis = shardedJedis.getShard(domain);  
    491.             ScanResult<Map.Entry<String, String>> scanResult;  
    492.             List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>();  
    493.             do {  
    494.                 scanResult = jedis.hscan(domain, String.valueOf(cursor), scanParams);  
    495.                 list.addAll(scanResult.getResult());  
    496.                 cursor = Integer.parseInt(scanResult.getStringCursor());  
    497.             } while (cursor > 0);  
    498.             return list;  
    499.         } catch (Exception ex) {  
    500.             logger.error("scanHSet error.", ex);  
    501.             returnBrokenResource(shardedJedis);  
    502.         } finally {  
    503.             returnResource(shardedJedis);  
    504.         }  
    505.         return null;  
    506.     }  
    507.   
    508.   
    509.     /** 
    510.      * 返回 domain 指定的哈希集中所有字段的value值 
    511.      * 
    512.      * @param domain 
    513.      * @return 
    514.      */  
    515.   
    516.     public List<String> hvals(String domain) {  
    517.         ShardedJedis shardedJedis = null;  
    518.         List<String> retList = null;  
    519.         try {  
    520.             shardedJedis = shardedJedisPool.getResource();  
    521.             retList = shardedJedis.hvals(domain);  
    522.         } catch (Exception ex) {  
    523.             logger.error("hvals error.", ex);  
    524.             returnBrokenResource(shardedJedis);  
    525.         } finally {  
    526.             returnResource(shardedJedis);  
    527.         }  
    528.         return retList;  
    529.     }  
    530.   
    531.     /** 
    532.      * 返回 domain 指定的哈希集中所有字段的key值 
    533.      * 
    534.      * @param domain 
    535.      * @return 
    536.      */  
    537.   
    538.     public Set<String> hkeys(String domain) {  
    539.         ShardedJedis shardedJedis = null;  
    540.         Set<String> retList = null;  
    541.         try {  
    542.             shardedJedis = shardedJedisPool.getResource();  
    543.             retList = shardedJedis.hkeys(domain);  
    544.         } catch (Exception ex) {  
    545.             logger.error("hkeys error.", ex);  
    546.             returnBrokenResource(shardedJedis);  
    547.         } finally {  
    548.             returnResource(shardedJedis);  
    549.         }  
    550.         return retList;  
    551.     }  
    552.   
    553.     /** 
    554.      * 返回 domain 指定的哈希key值总数 
    555.      * 
    556.      * @param domain 
    557.      * @return 
    558.      */  
    559.     public long lenHset(String domain) {  
    560.         ShardedJedis shardedJedis = null;  
    561.         long retList = 0;  
    562.         try {  
    563.             shardedJedis = shardedJedisPool.getResource();  
    564.             retList = shardedJedis.hlen(domain);  
    565.         } catch (Exception ex) {  
    566.             logger.error("hkeys error.", ex);  
    567.             returnBrokenResource(shardedJedis);  
    568.         } finally {  
    569.             returnResource(shardedJedis);  
    570.         }  
    571.         return retList;  
    572.     }  
    573.   
    574.     /** 
    575.      * 设置排序集合 
    576.      * 
    577.      * @param key 
    578.      * @param score 
    579.      * @param value 
    580.      * @return 
    581.      */  
    582.     public boolean setSortedSet(String key, long score, String value) {  
    583.         ShardedJedis shardedJedis = null;  
    584.         try {  
    585.             shardedJedis = shardedJedisPool.getResource();  
    586.             shardedJedis.zadd(key, score, value);  
    587.             return true;  
    588.         } catch (Exception ex) {  
    589.             logger.error("setSortedSet error.", ex);  
    590.             returnBrokenResource(shardedJedis);  
    591.         } finally {  
    592.             returnResource(shardedJedis);  
    593.         }  
    594.         return false;  
    595.     }  
    596.   
    597.     /** 
    598.      * 获得排序集合 
    599.      * 
    600.      * @param key 
    601.      * @param startScore 
    602.      * @param endScore 
    603.      * @param orderByDesc 
    604.      * @return 
    605.      */  
    606.     public Set<String> getSoredSet(String key, long startScore, long endScore, boolean orderByDesc) {  
    607.         ShardedJedis shardedJedis = null;  
    608.         try {  
    609.             shardedJedis = shardedJedisPool.getResource();  
    610.             if (orderByDesc) {  
    611.                 return shardedJedis.zrevrangeByScore(key, endScore, startScore);  
    612.             } else {  
    613.                 return shardedJedis.zrangeByScore(key, startScore, endScore);  
    614.             }  
    615.         } catch (Exception ex) {  
    616.             logger.error("getSoredSet error.", ex);  
    617.             returnBrokenResource(shardedJedis);  
    618.         } finally {  
    619.             returnResource(shardedJedis);  
    620.         }  
    621.         return null;  
    622.     }  
    623.   
    624.     /** 
    625.      * 计算排序长度 
    626.      * 
    627.      * @param key 
    628.      * @param startScore 
    629.      * @param endScore 
    630.      * @return 
    631.      */  
    632.     public long countSoredSet(String key, long startScore, long endScore) {  
    633.         ShardedJedis shardedJedis = null;  
    634.         try {  
    635.             shardedJedis = shardedJedisPool.getResource();  
    636.             Long count = shardedJedis.zcount(key, startScore, endScore);  
    637.             return count == null ? 0L : count;  
    638.         } catch (Exception ex) {  
    639.             logger.error("countSoredSet error.", ex);  
    640.             returnBrokenResource(shardedJedis);  
    641.         } finally {  
    642.             returnResource(shardedJedis);  
    643.         }  
    644.         return 0L;  
    645.     }  
    646.   
    647.     /** 
    648.      * 删除排序集合 
    649.      * 
    650.      * @param key 
    651.      * @param value 
    652.      * @return 
    653.      */  
    654.     public boolean delSortedSet(String key, String value) {  
    655.         ShardedJedis shardedJedis = null;  
    656.         try {  
    657.             shardedJedis = shardedJedisPool.getResource();  
    658.             long count = shardedJedis.zrem(key, value);  
    659.             return count > 0;  
    660.         } catch (Exception ex) {  
    661.             logger.error("delSortedSet error.", ex);  
    662.             returnBrokenResource(shardedJedis);  
    663.         } finally {  
    664.             returnResource(shardedJedis);  
    665.         }  
    666.         return false;  
    667.     }  
    668.   
    669.     /** 
    670.      * 获得排序集合 
    671.      * 
    672.      * @param key 
    673.      * @param startRange 
    674.      * @param endRange 
    675.      * @param orderByDesc 
    676.      * @return 
    677.      */  
    678.     public Set<String> getSoredSetByRange(String key, int startRange, int endRange, boolean orderByDesc) {  
    679.         ShardedJedis shardedJedis = null;  
    680.         try {  
    681.             shardedJedis = shardedJedisPool.getResource();  
    682.             if (orderByDesc) {  
    683.                 return shardedJedis.zrevrange(key, startRange, endRange);  
    684.             } else {  
    685.                 return shardedJedis.zrange(key, startRange, endRange);  
    686.             }  
    687.         } catch (Exception ex) {  
    688.             logger.error("getSoredSetByRange error.", ex);  
    689.             returnBrokenResource(shardedJedis);  
    690.         } finally {  
    691.             returnResource(shardedJedis);  
    692.         }  
    693.         return null;  
    694.     }  
    695.   
    696.     /** 
    697.      * 获得排序打分 
    698.      * 
    699.      * @param key 
    700.      * @return 
    701.      */  
    702.     public Double getScore(String key, String member) {  
    703.         ShardedJedis shardedJedis = null;  
    704.         try {  
    705.             shardedJedis = shardedJedisPool.getResource();  
    706.             return shardedJedis.zscore(key, member);  
    707.         } catch (Exception ex) {  
    708.             logger.error("getSoredSet error.", ex);  
    709.             returnBrokenResource(shardedJedis);  
    710.         } finally {  
    711.             returnResource(shardedJedis);  
    712.         }  
    713.         return null;  
    714.     }  
    715.   
    716.     public boolean set(String key, String value, int second) {  
    717.         ShardedJedis shardedJedis = null;  
    718.         try {  
    719.             shardedJedis = shardedJedisPool.getResource();  
    720.             shardedJedis.setex(key, second, value);  
    721.             return true;  
    722.         } catch (Exception ex) {  
    723.             logger.error("set error.", ex);  
    724.             returnBrokenResource(shardedJedis);  
    725.         } finally {  
    726.             returnResource(shardedJedis);  
    727.         }  
    728.         return false;  
    729.     }  
    730.   
    731.     public boolean set(String key, String value) {  
    732.         ShardedJedis shardedJedis = null;  
    733.         try {  
    734.             shardedJedis = shardedJedisPool.getResource();  
    735.             shardedJedis.set(key, value);  
    736.             return true;  
    737.         } catch (Exception ex) {  
    738.             logger.error("set error.", ex);  
    739.             returnBrokenResource(shardedJedis);  
    740.         } finally {  
    741.             returnResource(shardedJedis);  
    742.         }  
    743.         return false;  
    744.     }  
    745.   
    746.     public String get(String key, String defaultValue) {  
    747.         ShardedJedis shardedJedis = null;  
    748.         try {  
    749.             shardedJedis = shardedJedisPool.getResource();  
    750.             return shardedJedis.get(key) == null?defaultValue:shardedJedis.get(key);  
    751.         } catch (Exception ex) {  
    752.             logger.error("get error.", ex);  
    753.             returnBrokenResource(shardedJedis);  
    754.         } finally {  
    755.             returnResource(shardedJedis);  
    756.         }  
    757.         return defaultValue;  
    758.     }  
    759.   
    760.     public boolean del(String key) {  
    761.         ShardedJedis shardedJedis = null;  
    762.         try {  
    763.             shardedJedis = shardedJedisPool.getResource();  
    764.             shardedJedis.del(key);  
    765.             return true;  
    766.         } catch (Exception ex) {  
    767.             logger.error("del error.", ex);  
    768.             returnBrokenResource(shardedJedis);  
    769.         } finally {  
    770.             returnResource(shardedJedis);  
    771.         }  
    772.         return false;  
    773.     }  
    774.   
    775.     public long incr(String key) {  
    776.         ShardedJedis shardedJedis = null;  
    777.         try {  
    778.             shardedJedis = shardedJedisPool.getResource();  
    779.             return shardedJedis.incr(key);  
    780.         } catch (Exception ex) {  
    781.             logger.error("incr error.", ex);  
    782.             returnBrokenResource(shardedJedis);  
    783.         } finally {  
    784.             returnResource(shardedJedis);  
    785.         }  
    786.         return 0;  
    787.     }  
    788.   
    789.     public long decr(String key) {  
    790.         ShardedJedis shardedJedis = null;  
    791.         try {  
    792.             shardedJedis = shardedJedisPool.getResource();  
    793.             return shardedJedis.decr(key);  
    794.         } catch (Exception ex) {  
    795.             logger.error("incr error.", ex);  
    796.             returnBrokenResource(shardedJedis);  
    797.         } finally {  
    798.             returnResource(shardedJedis);  
    799.         }  
    800.         return 0;  
    801.     }  
    802.   
    803.   
    804.   
    805.     private void returnBrokenResource(ShardedJedis shardedJedis) {  
    806.         try {  
    807.             shardedJedisPool.returnBrokenResource(shardedJedis);  
    808.         } catch (Exception e) {  
    809.             logger.error("returnBrokenResource error.", e);  
    810.         }  
    811.     }  
    812.   
    813.     private void returnResource(ShardedJedis shardedJedis) {  
    814.         try {  
    815.             shardedJedisPool.returnResource(shardedJedis);  
    816.         } catch (Exception e) {  
    817.             logger.error("returnResource error.", e);  
    818.         }  
    819.     } 
  • 相关阅读:
    1093 Count PAT's（25 分）
    1089 Insert or Merge（25 分）
    1088 Rational Arithmetic（20 分）
    1081 Rational Sum（20 分）
    1069 The Black Hole of Numbers（20 分）
    1059 Prime Factors（25 分）
    1050 String Subtraction (20)
    根据生日计算员工年龄
    动态获取当前日期和时间
    对计数结果进行4舍5入
  • 原文地址：https://www.cnblogs.com/leo3689/p/4513365.html
Copyright © 2020-2023  润新知