Redis连接池配置

http://my.oschina.net/damihui/blog/173490
1.使用MAVEN引入使用的包。

view sourceprint?01 <dependency> 

02     <groupId>redis.clients</groupId> 

03     <artifactId>jedis</artifactId> 

04     <version>2.1.0</version> 

05     <scope>provided</scope> 

06 </dependency> 

07 <dependency> 

08     <groupId>org.springframework</groupId> 

09     <artifactId>spring-core</artifactId> 

10     <version>3.1.0.RELEASE</version> 

11     <scope>provided</scope> 

12 </dependency> 

13 <dependency> 

14     <groupId>org.springframework</groupId> 

15     <artifactId>spring-context</artifactId> 

16     <version>3.1.0.RELEASE</version> 

17     <scope>provided</scope> 

18 </dependency> 

19 <dependency> 

20     <groupId>org.springframework</groupId> 

21     <artifactId>spring-context-support</artifactId> 

22     <version>3.1.0.RELEASE</version> 

23     <scope>provided</scope> 

24 </dependency> 

25 <dependency> 

26     <groupId>org.springframework</groupId> 

27     <artifactId>spring-beans</artifactId> 

28     <version>3.1.0.RELEASE</version> 

29     <scope>provided</scope> 

30 </dependency> 

31 <dependency> 

32     <groupId>org.springframework</groupId> 

33     <artifactId>org.springframework.context</artifactId> 

34     <version>3.1.0.RELEASE</version> 

35     <scope>provided</scope> 

36 </dependency> 

37 <dependency> 

38     <groupId>org.springframework</groupId> 

39     <artifactId>spring-test</artifactId> 

40     <version>3.1.0.RELEASE</version> 

41     <scope>test</scope> 

42 </dependency> 

43 <dependency> 

44     <groupId>commons-io</groupId> 

45     <artifactId>commons-io</artifactId> 

46     <version>1.3.2</version> 

47 </dependency> 

48 <dependency> 

49     <groupId>commons-lang</groupId> 

50     <artifactId>commons-lang</artifactId> 

51     <version>2.3</version> 

52     <scope>provided</scope> 

53 </dependency> 

54 <dependency> 

55     <groupId>junit</groupId> 

56     <artifactId>junit</artifactId> 

57     <version>4.10</version> 

58     <scope>test</scope> 

59 </dependency> 

60 <dependency> 

61     <groupId>org.aspectj</groupId> 

62     <artifactId>aspectjweaver</artifactId> 

63     <version>1.6.12</version> 

64     <scope>provided</scope> 

65 </dependency> 

66 <dependency> 

67     <groupId>net.sourceforge.cglib</groupId> 

68     <artifactId>com.springsource.net.sf.cglib</artifactId> 

69     <version>2.2.0</version> 

70     <scope>provided</scope> 

71 </dependency> 

72 <dependency> 

73     <groupId>log4j</groupId> 

74     <artifactId>log4j</artifactId> 

75     <version>1.2.8</version> 

76 </dependency>

2.Jedis的连接池配置需要用到org.apache.commons.pool.impl.GenericObjectPool.Config.class，此类是 GenericObjectPool的一个内部类，使用spring xml配置时需要转换成以下自定义类。


view sourceprint?001 package com.antilost.redis.util; 

002   

003 import org.apache.commons.pool.impl.GenericObjectPool; 

004   

005 /** 

006  * User: *** 

007  * Date: 13-8-27 

008  * Time: 下午3:49 

009  */

010 public class GenericObjectPoolConfigWrapper { 

011   

012     private final GenericObjectPool.Config config; 

013   

014     public GenericObjectPoolConfigWrapper() { 

015         this.config = new GenericObjectPool.Config(); 

016     } 

017   

018     public GenericObjectPool.Config getConfig() { 

019         return config; 

020     } 

021   

022     public int getMaxIdle() { 

023         return this.config.maxIdle; 

024     } 

025   

026     public void setMaxIdle(int maxIdle) { 

027         this.config.maxIdle = maxIdle; 

028     } 

029   

030     public int getMinIdle() { 

031         return this.config.minIdle; 

032     } 

033   

034     public void setMinIdle(int minIdle) { 

035         this.config.minIdle = minIdle; 

036     } 

037   

038     public int getMaxActive() { 

039         return this.config.maxActive; 

040     } 

041   

042     public void setMaxActive(int maxActive) { 

043         this.config.maxActive = maxActive; 

044     } 

045   

046     public long getMaxWait() { 

047         return this.config.maxWait; 

048     } 

049   

050     public void setMaxWait(long maxWait) { 

051         this.config.maxWait = maxWait; 

052     } 

053   

054     public byte getWhenExhaustedAction() { 

055         return this.config.whenExhaustedAction; 

056     } 

057   

058     public void setWhenExhaustedAction(byte whenExhaustedAction) { 

059         this.config.whenExhaustedAction = whenExhaustedAction; 

060     } 

061   

062     public boolean isTestOnBorrow() { 

063         return this.config.testOnBorrow; 

064     } 

065   

066     public void setTestOnBorrow(boolean testOnBorrow) { 

067         this.config.testOnBorrow = testOnBorrow; 

068     } 

069   

070     public boolean isTestOnReturn() { 

071         return this.config.testOnReturn; 

072     } 

073   

074     public void setTestOnReturn(boolean testOnReturn) { 

075         this.config.testOnReturn = testOnReturn; 

076     } 

077   

078     public boolean isTestWhileIdle() { 

079         return this.config.testWhileIdle; 

080     } 

081   

082     public void setTestWhileIdle(boolean testWhileIdle) { 

083         this.config.testWhileIdle = testWhileIdle; 

084     } 

085   

086     public long getTimeBetweenEvictionRunsMillis() { 

087         return this.config.timeBetweenEvictionRunsMillis; 

088     } 

089   

090     public void setTimeBetweenEvictionRunsMillis( long timeBetweenEvictionRunsMillis) { 

091         this.config.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis; 

092     } 

093   

094     public int getNumTestsPerEvictionRun() { 

095         return this.config.numTestsPerEvictionRun; 

096     } 

097   

098     public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) { 

099         this.config.numTestsPerEvictionRun = numTestsPerEvictionRun; 

100     } 

101   

102     public long getMinEvictableIdleTimeMillis() { 

103         return this.config.minEvictableIdleTimeMillis; 

104     } 

105   

106     public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) { 

107         this.config.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis; 

108     } 

109   

110     public long getSoftMinEvictableIdleTimeMillis() { 

111         return this.config.softMinEvictableIdleTimeMillis; 

112     } 

113   

114     public void setSoftMinEvictableIdleTimeMillis( long softMinEvictableIdleTimeMillis) { 

115         this.config.softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis; 

116     } 

117   

118     public boolean isLifo() { 

119         return this.config.lifo; 

120     } 

121   

122     public void setLifo(boolean lifo) { 

123         this.config.lifo = lifo; 

124     } 

125 }

3.在Spring配置文件中注入GenericObjectPoolConfigWrapper.java类

view sourceprint?01 <aop:aspectj-autoproxy/> 

02 <context:annotation-config /> 

03 <context:property-placeholder location="classpath:jedis.properties" ignore-unresolvable="true"/> 

04 <bean id="jedisPoolConfig" class="com.antilost.redis.util.GenericObjectPoolConfigWrapper"> 

05         <!--最大连接数-->

06     <property name="maxActive" value="${${redis.pool.maxActive}}" /> 

07         <!--最大空闲连接数-->

08     <property name="maxIdle" value="${${redis.pool.maxIdle}}" /> 

09         <!--初始化连接数-->

10     <property name="minIdle" value="${${redis.pool.minIdle}}"/> 

11         <!--最大等待时间-->

12     <property name="maxWait" value="${${redis.pool.maxWait}}" /> 

13         <!--对拿到的connection进行validateObject校验-->

14     <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" /> 

15         <!--在进行returnObject对返回的connection进行validateObject校验-->

16     <property name="testOnReturn" value="${redis.pool.testOnReturn}" /> 

17         <!--定时对线程池中空闲的链接进行validateObject校验-->

18         <property name="testWhileIdle" value="true" /> 

19 </bean>

4.Redis的连接配置文件jedis.properties中，定义了各个环境的连接参数，具体配置如下


view sourceprint?01 redis.pool.maxActive=redis.pool.maxActive.${ServerType} 

02 redis.pool.maxIdle=redis.pool.maxIdle.${ServerType} 

03 redis.pool.maxWait=redis.pool.maxWait.${ServerType} 

04 redis.pool.minIdle=redis.pool.minIdle.${ServerType} 

05 redis.host=redis.host.${ServerType} 

06 redis.port=redis.port.${ServerType} 

07 redis.password=redis.password.${ServerType} 

08 redis.pool.testOnBorrow=true

09 redis.pool.testOnReturn=true

10 redis.timeout=1000

11 #C 

12 #REL 

13 redis.pool.maxActive.REL=200 

14 redis.pool.maxIdle.REL=50 

15 redis.pool.minIdle.REL=10 

16 redis.pool.maxWait.REL=300 

17 redis.host.REL=192.168.*.* 

18 redis.port.REL=6379 

19 redis.password.REL=***

20   

21 #VRF 

22 redis.pool.maxActive.VRF=200 

23 redis.pool.maxIdle.VRF=50 

24 redis.pool.minIdle.VRF=10 

25 redis.pool.maxWait.VRF=300 

26 redis.host.VRF=192.168.*.* 

27 redis.port.VRF=6379 

28 redis.password.VRF=***
根据系统环境变量JVM中ServerType的值，取不同的配置，实现多环境（测试环境、生产环境）集成。



5.Redis连接池配置

view sourceprint?01 <bean id="jedisPool" class="redis.clients.jedis.JedisPool" destroy-method="destroy"> 

02      <constructor-arg index="0"> 

03             <bean factory-bean="jedisPoolConfig" factory-method="getConfig"/> 

04      </constructor-arg> 

05         <constructor-arg index="1" value="${${redis.host}}"/> 

06         <constructor-arg index="2" value="${${redis.port}}"/> 

07         <!--timeout-->

08         <constructor-arg index="3" value="${redis.timeout}"/> 

09         <constructor-arg index="4" value="${${redis.password}}"/> 

10 </bean>
6.Redis 工具类 view sourceprint?001 public abstract class JCacheTools { 

002     public abstract int getDBIndex(); 

003     /** 

004      * 默认日志打印logger_default 

005      */

006     public static Logger logger_default = Logger.getLogger("logger_jCache_default"); 

007     /** 

008      * 失败日志logger，用于定期del指定的key 

009      */

010     public static Logger logger_failure = Logger.getLogger("logger_jCache_failure"); 

011   

012     @Resource

013     protected JedisPool jedisPool; 

014   

015     protected Jedis getJedis() throws JedisException { 

016         Jedis jedis = null; 

017         try { 

018             jedis = jedisPool.getResource(); 

019         } catch (JedisException e) { 

020             LogContext.instance().warn(logger_failure, "failed:jedisPool getResource.", e); 

021             if(jedis!=null){ 

022                 jedisPool.returnBrokenResource(jedis); 

023             } 

024             throw e; 

025         } 

026         return jedis; 

027     } 

028   

029     protected void release(Jedis jedis, boolean isBroken) { 

030         if (jedis != null) { 

031             if (isBroken) { 

032                 jedisPool.returnBrokenResource(jedis); 

033             } else { 

034                 jedisPool.returnResource(jedis); 

035             } 

036         } 

037     } 

038   

039     protected String addStringToJedis(String key, String value, int cacheSeconds, String methodName) { 

040         Jedis jedis = null; 

041         boolean isBroken = false; 

042         String lastVal = null; 

043         try { 

044             jedis = this.getJedis(); 

045             jedis.select(getDBIndex()); 

046             lastVal = jedis.getSet(key, value); 

047             if(cacheSeconds!=0){ 

048                 jedis.expire(key,cacheSeconds); 

049             } 

050             LogContext.instance().debug(logger_default, "succeed:" + methodName, key, value); 

051         } catch (Exception e) { 

052             isBroken = true; 

053             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, value, e); 

054         } finally { 

055             release(jedis, isBroken); 

056         } 

057         return lastVal; 

058     } 

059   

060     protected void addStringToJedis(Map<String,String> batchData, int cacheSeconds, String methodName) { 

061         Jedis jedis = null; 

062         boolean isBroken = false; 

063         try { 

064             jedis = this.getJedis(); 

065             jedis.select(getDBIndex()); 

066             Pipeline pipeline = jedis.pipelined(); 

067             for(Map.Entry<String,String> element:batchData.entrySet()){ 

068                 if(cacheSeconds!=0){ 

069                     pipeline.setex(element.getKey(),cacheSeconds,element.getValue()); 

070                 }else{ 

071                     pipeline.set(element.getKey(),element.getValue()); 

072                 } 

073             } 

074             pipeline.sync(); 

075             LogContext.instance().debug(logger_default, "succeed:" + methodName,batchData.size()); 

076         } catch (Exception e) { 

077             isBroken = true; 

078             e.printStackTrace(); 

079         } finally { 

080             release(jedis, isBroken); 

081         } 

082     } 

083   

084     protected void addListToJedis(String key, List<String> list, int cacheSeconds, String methodName) { 

085         if (list != null && list.size() > 0) { 

086             Jedis jedis = null; 

087             boolean isBroken = false; 

088             try { 

089                 jedis = this.getJedis(); 

090                 jedis.select(getDBIndex()); 

091                 if (jedis.exists(key)) { 

092                     jedis.del(key); 

093                 } 

094                 for (String aList : list) { 

095                     jedis.rpush(key, aList); 

096                 } 

097                 if(cacheSeconds!=0){ 

098                     jedis.expire(key, cacheSeconds); 

099                 } 

100                 LogContext.instance().debug(logger_default, "succeed:" + methodName, key, list.size()); 

101             } catch (JedisException e) { 

102                 isBroken = true; 

103                 LogContext.instance().warn(logger_failure, "failed:" + methodName, key, list.size(), e); 

104             } catch (Exception e) { 

105                 isBroken = true; 

106                 LogContext.instance().warn(logger_failure, "failed:" + methodName, key, list.size(), e); 

107             } finally { 

108                 release(jedis, isBroken); 

109             } 

110         } 

111     } 

112   

113     protected void addToSetJedis(String key, String[] value, String methodName) { 

114         Jedis jedis = null; 

115         boolean isBroken = false; 

116         try { 

117             jedis = this.getJedis(); 

118             jedis.select(getDBIndex()); 

119             jedis.sadd(key,value); 

120             LogContext.instance().debug(logger_default, "succeed:" + methodName, key, value); 

121         } catch (Exception e) { 

122             isBroken = true; 

123             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, value, e); 

124         } finally { 

125             release(jedis, isBroken); 

126         } 

127     } 

128   

129     protected void removeSetJedis(String key,String value, String methodName) { 

130         Jedis jedis = null; 

131         boolean isBroken = false; 

132         try { 

133             jedis = this.getJedis(); 

134             jedis.select(getDBIndex()); 

135             jedis.srem(key,value); 

136             LogContext.instance().debug(logger_default, "succeed:" + methodName, key, value); 

137         } catch (Exception e) { 

138             isBroken = true; 

139             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, value, e); 

140         } finally { 

141             release(jedis, isBroken); 

142         } 

143     } 

144   

145     protected void pushDataToListJedis(String key, String data, int cacheSeconds, String methodName) { 

146         Jedis jedis = null; 

147         boolean isBroken = false; 

148         try { 

149             jedis = this.getJedis(); 

150             jedis.select(getDBIndex()); 

151             jedis.rpush(key, data); 

152             if(cacheSeconds!=0){ 

153                 jedis.expire(key,cacheSeconds); 

154             } 

155             LogContext.instance().debug(logger_default, "succeed:" + methodName, key, data); 

156         } catch (Exception e) { 

157             isBroken = true; 

158             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, data, e); 

159         } finally { 

160             release(jedis, isBroken); 

161         } 

162     } 

163     protected void pushDataToListJedis(String key,List<String> batchData, int cacheSeconds, String methodName) { 

164         Jedis jedis = null; 

165         boolean isBroken = false; 

166         try { 

167             jedis = this.getJedis(); 

168             jedis.select(getDBIndex()); 

169             jedis.del(key); 

170             jedis.lpush(key,batchData.toArray(new String[batchData.size()])); 

171             if(cacheSeconds!=0) 

172                 jedis.expire(key,cacheSeconds); 

173             LogContext.instance().debug(logger_default, "succeed:" + methodName,batchData!=null?batchData.size():0); 

174         } catch (Exception e) { 

175             isBroken = true; 

176             LogContext.instance().warn(logger_failure, "failed:" + methodName, batchData!=null?batchData.size():0, e); 

177         } finally { 

178             release(jedis, isBroken); 

179         } 

180     } 

181   

182     /** 

183      * 删除list中的元素 

184      * @param key 

185      * @param values 

186      * @param methodName 

187      */

188     protected void deleteDataFromListJedis(String key,List<String> values, String methodName) { 

189         Jedis jedis = null; 

190         boolean isBroken = false; 

191         try { 

192             jedis = this.getJedis(); 

193             jedis.select(getDBIndex()); 

194             Pipeline pipeline = jedis.pipelined(); 

195             if(values!=null && !values.isEmpty()){ 

196                 for (String val:values){ 

197                     pipeline.lrem(key,0,val); 

198                 } 

199             } 

200             pipeline.sync(); 

201             LogContext.instance().debug(logger_default, "succeed:" + methodName,values!=null?values.size():0); 

202         } catch (Exception e) { 

203             isBroken = true; 

204             LogContext.instance().warn(logger_failure, "failed:" + methodName, values!=null?values.size():0, e); 

205         } finally { 

206             release(jedis, isBroken); 

207         } 

208     } 

209   

210     protected void addHashMapToJedis(String key, Map<String, String> map, int cacheSeconds, boolean isModified, String methodName) { 

211         boolean isBroken = false; 

212         Jedis jedis = null; 

213         if (map != null && map.size() > 0) { 

214             try { 

215                 jedis = this.getJedis(); 

216                 jedis.select(getDBIndex()); 

217                 jedis.hmset(key, map); 

218                 if (cacheSeconds >= 0) 

219                     jedis.expire(key, cacheSeconds); 

220                 LogContext.instance().debug(logger_default, "succeed:" + methodName, key, map.size()); 

221             } catch (Exception e) { 

222                 isBroken = true; 

223                 LogContext.instance().warn(logger_failure, "failed:" + methodName, key, map.size(), e); 

224             } finally { 

225                 release(jedis, isBroken); 

226             } 

227         } 

228     } 

229   

230     protected void addHashMapToJedis(String key, String field, String value, int cacheSeconds, String methodName) { 

231         boolean isBroken = false; 

232         Jedis jedis = null; 

233         try { 

234             jedis = this.getJedis(); 

235             if (jedis != null) { 

236                 jedis.select(getDBIndex()); 

237                 jedis.hset(key, field, value); 

238                 jedis.expire(key, cacheSeconds); 

239                 LogContext.instance().debug(logger_default, "succeed:" + methodName, key, field, value); 

240             } 

241         } catch (Exception e) { 

242             isBroken = true; 

243             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, field, value, e); 

244         }finally { 

245             release(jedis, isBroken); 

246         } 

247     } 

248   

249     protected void updateHashMapToJedis(String key, String incrementField, long incrementValue, String dateField, String dateValue, String methodName) { 

250         boolean isBroken = false; 

251         Jedis jedis = null; 

252         try { 

253             jedis = this.getJedis(); 

254             jedis.select(getDBIndex()); 

255             jedis.hincrBy(key, incrementField, incrementValue); 

256             jedis.hset(key, dateField, dateValue); 

257             LogContext.instance().debug(logger_default, "succeed:" + methodName, key, incrementField, incrementValue); 

258         } catch (Exception e) { 

259             isBroken = true; 

260             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, incrementField, incrementValue, e); 

261         }finally { 

262             release(jedis, isBroken); 

263         } 

264     } 

265   

266     public String getStringFromJedis(String key, String methodName) { 

267         String value = null; 

268         Jedis jedis = null; 

269         boolean isBroken = false; 

270         try { 

271             jedis = this.getJedis(); 

272             jedis.select(getDBIndex()); 

273             if (jedis.exists(key)) { 

274                 value = jedis.get(key); 

275                 value = StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value)?value:null; 

276                 LogContext.instance().debug(logger_default, "succeed:" + methodName, key, value); 

277             } 

278         } catch (Exception e) { 

279             isBroken = true; 

280             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, value, e); 

281         } finally { 

282             release(jedis, isBroken); 

283         } 

284         return value; 

285     } 

286   

287     public List<String> getStringFromJedis(String[] keys, String methodName) { 

288         Jedis jedis = null; 

289         boolean isBroken = false; 

290         try { 

291             jedis = this.getJedis(); 

292             jedis.select(getDBIndex()); 

293             return jedis.mget(keys); 

294         } catch (Exception e) { 

295             isBroken = true; 

296             LogContext.instance().warn(logger_failure, "failed:" + methodName, Arrays.toString(keys), e); 

297         } finally { 

298             release(jedis, isBroken); 

299         } 

300         return null; 

301     } 

302   

303     protected List<String> getListFromJedis(String key, String methodName) throws JMSCacheException { 

304         List<String> list = null; 

305         boolean isBroken = false; 

306         Jedis jedis = null; 

307         try { 

308             jedis = this.getJedis(); 

309             jedis.select(getDBIndex()); 

310             if (jedis.exists(key)) { 

311                 list = jedis.lrange(key, 0, -1); 

312                 LogContext.instance().debug(logger_default, "succeed:" + methodName, key, list != null ? list.size() : 0); 

313             } 

314         } catch (JedisException e) { 

315             isBroken = true; 

316             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, list != null ? list.size() : 0, e); 

317         } finally { 

318             release(jedis, isBroken); 

319         } 

320         return list; 

321     } 

322   

323     protected Set<String> getSetFromJedis(String key, String methodName) throws JMSCacheException { 

324         Set<String> list = null; 

325         boolean isBroken = false; 

326         Jedis jedis = null; 

327         try { 

328             jedis = this.getJedis(); 

329             jedis.select(getDBIndex()); 

330             if (jedis.exists(key)) { 

331                 list = jedis.smembers(key); 

332                 LogContext.instance().debug(logger_default, "succeed:" + methodName, key, list != null ? list.size() : 0); 

333             } 

334         } catch (Exception e) { 

335             isBroken = true; 

336             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, list != null ? list.size() : 0, e); 

337         } finally { 

338             release(jedis, isBroken); 

339         } 

340         return list; 

341     } 

342   

343     protected Map<String, String> getHashMapFromJedis(String key, String methodName) { 

344         Map<String, String> hashMap = null; 

345         boolean isBroken = false; 

346         Jedis jedis = null; 

347         try { 

348             jedis = this.getJedis(); 

349             jedis.select(getDBIndex()); 

350             hashMap = jedis.hgetAll(key); 

351             LogContext.instance().debug(logger_default, "succeed:" + methodName, key, hashMap != null ? hashMap.size() : 0); 

352         } catch (Exception e) { 

353             isBroken = true; 

354             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, hashMap != null ? hashMap.size() : 0, e); 

355         } finally { 

356             release(jedis, isBroken); 

357         } 

358         return hashMap; 

359     } 

360   

361     protected String getHashMapValueFromJedis(String key, String field, String methodName) { 

362         String value = null; 

363         boolean isBroken = false; 

364         Jedis jedis = null; 

365         try { 

366             jedis = this.getJedis(); 

367             if (jedis != null) { 

368                 jedis.select(getDBIndex()); 

369                 if (jedis.exists(key)) { 

370                     value = jedis.hget(key, field); 

371                     LogContext.instance().debug(logger_default, "succeed:" + methodName, key, field, value); 

372                 } 

373             } 

374         } catch (Exception e) { 

375             isBroken = true; 

376             LogContext.instance().warn(logger_failure, "failed:" + methodName, key, field, value, e); 

377         } finally { 

378             release(jedis, isBroken); 

379         } 

380         return value; 

381     } 

382   

383     public Long getIdentifyId(String identifyName ,String methodName) { 

384         boolean isBroken = false; 

385         Jedis jedis = null; 

386         Long identify=null; 

387         try { 

388             jedis = this.getJedis(); 

389             if (jedis != null) { 

390                 jedis.select(getDBIndex()); 

391                 identify = jedis.incr(identifyName); 

392                 if(identify==0){ 

393                     return jedis.incr(identifyName); 

394                 }else { 

395                     return identify; 

396                 } 

397             } 

398         } catch (Exception e) { 

399             isBroken = true; 

400             LogContext.instance().warn(logger_failure, "failed:" + methodName, identifyName, "", identify, e); 

401         } finally { 

402             release(jedis, isBroken); 

403         } 

404         return null; 

405     } 

406   

407   

408     /** 

409      * 删除某db的某个key值 

410      * @param key 

411      * @return 

412      */

413     public Long delKeyFromJedis(String key) { 

414         boolean isBroken = false; 

415         Jedis jedis = null; 

416         long result = 0; 

417         try { 

418             jedis = this.getJedis(); 

419             jedis.select(getDBIndex()); 

420             LogContext.instance().debug(logger_default, "succeed:delKeyFromJedis"); 

421             return jedis.del(key); 

422         } catch (Exception e) { 

423             isBroken = true; 

424             LogContext.instance().warn(logger_failure, "failed:delKeyFromJedis", e); 

425         } finally { 

426             release(jedis, isBroken); 

427         } 

428         return result; 

429     } 

430   

431     /** 

432      * 根据dbIndex flushDB每个shard 

433      * 

434      * @param dbIndex 

435      */

436     public void flushDBFromJedis(int dbIndex) { 

437         Jedis jedis = null; 

438         boolean isBroken = false; 

439         try { 

440             jedis = this.getJedis(); 

441             jedis.select(dbIndex); 

442             jedis.flushDB(); 

443             LogContext.instance().debug(logger_default, "succeed:flushDBFromJedis"); 

444         } catch (Exception e) { 

445             isBroken = true; 

446             LogContext.instance().warn(logger_failure, "failed:flushDBFromJedis", e); 

447         } finally { 

448             release(jedis, isBroken); 

449         } 

450     } 

451   

452     public boolean existKey(String key, String methodName) { 

453         Jedis jedis = null; 

454         boolean isBroken = false; 

455         try { 

456             jedis = this.getJedis(); 

457             jedis.select(getDBIndex()); 

458             LogContext.instance().debug(logger_default, "succeed:"+methodName); 

459             return jedis.exists(key); 

460         } catch (Exception e) { 

461             isBroken = true; 

462             LogContext.instance().warn(logger_failure, "failed:"+methodName, e); 

463         } finally { 

464             release(jedis, isBroken); 

465         } 

466         return false; 

467     } 

468   

469 }