Redis 切片池与非切片池，连接指定库以及基本配置

Redis 是一个开源、支持网络、基于内存、键值对存储数据库。  
  
关于切片池和非切片池的区别，  一般项目基本都使用非切片池；切片池主要用于分布式项目，可以设置主从Redis库。  
  

如果需要指明Redis连接第几个库，需要在使用Redis进行数据操作之前使用如下语句：  

Jedis resource = jedisPool.getResource();  

resource.select(1);  

注意：select(1)表示指定Redis库的第二个库（第一个用0）。  
  
使用最新Redis jar包可以发现，释放redis连接的方法  jedisPool.returnResource(jedis);  在Redis3.0之后不再推荐使用，改为 jedis.close(); 来代替：  

starting from Jedis 3.0 this method will not be exposed. Resource cleanup should be done using @see Jedis.close()  

查看Redis数据库，我们可以通过 Redis桌面管理工具 在windows下查看。

软件下载地址：

Redis jar包

Redis桌面管理工具

以下提供Redis的基本操作类：  

/**
 * 主要用来给用户提供一个设计完备的，通过jedis的jar包来管理redis内存数据库的各种方法
 */
public class RedisManager {
	
	private static Logger log_error = Logger.getLogger("error");
	
	// ip、port、AUTH属性都定义在了config.properties文件中
	private static String host = CfgReader.getParam("REDIS_HOST");
	private static int port = Integer.parseInt(CfgReader.getParam("REDIS_PORT")); 

	//访问密码
    private static String AUTH = CfgReader.getParam("REDIS_AUTH");
    
    //可用连接实例的最大数目，默认值为8；
    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 1024;
    
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 200;
    
    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static int MAX_WAIT = 60000;
    
    private static int TIMEOUT = 60000;
    
    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;
    
	// 设置为0的话就是永远都不会过期
	private static int expire = 0;

	// 定义一个管理池，所有的redisManager共同使用。
	private static JedisPool jedisPool = null;

	public RedisManager() {
	}

	/**
	 * 
	 * 初始化方法,在这个方法中通过host和port来初始化jedispool。
	 * 
	 */
	public static void init() {
		try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxIdle(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            if(RegexUtil.isEmpty(AUTH)) {
            	jedisPool = new JedisPool(config, host, port, TIMEOUT, AUTH);
            } else {
            	jedisPool = new JedisPool(config, host, port, TIMEOUT);
            }
        } catch (Exception e) {
            e.printStackTrace();
			log_error.error("-- Redis 连接出错--host="+host+",port="+port+",错误原因" + e);
        }
	}
	
    /**
     * 获取Jedis实例
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                resource.select(1);				//设置为第二个库（db1）
                return resource;
            } else {
    			MSGSendUtils.getInstance().sendMSG(CfgReader.getParam("error_name"), CfgReader.getParam("error_phone"), 
    					"获取的Redis链接为null");
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
			MSGSendUtils.getInstance().sendMSG(CfgReader.getParam("error_name"), CfgReader.getParam("error_phone"), 
					"获取Redis链接出错：" + e.getMessage());
            return null;
        }
    }
    
	/**
	 * get value from redis
	 * 
	 * @param key
	 * @return
	 */
	public static byte[] get(byte[] key) {
		byte[] value = null;
		Jedis jedis = getJedis();
		try {
			value = jedis.get(key);
		} finally {
			jedis.close();
		}
		return value;
	}

	/**
	 * get value from redis
	 * 
	 * @param key
	 * @return
	 */
	public static String get(String key) {
		String value = null;
		Jedis jedis = getJedis();
		try {
			value = jedis.get(key);
		} finally {
			jedis.close();
		}
		return value;
	}

	/**
	 * set
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public static void set(byte[] key, byte[] value) {
		Jedis jedis = getJedis();
		try {
			jedis.set(key, value);
			if (expire != 0) {
				jedis.expire(key, expire);
			}
		} finally {
			jedis.close();
		}
	}

	/**
	 * set
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public static void set(String key, String value) {
		Jedis jedis = getJedis();
		try {
			jedis.set(key, value);
			if (expire != 0) {
				jedis.expire(key, expire);
			}
		} finally {
			jedis.close();
		}
	}

	/**
	 * set
	 * 
	 * @param key
	 * @param value
	 * @param expire
	 * @return
	 */
	public static void set(byte[] key, byte[] value, int expire) {
		Jedis jedis = getJedis();
		try {
			jedis.set(key, value);
			if (expire != 0) {
				jedis.expire(key, expire);
			}
		} finally {
			jedis.close();
		}
	}

	/**
	 * set
	 * 
	 * @param key
	 * @param value
	 * @param expire
	 * @return
	 */
	public static void set(String key, String value, int expire) {
		Jedis jedis = getJedis();
		try {
			jedis.set(key, value);
			if (expire != 0) {
				jedis.expire(key, expire);
			}
		} finally {
			jedis.close();
		}
	}

	/**
	 * del
	 * 
	 * @param key
	 */
	public static void del(byte[] key) {
		Jedis jedis = getJedis();
		try {
			jedis.del(key);
		} finally {
			jedis.close();
		}
	}

	/**
	 * del
	 * 
	 * @param key
	 */
	public static void del(String key) {
		Jedis jedis = getJedis();
		try {
			jedis.del(key);
		} finally {
			jedis.close();
		}
	}

	/**
	 * 判断指定键是否存在
	 * @param key
	 * @return
	 */
	public static boolean exists(String key) {
		Jedis jedis = getJedis();
		boolean flag = jedis.exists(key);
		jedis.close();
		return flag ;
	}
	
	/**
	 * 获取key对应的值剩余存活时间
	 * @param key
	 * @return
	 * 		正数：剩余的时间(秒)
	 * 		负数：已过期
	 */
	public static Long ttlKey(String key) {
		Jedis jedis = getJedis();
		try {
			return jedis.ttl(key);
		} catch(Exception e) {
			log_error.error(" -- Redis 获取key对应的值剩余存活时间出错，出错原因：" + e);
			e.printStackTrace();
			return 0L;
		} finally {
			jedis.close();
		}
	}
	
	/**
	 * 获取key对应的值剩余存活时间
	 * @param key
	 * @return
	 * 		正数：剩余的时间(秒)
	 * 		负数：已过期
	 */
	public static Long ttlKey(byte[] key) {
		Jedis jedis = getJedis();
		try {
			return jedis.ttl(key);
		} catch(Exception e) {
			log_error.error(" -- Redis 获取key对应的值剩余存活时间出错，出错原因：" + e);
			e.printStackTrace();
			return 0L;
		} finally {
			jedis.close();
		}
	}
	
	/**
	 * 存储对象
	 * @param key
	 * @param obj
	 * @param expire
	 */
	public static void setObject(String key,Object obj,int expire) {
		byte[] data = ObjTOSerialize(obj);
		Jedis jedis = getJedis();
		jedis.set(key.getBytes(),data);
		if(expire != 0) {
			jedis.expire(key, expire);
		}
		jedis.close();
	}
	
	/**
	 * 获取对象
	 * @param key
	 * @return
	 */
	public static Object getObject(String key) {
		Jedis jedis = getJedis();
		byte[] data = jedis.get(key.getBytes());
		Object obj = null;
		if(data != null) {
			obj = unSerialize(data);
		}
		jedis.close();
		return obj;
	}
	
	/**
	 * 
	 * 序列化一个对象
	 * @param obj
	 * @return
	 */
	public static byte[] ObjTOSerialize(Object obj) {
		ObjectOutputStream oos = null;
		ByteArrayOutputStream byteOut = null;
		try {
			byteOut = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(byteOut);
			oos.writeObject(obj);
			byte[] bytes = byteOut.toByteArray();
			return bytes;
		} catch (Exception e) {
			log_error.error("-- Redis序列化对象出错："+e);
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 反序列化一个对象
	 * @param bytes
	 * @return
	 */
	public static Object unSerialize(byte[] bytes) {
		ByteArrayInputStream in = null;
		try {
			in = new ByteArrayInputStream(bytes);
			ObjectInputStream objIn = new ObjectInputStream(in);
			return objIn.readObject();
		} catch (Exception e) {
			log_error.error("-- Redis反序列化对象出错："+e);
			e.printStackTrace();
		}
		return null;
	}

}