java中Redis工具类

Redis的应用

/**
 * @文件名 RedisUtil.java
 * @包名 com.cngrain.universe
 * @说明 Redis java操作类
 * @作者 
 * @时间 
 * @版本 V1.0
 */ 

import com.alibaba.fastjson.JSONObject;
import com.cngrain.entity.TbMemberOperator;
import com.cngrain.entity.TbSysUser;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;
import redis.clients.util.Pool;

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


/**
 * @类名 RedisUtil
 * @描述 Redis java操作类
 * @作者 
 * @日期 2015年6月19日 下午5:07:06
 * ========修改日志=======
 *
 */
public class RedisUtil {

	/*
	 *  是否为集群
	 */
	public static boolean isCluster = false;
	/*
	 * server信息
	 */
	public static String serverInfo = null;
	/*
	 *  在应用初始化的时候生成连接池
	 */
	private static Pool<Jedis> pool = null;
	/*
	 * server信息List
	 */
	private static List<String> serverList = new ArrayList<String>();
	
	// 在应用初始化的时候生成连接池
//		private static Pool<Jedis> pool = null;
//		
//		private static boolean isCluster = false;
//		
//		private static List<String> serverList = new ArrayList<String>();
		
	static {
		try {
			Properties prop = new Properties(); 
			InputStream in = RedisUtil.class.getClassLoader().getResourceAsStream("redis.properties");
			prop.load(in);
			in.close();
			
			String mode = prop.getProperty("mode");
			
			if("cluster".equals(mode)){
				//集群模式
				isCluster = true;
				
			}else{
				//单服务器模式
				isCluster= false;
			}
			
			String server = prop.getProperty("servers");
			System.out.println("mode:"+mode+".servers"+server);
			serverInfo = server;
			String[] servers = server.split(",");
			for(String str : servers){
				serverList.add(str.trim());
			}
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	private static Pool<Jedis> getPool(){
		
		if(null == pool){
			
			if(isCluster){
				Set<String> sentinels = new HashSet<String>(16);
				
				if(serverList.size()>0){
					for(String server : serverList){
						sentinels.add(server);
					}
				}
				
				GenericObjectPoolConfig config = new GenericObjectPoolConfig();
				
				//连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
				config.setBlockWhenExhausted(true);
				
				//设置的逐出策略类名, 默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)
				config.setEvictionPolicyClassName("org.apache.commons.pool2.impl.DefaultEvictionPolicy");
				
				//是否启用pool的jmx管理功能, 默认true
				config.setJmxEnabled(true);
				
				//是否启用后进先出, 默认true
				config.setLifo(true);
				
				//最大连接数, 默认8个
				config.setMaxTotal(1500);
				
				//获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
				config.setMaxWaitMillis(-1);
				
				//最大空闲连接数, 默认8个
				config.setMaxIdle(60);
				
				//最小空闲连接数, 默认0
				config.setMinIdle(0);
				
				//逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
				config.setMinEvictableIdleTimeMillis(1800000);
				
				//每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
				config.setNumTestsPerEvictionRun(3);
				
				//对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出,不再根据MinEvictableIdleTimeMillis判断  (默认逐出策略)   
				config.setSoftMinEvictableIdleTimeMillis(1800000);
				
				//在获取连接的时候检查有效性, 默认false
				config.setTestOnBorrow(false);
				
				//在空闲时检查有效性, 默认false
				config.setTestWhileIdle(false);
				
				//逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
				config.setTimeBetweenEvictionRunsMillis(-1);
				
				pool = new JedisSentinelPool("redismaster", sentinels, config, 100000);
			}else{
				JedisPoolConfig config = new JedisPoolConfig();
				config.setMaxIdle(10);
				config.setMaxTotal(30);
				config.setMaxWaitMillis(3*1000);
				
				String server = serverList.get(0);
				
				String[] temp = server.split(":");
				int port = Integer.parseInt(temp[1]);
				
				pool = new JedisPool(config, temp[0], port);
			}
			
		}
		
		return pool;
		
	}

	/**
	 * 
	 * @throws Exception 
	 * @名称 get
	 * @描述 获取字符型key的value数据
	 * @参数 @param key
	 * @参数 @return
	 * @返回值 String
	 * @作者 
	 * @时间 2015年7月11日 下tokenToType午3:58:32
	 */
	public static String get(String key){

		String value = null;
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			value = jedis.get(key);
	    } catch (Exception e) {
			e.printStackTrace();
//			throw e;
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}

		return value;
	}

	/**
	 * 
	 * @名称 get
	 * @描述 获取字符型key的value数据
	 * @参数 @param key
	 * @参数 @return
	 * @返回值 byte[]
	 * @作者 
	 * @时间 2015年7月11日 下午4:00:41
	 */
	public static byte[] get(byte[] key) {

		byte[] value = null;
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			value = jedis.get(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}

		return value;
	}
	
	/**
	 * 
	 * @名称 set
	 * @描述 设置字符型key和value
	 * @参数 @param key
	 * @参数 @param value
	 * @返回值 void
	 * @作者 
	 * @时间 2015年7月11日 下午4:01:01
	 */
	public static void set(String key,String value) {

		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.set(key, value);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}
	
	/**
	 * 
	 * @名称 set
	 * @描述 设置字符型key和value
	 * @参数 @param key
	 * @参数 @param value
	 * @返回值 void
	 * @作者 
	 * @时间 2015年7月11日 下午4:01:43
	 */
	public static void set(byte[] key, byte[] value) {

		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.set(key, value);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}

	/**
	 * 
	 * @名称 set
	 * @描述 设置字符型key和value 及过期时间
	 * @参数 @param key
	 * @参数 @param value
	 * @参数 @param time
	 * @返回值 void
	 * @作者 
	 * @时间 2015年7月11日 下午4:02:22
	 */
	public static void set(byte[] key, byte[] value, int time) {

		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.set(key, value);
			jedis.expire(key, time);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}

	/**
	 * 
	 * @名称 hset
	 * @描述 保存散列key的 field和 value
	 * @参数 @param key
	 * @参数 @param field
	 * @参数 @param value
	 * @返回值 void
	 * @作者 
	 * @时间 2015年7月11日 下午4:02:51
	 */
	public static void hset(byte[] key, byte[] field, byte[] value) {
		
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.hset(key, field, value);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}

	/**
	 * 
	 * @名称 hset
	 * @描述 保存散列key的 field和 value
	 * @参数 @param key
	 * @参数 @param field
	 * @参数 @param value
	 * @返回值 void
	 * @作者 
	 * @时间 2015年7月11日 下午4:03:57
	 */
	public static void hset(String key, String field, String value) {
		
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.hset(key, field, value);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}
	
	/**
	 * 
	 * @名称 mhset
	 * @描述 散列对象设置
	 * @参数 @param key
	 * @参数 @param field
	 * @参数 @param value
	 * @返回值 void
	 * @作者 
	 * @时间 2015年7月11日 上午9:54:10
	 */
	public static void mhset(String key, Map<String, String> hash) {
		
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.hmset(key, hash);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}
	
	/**
	 * 
	 * @名称 llen
	 * @描述 查询list长度
	 * @参数 @param key
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2015年7月11日 下午4:04:14
	 */
	public static long llen(String key) {
		
		Jedis jedis = null;
		long length=0;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			length= jedis.llen(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return length;
	}
	
	/**
	 * 
	 * @名称 llen
	 * @描述 查询list长度
	 * @参数 @param key
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2015年7月11日 下午4:51:57
	 */
	public static long llen(byte[] key) {

		long len = 0;
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.llen(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return len;
	}
	
	/**
	 * 
	 * @名称 hget
	 * @描述 查询散列key中field的value
	 * @参数 @param key
	 * @参数 @param field
	 * @参数 @return
	 * @返回值 String
	 * @作者 
	 * @时间 2015年7月11日 下午4:04:47
	 */
	public static String hget(String key, String field) {

		String value = null;
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			value = jedis.hget(key, field);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return value;
	}
	
	/**
	 * 
	 * @名称 hdel
	 * @描述 散列删除
	 * @参数 @param key
	 * @参数 @param field
	 * @参数 @return
	 * @返回值 String
	 * @作者 
	 * @时间 2015年11月10日 下午6:24:51
	 */
	public static Long hdel(String key, String field) {
		
		long value = 0;
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			value = jedis.hdel(key, field);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return value;
	}
	
	/**
	 * 
	 * @名称 hgetAll
	 * @描述  查询散列key 所有键值对
	 * @参数 @param key
	 * @参数 @return
	 * @返回值 Map<String,String>
	 * @作者 
	 * @时间 2015年7月12日 上午11:44:01
	 */
	public static Map<String, String> hgetAll(String key) {
		
		Map<String, String> value = null;
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			value = jedis.hgetAll(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return value;
	}

	/**
	 * 获取数据
	 * 
	 * @param key
	 * @return
	 */
	public static byte[] hget(byte[] key, byte[] field) {

		byte[] value = null;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			value = jedis.hget(key, field);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}

		return value;
	}

	public static void hdel(byte[] key, byte[] field) {

		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.hdel(key, field);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}

	public static void lpush(byte[] key, byte[] value) {

		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.lpush(key, value);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}
	
	public static void lpush(String key, String value) {

		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.lpush(key, value);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}

	public static void rpush(byte[] key, byte[] value) {

		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.rpush(key, value);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}
	
	public static void rpush(String key,String value) {

		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.rpush(key, value);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}

	public static String rpoplpush(String key,String destination) {

		Jedis jedis = null;
		String outValue="";
		try { 
			pool = getPool();
			jedis = pool.getResource();
			outValue = jedis.rpoplpush(key, destination);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return outValue;
	}
	
	public static void rpoplpush(byte[] key, byte[] destination) {

		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.rpoplpush(key, destination);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}

	public static List<byte[]> lpopList(byte[] key) {

		List<byte[]> list = null;
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			list = jedis.lrange(key, 0, -1);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return list;
	}

	public static byte[] rpop(byte[] key) {

		byte[] bytes = null;
		Jedis jedis = null;
		
		try { 
			pool = getPool();
			jedis = pool.getResource();
			bytes = jedis.rpop(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return bytes;
	}
	
	public static String rpop(String key) {

		String result = null;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.rpop(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	public static List<String> brpop(String key) {

		List<String> result = null;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.brpop(0,key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	public static void hmset(Object key, Map<String,String> hash) {
		
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.hmset(key.toString(), hash);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}

	public static void hmset(Object key, Map<String,String> hash, int time) {
		
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.hmset(key.toString(), hash);
			jedis.expire(key.toString(), time);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}

	public static List<String> hmget(Object key, String... fields) {
		
		List<String> result = null;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.hmget(key.toString(), fields);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}

	public static Set<String> hkeys(String key) {
		
		Set<String> result = null;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.hkeys(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	/**
	 * 
	 * @名称 keys
	 * @描述 查询匹配pattern的key 集合
	 * @参数 @param key
	 * @参数 @return
	 * @返回值 Set
	 * @作者 
	 * @时间 2015年7月11日 下午3:19:48
	 */
	public static Set<String> keys(String pattern) {
		
		Set<String> result = null;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.keys(pattern);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	public static List<byte[]> lrange(byte[] key, int from, int to) {
		
		List<byte[]> result = null;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.lrange(key, from, to);

	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	public static List<String> lrange(String key, int from, int to) {
		
		List<String> result = null;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.lrange(key, from, to);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	public static Map<byte[], byte[]> hgetAll(byte[] key) {
		
		Map<byte[], byte[]> result = null;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.hgetAll(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}

	/**
	 * 
	 * @名称 del
	 * @描述 删除key
	 * @参数 @param key
	 * @返回值 void
	 * @作者 
	 * @时间 2015年7月11日 下午4:55:25
	 */
	public static void del(byte[] key) {
		
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.del(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}
	
	/**
	 * 
	 * @名称 del
	 * @描述 删除key
	 * @参数 @param key
	 * @返回值 void
	 * @作者 
	 * @时间 2015年7月11日 下午4:55:07
	 */
	public static void del(String key) {

		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.del(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}
	
	/**
	 * 
	 * @名称 flushAll
	 * @描述 清空所有数据
	 * @参数 
	 * @返回值 void
	 * @作者 
	 * @时间 2015年7月11日 下午4:54:47
	 */
	public static void flushAll(){
		
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			jedis.flushAll();
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
	}

	/**
	 * 
	 * @名称 ttl
	 * @描述 返回剩余时间
	 * @参数 @param key
	 * @参数 @return 
	 * 			-2 键不存在。
	 * 			-1 键存在，但没有设置过期时间或者生存时间。
	 * 			>= 0 键的剩余生存时间。
	 * @返回值 long
	 * @作者 
	 * @时间 2015年7月7日 下午5:40:04
	 */
	public static long ttl(String key) {

		long time = 0;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			time = jedis.ttl(key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return time;
	}
	
	/**
	 * 
	 * @名称 expire
	 * @描述 设置键的生存时间
	 * @参数 @param key 
	 * @参数 @param seconds 时间单位 秒
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2015年7月7日 下午5:36:54
	 */
	public static long expire(String key, int seconds) {

		long len = 0;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			len = jedis.expire(key, seconds);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return len;
	}

	/**
	 * 
	 * @名称 setnx
	 * @描述 设置不存在的key
	 * @参数 @param key
	 * @参数 @param value
	 * @参数 @return 1:设置成功。0：设置失败。
	 * @返回值 long
	 * @作者 
	 * @时间 2015年7月8日 下午3:29:01
	 */
	public static long setnx(String key, String value) {
		
		long result = 0;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.setnx(key, value);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	/**
	 * 
	 * @名称 sismember
	 * @描述  set集合操作：检查给定的元素是否存在于集合
	 * @参数 @param setkey
	 * @参数 @param key
	 * @参数 @return true 存在， false 不存在
	 * @返回值 boolean
	 * @作者 
	 * @时间 2015年7月11日 下午4:49:54
	 */
	public static boolean sismember(String setkey, String key) {
		
		boolean result = false;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.sismember(setkey, key);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	/**
	 * 
	 * @名称 sadd
	 * @描述 set集合操作：集合中添加一个元素
	 * @参数 @param setkey
	 * @参数 @param memeber
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2015年7月11日 下午5:12:40
	 */
	public static long sadd(String setkey, String memeber) {
		
		long result = 0 ;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.sadd(setkey, memeber);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	/**
	 * 
	 * @名称 srem
	 * @描述 set集合操作：集合中删除一个元素
	 * @参数 @param setkey
	 * @参数 @param memeber
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2015年7月11日 下午5:30:30
	 */
	public static long srem(String setkey, String memeber) {
		
		long result = 0 ;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.srem(setkey, memeber);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	/**
	 * @名称 smembers
	 * @描述 set集合操作：获取集合
	 * @参数 @param setKey
	 * @参数 @return
	 * @返回值 Set<String>
	 * @作者 
	 * @时间 2016年1月19日 下午2:04:24
	 */
	public static Set<String> smembers(String setKey){
		Set<String> result = null;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.smembers(setKey);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}

	/**
	 * 
	 * @名称 info
	 * @描述 查看服务器当前的状态信息和统计信息
	 * @参数 @return
	 * @返回值 String
	 * @作者 
	 * @时间 2015年8月3日 下午2:33:55
	 */
	public static String info() {
		
		String result = "";
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.info();
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	/**
	 * 
	 * @名称 zadd
	 * @描述 
	 * @参数 @return
	 * @返回值 Integer reply, specifically: 
	 * 				1 if the new element was added 
	 * 				0 if the element was already a member of the sorted set and the score was updated
	 * @作者 
	 * @时间 2015年8月12日 上午9:40:32
	 */
	public static long zadd(String key, double score, String element) {
		
		long result = 0;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.zadd(key, score, element);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	/**
	 * 
	 * @名称 zrem
	 * @描述 TODO(根据element删除zset)
	 * @参数 @param key
	 * @参数 @param element
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2015-8-27 上午10:48:52
	 */
	public static long zrem(String key, String element) {
		
		long result = 0;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.zrem(key,element);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	/**
	 * 
	 * @名称 zadd
	 * @描述 TODO(批量添加 zset)
	 * @参数 @param key
	 * @参数 @param scoreMembers
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2015-8-27 上午10:55:45
	 */
	public static long zadd(String key,Map<String,Double> scoreMembers) {
		
		long result = 0;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.zadd(key, scoreMembers);
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	/**
	 * 
	 * @名称 zrem
	 * @描述 TODO(批量删除ZSET list elements)
	 * @参数 @param key
	 * @参数 @param elements
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2015-8-27 上午10:54:57
	 */
	public static long zrem(String key,List<String> elements) {
		long result = 0;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			for (String element : elements) {
				result = jedis.zrem(key, element);
			}
	    } catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		return result;
	}
	
	/**
	 * 
	 * @throws Exception 
	 * @名称 incr
	 * @描述 针对数字值递增一
	 * @参数 @param key
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2015年8月14日 下午4:46:45
	 */
//	public static long incr(String key) throws Exception {
	public static long incr(String key) {
		
		long result = 0;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.incr(key);
	    } catch (Exception e) {
			e.printStackTrace();
//			throw e;
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}
	
	/**
	 * @名称 decr
	 * @描述 针对数字值递减一
	 * @参数 @param key
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2016年3月3日 下午3:49:47
	 */
	public static long decr(String key){
		long result = 0;
		Jedis jedis = null;
		try { 
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.decr(key);
	    } catch (Exception e) {
			e.printStackTrace();
//			throw e;
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		
		return result;
	}

	/**
	 * @Description: 根据参数 count 的值，移除列表中与参数 value 相等的元素。根据参数 count 的值，移除列表中与参数 value 相等的元素。
	 * @param: count 的值可以是以下几种：
	 * count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
	 * count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
	 * count = 0 : 移除表中所有与 value 相等的值。
	 * @return:
	 * @auther: 
	 * @date: 2018-12-3 18:58
	 */
	public static long lrem(String key, long count, String value){
		Jedis jedis = null;
		long lrem = 0;
		try {
			pool = getPool();
			jedis = pool.getResource();
			lrem = jedis.lrem(key, count, value);
		} catch (Exception e) {
			e.printStackTrace();
//			throw e;
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}

		return lrem;
	}

	/**
	 *
	 * @名称 zremByScore
	 * @描述	根据分值删除element
	 * 		zremrangebyscore(key, min, max) ：删除名称为key的zset中score >= min且score <= max的所有元素
	 * @参数 @param key
	 * @参数 @param score
	 * @参数 @return
	 * @返回值 long
	 * @作者 
	 * @时间 2018-9-13 下午4:16:10
	 */
	public static long zremByScore(String key,String score) {
		long result = 0;
		Jedis jedis = null;
		try {
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.zremrangeByScore(key, score, score);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		return result;
	}

	/**
	 *
	 * @名称 exists
	 * @描述	是否存在键值
	 * @参数 @param key
	 * @参数 @return
	 * @返回值 boolean
	 * @作者 
	 * @时间 2018-9-13 下午4:16:10
	 */
	public static boolean exists(String key) {
		boolean result = false;
		Jedis jedis = null;
		try {
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.exists(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		return result;
	}

	/**
	 *
	 * @名称 zrange
	 * @描述	获取zset key中start到end的元素
	 * @参数 @param key
	 * @参数 @param start
	 * @参数 @param end
	 * @参数 @return
	 * @返回值 Set<String>
	 * @作者 
	 * @时间 2018-9-13 下午4:16:10
	 */
	public static Set<String> zrange(String key,long start,long end) {
		Set<String> result = null;
		Jedis jedis = null;
		try {
			pool = getPool();
			jedis = pool.getResource();
			result = jedis.zrange(key, start, end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		return result;
	}

	/**
	 *
	 * @名称 zcount
	 * @描述	zset大小
	 * @参数 @param key
	 * @参数 @return
	 * @返回值 boolean
	 * @作者 
	 * @时间 2018-9-13 下午4:16:10
	 */
	public static long zcount(String key) {
		long result = 0;
		Jedis jedis = null;
		try {
			pool = getPool();
			jedis = pool.getResource();
			//zcount(final String key, final String min, final String max) 无限
			result = jedis.zcount(key, "-inf", "+inf");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//返还到连接池
			if(jedis != null){ jedis.close();}
		}
		return result;
	}

	public static TbSysUser tokenToUser(String token) {
		if(token==null||token.isEmpty()) {
			return null;
		}
		JSONObject jsStr = JSONObject.parseObject(get(token+"_info"));
		return JSONObject.toJavaObject(jsStr, TbSysUser.class);
	}

	/***
	 * @名称 tokenToMember
	 * @描述 通过token获取前台用户信息
	 * @参数 [token]
	 * @返回值 com.cngrain.entity.TbMemberOperator
	 * @作者 
	 * @时间 2018/9/25 19:00
	 */
	public static TbMemberOperator tokenToMember(String token) {
		if(token==null||token.isEmpty()) {
			return null;
		}
		JSONObject jsStr = JSONObject.parseObject(get(token+"_info"));
		return JSONObject.toJavaObject(jsStr, TbMemberOperator.class);
	}

	/***
	 * @名称 tokenToType
	 * @描述 通过token获取产后服务系统当前登录用户为前台用户还是后台用户
	 * @参数 [token]
	 * @返回值 String
	 * @作者 
	 * @时间 2018/9/25 19:00
	 */
	public static String tokenToType(String token) {
		if(token==null||token.isEmpty()) {
			return null;
		}
		return get(token+"_type");
	}


	
	public static void main(String[] args) {
		System.out.println(tokenToUser("").getPassword());
	}

}