jar包

    
     2.7.2
     
    
     1.6.2.RELEASE
    

         
     
      redis.clients
          
     
      jedis
          
     
      ${version.clients.jedis}
      
     
         
     
      org.springframework.data
          
     
      spring-data-redis
          
     
      ${version.data.redis}
      
     properties配置

#最大连接数 redis.pool.maxTotal=30 #最大空闲时间 redis.pool.maxIdle=10 #每次最大连接数 redis.pool.numTestsPerEvictionRun=1024 #释放扫描的扫描间隔 redis.pool.timeBetweenEvictionRunsMillis=30000 #连接的最小空闲时间 redis.pool.minEvictableIdleTimeMillis=1800000 #连接控歘按时间多久后释放，当空闲时间>该值且空闲连接>最大空闲连接数时直接释放 redis.pool.softMinEvictableIdleTimeMillis=10000 #获得链接时的最大等待毫秒数，小于0：阻塞不确定时间，默认-1 redis.pool.maxWaitMillis=1500 #在获得链接的时候检查有效性，默认false redis.pool.testOnBorrow=true #在空闲时检查有效性，默认false redis.pool.testWhileIdle=true #连接耗尽时是否阻塞，false报异常，true阻塞超时,默认true redis.pool.blockWhenExhausted=false #JedisConnectionFactory的参数 #主机地址，默认：localhost redis.hostName=127.0.0.1 #主机端口，默认：6379 redis.port=6379 #超时时间，默认：2000 redis.timeout=3000 #密码 redis.pass= #是否使用连接池，默认true redis.usePool=true #使用数据库的索引，0-15之间的数字，默认：0 redis.dbIndex=0 bean xml的配置

         
          
          
          
          
          
          
          
          
          
          
          
          
          
          
          
          
          
          
          
      
     
     
     
         
          
              
           
          
              
           
          
              
           
          
              
           
          
          
      
     以上几步之后就可以使用 @Autowired private RedisTemplate redisTemplate; 来操作redis了 ================================================================================================ 也可以自己封装一个RedisUtil的类 eg: RedisCacheUtil.java

import org.springframework.data.redis.core.RedisTemplate; import org.springframework.util.CollectionUtils; import javax.annotation.Resource; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; /**  * 
Description:redis缓存工具类
  *  * @Author: Austin  **/ public class RedisCacheUtil {
      @Resource     private RedisTemplate
    
      redisTemplate;     public void setRedisTemplate(RedisTemplate
     
       redisTemplate) {
          this.redisTemplate = redisTemplate;     }     /**      * 指定缓存失效时间      *      * @param key 键      * @param time 时间(秒)      * @return      */     public boolean expire(String key, long time) {
          try {
              if (time > 0) {
                  redisTemplate.expire(key, time, TimeUnit.SECONDS);             }             return true;         } catch (Exception e) {
              e.printStackTrace();             return false;         }     }     /**      * 根据key 获取过期时间      *      * @param key 键 不能为null      * @return 时间(秒) 返回0代表为永久有效      */     public long getExpire(String key) {
          return redisTemplate.getExpire(key, TimeUnit.SECONDS);     }     /**      * 判断key是否存在      *      * @param key      *            键      * @return true 存在 false不存在      */     public boolean hasKey(String key) {
          try {
              return redisTemplate.hasKey(key);         } catch (Exception e) {
              e.printStackTrace();             return false;         }     }     /**      * 删除缓存      *      * @param key 可以传一个值 或多个      */     @SuppressWarnings("unchecked")     public void del(String... key) {
          if (key != null && key.length > 0) {
              if (key.length == 1) {
                  redisTemplate.delete(key[0]);             } else {
                  redisTemplate.delete(CollectionUtils.arrayToList(key));             }         }     }     // ============================String=============================     /**      * 普通缓存获取      *      * @param key 键      * @return 值      */     public Object get(String key) {
          return key == null ? null : redisTemplate.opsForValue().get(key);     }     /**      * 普通缓存放入      *      * @param key 键      * @param value 值      * @return true成功 false失败      */     public boolean set(String key, Object value) {
          try {
              redisTemplate.opsForValue().set(key, value);             return true;         } catch (Exception e) {
              e.printStackTrace();             return false;         }     }     /**      * 普通缓存放入并设置时间      *      * @param key 键      * @param value 值      * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期      * @return true成功 false 失败      */     public boolean set(String key, Object value, long time) {
          try {
              if (time > 0) {
                  redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);             } else {
                  set(key, value);             }             return true;         } catch (Exception e) {
              e.printStackTrace();             return false;         }     }     /**      * 递增      *      * @param key 键      * @paramby 要增加几(大于0)      * @return      */     public long incr(String key, long delta) {
          if (delta < 0) {
              throw new RuntimeException("递增因子必须大于0");         }         return redisTemplate.opsForValue().increment(key, delta);     }     /**      * 递减      *      * @param key 键      * @paramby 要减少几(小于0)      * @return      */     public long decr(String key, long delta) {
          if (delta < 0) {
              throw new RuntimeException("递减因子必须大于0");         }         return redisTemplate.opsForValue().increment(key, -delta);     }     // ================================Map=================================     /**      * HashGet      *      * @param key 键 不能为null      * @param item 项 不能为null      * @return 值      */     public Object hget(String key, String item) {
          return redisTemplate.opsForHash().get(key, item);     }     /**      * 获取hashKey对应的所有键值      *      * @param key 键      * @return 对应的多个键值      */     public Map
      
        hmget(String key) {
          return redisTemplate.opsForHash().entries(key);     }     /**      * HashSet      *      * @param key 键      * @param map 对应多个键值      * @return true 成功 false 失败      */     public boolean hmset(String key, Map
       
         map) {
          try {
              redisTemplate.opsForHash().putAll(key, map);             return true;         } catch (Exception e) {
              e.printStackTrace();             return false;         }     }     /**      * HashSet 并设置时间      *      * @param key 键      * @param map 对应多个键值      * @param time 时间(秒)      * @return true成功 false失败      */     public boolean hmset(String key, Map
        
          map, long time) {
          try {
              redisTemplate.opsForHash().putAll(key, map);             if (time > 0) {
                  expire(key, time);             }             return true;         } catch (Exception e) {
              e.printStackTrace();             return false;         }     }     /**      * 向一张hash表中放入数据,如果不存在将创建      *      * @param key 键      * @param item 项      * @param value 值      * @return true 成功 false失败      */     public boolean hset(String key, String item, Object value) {
          try {
              redisTemplate.opsForHash().put(key, item, value);             return true;         } catch (Exception e) {
              e.printStackTrace();             return false;         }     }     /**      * 向一张hash表中放入数据,如果不存在将创建      *      * @param key 键      * @param item 项      * @param value 值      * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间      * @return true 成功 false失败      */     public boolean hset(String key, String item, Object value, long time) {
          try {
              redisTemplate.opsForHash().put(key, item, value);             if (time > 0) {
                  expire(key, time);             }             return true;         } catch (Exception e) {
              e.printStackTrace();             return false;         }     }     /**      * 删除hash表中的值      *      * @param key 键 不能为null      * @param item 项 可以使多个 不能为null      */     public void hdel(String key, Object... item) {
          redisTemplate.opsForHash().delete(key, item);     }     /**      * 判断hash表中是否有该项的值      *      * @param key 键 不能为null      * @param item 项 不能为null      * @return true 存在 false不存在      */     public boolean hHasKey(String key, String item) {
          return redisTemplate.opsForHash().hasKey(key, item);     }     /**      * hash递增 如果不存在,就会创建一个 并把新增后的值返回      *      * @param key 键      * @param item 项      * @param by 要增加几(大于0)      * @return      */     public double hincr(String key, String item, double by) {
          return redisTemplate.opsForHash().increment(key, item, by);     }     /**      * hash递减      *      * @param key 键      * @param item 项      * @param by 要减少记(小于0)      * @return      */     public double hdecr(String key, String item, double by) {
          return redisTemplate.opsForHash().increment(key, item, -by);     }     // ============================set=============================     /**      * 根据key获取Set中的所有值      *      * @param key 键      * @return      */     public Set
         
        
       
      
     
    

         
      
     就可以使用封装类来操作redis @Autowried private RedisCacheUtil redisCacheUtil;