package com.jedis.mq;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * 属性配置类
 *
 */
public class Configuration extends Properties {
	private static final long serialVersionUID = 50440463580273222L;
	private static Configuration instance = null;

	public static synchronized Configuration getInstance() {
		if (instance == null) {
			instance = new Configuration();
		}
		return instance;
	}

	public String getProperty(String key, String defaultValue) {
		String val = getProperty(key);
		return (val == null || val.isEmpty()) ? defaultValue : val;
	}

	public String getString(String name, String defaultValue) {
		return this.getProperty(name, defaultValue);
	}

	public int getInt(String name, int defaultValue) {
		String val = this.getProperty(name);
		return (val == null || val.isEmpty()) ? defaultValue : Integer.parseInt(val);
	}

	public long getLong(String name, long defaultValue) {
		String val = this.getProperty(name);
		return (val == null || val.isEmpty()) ? defaultValue : Integer.parseInt(val);
	}

	public float getFloat(String name, float defaultValue) {
		String val = this.getProperty(name);
		return (val == null || val.isEmpty()) ? defaultValue : Float.parseFloat(val);
	}

	public double getDouble(String name, double defaultValue) {
		String val = this.getProperty(name);
		return (val == null || val.isEmpty()) ? defaultValue : Double.parseDouble(val);
	}

	public byte getByte(String name, byte defaultValue) {
		String val = this.getProperty(name);
		return (val == null || val.isEmpty()) ? defaultValue : Byte.parseByte(val);
	}

	public Configuration() {
		InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream("config.xml");
		try {
			this.loadFromXML(in);
			in.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

package com.jedis;

import java.util.HashMap;
import java.util.Map;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Redis工具类,用于获取RedisPool. You shouldn't use the same instance from different
 * threads because you'll have strange errors. And sometimes creating lots of
 * Jedis instances is not good enough because it means lots of sockets and
 * connections, which leads to strange errors as well. A single Jedis instance
 * is not threadsafe! To avoid these problems, you should use JedisPool, which
 * is a threadsafe pool of network connections. This way you can overcome those
 * strange errors and achieve great performance. To use it, init a pool:
 * JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost"); You can
 * store the pool somewhere statically, it is thread-safe. JedisPoolConfig
 * includes a number of helpful Redis-specific connection pooling defaults. For
 * example, Jedis with JedisPoolConfig will close a connection after 300 seconds
 * if it has not been returned.
 */
@SuppressWarnings("deprecation")
public class JedisUtil {
	private static Map<String, JedisPool> maps = new HashMap<String, JedisPool>();

	/**
	 * 私有构造器
	 *
	 */
	private JedisUtil() {
	}

	/**
	 * 获取连接池
	 * 
	 * @return 连接池实例
	 */
	private static JedisPool getPool(String ip, int port) {
		String key = ip + ":" + port;
		JedisPool pool = null;
		if (!maps.containsKey(key)) {
			JedisPoolConfig config = new JedisPoolConfig();
			config.setMaxIdle(10);
			config.setMaxWaitMillis(1000);
			config.setTestOnBorrow(true);
			config.setTestOnReturn(true);
			try {
				/**
				 * 如果你遇到 java.net.SocketTimeoutException: Read timed out
				 * exception的异常信息 请尝试在构造JedisPool的时候设置自己的超时值.
				 * JedisPool默认的超时时间是2秒(单位毫秒)
				 */
				pool = new JedisPool(config, ip, port, 30);
				maps.put(key, pool);
			} catch (Exception e) {
				e.printStackTrace();
			}
		} else {
			pool = maps.get(key);
		}
		return pool;
	}

	/**
	 * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载
	 */
	private static class RedisUtilHolder {
		/**
		 * 静态初始化器，由JVM来保证线程安全
		 */
		private static JedisUtil instance = new JedisUtil();
	}

	/**
	 * 当getInstance方法第一次被调用的时候，它第一次读取RedisUtilHolder.instance，导致RedisUtilHolder类得到初始化
	 * 而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建RedisUtil的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性
	 * 这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本
	 *
	 */
	public static JedisUtil getInstance() {
		return RedisUtilHolder.instance;
	}

	/**
	 * 获取Redis实例
	 * 
	 * @return Redis工具类实例
	 */
	public Jedis getJedis(String ip, int port) {
		Jedis jedis = null;
		int count = 0;
		do {
			try {
				jedis = getPool(ip, port).getResource();
			} catch (Exception e) {
				// 销毁对象
				getPool(ip, port).returnBrokenResource(jedis);
			}
			count++;
		} while (jedis == null && count < 10);
		return jedis;
	}

	/**
	 * 释放redis实例到连接池
	 * 
	 * @param jedis redis实例
	 */
	public void closeJedis(Jedis jedis, String ip, int port) {
		if (jedis != null) {
			getPool(ip, port).returnResource(jedis);
		}
	}
}