Redis連接池配置及初始化實現(xiàn)

public class RedisPoolConfigure {

 //Redis服務(wù)器IP
 private String ADDR ;
 
 //Redis的端口號
 private int PORT ;
 
 //可用連接實例的最大數(shù)目
 private int MAX_ACTIVE ;
 
 //pool中的idle jedis實例數(shù)
 private int MAX_IDLE ;
 
 //等待可用連接的最大時間，單位毫秒
 private int MAX_WAIT ;
 //超時時間，單位毫秒
 private int TIME_OUT ;
 //設(shè)置的逐出策略類名, 默認DefaultEvictionPolicy(當(dāng)連接超過最大空閑時間,或連接數(shù)超過最大空閑連接數(shù))
 private String EVICTION_POLICY_CLASS_NAME ;
 
 //連接耗盡時是否阻塞, false報異常,ture阻塞直到超時
 private boolean BLOCK_WHEN_EXHAUSTED;
 
 //是否啟用pool的jmx管理功能, 默認true
 private boolean JMX_ENABLED;
 
 //在borrow一個jedis實例時，是否提前進行validate操作；如果為true，則得到的jedis實例均是可用的；
 private boolean TEST_ON_BORROW ;
 
 //服務(wù)器密碼
 private String REDIS_PASS;
 //redis選擇數(shù)據(jù)庫DB
 private int REDIS_DB;
 
 
 private String LUASHA;
 
 private MapString, String> configure = null;
 
 /**
  * 根據(jù)配置文件,將RedisPool連接配置初始化
  */
 public RedisPoolConfigure(){
  try {
  configure = new ConfigureReader().readProperties("redis.properties");
 } catch (IOException e) {
 e.printStackTrace();
 }
  this.ADDR = configure.get("REDIS.ADDR");
  this.LUASHA = configure.get("REDIS.LUA_HASH");
  this.EVICTION_POLICY_CLASS_NAME = configure.get("REDIS.EVICTION_POLICY_CLASS_NAME");
  this.BLOCK_WHEN_EXHAUSTED = Boolean.parseBoolean(configure.get("REDIS.BLOCK_WHEN_EXHAUSTED"));
  this.JMX_ENABLED = Boolean.parseBoolean(configure.get("REDIS.JMX_ENABLED"));
  this.TEST_ON_BORROW = Boolean.parseBoolean(configure.get("REDIS.TEST_ON_BORROW"));
  this.REDIS_PASS=configure.get("REDIS.PASS");
  
  if(typeCheck()){
  this.PORT = new Integer(configure.get("REDIS.PORT"));
  this.MAX_ACTIVE = new Integer(configure.get("REDIS.MAX_ACTIVE"));
  this.MAX_IDLE = new Integer(configure.get("REDIS.MAX_IDLE"));
  this.MAX_WAIT = new Integer(configure.get("REDIS.MAX_WAIT"));
  this.REDIS_DB=new Integer(configure.get("REDIS.DB"));
  }else{
  System.out.println("error");
  }
 }
 
 /**
  * 輔助工具,檢查map中數(shù)據(jù)的類型
  * @return
  */
 private boolean typeCheck() {
 if (isNumeric(configure.get("REDIS.PORT")) 
  isNumeric(configure.get("REDIS.MAX_ACTIVE"))
  isNumeric(configure.get("REDIS.MAX_IDLE")) 
  isNumeric(configure.get("REDIS.MAX_WAIT"))
  isNumeric(configure.get("REDIS.DB"))) {
 return true;
 } 
 return false;
 }

 public String getADDR() {
 return ADDR;
 }

 public int getPORT() {
 return PORT;
 }


 public int getMAX_ACTIVE() {
 return MAX_ACTIVE;
 }

 public int getMAX_IDLE() {
 return MAX_IDLE;
 }

 public int getMAX_WAIT() {
 return MAX_WAIT;
 }

 public int getTIME_OUT() {
 return TIME_OUT;
 }

 public boolean isTEST_ON_BORROW() {
 return TEST_ON_BORROW;
 }

 public String getEVICTION_POLICY_CLASS_NAME() {
 return EVICTION_POLICY_CLASS_NAME;
 }

 public boolean isBLOCK_WHEN_EXHAUSTED() {
 return BLOCK_WHEN_EXHAUSTED;
 }

 public boolean isJMX_ENABLED() {
 return JMX_ENABLED;
 }
 /**
 * 判斷傳入的數(shù)據(jù)是否為純數(shù)字構(gòu)成
 * @param str
 * @return
 */
 public boolean isNumeric(String str) {
 if(str==null || "".equals(str)){
 return false;
 }
 for (int i = 0; i  str.length(); i++) {
 if (!Character.isDigit(str.charAt(i))) {
 return false;
 }
 }
 return true;
 }

 public String getLUASHA() {
 return LUASHA;
 }

 public void setLUASHA(String lUASHA) {
 LUASHA = lUASHA;
 }

 public String getREDIS_PASS() {
 return REDIS_PASS;
 }

 public void setREDIS_PASS(String rEDIS_PASS) {
 REDIS_PASS = rEDIS_PASS;
 }

 public int getREDIS_DB() {
 return REDIS_DB;
 }

 public void setREDIS_DB(int rEDIS_DB) {
 REDIS_DB = rEDIS_DB;
 }
}

/**
 * jedis的連接池,返回未封裝的jedis對象
 * 一般只有在RedisCache類提供的操作粒度不足使用時才使用此類提供的原生jedis方法
 * @author Hector
 *
 */
public class RedisPool {
 
 private static JedisPool jedisPool = null;
 
 /**
  * 初始化Redis連接池
  */
 static {
  try {
   RedisPoolConfigure configure = new RedisPoolConfigure();
   JedisPoolConfig config = new JedisPoolConfig();
   config.setBlockWhenExhausted(configure.isBLOCK_WHEN_EXHAUSTED());
   config.setEvictionPolicyClassName(configure.getEVICTION_POLICY_CLASS_NAME());
   config.setJmxEnabled(configure.isJMX_ENABLED());
   config.setMaxIdle(configure.getMAX_IDLE());
   config.setMaxTotal(configure.getMAX_ACTIVE());
   config.setMaxWaitMillis(configure.getMAX_WAIT());
   config.setTestOnBorrow(configure.isTEST_ON_BORROW());
   jedisPool = new JedisPool(config, configure.getADDR(), configure.getPORT(), configure.getTIME_OUT(),configure.getREDIS_PASS(),configure.getREDIS_DB());
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
 
 /**
  * 獲取Jedis實例
  * @return
  */
 public synchronized static Jedis getJedis() {
  Jedis resource=null;
  try {
   if (jedisPool != null) {
    resource = jedisPool.getResource();
    return resource;
   } else {
    return null;
   }
  } catch (Exception e) {
   e.printStackTrace();
   return null;
  }
 }
 
 
 /**
  * 釋放jedis資源
  * @param jedis
  */
 public static void close(final Jedis jedis) {
  if (jedis != null) {
   jedis.close();
  }
 }
 
 public static JedisPool getJedisPool() {
 return jedisPool;
 }
}