redis在Java web项目的简单应用

最新推荐文章于 2021-02-28 09:51:02 发布
最新推荐文章于 2021-02-28 09:51:02 发布
阅读量244 收藏 4
点赞数
[java]  view plain  copy
  1. 一.准备要使用的的jar包,我使用了以下jar包，关于json的jar包是方便存储和转换redis用到的值;  

二.编写加载redis是要用到的实例类

[java]  view plain  copy
  1. package com.redis;    
  2.     
  3. import redis.clients.jedis.ShardedJedis;    
  4.     
  5. /**    
  6.  * @Title: RedisDataSource.java  
  7.  * @copyright   
  8.  * @Package com.cy.redis  
  9.  * @Description: 该接口用于获取redis客户端实例，通过该实例操作redis数据源  
  10.  * @author   
  11.  * @date 2016-10-21 下午04:22:41  
  12.  */    
  13. public interface RedisDataSource {    
  14.         
  15.     public abstract ShardedJedis getRedisClient();    
  16.         
  17.     public void returnResource(ShardedJedis shardedJedis);    
  18.         
  19.         public void returnResource(ShardedJedis shardedJedis,boolean broken);    
  20.     
  21. }    
[java]  view plain  copy
  1. package com.redis;    
  2.     
  3. import org.slf4j.LoggerFactory;    
  4. import org.springframework.beans.factory.annotation.Autowired;    
  5.     
  6. import redis.clients.jedis.ShardedJedis;    
  7. import redis.clients.jedis.ShardedJedisPool;    
  8.     
  9. /**    
  10.  * @Title: RedisDataSourceImpl.java  
  11.  * @copyright   
  12.  * @Package com.cy.redis  
  13.  * @Description: 获取redis客户端实例，通过该实例操作redis数据源  
  14.  * @author   
  15.  * @date 2016-10-21 下午04:22:54  
  16.  */    
  17. public class RedisDataSourceImpl implements RedisDataSource{    
  18.     
  19.     private static final org.slf4j.Logger log = LoggerFactory.getLogger(RedisDataSourceImpl.class);    
  20.         
  21.     @Autowired    
  22.     private ShardedJedisPool shardedJedisPool;    
  23.         
  24.     public ShardedJedisPool getShardedJedisPool() {    
  25.         return shardedJedisPool;    
  26.     }    
  27.     
  28.     public void setShardedJedisPool(ShardedJedisPool shardedJedisPool) {    
  29.         this.shardedJedisPool = shardedJedisPool;    
  30.     }    
  31.     
  32.     /**  
  33.      * 获取redis客户端  
  34.      */    
  35.     public ShardedJedis getRedisClient() {    
  36.         try {    
  37.             ShardedJedis shardedJedis=shardedJedisPool.getResource();    
  38.             return shardedJedis;    
  39.         } catch (Exception e) {    
  40.             log.error("getRedisClient ,error",e);    
  41.             e.printStackTrace();    
  42.         }    
  43.         return null;    
  44.     }    
  45.     
  46.     /**  
  47.      * 将资源返还给pool  
  48.      */    
  49.     @SuppressWarnings("deprecation")    
  50.     public void returnResource(ShardedJedis shardedJedis) {    
  51.         shardedJedisPool.returnResource(shardedJedis);    
  52.             
  53.     }    
  54.     
  55.     /**  
  56.      * 出现异常后返回资源给pool  
  57.      */    
  58.     @SuppressWarnings("deprecation")    
  59.     public void returnResource(ShardedJedis shardedJedis, boolean broken) {    
  60.         if(broken){    
  61.             shardedJedisPool.returnBrokenResource(shardedJedis);    
  62.         }else{    
  63.             shardedJedisPool.returnResource(shardedJedis);    
  64.         }    
  65.             
  66.     }    
  67.     
  68. }   


[java]  view plain  copy
  1. package com.redis;    
  2.     
  3. import org.slf4j.LoggerFactory;    
  4. import org.springframework.beans.factory.annotation.Autowired;    
  5.     
  6. import redis.clients.jedis.Jedis;    
  7. import redis.clients.jedis.JedisShardInfo;    
  8. import redis.clients.jedis.ShardedJedis;    
  9.     
  10. /**    
  11.  * @Title: RedisClientTemplate.java  
  12.  * @copyright   
  13.  * @Package com.cy.redis  
  14.  * @Description: 用于操作redis取值、存值操作的工具类  
  15.  * @author   
  16.  * @date 2016-10-21 下午04:21:59  
  17.  */    
  18. public class RedisClientTemplate {    
  19.         
  20.     private static final org.slf4j.Logger log=LoggerFactory.getLogger(RedisClientTemplate.class);    
  21.         
  22.     @Autowired    
  23.     private RedisDataSource redisDataSource;    
  24.     
  25.     public RedisDataSource getRedisDataSource() {    
  26.         return redisDataSource;    
  27.     }    
  28.     
  29.     public void setRedisDataSource(RedisDataSource redisDataSource) {    
  30.         this.redisDataSource = redisDataSource;    
  31.     }    
  32.         
  33.     public void disconnect(){    
  34.         ShardedJedis shardedJedis=redisDataSource.getRedisClient();    
  35.         shardedJedis.disconnect();    
  36.     }    
  37.         
  38.     /**  
  39.     * @Description: 在redis里设置单个值  
  40.     * @author Mr.chen  
  41.     * @date 2016-10-21 下午04:37:06  
  42.      */    
  43.     public String set(String key, String value){    
  44.         String result=null;    
  45.         ShardedJedis shardedJedis=redisDataSource.getRedisClient();    
  46.         if(shardedJedis==null){    
  47.             return result;    
  48.         }    
  49.         boolean broken=false;    
  50.         try {    
  51.             result=shardedJedis.set(key, value);    
  52.         } catch (Exception e) {    
  53.             broken=true;    
  54.             e.printStackTrace();    
  55.         }finally{    
  56.             redisDataSource.returnResource(shardedJedis, broken);    
  57.         }    
  58.             
  59.         return result;    
  60.     }    
  61.         
  62.     /**  
  63.     * @Description: 获取redis单个值   
  64.     * @author Mr.chen  
  65.     * @date 2016-10-21 下午04:40:57  
  66.      */    
  67.     public String get(String key) {    
  68.         String result = null;    
  69.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  70.         if (shardedJedis == null) {    
  71.             return result;    
  72.         }    
  73.         boolean broken = false;    
  74.         try {    
  75.             result = shardedJedis.get(key);    
  76.     
  77.         } catch (Exception e) {    
  78.             log.error(e.getMessage(), e);    
  79.             broken = true;    
  80.         } finally {    
  81.             redisDataSource.returnResource(shardedJedis, broken);    
  82.         }    
  83.         return result;    
  84.     }    
  85.         
  86.     /**  
  87.     * @Description: 判断redis是否存在key  
  88.     * @author Mr.chen  
  89.     * @date 2016-10-21 下午04:41:39  
  90.      */    
  91.     public Boolean exists(String key) {    
  92.         Boolean result = false;    
  93.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  94.         if (shardedJedis == null) {    
  95.             return result;    
  96.         }    
  97.         boolean broken = false;    
  98.         try {    
  99.             result = shardedJedis.exists(key);    
  100.         } catch (Exception e) {    
  101.             log.error(e.getMessage(), e);    
  102.             broken = true;    
  103.         } finally {    
  104.             redisDataSource.returnResource(shardedJedis, broken);    
  105.         }    
  106.         return result;    
  107.     }    
  108.         
  109.     /**  
  110.     * @Description: 获取key返回存储值的类型   
  111.     * @author Mr.chen  
  112.     * @date 2016-10-21 下午04:42:08  
  113.      */    
  114.     public String type(String key) {    
  115.         String result = null;    
  116.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  117.         if (shardedJedis == null) {    
  118.             return result;    
  119.         }    
  120.         boolean broken = false;    
  121.         try {    
  122.             result = shardedJedis.type(key);    
  123.     
  124.         } catch (Exception e) {    
  125.             log.error(e.getMessage(), e);    
  126.             broken = true;    
  127.         } finally {    
  128.             redisDataSource.returnResource(shardedJedis, broken);    
  129.         }    
  130.         return result;    
  131.     }    
  132.         
  133.     /**  
  134.     * @Description: 在某段时间后实现  
  135.     * @author Mr.chen  
  136.     * @date 2016-10-21 下午04:43:25  
  137.      */    
  138.     public Long expire(String key, int seconds) {    
  139.         Long result = null;    
  140.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  141.         if (shardedJedis == null) {    
  142.             return result;    
  143.         }    
  144.         boolean broken = false;    
  145.         try {    
  146.             result = shardedJedis.expire(key, seconds);    
  147.     
  148.         } catch (Exception e) {    
  149.             log.error(e.getMessage(), e);    
  150.             broken = true;    
  151.         } finally {    
  152.             redisDataSource.returnResource(shardedJedis, broken);    
  153.         }    
  154.         return result;    
  155.     }    
  156.     
  157.     /**  
  158.     * @Description: 在某个时间点失效   
  159.     * @author Mr.chen  
  160.     * @date 2016-10-21 下午04:43:40  
  161.      */    
  162.     public Long expireAt(String key, long unixTime) {    
  163.         Long result = null;    
  164.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  165.         if (shardedJedis == null) {    
  166.             return result;    
  167.         }    
  168.         boolean broken = false;    
  169.         try {    
  170.             result = shardedJedis.expireAt(key, unixTime);    
  171.     
  172.         } catch (Exception e) {    
  173.             log.error(e.getMessage(), e);    
  174.             broken = true;    
  175.         } finally {    
  176.             redisDataSource.returnResource(shardedJedis, broken);    
  177.         }    
  178.         return result;    
  179.     }    
  180.     
  181.     /**  
  182.     * @Description: 以秒为单位，返回给定 key 的剩余生存时间  
  183.     * @author Mr.chen  
  184.     * @date 2016-10-21 下午04:44:00  
  185.      */    
  186.     public Long ttl(String key) {    
  187.         Long result = null;    
  188.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  189.         if (shardedJedis == null) {    
  190.             return result;    
  191.         }    
  192.         boolean broken = false;    
  193.         try {    
  194.             result = shardedJedis.ttl(key);    
  195.     
  196.         } catch (Exception e) {    
  197.             log.error(e.getMessage(), e);    
  198.             broken = true;    
  199.         } finally {    
  200.             redisDataSource.returnResource(shardedJedis, broken);    
  201.         }    
  202.         return result;    
  203.     }    
  204.     
  205.     /**  
  206.     * @Description: 将 key 的值设为 value ，当且仅当 key 不存在  
  207.     * @author Mr.chen  
  208.     * @date 2016-10-21 下午04:44:17  
  209.      */    
  210.     public Long setnx(String key, String value) {    
  211.         Long result = null;    
  212.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  213.         if (shardedJedis == null) {    
  214.             return result;    
  215.         }    
  216.         boolean broken = false;    
  217.         try {    
  218.             result = shardedJedis.setnx(key, value);    
  219.         } catch (Exception e) {    
  220.             log.error(e.getMessage(), e);    
  221.             broken = true;    
  222.         } finally {    
  223.             redisDataSource.returnResource(shardedJedis, broken);    
  224.         }    
  225.         return result;    
  226.     }    
  227.     /**  
  228.      * 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)  
  229.      * @param key  
  230.      * @param seconds  
  231.      * @param value  
  232.      * @return  
  233.      */    
  234.     public String setex(String key, int seconds, String value) {    
  235.         String result = null;    
  236.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  237.         if (shardedJedis == null) {    
  238.             return result;    
  239.         }    
  240.         boolean broken = false;    
  241.         try {    
  242.             result = shardedJedis.setex(key, seconds, value);    
  243.     
  244.         } catch (Exception e) {    
  245.             log.error(e.getMessage(), e);    
  246.             broken = true;    
  247.         } finally {    
  248.             redisDataSource.returnResource(shardedJedis, broken);    
  249.         }    
  250.         return result;    
  251.     }    
  252.     /**  
  253.      * 将 key 所储存的值减去减量 integer   
  254.      * @param key  
  255.      * @param integer  
  256.      * @return  
  257.      */    
  258.     public Long decrBy(String key, long integer) {    
  259.         Long result = null;    
  260.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  261.         if (shardedJedis == null) {    
  262.             return result;    
  263.         }    
  264.         boolean broken = false;    
  265.         try {    
  266.             result = shardedJedis.decrBy(key, integer);    
  267.     
  268.         } catch (Exception e) {    
  269.             log.error(e.getMessage(), e);    
  270.             broken = true;    
  271.         } finally {    
  272.             redisDataSource.returnResource(shardedJedis, broken);    
  273.         }    
  274.         return result;    
  275.     }    
  276.     /**  
  277.      * 将 key 中储存的数字值减一。  
  278.      * @param key  
  279.      * @return  
  280.      */    
  281.     public Long decr(String key) {    
  282.         Long result = null;    
  283.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  284.         if (shardedJedis == null) {    
  285.             return result;    
  286.         }    
  287.         boolean broken = false;    
  288.         try {    
  289.             result = shardedJedis.decr(key);    
  290.     
  291.         } catch (Exception e) {    
  292.             log.error(e.getMessage(), e);    
  293.             broken = true;    
  294.         } finally {    
  295.             redisDataSource.returnResource(shardedJedis, broken);    
  296.         }    
  297.         return result;    
  298.     }    
  299.     /**  
  300.      * 将 key 所储存的值加上增量 integer   
  301.      * @param key  
  302.      * @param integer  
  303.      * @return  
  304.      */    
  305.     public Long incrBy(String key, long integer) {    
  306.         Long result = null;    
  307.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  308.         if (shardedJedis == null) {    
  309.             return result;    
  310.         }    
  311.         boolean broken = false;    
  312.         try {    
  313.             result = shardedJedis.incrBy(key, integer);    
  314.     
  315.         } catch (Exception e) {    
  316.             log.error(e.getMessage(), e);    
  317.             broken = true;    
  318.         } finally {    
  319.             redisDataSource.returnResource(shardedJedis, broken);    
  320.         }    
  321.         return result;    
  322.     }    
  323.     /**  
  324.      * 将 key 中储存的数字值增一  
  325.      * @param key  
  326.      * @return  
  327.      */    
  328.     public Long incr(String key) {    
  329.         Long result = null;    
  330.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  331.         if (shardedJedis == null) {    
  332.             return result;    
  333.         }    
  334.         boolean broken = false;    
  335.         try {    
  336.             result = shardedJedis.incr(key);    
  337.     
  338.         } catch (Exception e) {    
  339.             log.error(e.getMessage(), e);    
  340.             broken = true;    
  341.         } finally {    
  342.             redisDataSource.returnResource(shardedJedis, broken);    
  343.         }    
  344.         return result;    
  345.     }    
  346.     /**  
  347.      * 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。  
  348.      * 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。  
  349.      * @param key  
  350.      * @param value  
  351.      * @return  
  352.      */    
  353.     public Long append(String key, String value) {    
  354.         Long result = null;    
  355.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  356.         if (shardedJedis == null) {    
  357.             return result;    
  358.         }    
  359.         boolean broken = false;    
  360.         try {    
  361.             result = shardedJedis.append(key, value);    
  362.     
  363.         } catch (Exception e) {    
  364.             log.error(e.getMessage(), e);    
  365.             broken = true;    
  366.         } finally {    
  367.             redisDataSource.returnResource(shardedJedis, broken);    
  368.         }    
  369.         return result;    
  370.     }    
  371.     /**  
  372.      * 返回名称为key的string的value的子串  
  373.      * @param key  
  374.      * @param start  
  375.      * @param end  
  376.      * @return  
  377.      */    
  378.     public String substr(String key, int start, int end) {    
  379.         String result = null;    
  380.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  381.         if (shardedJedis == null) {    
  382.             return result;    
  383.         }    
  384.         boolean broken = false;    
  385.         try {    
  386.             result = shardedJedis.substr(key, start, end);    
  387.     
  388.         } catch (Exception e) {    
  389.             log.error(e.getMessage(), e);    
  390.             broken = true;    
  391.         } finally {    
  392.             redisDataSource.returnResource(shardedJedis, broken);    
  393.         }    
  394.         return result;    
  395.     }    
  396.     /**  
  397.      * 将哈希表 key 中的域 field 的值设为 value   
  398.      * @param key  
  399.      * @param field  
  400.      * @param value  
  401.      * @return  
  402.      */    
  403.     public Long hset(String key, String field, String value) {    
  404.         Long result = null;    
  405.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  406.         if (shardedJedis == null) {    
  407.             return result;    
  408.         }    
  409.         boolean broken = false;    
  410.         try {    
  411.             result = shardedJedis.hset(key, field, value);    
  412.     
  413.         } catch (Exception e) {    
  414.             log.error(e.getMessage(), e);    
  415.             broken = true;    
  416.         } finally {    
  417.             redisDataSource.returnResource(shardedJedis, broken);    
  418.         }    
  419.         return result;    
  420.     }    
  421.     /**  
  422.      * 返回哈希表 key 中给定域 field 的值  
  423.      * @param key  
  424.      * @param field  
  425.      * @return  
  426.      */    
  427.     public String hget(String key, String field) {    
  428.         String result = null;    
  429.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  430.         if (shardedJedis == null) {    
  431.             return result;    
  432.         }    
  433.         boolean broken = false;    
  434.         try {    
  435.             result = shardedJedis.hget(key, field);    
  436.     
  437.         } catch (Exception e) {    
  438.             log.error(e.getMessage(), e);    
  439.             broken = true;    
  440.         } finally {    
  441.             redisDataSource.returnResource(shardedJedis, broken);    
  442.         }    
  443.         return result;    
  444.     }    
  445.     /**  
  446.      * 同时将多个 field-value (域-值)对设置到哈希表 key 中。  
  447.      * @param key  
  448.      * @param hash  
  449.      * @return  
  450.      */    
  451.     public String hmset(String key, Map<String, String> hash) {    
  452.         String result = null;    
  453.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  454.         if (shardedJedis == null) {    
  455.             return result;    
  456.         }    
  457.         boolean broken = false;    
  458.         try {    
  459.             result = shardedJedis.hmset(key, hash);    
  460.     
  461.         } catch (Exception e) {    
  462.             log.error(e.getMessage(), e);    
  463.             broken = true;    
  464.         } finally {    
  465.             redisDataSource.returnResource(shardedJedis, broken);    
  466.         }    
  467.         return result;    
  468.     }    
  469.     /**  
  470.      * 返回哈希表 key 中，一个或多个给定域的值  
  471.      * @param key  
  472.      * @param fields  
  473.      * @return  
  474.      */    
  475.     public List<String> hmget(String key, String... fields) {    
  476.         List<String> result = null;    
  477.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  478.         if (shardedJedis == null) {    
  479.             return result;    
  480.         }    
  481.         boolean broken = false;    
  482.         try {    
  483.             result = shardedJedis.hmget(key, fields);    
  484.     
  485.         } catch (Exception e) {    
  486.             log.error(e.getMessage(), e);    
  487.             broken = true;    
  488.         } finally {    
  489.             redisDataSource.returnResource(shardedJedis, broken);    
  490.         }    
  491.         return result;    
  492.     }    
  493.     /**  
  494.      * 为哈希表 key 中的域 field 的值加上增量 value  
  495.      * @param key  
  496.      * @param field  
  497.      * @param value  
  498.      * @return  
  499.      */    
  500.     public Long hincrBy(String key, String field, long value) {    
  501.         Long result = null;    
  502.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  503.         if (shardedJedis == null) {    
  504.             return result;    
  505.         }    
  506.         boolean broken = false;    
  507.         try {    
  508.             result = shardedJedis.hincrBy(key, field, value);    
  509.     
  510.         } catch (Exception e) {    
  511.             log.error(e.getMessage(), e);    
  512.             broken = true;    
  513.         } finally {    
  514.             redisDataSource.returnResource(shardedJedis, broken);    
  515.         }    
  516.         return result;    
  517.     }    
  518.     /**  
  519.      * 查看哈希表 key 中，给定域 field 是否存在。  
  520.      * @param key  
  521.      * @param field  
  522.      * @return  
  523.      */    
  524.     public Boolean hexists(String key, String field) {    
  525.         Boolean result = false;    
  526.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  527.         if (shardedJedis == null) {    
  528.             return result;    
  529.         }    
  530.         boolean broken = false;    
  531.         try {    
  532.             result = shardedJedis.hexists(key, field);    
  533.     
  534.         } catch (Exception e) {    
  535.             log.error(e.getMessage(), e);    
  536.             broken = true;    
  537.         } finally {    
  538.             redisDataSource.returnResource(shardedJedis, broken);    
  539.         }    
  540.         return result;    
  541.     }    
  542.     /**  
  543.      * 删除key  
  544.      * @param key  
  545.      * @return  
  546.      */    
  547.     public Long del(String key) {    
  548.         Long result = null;    
  549.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  550.         if (shardedJedis == null) {    
  551.             return result;    
  552.         }    
  553.         boolean broken = false;    
  554.         try {    
  555.             result = shardedJedis.del(key);    
  556.     
  557.         } catch (Exception e) {    
  558.             log.error(e.getMessage(), e);    
  559.             broken = true;    
  560.         } finally {    
  561.             redisDataSource.returnResource(shardedJedis, broken);    
  562.         }    
  563.         return result;    
  564.     }    
  565.     /**  
  566.      * 删除哈希表 key 中的一个或多个指定域。  
  567.      * @param key  
  568.      * @param field  
  569.      * @return  
  570.      */    
  571.     public Long hdel(String key, String field) {    
  572.         Long result = null;    
  573.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  574.         if (shardedJedis == null) {    
  575.             return result;    
  576.         }    
  577.         boolean broken = false;    
  578.         try {    
  579.             result = shardedJedis.hdel(key, field);    
  580.     
  581.         } catch (Exception e) {    
  582.             log.error(e.getMessage(), e);    
  583.             broken = true;    
  584.         } finally {    
  585.             redisDataSource.returnResource(shardedJedis, broken);    
  586.         }    
  587.         return result;    
  588.     }    
  589.     /**  
  590.      * 返回哈希表 key 中域的数量。  
  591.      * @param key  
  592.      * @return  
  593.      */    
  594.     public Long hlen(String key) {    
  595.         Long result = null;    
  596.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  597.         if (shardedJedis == null) {    
  598.             return result;    
  599.         }    
  600.         boolean broken = false;    
  601.         try {    
  602.             result = shardedJedis.hlen(key);    
  603.     
  604.         } catch (Exception e) {    
  605.             log.error(e.getMessage(), e);    
  606.             broken = true;    
  607.         } finally {    
  608.             redisDataSource.returnResource(shardedJedis, broken);    
  609.         }    
  610.         return result;    
  611.     }    
  612.     /**  
  613.      * 返回哈希表 key 中的所有域。  
  614.      * @param key  
  615.      * @return  
  616.      */    
  617.     public Set<String> hkeys(String key) {    
  618.         Set<String> result = null;    
  619.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  620.         if (shardedJedis == null) {    
  621.             return result;    
  622.         }    
  623.         boolean broken = false;    
  624.         try {    
  625.             result = shardedJedis.hkeys(key);    
  626.     
  627.         } catch (Exception e) {    
  628.             log.error(e.getMessage(), e);    
  629.             broken = true;    
  630.         } finally {    
  631.             redisDataSource.returnResource(shardedJedis, broken);    
  632.         }    
  633.         return result;    
  634.     }    
  635.     /**  
  636.      * 返回哈希表 key 中所有域的值。  
  637.      * @param key  
  638.      * @return  
  639.      */    
  640.     public List<String> hvals(String key) {    
  641.         List<String> result = null;    
  642.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  643.         if (shardedJedis == null) {    
  644.             return result;    
  645.         }    
  646.         boolean broken = false;    
  647.         try {    
  648.             result = shardedJedis.hvals(key);    
  649.     
  650.         } catch (Exception e) {    
  651.             log.error(e.getMessage(), e);    
  652.             broken = true;    
  653.         } finally {    
  654.             redisDataSource.returnResource(shardedJedis, broken);    
  655.         }    
  656.         return result;    
  657.     }    
  658.      /**  
  659.       * 返回哈希表 key 中，所有的域和值。  
  660.       * @param key  
  661.       * @return  
  662.       */    
  663.     public Map<String, String> hgetAll(String key) {    
  664.         Map<String, String> result = null;    
  665.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  666.         if (shardedJedis == null) {    
  667.             return result;    
  668.         }    
  669.         boolean broken = false;    
  670.         try {    
  671.             result = shardedJedis.hgetAll(key);    
  672.     
  673.         } catch (Exception e) {    
  674.             log.error(e.getMessage(), e);    
  675.             broken = true;    
  676.         } finally {    
  677.             redisDataSource.returnResource(shardedJedis, broken);    
  678.         }    
  679.         return result;    
  680.     }    
  681.     
  682.     // ================list ====== l表示 list或 left, r表示right====================    
  683.     /**  
  684.      * 将一个或多个值 value 插入到列表 key 的表尾(最右边)  
  685.      * @param key  
  686.      * @param string  
  687.      * @return  
  688.      */    
  689.     public Long rpush(String key, String string) {    
  690.         Long result = null;    
  691.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  692.         if (shardedJedis == null) {    
  693.             return result;    
  694.         }    
  695.         boolean broken = false;    
  696.         try {    
  697.             result = shardedJedis.rpush(key, string);    
  698.     
  699.         } catch (Exception e) {    
  700.             log.error(e.getMessage(), e);    
  701.             broken = true;    
  702.         } finally {    
  703.             redisDataSource.returnResource(shardedJedis, broken);    
  704.         }    
  705.         return result;    
  706.     }    
  707.     /**  
  708.      * 将一个或多个值 value 插入到列表 key 的表头  
  709.      * @param key  
  710.      * @param string  
  711.      * @return  
  712.      */    
  713.     public Long lpush(String key, String string) {    
  714.         Long result = null;    
  715.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  716.         if (shardedJedis == null) {    
  717.             return result;    
  718.         }    
  719.         boolean broken = false;    
  720.         try {    
  721.             result = shardedJedis.lpush(key, string);    
  722.     
  723.         } catch (Exception e) {    
  724.             log.error(e.getMessage(), e);    
  725.             broken = true;    
  726.         } finally {    
  727.             redisDataSource.returnResource(shardedJedis, broken);    
  728.         }    
  729.         return result;    
  730.     }    
  731.     /**  
  732.      * 返回列表 key 的长度。  
  733.      * @param key  
  734.      * @return  
  735.      */    
  736.     public Long llen(String key) {    
  737.         Long result = null;    
  738.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  739.         if (shardedJedis == null) {    
  740.             return result;    
  741.         }    
  742.         boolean broken = false;    
  743.         try {    
  744.             result = shardedJedis.llen(key);    
  745.     
  746.         } catch (Exception e) {    
  747.             log.error(e.getMessage(), e);    
  748.             broken = true;    
  749.         } finally {    
  750.             redisDataSource.returnResource(shardedJedis, broken);    
  751.         }    
  752.         return result;    
  753.     }    
  754.      /**  
  755.       * 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定  
  756.       * @param key  
  757.       * @param start  
  758.       * @param end  
  759.       * @return  
  760.       */    
  761.     public List<String> lrange(String key, long start, long end) {    
  762.         List<String> result = null;    
  763.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  764.         if (shardedJedis == null) {    
  765.             return result;    
  766.         }    
  767.         boolean broken = false;    
  768.         try {    
  769.             result = shardedJedis.lrange(key, start, end);    
  770.     
  771.         } catch (Exception e) {    
  772.             log.error(e.getMessage(), e);    
  773.             broken = true;    
  774.         } finally {    
  775.             redisDataSource.returnResource(shardedJedis, broken);    
  776.         }    
  777.         return result;    
  778.     }    
  779.     /**  
  780.      * 只保留指定区间内的元素，不在指定区间之内的元素都将被删除  
  781.      * @param key  
  782.      * @param start  
  783.      * @param end  
  784.      * @return  
  785.      */    
  786.     public String ltrim(String key, long start, long end) {    
  787.         String result = null;    
  788.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  789.         if (shardedJedis == null) {    
  790.             return result;    
  791.         }    
  792.         boolean broken = false;    
  793.         try {    
  794.             result = shardedJedis.ltrim(key, start, end);    
  795.     
  796.         } catch (Exception e) {    
  797.             log.error(e.getMessage(), e);    
  798.             broken = true;    
  799.         } finally {    
  800.             redisDataSource.returnResource(shardedJedis, broken);    
  801.         }    
  802.         return result;    
  803.     }    
  804.     /**  
  805.      * 返回列表 key 中，下标为 index 的元素。  
  806.      * @param key  
  807.      * @param index  
  808.      * @return  
  809.      */    
  810.     public String lindex(String key, long index) {    
  811.         String result = null;    
  812.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  813.         if (shardedJedis == null) {    
  814.             return result;    
  815.         }    
  816.         boolean broken = false;    
  817.         try {    
  818.             result = shardedJedis.lindex(key, index);    
  819.     
  820.         } catch (Exception e) {    
  821.             log.error(e.getMessage(), e);    
  822.             broken = true;    
  823.         } finally {    
  824.             redisDataSource.returnResource(shardedJedis, broken);    
  825.         }    
  826.         return result;    
  827.     }    
  828.     /**  
  829.      * 将列表 key 下标为 index 的元素的值设置为 value  
  830.      * @param key  
  831.      * @param index  
  832.      * @param value  
  833.      * @return  
  834.      */    
  835.     public String lset(String key, long index, String value) {    
  836.         String result = null;    
  837.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  838.         if (shardedJedis == null) {    
  839.             return result;    
  840.         }    
  841.         boolean broken = false;    
  842.         try {    
  843.             result = shardedJedis.lset(key, index, value);    
  844.     
  845.         } catch (Exception e) {    
  846.             log.error(e.getMessage(), e);    
  847.             broken = true;    
  848.         } finally {    
  849.             redisDataSource.returnResource(shardedJedis, broken);    
  850.         }    
  851.         return result;    
  852.     }    
  853.     
  854.   /**  
  855.    * 移除并返回列表 key 的头元素  
  856.    * @param key  
  857.    * @return  
  858.    */    
  859.     public String lpop(String key) {    
  860.         String result = null;    
  861.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  862.         if (shardedJedis == null) {    
  863.             return result;    
  864.         }    
  865.         boolean broken = false;    
  866.         try {    
  867.             result = shardedJedis.lpop(key);    
  868.     
  869.         } catch (Exception e) {    
  870.             log.error(e.getMessage(), e);    
  871.             broken = true;    
  872.         } finally {    
  873.             redisDataSource.returnResource(shardedJedis, broken);    
  874.         }    
  875.         return result;    
  876.     }    
  877.     /**  
  878.      * 移除并返回列表 key 的尾元素。  
  879.      * @param key  
  880.      * @return  
  881.      */    
  882.     public String rpop(String key) {    
  883.         String result = null;    
  884.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  885.         if (shardedJedis == null) {    
  886.             return result;    
  887.         }    
  888.         boolean broken = false;    
  889.         try {    
  890.             result = shardedJedis.rpop(key);    
  891.     
  892.         } catch (Exception e) {    
  893.             log.error(e.getMessage(), e);    
  894.             broken = true;    
  895.         } finally {    
  896.             redisDataSource.returnResource(shardedJedis, broken);    
  897.         }    
  898.         return result;    
  899.     }    
  900.     
  901.     //return 1 add a not exist value ,    
  902.     //return 0 add a exist value    
  903.     /**  
  904.      * 将一个或多个 member 元素加入到集合 key 当中  
  905.      * @param key  
  906.      * @param member  
  907.      * @return  
  908.      */    
  909.     public Long sadd(String key, String member) {    
  910.         Long result = null;    
  911.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  912.         if (shardedJedis == null) {    
  913.             return result;    
  914.         }    
  915.         boolean broken = false;    
  916.         try {    
  917.             result = shardedJedis.sadd(key, member);    
  918.     
  919.         } catch (Exception e) {    
  920.             log.error(e.getMessage(), e);    
  921.             broken = true;    
  922.         } finally {    
  923.             redisDataSource.returnResource(shardedJedis, broken);    
  924.         }    
  925.         return result;    
  926.     }    
  927.     /**  
  928.      * 返回集合 key 中的所有成员。  
  929.      * @param key  
  930.      * @return  
  931.      */    
  932.     public Set<String> smembers(String key) {    
  933.         Set<String> result = null;    
  934.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  935.         if (shardedJedis == null) {    
  936.             return result;    
  937.         }    
  938.         boolean broken = false;    
  939.         try {    
  940.             result = shardedJedis.smembers(key);    
  941.     
  942.         } catch (Exception e) {    
  943.             log.error(e.getMessage(), e);    
  944.             broken = true;    
  945.         } finally {    
  946.             redisDataSource.returnResource(shardedJedis, broken);    
  947.         }    
  948.         return result;    
  949.     }    
  950.     
  951.     /**  
  952.      * 返回集合 key 的基数(集合中元素的数量)  
  953.      * @param key  
  954.      * @return  
  955.      */    
  956.     public Long scard(String key) {    
  957.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  958.         Long result = null;    
  959.         if (shardedJedis == null) {    
  960.             return result;    
  961.         }    
  962.         boolean broken = false;    
  963.         try {    
  964.             result = shardedJedis.scard(key);    
  965.     
  966.         } catch (Exception e) {    
  967.             log.error(e.getMessage(), e);    
  968.             broken = true;    
  969.         } finally {    
  970.             redisDataSource.returnResource(shardedJedis, broken);    
  971.         }    
  972.         return result;    
  973.     }    
  974.     /**  
  975.      * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中  
  976.      * @param key  
  977.      * @param score  
  978.      * @param member  
  979.      * @return  
  980.      */    
  981.     public Long zadd(String key, double score, String member) {    
  982.         Long result = null;    
  983.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  984.         if (shardedJedis == null) {    
  985.             return result;    
  986.         }    
  987.         boolean broken = false;    
  988.         try {    
  989.             result = shardedJedis.zadd(key, score, member);    
  990.         } catch (Exception e) {    
  991.             log.error(e.getMessage(), e);    
  992.             broken = true;    
  993.         } finally {    
  994.             redisDataSource.returnResource(shardedJedis, broken);    
  995.         }    
  996.         return result;    
  997.     }    
  998.     /**  
  999.      * 返回有序集 key 中，指定区间内的成员  
  1000.      * @param key  
  1001.      * @param start  
  1002.      * @param end  
  1003.      * @return  
  1004.      */    
  1005.     public Set<String> zrange(String key, int start, int end) {    
  1006.         Set<String> result = null;    
  1007.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1008.         if (shardedJedis == null) {    
  1009.             return result;    
  1010.         }    
  1011.         boolean broken = false;    
  1012.         try {    
  1013.             result = shardedJedis.zrange(key, start, end);    
  1014.         } catch (Exception e) {    
  1015.             log.error(e.getMessage(), e);    
  1016.             broken = true;    
  1017.         } finally {    
  1018.             redisDataSource.returnResource(shardedJedis, broken);    
  1019.         }    
  1020.         return result;    
  1021.     }    
  1022.     /**  
  1023.      * 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略  
  1024.      * @param key  
  1025.      * @param member  
  1026.      * @return  
  1027.      */    
  1028.     public Long zrem(String key, String member) {    
  1029.         Long result = null;    
  1030.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1031.         if (shardedJedis == null) {    
  1032.             return result;    
  1033.         }    
  1034.         boolean broken = false;    
  1035.         try {    
  1036.             result = shardedJedis.zrem(key, member);    
  1037.         } catch (Exception e) {    
  1038.             log.error(e.getMessage(), e);    
  1039.             broken = true;    
  1040.         } finally {    
  1041.             redisDataSource.returnResource(shardedJedis, broken);    
  1042.         }    
  1043.         return result;    
  1044.     }    
  1045.     /**  
  1046.      * 为有序集 key 的成员 member 的 score 值加上增量 member 。  
  1047.      * @param key  
  1048.      * @param score  
  1049.      * @param member  
  1050.      * @return  
  1051.      */    
  1052.     public Double zincrby(String key, double score, String member) {    
  1053.         Double result = null;    
  1054.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1055.         if (shardedJedis == null) {    
  1056.             return result;    
  1057.         }    
  1058.         boolean broken = false;    
  1059.         try {    
  1060.     
  1061.             result = shardedJedis.zincrby(key, score, member);    
  1062.     
  1063.         } catch (Exception e) {    
  1064.             log.error(e.getMessage(), e);    
  1065.             broken = true;    
  1066.         } finally {    
  1067.             redisDataSource.returnResource(shardedJedis, broken);    
  1068.         }    
  1069.         return result;    
  1070.     }    
  1071.     /**  
  1072.      * 回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列  
  1073.      * @param key  
  1074.      * @param member  
  1075.      * @return  
  1076.      */    
  1077.     public Long zrank(String key, String member) {    
  1078.         Long result = null;    
  1079.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1080.         if (shardedJedis == null) {    
  1081.             return result;    
  1082.         }    
  1083.         boolean broken = false;    
  1084.         try {    
  1085.     
  1086.             result = shardedJedis.zrank(key, member);    
  1087.     
  1088.         } catch (Exception e) {    
  1089.             log.error(e.getMessage(), e);    
  1090.             broken = true;    
  1091.         } finally {    
  1092.             redisDataSource.returnResource(shardedJedis, broken);    
  1093.         }    
  1094.         return result;    
  1095.     }    
  1096.     /**  
  1097.      * 返回有序集 key 的基数  
  1098.      * @param key  
  1099.      * @return  
  1100.      */    
  1101.         public Long zcard(String key) {    
  1102.         Long result = null;    
  1103.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1104.         if (shardedJedis == null) {    
  1105.             return result;    
  1106.         }    
  1107.         boolean broken = false;    
  1108.         try {    
  1109.     
  1110.             result = shardedJedis.zcard(key);    
  1111.     
  1112.         } catch (Exception e) {    
  1113.             log.error(e.getMessage(), e);    
  1114.             broken = true;    
  1115.         } finally {    
  1116.             redisDataSource.returnResource(shardedJedis, broken);    
  1117.         }    
  1118.         return result;    
  1119.     }    
  1120.     /**  
  1121.      * 返回有序集 key 中，成员 member 的 score 值。  
  1122.      * @param key  
  1123.      * @param member  
  1124.      * @return  
  1125.      */    
  1126.     public Double zscore(String key, String member) {    
  1127.         Double result = null;    
  1128.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1129.         if (shardedJedis == null) {    
  1130.             return result;    
  1131.         }    
  1132.         boolean broken = false;    
  1133.         try {    
  1134.     
  1135.             result = shardedJedis.zscore(key, member);    
  1136.     
  1137.         } catch (Exception e) {    
  1138.             log.error(e.getMessage(), e);    
  1139.             broken = true;    
  1140.         } finally {    
  1141.             redisDataSource.returnResource(shardedJedis, broken);    
  1142.         }    
  1143.         return result;    
  1144.     }    
  1145.     
  1146.    /**  
  1147.     * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量  
  1148.     * @param key  
  1149.     * @param min  
  1150.     * @param max  
  1151.     * @return  
  1152.     */    
  1153.     public Long zcount(String key, double min, double max) {    
  1154.         Long result = null;    
  1155.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1156.         if (shardedJedis == null) {    
  1157.             return result;    
  1158.         }    
  1159.         boolean broken = false;    
  1160.         try {    
  1161.     
  1162.             result = shardedJedis.zcount(key, min, max);    
  1163.     
  1164.         } catch (Exception e) {    
  1165.             log.error(e.getMessage(), e);    
  1166.             broken = true;    
  1167.         } finally {    
  1168.             redisDataSource.returnResource(shardedJedis, broken);    
  1169.         }    
  1170.         return result;    
  1171.     }    
  1172.     
  1173.     /**  
  1174.      * 批量存储  
  1175.      * @param key  
  1176.      * @param value  
  1177.      * @return  
  1178.      */    
  1179.     public String set(byte[] key, byte[] value) {    
  1180.         String result = null;    
  1181.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1182.         if (shardedJedis == null) {    
  1183.             return result;    
  1184.         }    
  1185.         boolean broken = false;    
  1186.         try {    
  1187.     
  1188.             result = shardedJedis.set(key, value);    
  1189.     
  1190.         } catch (Exception e) {    
  1191.             log.error(e.getMessage(), e);    
  1192.             broken = true;    
  1193.         } finally {    
  1194.             redisDataSource.returnResource(shardedJedis, broken);    
  1195.         }    
  1196.         return result;    
  1197.     }    
  1198.     /**  
  1199.      * 获取多个key的值  
  1200.      * @param key  
  1201.      * @return  
  1202.      */    
  1203.     public byte[] get(byte[] key) {    
  1204.         byte[] result = null;    
  1205.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1206.         if (shardedJedis == null) {    
  1207.             return result;    
  1208.         }    
  1209.         boolean broken = false;    
  1210.         try {    
  1211.     
  1212.             result = shardedJedis.get(key);    
  1213.     
  1214.         } catch (Exception e) {    
  1215.             log.error(e.getMessage(), e);    
  1216.             broken = true;    
  1217.         } finally {    
  1218.             redisDataSource.returnResource(shardedJedis, broken);    
  1219.         }    
  1220.         return result;    
  1221.     }    
  1222.     /**  
  1223.      * 判断多个key存在  
  1224.      * @param key  
  1225.      * @return  
  1226.      */    
  1227.     public Boolean exists(byte[] key) {    
  1228.         Boolean result = false;    
  1229.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1230.         if (shardedJedis == null) {    
  1231.             return result;    
  1232.         }    
  1233.         boolean broken = false;    
  1234.         try {    
  1235.     
  1236.             result = shardedJedis.exists(key);    
  1237.     
  1238.         } catch (Exception e) {    
  1239.             log.error(e.getMessage(), e);    
  1240.             broken = true;    
  1241.         } finally {    
  1242.             redisDataSource.returnResource(shardedJedis, broken);    
  1243.         }    
  1244.         return result;    
  1245.     }    
  1246.     
  1247.     public Long expire(byte[] key, int seconds) {    
  1248.         Long result = null;    
  1249.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1250.         if (shardedJedis == null) {    
  1251.             return result;    
  1252.         }    
  1253.         boolean broken = false;    
  1254.         try {    
  1255.     
  1256.             result = shardedJedis.expire(key, seconds);    
  1257.     
  1258.         } catch (Exception e) {    
  1259.             log.error(e.getMessage(), e);    
  1260.             broken = true;    
  1261.         } finally {    
  1262.             redisDataSource.returnResource(shardedJedis, broken);    
  1263.         }    
  1264.         return result;    
  1265.     }    
  1266.     
  1267.     public Long expireAt(byte[] key, long unixTime) {    
  1268.         Long result = null;    
  1269.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1270.         if (shardedJedis == null) {    
  1271.             return result;    
  1272.         }    
  1273.         boolean broken = false;    
  1274.         try {    
  1275.     
  1276.             result = shardedJedis.expireAt(key, unixTime);    
  1277.     
  1278.         } catch (Exception e) {    
  1279.             log.error(e.getMessage(), e);    
  1280.             broken = true;    
  1281.         } finally {    
  1282.             redisDataSource.returnResource(shardedJedis, broken);    
  1283.         }    
  1284.         return result;    
  1285.     }    
  1286.     
  1287.     public Long ttl(byte[] key) {    
  1288.         Long result = null;    
  1289.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1290.         if (shardedJedis == null) {    
  1291.             return result;    
  1292.         }    
  1293.         boolean broken = false;    
  1294.         try {    
  1295.     
  1296.             result = shardedJedis.ttl(key);    
  1297.     
  1298.         } catch (Exception e) {    
  1299.             log.error(e.getMessage(), e);    
  1300.             broken = true;    
  1301.         } finally {    
  1302.             redisDataSource.returnResource(shardedJedis, broken);    
  1303.         }    
  1304.         return result;    
  1305.     }    
  1306.     
  1307.     public Long append(byte[] key, byte[] value) {    
  1308.         Long result = null;    
  1309.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1310.         if (shardedJedis == null) {    
  1311.             return result;    
  1312.         }    
  1313.         boolean broken = false;    
  1314.         try {    
  1315.     
  1316.             result = shardedJedis.append(key, value);    
  1317.     
  1318.         } catch (Exception e) {    
  1319.             log.error(e.getMessage(), e);    
  1320.             broken = true;    
  1321.         } finally {    
  1322.             redisDataSource.returnResource(shardedJedis, broken);    
  1323.         }    
  1324.         return result;    
  1325.     }    
  1326.     
  1327.    /**  
  1328.     * 批量增加到hash  
  1329.     * @param key  
  1330.     * @param field  
  1331.     * @param value  
  1332.     * @return  
  1333.     */    
  1334.     public Long hset(byte[] key, byte[] field, byte[] value) {    
  1335.         Long result = null;    
  1336.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1337.         if (shardedJedis == null) {    
  1338.             return result;    
  1339.         }    
  1340.         boolean broken = false;    
  1341.         try {    
  1342.     
  1343.             result = shardedJedis.hset(key, field, value);    
  1344.     
  1345.         } catch (Exception e) {    
  1346.             log.error(e.getMessage(), e);    
  1347.             broken = true;    
  1348.         } finally {    
  1349.             redisDataSource.returnResource(shardedJedis, broken);    
  1350.         }    
  1351.         return result;    
  1352.     }    
  1353.     /**  
  1354.      * 批量获取field域值  
  1355.      * @param key  
  1356.      * @param field  
  1357.      * @return  
  1358.      */    
  1359.     public byte[] hget(byte[] key, byte[] field) {    
  1360.         byte[] result = null;    
  1361.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1362.         if (shardedJedis == null) {    
  1363.             return result;    
  1364.         }    
  1365.         boolean broken = false;    
  1366.         try {    
  1367.     
  1368.             result = shardedJedis.hget(key, field);    
  1369.     
  1370.         } catch (Exception e) {    
  1371.             log.error(e.getMessage(), e);    
  1372.             broken = true;    
  1373.         } finally {    
  1374.             redisDataSource.returnResource(shardedJedis, broken);    
  1375.         }    
  1376.         return result;    
  1377.     }    
  1378.     
  1379.     public String hmset(byte[] key, Map<byte[], byte[]> hash) {    
  1380.         String result = null;    
  1381.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1382.         if (shardedJedis == null) {    
  1383.             return result;    
  1384.         }    
  1385.         boolean broken = false;    
  1386.         try {    
  1387.     
  1388.             result = shardedJedis.hmset(key, hash);    
  1389.     
  1390.         } catch (Exception e) {    
  1391.     
  1392.             log.error(e.getMessage(), e);    
  1393.             broken = true;    
  1394.         } finally {    
  1395.             redisDataSource.returnResource(shardedJedis, broken);    
  1396.         }    
  1397.         return result;    
  1398.     }    
  1399.     
  1400.     public List<byte[]> hmget(byte[] key, byte[]... fields) {    
  1401.         List<byte[]> result = null;    
  1402.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1403.         if (shardedJedis == null) {    
  1404.             return result;    
  1405.         }    
  1406.         boolean broken = false;    
  1407.         try {    
  1408.     
  1409.             result = shardedJedis.hmget(key, fields);    
  1410.     
  1411.         } catch (Exception e) {    
  1412.     
  1413.             log.error(e.getMessage(), e);    
  1414.             broken = true;    
  1415.         } finally {    
  1416.             redisDataSource.returnResource(shardedJedis, broken);    
  1417.         }    
  1418.         return result;    
  1419.     }    
  1420.     
  1421.         
  1422.     public Boolean hexists(byte[] key, byte[] field) {    
  1423.         Boolean result = false;    
  1424.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1425.         if (shardedJedis == null) {    
  1426.             return result;    
  1427.         }    
  1428.         boolean broken = false;    
  1429.         try {    
  1430.     
  1431.             result = shardedJedis.hexists(key, field);    
  1432.     
  1433.         } catch (Exception e) {    
  1434.     
  1435.             log.error(e.getMessage(), e);    
  1436.             broken = true;    
  1437.         } finally {    
  1438.             redisDataSource.returnResource(shardedJedis, broken);    
  1439.         }    
  1440.         return result;    
  1441.     }    
  1442.     /**  
  1443.      * 批量删除hash的key  
  1444.      * @param key  
  1445.      * @param field  
  1446.      * @return  
  1447.      */    
  1448.     public Long hdel(byte[] key, byte[] field) {    
  1449.         Long result = null;    
  1450.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1451.         if (shardedJedis == null) {    
  1452.             return result;    
  1453.         }    
  1454.         boolean broken = false;    
  1455.         try {    
  1456.     
  1457.             result = shardedJedis.hdel(key, field);    
  1458.     
  1459.         } catch (Exception e) {    
  1460.     
  1461.             log.error(e.getMessage(), e);    
  1462.             broken = true;    
  1463.         } finally {    
  1464.             redisDataSource.returnResource(shardedJedis, broken);    
  1465.         }    
  1466.         return result;    
  1467.     }    
  1468.     public Long rpush(byte[] key, byte[] string) {    
  1469.         Long result = null;    
  1470.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1471.         if (shardedJedis == null) {    
  1472.             return result;    
  1473.         }    
  1474.         boolean broken = false;    
  1475.         try {    
  1476.     
  1477.             result = shardedJedis.rpush(key, string);    
  1478.     
  1479.         } catch (Exception e) {    
  1480.     
  1481.             log.error(e.getMessage(), e);    
  1482.             broken = true;    
  1483.         } finally {    
  1484.             redisDataSource.returnResource(shardedJedis, broken);    
  1485.         }    
  1486.         return result;    
  1487.     }    
  1488.     
  1489.     public Long lpush(byte[] key, byte[] string) {    
  1490.         Long result = null;    
  1491.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1492.         if (shardedJedis == null) {    
  1493.             return result;    
  1494.         }    
  1495.         boolean broken = false;    
  1496.         try {    
  1497.     
  1498.             result = shardedJedis.lpush(key, string);    
  1499.     
  1500.         } catch (Exception e) {    
  1501.     
  1502.             log.error(e.getMessage(), e);    
  1503.             broken = true;    
  1504.         } finally {    
  1505.             redisDataSource.returnResource(shardedJedis, broken);    
  1506.         }    
  1507.         return result;    
  1508.     }    
  1509.     
  1510.     public Long llen(byte[] key) {    
  1511.         Long result = null;    
  1512.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1513.         if (shardedJedis == null) {    
  1514.             return result;    
  1515.         }    
  1516.         boolean broken = false;    
  1517.         try {    
  1518.     
  1519.             result = shardedJedis.llen(key);    
  1520.     
  1521.         } catch (Exception e) {    
  1522.     
  1523.             log.error(e.getMessage(), e);    
  1524.             broken = true;    
  1525.         } finally {    
  1526.             redisDataSource.returnResource(shardedJedis, broken);    
  1527.         }    
  1528.         return result;    
  1529.     }    
  1530.     
  1531.     public List<byte[]> lrange(byte[] key, int start, int end) {    
  1532.         List<byte[]> result = null;    
  1533.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1534.         if (shardedJedis == null) {    
  1535.             return result;    
  1536.         }    
  1537.         boolean broken = false;    
  1538.         try {    
  1539.     
  1540.             result = shardedJedis.lrange(key, start, end);    
  1541.     
  1542.         } catch (Exception e) {    
  1543.     
  1544.             log.error(e.getMessage(), e);    
  1545.             broken = true;    
  1546.         } finally {    
  1547.             redisDataSource.returnResource(shardedJedis, broken);    
  1548.         }    
  1549.         return result;    
  1550.     }    
  1551.     
  1552.        
  1553.     public String lset(byte[] key, int index, byte[] value) {    
  1554.         String result = null;    
  1555.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1556.         if (shardedJedis == null) {    
  1557.             return result;    
  1558.         }    
  1559.         boolean broken = false;    
  1560.         try {    
  1561.     
  1562.             result = shardedJedis.lset(key, index, value);    
  1563.     
  1564.         } catch (Exception e) {    
  1565.     
  1566.             log.error(e.getMessage(), e);    
  1567.             broken = true;    
  1568.         } finally {    
  1569.             redisDataSource.returnResource(shardedJedis, broken);    
  1570.         }    
  1571.         return result;    
  1572.     }    
  1573.     public Long lrem(byte[] key, int count, byte[] value) {    
  1574.         Long result = null;    
  1575.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1576.         if (shardedJedis == null) {    
  1577.             return result;    
  1578.         }    
  1579.         boolean broken = false;    
  1580.         try {    
  1581.     
  1582.             result = shardedJedis.lrem(key, count, value);    
  1583.     
  1584.         } catch (Exception e) {    
  1585.     
  1586.             log.error(e.getMessage(), e);    
  1587.             broken = true;    
  1588.         } finally {    
  1589.             redisDataSource.returnResource(shardedJedis, broken);    
  1590.         }    
  1591.         return result;    
  1592.     }    
  1593.     
  1594.     public byte[] lpop(byte[] key) {    
  1595.         byte[] result = null;    
  1596.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1597.         if (shardedJedis == null) {    
  1598.             return result;    
  1599.         }    
  1600.         boolean broken = false;    
  1601.         try {    
  1602.     
  1603.             result = shardedJedis.lpop(key);    
  1604.     
  1605.         } catch (Exception e) {    
  1606.     
  1607.             log.error(e.getMessage(), e);    
  1608.             broken = true;    
  1609.         } finally {    
  1610.             redisDataSource.returnResource(shardedJedis, broken);    
  1611.         }    
  1612.         return result;    
  1613.     }    
  1614.     
  1615.     public byte[] rpop(byte[] key) {    
  1616.         byte[] result = null;    
  1617.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1618.         if (shardedJedis == null) {    
  1619.             return result;    
  1620.         }    
  1621.         boolean broken = false;    
  1622.         try {    
  1623.     
  1624.             result = shardedJedis.rpop(key);    
  1625.     
  1626.         } catch (Exception e) {    
  1627.     
  1628.             log.error(e.getMessage(), e);    
  1629.             broken = true;    
  1630.         } finally {    
  1631.             redisDataSource.returnResource(shardedJedis, broken);    
  1632.         }    
  1633.         return result;    
  1634.     }    
  1635.   /**  
  1636.    *   批量增加到set  
  1637.    * @param key  
  1638.    * @param member  
  1639.    * @return  
  1640.    */    
  1641.     public Long sadd(byte[] key, byte[] member) {    
  1642.         Long result = null;    
  1643.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1644.         if (shardedJedis == null) {    
  1645.             return result;    
  1646.         }    
  1647.         boolean broken = false;    
  1648.         try {    
  1649.     
  1650.             result = shardedJedis.sadd(key, member);    
  1651.     
  1652.         } catch (Exception e) {    
  1653.     
  1654.             log.error(e.getMessage(), e);    
  1655.             broken = true;    
  1656.         } finally {    
  1657.             redisDataSource.returnResource(shardedJedis, broken);    
  1658.         }    
  1659.         return result;    
  1660.     }    
  1661.     
  1662.     public Set<byte[]> smembers(byte[] key) {    
  1663.         Set<byte[]> result = null;    
  1664.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1665.         if (shardedJedis == null) {    
  1666.             return result;    
  1667.         }    
  1668.         boolean broken = false;    
  1669.         try {    
  1670.     
  1671.             result = shardedJedis.smembers(key);    
  1672.     
  1673.         } catch (Exception e) {    
  1674.     
  1675.             log.error(e.getMessage(), e);    
  1676.             broken = true;    
  1677.         } finally {    
  1678.             redisDataSource.returnResource(shardedJedis, broken);    
  1679.         }    
  1680.         return result;    
  1681.     }    
  1682.     
  1683.     public Long scard(byte[] key) {    
  1684.         Long result = null;    
  1685.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1686.         if (shardedJedis == null) {    
  1687.             return result;    
  1688.         }    
  1689.         boolean broken = false;    
  1690.         try {    
  1691.     
  1692.             result = shardedJedis.scard(key);    
  1693.     
  1694.         } catch (Exception e) {    
  1695.     
  1696.             log.error(e.getMessage(), e);    
  1697.             broken = true;    
  1698.         } finally {    
  1699.             redisDataSource.returnResource(shardedJedis, broken);    
  1700.         }    
  1701.         return result;    
  1702.     }    
  1703.     
  1704.     public Long zadd(byte[] key, double score, byte[] member) {    
  1705.         Long result = null;    
  1706.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1707.         if (shardedJedis == null) {    
  1708.             return result;    
  1709.         }    
  1710.         boolean broken = false;    
  1711.         try {    
  1712.     
  1713.             result = shardedJedis.zadd(key, score, member);    
  1714.     
  1715.         } catch (Exception e) {    
  1716.     
  1717.             log.error(e.getMessage(), e);    
  1718.             broken = true;    
  1719.         } finally {    
  1720.             redisDataSource.returnResource(shardedJedis, broken);    
  1721.         }    
  1722.         return result;    
  1723.     }    
  1724.     
  1725.        
  1726.     public Long zcard(byte[] key) {    
  1727.         Long result = null;    
  1728.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1729.         if (shardedJedis == null) {    
  1730.             return result;    
  1731.         }    
  1732.         boolean broken = false;    
  1733.         try {    
  1734.     
  1735.             result = shardedJedis.zcard(key);    
  1736.     
  1737.         } catch (Exception e) {    
  1738.     
  1739.             log.error(e.getMessage(), e);    
  1740.             broken = true;    
  1741.         } finally {    
  1742.             redisDataSource.returnResource(shardedJedis, broken);    
  1743.         }    
  1744.         return result;    
  1745.     }    
  1746.     
  1747.     public JedisShardInfo getShardInfo(String key) {    
  1748.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1749.         JedisShardInfo result = null;    
  1750.         if (shardedJedis == null) {    
  1751.             return result;    
  1752.         }    
  1753.         boolean broken = false;    
  1754.         try {    
  1755.             result = shardedJedis.getShardInfo(key);    
  1756.         } catch (Exception e) {    
  1757.             log.error(e.getMessage(), e);    
  1758.             broken = true;    
  1759.         } finally {    
  1760.             redisDataSource.returnResource(shardedJedis, broken);    
  1761.         }    
  1762.         return result;    
  1763.     }    
  1764.     
  1765.     public Collection<JedisShardInfo> getAllShardInfo() {    
  1766.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1767.         Collection<JedisShardInfo> result = null;    
  1768.         if (shardedJedis == null) {    
  1769.             return result;    
  1770.         }    
  1771.         boolean broken = false;    
  1772.         try {    
  1773.             result = shardedJedis.getAllShardInfo();    
  1774.     
  1775.         } catch (Exception e) {    
  1776.             log.error(e.getMessage(), e);    
  1777.             broken = true;    
  1778.         } finally {    
  1779.             redisDataSource.returnResource(shardedJedis, broken);    
  1780.         }    
  1781.         return result;    
  1782.     }    
  1783.     
  1784.     public Collection<Jedis> getAllShards() {    
  1785.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
  1786.         Collection<Jedis> result = null;    
  1787.         if (shardedJedis == null) {    
  1788.             return result;    
  1789.         }    
  1790.         boolean broken = false;    
  1791.         try {    
  1792.             result = shardedJedis.getAllShards();    
  1793.     
  1794.         } catch (Exception e) {    
  1795.             log.error(e.getMessage(), e);    
  1796.             broken = true;    
  1797.         } finally {    
  1798.             redisDataSource.returnResource(shardedJedis, broken);    
  1799.         }    
  1800.         return result;    
  1801.     }    
  1802.     
  1803. }   


三.配置spring xml文件

[java]  view plain  copy
  1. <beans xmlns="http://www.springframework.org/schema/beans"    
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"    
  3.     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"    
  4.     xsi:schemaLocation="    
  5.     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd    
  6.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd    
  7.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">    
  8.       
  9.         
  10.     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">    
  11.        <property name="maxTotal" value="2048" />      
  12.        <property name="maxIdle" value="200" />      
  13.        <property name="numTestsPerEvictionRun" value="1024"/>      
  14.        <property name="timeBetweenEvictionRunsMillis" value="30000" />      
  15.        <property name="minEvictableIdleTimeMillis" value="-1" />      
  16.        <property name="softMinEvictableIdleTimeMillis" value="10000" />      
  17.        <property name="maxWaitMillis" value="1500"/>      
  18.        <property name="testOnBorrow" value="true" />      
  19.        <property name="testWhileIdle" value="true"/>      
  20.        <property name="testOnReturn" value="false"/>      
  21.        <property name="jmxEnabled" value="true"/>      
  22.        <property name="blockWhenExhausted" value="false"/>     
  23.     </bean>    
  24.     
  25.     <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">    
  26.         <constructor-arg index="0" ref="jedisPoolConfig" />    
  27.         <constructor-arg index="1">    
  28.             <list>    
  29.                 <bean class="redis.clients.jedis.JedisShardInfo">    
  30.                     <constructor-arg name="host" value="127.0.0.1" />    
  31.                     <constructor-arg name="port" value="6379" />    
  32.                     <constructor-arg name="timeout" value="10000" />    
  33.                 </bean>    
  34.             </list>    
  35.         </constructor-arg>    
  36.     </bean>    
  37.     <bean id="redisDataSource" class="redis.dao.RedisDataSourceImpl">    
  38.         <property name="shardedJedisPool" ref="shardedJedisPool"></property>    
  39.     </bean>    
  40.     <bean id="redisClientTemplate" class="redis.dao.RedisClientTemplate">    
  41.         <property name="redisDataSource" ref="redisDataSource"></property>    
  42.     </bean>    
  43. </beans>  

四.代码中的使用，原则就是在执行service时，先通过key到redis里检测是否存在，如果存在则在

redis里去数据,如果没有则到数据库去数据,然后存到redis里


[java]  view plain  copy
  1. public class StudentinfoServiceImpl implements StudentinfoService{    
  2.         
  3.     private StudentinfoDao studentinfoDao;    
  4.         
  5.     private RedisClientTemplate redisClientTemplate;    
  6.         
  7.     private static final ObjectMapper mapper=new ObjectMapper();    
  8.         
  9.     public List<Studentinfo> getStudentinfoByStu(Studentinfo stu) {    
  10.         String key="getStudentinfoByStu:usernumber:"+stu.getUsernumber()+":name:"+stu.getName()+":idnumber:"+stu.getIdnumber();    
  11.         try {    
  12.             boolean flag=redisClientTemplate.exists(key);    
  13.             if(flag){    
  14.                 String stuJsonStr=redisClientTemplate.get(key);    
  15.                 List<Studentinfo> list=mapper.readValue(stuJsonStr, new TypeReference<List<Studentinfo>>() {});    
  16.                 return list;    
  17.             }    
  18.         } catch (Exception e) {    
  19.             e.printStackTrace();    
  20.         }    
  21.         String hql="from Studentinfo where 1=1";    
  22.         if(stu!=null){    
  23.             if(stu.getUsernumber()!=null){    
  24.                 hql+=" and usernumber like '%"+stu.getUsernumber()+"%' ";    
  25.             }    
  26.         }    
  27.         List<Studentinfo> list = studentinfoDao.getStudentinfoByStu(hql);    
  28.         try {    
  29.             String stuJsonStr=mapper.writeValueAsString(list);    
  30.             redisClientTemplate.setex(key, 60, stuJsonStr);    
  31.         } catch (Exception e) {    
  32.             e.printStackTrace();    
  33.         }    
  34.         return list;    
  35.     }    
  36.         
  37.     
  38.     public StudentinfoDao getStudentinfoDao() {    
  39.         return studentinfoDao;    
  40.             
  41.     }    
  42.     
  43.     public void setStudentinfoDao(StudentinfoDao studentinfoDao) {    
  44.         this.studentinfoDao = studentinfoDao;    
  45.     }    
  46.     
  47.     public RedisClientTemplate getRedisClientTemplate() {    
  48.         return redisClientTemplate;    
  49.     }    
  50.     
  51.     public void setRedisClientTemplate(RedisClientTemplate redisClientTemplate) {    
  52.         this.redisClientTemplate = redisClientTemplate;    
  53.     }    
  54.     
  55. }   


原文
w_iceh
关注
JAVA WEB项目内置REDIS方法教程
洛阳泰山的博客
07-02 2496
需求场景 中型以上的公司，项目部署时，往往是又实施负责项目部署的，开发者给实施人员，提供部署文档，实施按照部署文档来部署项目。由于实施人员水平参差不齐，大不多数实施人员不懂技术。部署中间，会反复问开发人员问题。为了减少项目的部署环节和难度，小型项目会选择内置数据库和redis,下面介绍的是java web项目内置redis的方法 redis内置springboot项目方法 springboot项目pom文件引入 <!-- 内嵌redis server--> .
在Java程序中使用Redis
十年代码写十年
11-27 558
为了实际的工作和学习的需要，本教程会以 Spring 的视角为主向读者介绍在 Java 中如何使用 Redis，不过在基础章节会以 XML 方式的配置为主，而在实践章节则会以 Java 的配置为主介绍 Redis，你可以根据需要使用 XML 或者注解来实现你想要的功能。 在 Java 中使用 Redis 工具，要先下载 jedis.Jar 包，把它加载到工程的路径中，所以首先打开网站http:/...
Redis在Web项目中的应用与实践
weixin_33827590的博客
02-17 2020
原文链接：Redis在Web项目中的应用与实践 Redis作为一个开源的(BSD)基于内存的高性能存储系统，已经被各大互联网公司广泛使用，并且有着诸多的应用场景。本篇文章将基于PHP来详细讲解Redis在Web项目中的主要应用与实践。 缓存 这里所介绍的缓存是指可以丢失或过期的数据。常用的命令有 set, hset, get, hget...
redis在java项目中的使用
weixin_30306905的博客
10-28 224
在上一篇文章中已经讲了redis的spring配置，这篇将会描述redis在java项目中的使用。 redis存储形式都是key-value（键值对），按照存储的内容分为两种，一种是存简单数据，即数字，字符串等，可以用string-value的形式存储；另一种是存对象、集合等，最好用序列化的方式来存储。 1、存储简单数据 try { Jedis jedis = new...
redis在java中的使用
热门推荐
实践是最好的方法
12-05 1万+
点击阅读：关于redis的基础知识介绍 点击阅读：redis集成ibatis缓存 使用Java操作Redis需要jedis jar包 这里使用的是maven pom.xml <dependency> <groupId>redis.client</groupId> <artifactId>jedis</artifactId>
redis的java项目应用.zip
06-30
本项目实例将深入探讨如何在Java Web应用中集成和使用Redis，以提高系统的响应速度和整体性能。 首先，Redis是一个开源的内存数据结构存储系统，它可以存储键值对、字符串、哈希表、链表、集合等多种数据结构。它的...
Java web 项目电子商城
最新发布
05-30
springboot、springmvc、mybatis-plus、lombok、vue2.0，redis 准备环境： windows/mac、Idea jdk1.8、 mysql、maven、redis 功能说明 前台： 购买首页：展示商品信息 商品分类：按分类展示商品信息 我的...
Java简单实现session保存到redis的方法示例
08-27
Java简单实现session保存到redis的方法示例是将Java应用程序的session数据保存到Redis缓存服务器的方法，解决了在负载均衡情况下用户session不一致的问题。该方法通过配置web.xml文件中的过滤器，使用RedisTemplate...
spark-redis-bootstrap-buck:使用 spark、redis、bootstrap 和 buck 的 Java 8 Web 应用程序堆栈模板项目
06-11
spark-redis-bootstrap-buck 使用 spark、redis、bootstrap、jade 和 buck 的 Java 8 web 应用程序堆栈的模板项目 克隆我 安装并启动redis 运行 npm 安装 克隆 buck 并将 buck/bin 放在您的路径上 降压运行：srbb
Redis在java上的简单应用
tianjingsha_persume的博客
11-26 160
redis是一款缓存产品，可以把数据持久化到硬盘，支持key-value，list，set，zset，hash等结构类型的数据。 优点：读写性能极高，读的速度是110000次/s,写的速度是81000次/s。 实战使用： 要学使用redis技术，可以先在本地搞一个小demo。 1.windos系统需要先安装redis服务，下载地址：https://github.com/dmajkic/redis/...
redis java 使用_redis在java项目中的使用
weixin_39620679的博客
02-12 154
在上一篇文章中已经讲了redis的spring配置，这篇将会描述redis在java项目中的使用。redis存储形式都是key-value(键值对)，按照存储的内容分为两种，一种是存简单数据，即数字，字符串等，可以用string-value的形式存储；另一种是存对象、集合等，最好用序列化的方式来存储。1、存储简单数据try {Jedis jedis = new Jedis();jedis.set(...
Redis在javaWeb项目中的应用
asdfghjklor的博客
04-10 3529
1，自己搭建服务器，安装redis，网上很多单独安装方法，不说了 2，在javaweb工程中引入依赖，jedis是操作redis的客户端 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version&...
redis的使用 Java_redis在java项目中的使用
weixin_28931449的博客
02-12 1012
在上一篇文章中已经讲了redis的spring配置，这篇将会描述redis在java项目中的使用。redis存储形式都是key-value(键值对)，按照存储的内容分为两种，一种是存简单数据，即数字，字符串等，可以用string-value的形式存储；另一种是存对象、集合等，最好用序列化的方式来存储。1、存储简单数据try{Jedis jedis= newJedis();jedis.set("na...
Redis在Java程序开发中的应用
qq_42282792的博客
07-30 288
一、阻塞、非阻塞和多路复用器 1.阻塞 就是在等待的过程中，你不去做其他任何事情，一直等待响应 2.非阻塞 非阻塞,就是你再等待的过程中可以去做其他的事 3.多路复用器 多路复用器,接收请求，转发请求，但不处理请求，不会等待请求。 SpringBoot 整合 Redis 1. 引入 redis 依赖包 <!-- 引入 redis 依赖包 --> <dependency> <groupId>org.springframework.boot</groupId&gt
java web中使用redis_redis在web项目中使用 JavaWeb项目中加入redis缓存 - 电脑 - 云图网...
weixin_42715262的博客
02-28 360
redis在web项目中使用 JavaWeb项目中加入redis缓存2017-06-13 18:32:46实习电脑关于redis缓存的优缺点不再多做结束，请自行上网查询2.下载解压后，运行redis-server.exe3.测试写入代码package com.redis;import java.util.HashMap;import java.util.HashSet;import java.ut...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值