有关java中Redis使用的理解

过年之后项目中也开始使用redis了.使用学习了redis也一段时间了，说一下使用学习总结的东西.首先Redis有2个作用：一个是作为nosql非关系型数据库存储数据（非关系行数据库指的就是无法通过字段关联 实现关联查询，常见的有内查询与外查询，左连接，右连接等）,另一个作用就是类似缓存存储服务器，存储一些会过期的数据（这主要是由于Redis可以设置key的有效期）

为什么使用Redis

• Redis读写性能高，平均redis写入数据每秒在8W左右，读取速度在11W左右.
• Redis作为数据库的特点，有事务控制，虽然没什么鸟用，前面存了的数据 还是存了，压根不会回滚。存储数据量大，可以主从数据库复制（听过没用过）
• Redis是作为缓存服务器的特点,支持存储的数据结构类型由5种，包含String,List,HashMap,有序集合，无序集合
• Redis支持Key超时，通过作为分布式缓存服务解决方案.可以用来存储一些会过期的缓存数据.

Redis存储的数据结构
redis存储的数据结构是key-value形式的，这样value存储的数据类型就支持很多，比如有string,List,HashMap(存储对象很常用)，有序集合（通过score自动排序），无序集合.其中最常用的应该是 前面4种。具体在下面降到

• String:相比这种数据类型是用来存储session最常用到的。设置和读取string数据的方法为set get.

• HashMap<key,value>这种数据类型用来存储对象用到的最多，因为HashMap是key-value形式的，所以特别适合存储像对象这种字段名对应字段值的数据类型.实际项目中可能是redis创建一个HashMap集合，用于临时缓存客户下单或永久存储购买数量及金额信息. 存入数据的方法为hset hget key field–>value

• List列表.主要是指的存储字符串列表.项目中我用来永久缓存 客户购买电池片数量的信息.将电池片编号 加入到List集合中，当然也可以将list放入HashMap的value中去，但是感觉这样太过复杂了。读取和放入的方法为lrange 0 10,lpush key value

• Set无序集合：首先这个数据结构是来自HashMap中的所有的key值，如果因为是没有顺序的，所以重复添加数据是只有一个保存的.放入数据和读取的方法为sadd key,smembers key;

• Zset有序集合，向有序集合中存入数据 可以自动排序(与Set一样不允许重复的value值)。原理是通过放入与分数关联value值。比如zadd key 0 “a”,zadd key 1 “b”;
  那么ZRANGESCORE 0 1；读取出来的顺序 就是上面按照让如key值中0~1的顺序.
  Redis中的常用命令

• 运行redis，进入Redis安装目录,window下运行redis-cli.exe客户端，linux下运行./redis-cli 即可，然后auth password进入即可，具体界面如下
  
  Redis5中数据结构读取
  虽然上面在介绍这5种数据结构的时候已经讲到了，但是还是强调下，毕竟很重要的。

• String: get set

• HashMap:hget hset

• List:lrange 0 100,lpush key value

• Set:sadd key score value,smembers key

• ZSet:zadd key,ZRANGE KEY X X

Redis在SSM框架中的配置
本来项目中有关Redis的配置已经由架构师搭好了，不怎么改动的，只需要redis配置文件在哪里，相关redis客户端账号密码在哪个配置文件就好的.但是项目经理突然将要用Spirng带的redis工具类，说是lura语言中需要实现redis序列化。本来是用Jedis的存储数据是string类型完全够用了，但是为了能够兼容项目经理写的lura语言那就用嘛。因为spring提供的redsi管理 也包括redis连接池，读取，放入，删除key等操作，最重要的是可以处理对象，而Jedis也就是最常用的只包含了string类型的处理，如果要处理对象还要自己写比较麻烦 不划算.下面介绍下我常用的在SSM框架中 使用方式

1. Redis.xml配置文件方式org.springframework.data.redis.core.RedisTemplate

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:task="http://www.springframework.org/schema/task"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/task
	http://www.springframework.org/schema/task/spring-task.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd">
		
	<!-- ==============================Redis============================== -->

	<!-- redis 配置信息 -->
	<!-- ==============================Redis============================== -->
	
	<!-- redis session config -->
	<bean class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">
		<property name="maxInactiveIntervalInSeconds" value="1200"/>
	</bean>
	<!--
	<bean class="org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory">
		<property name="hostName" value="${redis.host}"/>
	    <property name="port" value="6379"/>
	    <property name="password" value="${redis.pass"/>
	</bean>
	-->
	<!-- redis configuration -->
	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxIdle" value="300" /> <!-- 最大能够保持idel状态的对象数  -->
		<property name="maxTotal" value="60000" /> <!-- 最大分配的对象数 -->
		<property name="testOnBorrow" value="true" /> <!-- 当调用borrow Object方法时，是否进行有效性检查 -->
	</bean>
	
	<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="hostName" value="${redis.host}" />
		<property name="port" value="${redis.port}" />
		<property name="poolConfig" ref="jedisPoolConfig" />
		<property name="password" value="${redis.pass}"></property>
		<property name="usePool" value="true" />
	</bean>

	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="jedisConnectionFactory" />
		<property name="keySerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="valueSerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="hashKeySerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="hashValueSerializer">
			<bean
				class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />
		</property>
	</bean>   
</beans>

代码中使用方法：加入注解，使用注解调用相关api

	@Autowired
	private RedisTemplate<String, Object> redisTemplate;
	//放入有序集合ZSet
	redisTemplate.opsForZSet().add(rank_key_day, rank_member_day, Double.parseDouble(amount_day));

2. Jedis方式，一般将Jedis的方式封装为工具类，包含了线程池读取Jedis连接
   各种数据类型存 取 删的操作。

package com.bxd.core.util;


import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.support.PropertiesLoaderUtils;

import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


public class RedisUtil {
	private static final Logger LOGGER = LoggerFactory.getLogger(RedisUtil.class);  
    private static JedisPool pool = null;  
  
    private static String host;
    private static int port;
    private static int timeout;
    private static String pass;
    public static Properties properties = null;
    static{
    	//使用配置文件中有关redis的配置,存放有关
		if (properties == null) { 
			try {
				properties = new Properties();
				//本地环境
				properties=PropertiesLoaderUtils.loadAllProperties("config/dbconfig.properties");
				//测试环境
//				InputStream in = new BufferedInputStream(new FileInputStream(System.getProperty("catalina.home") + "/webapps/config/" +"dbconfig.properties"));
//				properties.load(in);
				host = properties.getProperty("redis.host");
		    	port = Integer.valueOf( properties.getProperty("redis.port"));
		    	timeout = Integer.valueOf( properties.getProperty("redis.timeout"));
		    	pass =  properties.getProperty("redis.pass");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
    }
    
    private static RedisUtil ru = new RedisUtil();  
     

    
    public RedisUtil() {  
        if (pool == null) {  
           
            JedisPoolConfig config = new JedisPoolConfig();  
            // 控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；  
            // 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。  
            config.setMaxTotal(10000);  
            // 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。  
            config.setMaxIdle(2000);  
            // 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；  
            config.setMaxWaitMillis(1000 * 100);  
            config.setTestOnBorrow(true);  
            pool = new JedisPool(config, host, port, timeout,pass);  
        }  
          
    }  
  
    /** 
     * <p>通过key获取储存在redis中的value</p> 
     * <p>并释放连接</p> 
     * @param key 
     * @return 成功返回value 失败返回null 
     */  
    public String get(String key){  
        Jedis jedis = null;  
        String value = null;  
        try {  
            jedis = pool.getResource();  
            value = jedis.get(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return value;  
    }  
  
    /** 
     * <p>向redis存入key和value,并释放连接资源</p> 
     * <p>如果key已经存在 则覆盖</p> 
     * @param key 
     * @param value 
     * @return 成功 返回OK 失败返回 0 
     */  
    public String set(String key,String value){  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.set(key, value);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
            return "0";  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  
  
  
    /** 
     * <p>删除指定的key,也可以传入一个包含key的数组</p> 
     * @param keys 一个key  也可以使 string 数组 
     * @return 返回删除成功的个数 
     */  
    public Long del(String...keys){  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.del(keys);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  
  
    /** 
     * <p>通过key向指定的value值追加值</p> 
     * @param key 
     * @param str 
     * @return 成功返回 添加后value的长度 失败 返回 添加的 value 的长度  异常返回0L 
     */  
    public Long append(String key ,String str){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.append(key, str);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>判断key是否存在</p> 
     * @param key 
     * @return true OR false 
     */  
    public Boolean exists(String key){  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.exists(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
            return false;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  
  
    /** 
     * <p>设置key value,如果key已经存在则返回0,nx==> not exist</p> 
     * @param key 
     * @param value 
     * @return 成功返回1 如果存在 和 发生异常 返回 0 
     */  
    public Long setnx(String key ,String value){  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.setnx(key, value);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  
  
    /** 
     * <p>设置key value并制定这个键值的有效期</p> 
     * @param key 
     * @param value 
     * @param seconds 单位:秒 
     * @return 成功返回OK 失败和异常返回null 
     */  
    public String setex(String key,String value,int seconds){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.setex(key, seconds, value);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
  
    /** 
     * <p>通过key 和offset 从指定的位置开始将原先value替换</p> 
     * <p>下标从0开始,offset表示从offset下标开始替换</p> 
     * <p>如果替换的字符串长度过小则会这样</p> 
     * <p>example:</p> 
     * <p>value : bigsea@zto.cn</p> 
     * <p>str : abc </p> 
     * <P>从下标7开始替换  则结果为</p> 
     * <p>RES : bigsea.abc.cn</p> 
     * @param key 
     * @param str 
     * @param offset 下标位置 
     * @return 返回替换后  value 的长度 
     */  
    public Long setrange(String key,String str,int offset){  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.setrange(key, offset, str);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  
  
  
  
    /** 
     * <p>通过批量的key获取批量的value</p> 
     * @param keys string数组 也可以是一个key 
     * @return 成功返回value的集合, 失败返回null的集合 ,异常返回空 
     */  
    public List<String> mget(String...keys){  
        Jedis jedis = null;  
        List<String> values = null;  
        try {  
            jedis = pool.getResource();  
            values = jedis.mget(keys);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return values;  
    }  
  
    /** 
     * <p>批量的设置key:value,可以一个</p> 
     * <p>example:</p> 
     * <p>  obj.mset(new String[]{"key2","value1","key2","value2"})</p> 
     * @param keysvalues 
     * @return 成功返回OK 失败 异常 返回 null 
     * 
     */  
    public String mset(String...keysvalues){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.mset(keysvalues);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>批量的设置key:value,可以一个,如果key已经存在则会失败,操作会回滚</p> 
     * <p>example:</p> 
     * <p>  obj.msetnx(new String[]{"key2","value1","key2","value2"})</p> 
     * @param keysvalues 
     * @return 成功返回1 失败返回0 
     */  
    public Long msetnx(String...keysvalues){  
        Jedis jedis = null;  
        Long res = 0L;  
        try {  
            jedis = pool.getResource();  
            res =jedis.msetnx(keysvalues);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>设置key的值,并返回一个旧值</p> 
     * @param key 
     * @param value 
     * @return 旧值 如果key不存在 则返回null 
     */  
    public String getset(String key,String value){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.getSet(key, value);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过下标 和key 获取指定下标位置的 value</p> 
     * @param key 
     * @param startOffset 开始位置 从0 开始 负数表示从右边开始截取 
     * @param endOffset 
     * @return 如果没有返回null 
     */  
    public String getrange(String key, int startOffset ,int endOffset){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.getrange(key, startOffset, endOffset);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key 对value进行加值+1操作,当value不是int类型时会返回错误,当key不存在是则value为1</p> 
     * @param key 
     * @return 加值后的结果 
     */  
    public Long incr(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.incr(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key给指定的value加值,如果key不存在,则这是value为该值</p> 
     * @param key 
     * @param integer 
     * @return 
     */  
    public Long incrBy(String key,Long integer){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.incrBy(key, integer);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>对key的值做减减操作,如果key不存在,则设置key为-1</p> 
     * @param key 
     * @return 
     */  
    public Long decr(String key) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.decr(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>减去指定的值</p> 
     * @param key 
     * @param integer 
     * @return 
     */  
    public Long decrBy(String key,Long integer){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.decrBy(key, integer);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取value值的长度</p> 
     * @param key 
     * @return 失败返回null 
     */  
    public Long serlen(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.strlen(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key给field设置指定的值,如果key不存在,则先创建</p> 
     * @param key 
     * @param field 字段 
     * @param value 
     * @return 如果存在返回0 异常返回null 
     */  
    public Long hset(String key,String field,String value) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hset(key, field, value);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key给field设置指定的值,如果key不存在则先创建,如果field已经存在,返回0</p> 
     * @param key 
     * @param field 
     * @param value 
     * @return 
     */  
    public Long hsetnx(String key,String field,String value){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hsetnx(key, field, value);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key同时设置 hash的多个field</p> 
     * @param key 
     * @param hash 
     * @return 返回OK 异常返回null 
     */  
    public String hmset(String key,Map<String, String> hash){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hmset(key, hash);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key 和 field 获取指定的 value</p> 
     * @param key 
     * @param field 
     * @return 没有返回null 
     */  
    public String hget(String key, String field){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hget(key, field);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key 和 fields 获取指定的value 如果没有对应的value则返回null</p> 
     * @param key 
     * @param fields 可以使 一个String 也可以是 String数组 
     * @return 
     */  
    public List<String> hmget(String key,String...fields){  
        Jedis jedis = null;  
        List<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hmget(key, fields);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key给指定的field的value加上给定的值</p> 
     * @param key 
     * @param field 
     * @param value 
     * @return 
     */  
    public Long hincrby(String key ,String field ,Long value){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hincrBy(key, field, value);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key和field判断是否有指定的value存在</p> 
     * @param key 
     * @param field 
     * @return 
     */  
    public Boolean hexists(String key , String field){  
        Jedis jedis = null;  
        Boolean res = false;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hexists(key, field);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回field的数量</p> 
     * @param key 
     * @return 
     */  
    public Long hlen(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hlen(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
  
    }  
  
    /** 
     * <p>通过key 删除指定的 field </p> 
     * @param key 
     * @param fields 可以是 一个 field 也可以是 一个数组 
     * @return 
     */  
    public Long hdel(String key ,String...fields){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hdel(key, fields);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回所有的field</p> 
     * @param key 
     * @return 
     */  
    public Set<String> hkeys(String key){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hkeys(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回所有和key有关的value</p> 
     * @param key 
     * @return 
     */  
    public List<String> hvals(String key){  
        Jedis jedis = null;  
        List<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hvals(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取所有的field和value</p> 
     * @param key 
     * @return 
     */  
    public Map<String, String> hgetall(String key){  
        Jedis jedis = null;  
        Map<String, String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hgetAll(key);  
        } catch (Exception e) {  
            // TODO  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key向list头部添加字符串</p> 
     * @param key 
     * @param strs 可以使一个string 也可以使string数组 
     * @return 返回list的value个数 
     */  
    public Long lpush(String key ,String...strs){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lpush(key, strs);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key向list尾部添加字符串</p> 
     * @param key 
     * @param strs 可以使一个string 也可以使string数组 
     * @return 返回list的value个数 
     */  
    public Long rpush(String key ,String...strs){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.rpush(key, strs);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key在list指定的位置之前或者之后 添加字符串元素</p> 
     * @param key 
     * @param where LIST_POSITION枚举类型 
     * @param pivot list里面的value 
     * @param value 添加的value 
     * @return 
     */  
    public Long linsert(String key, LIST_POSITION where,  
                        String pivot, String value){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.linsert(key, where, pivot, value);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key设置list指定下标位置的value</p> 
     * <p>如果下标超过list里面value的个数则报错</p> 
     * @param key 
     * @param index 从0开始 
     * @param value 
     * @return 成功返回OK 
     */  
    public String lset(String key ,Long index, String value){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lset(key, index, value);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key从对应的list中删除指定的count个 和 value相同的元素</p> 
     * @param key 
     * @param count 当count为0时删除全部 
     * @param value 
     * @return 返回被删除的个数 
     */  
    public Long lrem(String key,long count,String value){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lrem(key, count, value);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key保留list中从strat下标开始到end下标结束的value值</p> 
     * @param key 
     * @param start 
     * @param end 
     * @return 成功返回OK 
     */  
    public String ltrim(String key ,long start ,long end){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.ltrim(key, start, end);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key从list的头部删除一个value,并返回该value</p> 
     * @param key 
     * @return 
     */  
    synchronized public String lpop(String key){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lpop(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key从list尾部删除一个value,并返回该元素</p> 
     * @param key 
     * @return 
     */  
    synchronized public String rpop(String key){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.rpop(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key从一个list的尾部删除一个value并添加到另一个list的头部,并返回该value</p> 
     * <p>如果第一个list为空或者不存在则返回null</p> 
     * @param srckey 
     * @param dstkey 
     * @return 
     */  
    public String rpoplpush(String srckey, String dstkey){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.rpoplpush(srckey, dstkey);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取list中指定下标位置的value</p> 
     * @param key 
     * @param index 
     * @return 如果没有返回null 
     */  
    public String lindex(String key,long index){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lindex(key, index);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回list的长度</p> 
     * @param key 
     * @return 
     */  
    public Long llen(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.llen(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取list指定下标位置的value</p> 
     * <p>如果start 为 0 end 为 -1 则返回全部的list中的value</p> 
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    public List<String> lrange(String key,long start,long end){  
        Jedis jedis = null;  
        List<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lrange(key, start, end);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key向指定的set中添加value</p> 
     * @param key 
     * @param members 可以是一个String 也可以是一个String数组 
     * @return 添加成功的个数 
     */  
    public Long sadd(String key,String...members){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sadd(key, members);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key删除set中对应的value值</p> 
     * @param key 
     * @param members 可以是一个String 也可以是一个String数组 
     * @return 删除的个数 
     */  
    public Long srem(String key,String...members){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.srem(key, members);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key随机删除一个set中的value并返回该值</p> 
     * @param key 
     * @return 
     */  
    public String spop(String key){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.spop(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取set中的差集</p> 
     * <p>以第一个set为标准</p> 
     * @param keys 可以使一个string 则返回set中所有的value 也可以是string数组 
     * @return 
     */  
    public Set<String> sdiff(String...keys){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sdiff(keys);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取set中的差集并存入到另一个key中</p> 
     * <p>以第一个set为标准</p> 
     * @param dstkey 差集存入的key 
     * @param keys 可以使一个string 则返回set中所有的value 也可以是string数组 
     * @return 
     */  
    public Long sdiffstore(String dstkey,String... keys){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sdiffstore(dstkey, keys);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取指定set中的交集</p> 
     * @param keys 可以使一个string 也可以是一个string数组 
     * @return 
     */  
    public Set<String> sinter(String...keys){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sinter(keys);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取指定set中的交集 并将结果存入新的set中</p> 
     * @param dstkey 
     * @param keys 可以使一个string 也可以是一个string数组 
     * @return 
     */  
    public Long sinterstore(String dstkey,String...keys){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sinterstore(dstkey, keys);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回所有set的并集</p> 
     * @param keys 可以使一个string 也可以是一个string数组 
     * @return 
     */  
    public Set<String> sunion(String... keys){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sunion(keys);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回所有set的并集,并存入到新的set中</p> 
     * @param dstkey 
     * @param keys 可以使一个string 也可以是一个string数组 
     * @return 
     */  
    public Long sunionstore(String dstkey,String...keys){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sunionstore(dstkey, keys);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key将set中的value移除并添加到第二个set中</p> 
     * @param srckey 需要移除的 
     * @param dstkey 添加的 
     * @param member set中的value 
     * @return 
     */  
    public Long smove(String srckey, String dstkey, String member){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.smove(srckey, dstkey, member);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取set中value的个数</p> 
     * @param key 
     * @return 
     */  
    public Long scard(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.scard(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key判断value是否是set中的元素</p> 
     * @param key 
     * @param member 
     * @return 
     */  
    public Boolean sismember(String key,String member){  
        Jedis jedis = null;  
        Boolean res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sismember(key, member);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取set中随机的value,不删除元素</p> 
     * @param key 
     * @return 
     */  
    public String srandmember(String key){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.srandmember(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取set中所有的value</p> 
     * @param key 
     * @return 
     */  
    public Set<String> smembers(String key){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.smembers(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
  
    /** 
     * <p>通过key向zset中添加value,score,其中score就是用来排序的</p> 
     * <p>如果该value已经存在则根据score更新元素</p> 
     * @param key 
     * @param score 
     * @param member 
     * @return 
     */  
    public Long zadd(String key,double score,String member){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zadd(key, score, member);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key删除在zset中指定的value</p> 
     * @param key 
     * @param members 可以使一个string 也可以是一个string数组 
     * @return 
     */  
    public Long zrem(String key,String...members){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrem(key, members);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key增加该zset中value的score的值</p> 
     * @param key 
     * @param score 
     * @param member 
     * @return 
     */  
    public Double zincrby(String key ,double score ,String member){  
        Jedis jedis = null;  
        Double res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zincrby(key, score, member);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回zset中value的排名</p> 
     * <p>下标从小到大排序</p> 
     * @param key 
     * @param member 
     * @return 
     */  
    public Long zrank(String key,String member){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrank(key, member);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回zset中value的排名</p> 
     * <p>下标从大到小排序</p> 
     * @param key 
     * @param member 
     * @return 
     */  
    public Long zrevrank(String key,String member){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrank(key, member);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key将获取score从start到end中zset的value</p> 
     * <p>socre从大到小排序</p> 
     * <p>当start为0 end为-1时返回全部</p> 
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    public Set<String> zrevrange(String key ,long start ,long end){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrange(key, start, end);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回指定score内zset中的value</p> 
     * @param key 
     * @param max 
     * @param min 
     * @return 
     */  
    public Set<String> zrangebyscore(String key,String max,String min){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrangeByScore(key, max, min);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回指定score内zset中的value</p> 
     * @param key 
     * @param max 
     * @param min 
     * @return 
     */  
    public Set<String> zrangeByScore(String key ,double max,double min){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrangeByScore(key,max,min);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>返回指定区间内zset中value的数量</p> 
     * @param key 
     * @param min 
     * @param max 
     * @return 
     */  
    public Long zcount(String key,String min,String max){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zcount(key, min, max);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key返回zset中的value个数</p> 
     * @param key 
     * @return 
     */  
    public Long zcard(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zcard(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key获取zset中value的score值</p> 
     * @param key 
     * @param member 
     * @return 
     */  
    public Double zscore(String key,String member){  
        Jedis jedis = null;  
        Double res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zscore(key, member);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key删除给定区间内的元素</p> 
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    public Long zremrangeByRank(String key ,long start, long end){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zremrangeByRank(key, start, end);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key删除指定score内的元素</p> 
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    public Long zremrangeByScore(String key,double start,double end){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zremrangeByScore(key, start, end);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
    /** 
     * <p>返回满足pattern表达式的所有key</p> 
     * <p>keys(*)</p> 
     * <p>返回所有的key</p> 
     * @param pattern 
     * @return 
     */  
    public Set<String> keys(String pattern){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.keys(pattern);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * <p>通过key判断值得类型</p> 
     * @param key 
     * @return 
     */  
    public String type(String key){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.type(key);  
        } catch (Exception e) {  
              
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
  
    /** 
     * 返还到连接池 
     * 
     * @param pool 
     * @param jedis 
     */  
    @SuppressWarnings("deprecation")
	public static void returnResource(JedisPool pool, Jedis jedis) {  
        if (jedis != null) {  
            pool.returnResource(jedis);  
        }  
    }  
  
    public static RedisUtil getRu() {  
        return ru;  
    }  
  
    public static void setRu(RedisUtil ru) {  
        RedisUtil.ru = ru;  
    }  
}

总结
另外一些就是Redis有关事务，发布订阅的一些东西，用到的可能性比较小，知道就好。另外给大家介绍一款在window可视化管理Reids工具RedisDesktopManager.
页面如下.