14.1 Redis入门

14.2 Redis数据模型

14.3 Jedis基础编程的实践案例

  1.         <dependency>
  2.             <groupId>redis.clients</groupId>
  3.             <artifactId>jedis</artifactId>
  4.             <version>2.9.0</version>
  5.         </dependency>

14.3.1 Jedis操作String字符串

  1.     @Test
  2.     public void operateString() {
  3.         Jedis jedis = new Jedis("localhost", 6379);
  4.         //如果返回 pang 代表链接成功
  5.         Logger.info("jedis.ping():" + jedis.ping());
  6.         //设置key0的值 123456
  7.         jedis.set("key0", "123456");
  8.         //返回数据类型  string
  9.         Logger.info("jedis.type(key0): " + jedis.type("key0"));
  10.         //get key
  11.         Logger.info("jedis.get(key0): " + jedis.get("key0"));
  12.         // key是否存在
  13.         Logger.info("jedis.exists(key0):" + jedis.exists("key0"));
  14.         //返回key的长度
  15.         Logger.info("jedis.strlen(key0): " + jedis.strlen("key0"));
  16.         //返回截取字符串, 范围 0,-1 表示截取全部
  17.         Logger.info("jedis.getrange(key0): " + jedis.getrange("key0", 0, -1));
  18.         //返回截取字符串, 范围 1,4 表示从表示区间[1,4]
  19.         Logger.info("jedis.getrange(key0): " + jedis.getrange("key0", 1, 4));
  21.          //追加
  22.         Logger.info("jedis.append(key0): " + jedis.append("key0", "appendStr"));
  23.         Logger.info("jedis.get(key0): " + jedis.get("key0"));
  25.         //重命名
  26.         jedis.rename("key0", "key0_new");
  27.         //判断key 是否存在
  28.         Logger.info("jedis.exists(key0): " + jedis.exists("key0"));
  30.         //批量插入
  31.         jedis.mset("key1", "val1", "key2", "val2", "key3", "100");
  32.         //批量取出
  33.         Logger.info("jedis.mget(key1,key2,key3): " + jedis.mget("key1", "key2", "key3"));
  34.         //删除
  35.         Logger.info("jedis.del(key1): " + jedis.del("key1"));
  36.         Logger.info("jedis.exists(key1): " + jedis.exists("key1"));
  37.         //取出旧值 并set新值
  38.         Logger.info("jedis.getSet(key2): " + jedis.getSet("key2", "value3"));
  39.         //自增1 要求数值类型
  40.         Logger.info("jedis.incr(key3): " + jedis.incr("key3"));
  41.         //自增15 要求数值类型
  42.         Logger.info("jedis.incrBy(key3): " + jedis.incrBy("key3", 15));
  43.         //自减1 要求数值类型
  44.         Logger.info("jedis.decr(key3): " + jedis.decr("key3"));
  45.         //自减5 要求数值类型
  46.         Logger.info("jedis.decrBy(key3): " + jedis.decrBy("key3", 15));
  47.         //增加浮点类型
  48.         Logger.info("jedis.incrByFloat(key3): " + jedis.incrByFloat("key3", 1.1));
  50.         //返回0 只有在key不存在的时候才设置
  51.         Logger.info("jedis.setnx(key3): " + jedis.setnx("key3", "existVal"));
  52.         Logger.info("jedis.get(key3): " + jedis.get("key3"));// 3.1
  54.         //只有key都不存在的时候才设置,这里返回 null
  55.         Logger.info("jedis.msetnx(key2,key3): " + jedis.msetnx("key2", "exists1", "key3", "exists2"));
  56.         Logger.info("jedis.mget(key2,key3): " + jedis.mget("key2", "key3"));
  58.         //设置key 2 秒后失效
  59.         jedis.setex("key4", 2, "2 seconds is no Val");
  60.         try {
  61.             Thread.sleep(3000);
  62.         } catch (InterruptedException e) {
  63.             e.printStackTrace();
  64.         }
  65.         // 2 seconds is no Val
  66.         Logger.info("jedis.get(key4): " + jedis.get("key4"));
  69.         jedis.set("key6", "123456789");
  70.         //下标从0开始，从第三位开始,将新值覆盖旧值
  71.         jedis.setrange("key6", 3, "abcdefg");
  72.         //返回：123abcdefg
  73.         Logger.info("jedis.get(key6): " + jedis.get("key6"));
  75.         //返回所有匹配的key
  76.         Logger.info("jedis.get(key*): " + jedis.keys("key*"));
  78.         jedis.close();
  80.     }

14.3.2 Jedis操作List列表

  1.     @Test
  2.     public void operateList() {
  3.         Jedis jedis = new Jedis("localhost");
  4.         Logger.info("jedis.ping(): " +jedis.ping());
  5.         jedis.del("list1");
  7.         //从list尾部添加3个元素
  8.         jedis.rpush("list1", "zhangsan", "lisi", "wangwu");
  10.         //取得类型, list
  11.         Logger.info("jedis.type(): " +jedis.type("list1"));
  13.         //遍历区间[0,-1]，取得全部的元素
  14.         Logger.info("jedis.lrange(0,-1): " +jedis.lrange("list1", 0, -1));
  15.         //遍历区间[1,2]，取得区间的元素
  16.         Logger.info("jedis.lrange(1,2): " +jedis.lrange("list1", 1, 2));
  18.         //获取list长度
  19.         Logger.info("jedis.llen(list1): " +jedis.llen("list1"));
  20.         //获取下标为 1 的元素
  21.         Logger.info("jedis.lindex(list1,1): " +jedis.lindex("list1", 1));
  22.         //左侧弹出元素
  23.         Logger.info("jedis.lpop(): " +jedis.lpop("list1"));
  24.         //右侧弹出元素
  25.         Logger.info("jedis.rpop(): " +jedis.rpop("list1"));
  26.         //设置下标为0的元素val
  27.         jedis.lset("list1", 0, "lisi2");
  28.         //最后，遍历区间[0,-1]，取得全部的元素
  29.         Logger.info("jedis.lrange(0,-1): " +jedis.lrange("list1", 0, -1));
  31.         jedis.close();
  32.     }

14.3.3 Jedis操作Hash哈希表

  1.     @Test
  2.     public void operateHash() {
  4.         Jedis jedis = new Jedis("localhost");
  5.         jedis.del("config");
  6.         //设置hash的 field-value 对
  7.         jedis.hset("config", "ip", "127.0.0.1");
  10.         //取得hash的 field的关联的value值
  11.         Logger.info("jedis.hget(): " + jedis.hget("config", "ip"));
  12.         //取得类型：hash
  13.         Logger.info("jedis.type(): " + jedis.type("config"));
  15.         //批量添加 field-value 对，参数为java map
  16.         Map<String, String> configFields = new HashMap<String, String>();
  17.         configFields.put("port", "8080");
  18.         configFields.put("maxalive", "3600");
  19.         configFields.put("weight", "1.0");
  20.         //执行批量添加
  21.         jedis.hmset("config", configFields);
  22.         //批量获取：取得全部 field-value 对，返回 java map
  23.         Logger.info("jedis.hgetAll(): " + jedis.hgetAll("config"));
  24.         //批量获取：取得部分 field对应的value，返回 java map
  25.         Logger.info("jedis.hmget(): " + jedis.hmget("config", "ip", "port"));
  27.         //浮点数增加: 类似于String的 incrByFloat
  28.         jedis.hincrByFloat("config", "weight", 1.2);
  29.         Logger.info("jedis.hget(weight): " + jedis.hget("config", "weight"));
  31.         //获取所有的key
  32.         Logger.info("jedis.hkeys(config): " + jedis.hkeys("config"));
  33.         //获取所有的val
  34.         Logger.info("jedis.hvals(config): " + jedis.hvals("config"));
  36.         //获取长度
  37.         Logger.info("jedis.hlen(): " + jedis.hlen("config"));
  38.         //判断field是否存在
  39.         Logger.info("jedis.hexists(weight): " + jedis.hexists("config", "weight"));
  41.         //删除一个field
  42.         jedis.hdel("config", "weight");
  43.         Logger.info("jedis.hexists(weight): " + jedis.hexists("config", "weight"));
  46.         jedis.close();
  47.     }

14.3.4 Jedis操作Set集合

  1.     @Test
  2.     public void operateSet() {
  3.         Jedis jedis = new Jedis("localhost");
  4.         jedis.del("set1");
  5.         Logger.info("jedis.ping(): " + jedis.ping());
  6.         Logger.info("jedis.type(): " + jedis.type("set1"));
  8.         //sadd函数: 向集合添加元素
  9.         jedis.sadd("set1", "user01", "user02", "user03");
  10.         //smembers函数: 遍历所有元素
  11.         Logger.info("jedis.smembers(): " + jedis.smembers("set1"));
  12.         //scard函数: 获取集合元素个数
  13.         Logger.info("jedis.scard(): " + jedis.scard("set1"));
  14.         //sismember 判断是否是集合元素
  15.         Logger.info("jedis.sismember(user04): " + jedis.sismember("set1", "user04"));
  16.         //srem函数：移除元素
  17.         Logger.info("jedis.srem(): " + jedis.srem("set1", "user02", "user01"));
  18.         //smembers函数: 遍历所有元素
  19.         Logger.info("jedis.smembers(): " + jedis.smembers("set1"));
  21.         jedis.close();
  22.     }

14.3.5 Jedis操作Zset有序集合

  1.     @Test
  2.     public void operateZset() {
  4.         Jedis jedis = new Jedis("localhost");
  5.         Logger.info("jedis.get(): " + jedis.ping());
  7.         jedis.del("salary");
  8.         Map<String, Double> members = new HashMap<String, Double>();
  9.         members.put("u01", 1000.0);
  10.         members.put("u02", 2000.0);
  11.         members.put("u03", 3000.0);
  12.         members.put("u04", 13000.0);
  13.         members.put("u05", 23000.0);
  14.         //批量添加元素
  15.         jedis.zadd("salary", members);
  16.         //类型,zset
  17.         Logger.info("jedis.type(): " + jedis.type("salary"));
  19.         //获取集合元素个数
  20.         Logger.info("jedis.zcard(): " + jedis.zcard("salary"));
  21.         //按照下标[起,止]遍历元素
  22.         Logger.info("jedis.zrange(): " + jedis.zrange("salary", 0, -1));
  23.         //按照下标[起,止]倒序遍历元素
  24.         Logger.info("jedis.zrevrange(): " + jedis.zrevrange("salary", 0, -1));
  26.         //按照分数（薪资）[起,止]遍历元素
  27.         Logger.info("jedis.zrangeByScore(): " + jedis.zrangeByScore("salary", 1000, 10000));
  28.         //按照薪资[起,止]遍历元素,带分数返回
  29.         Set<Tuple> res0 = jedis.zrangeByScoreWithScores("salary", 1000, 10000);
  30.         for (Tuple temp : res0) {
  31.             Logger.info("Tuple.get(): " + temp.getElement() + " -> " + temp.getScore());
  32.         }
  33.         //按照分数[起,止]倒序遍历元素
  34.         Logger.info("jedis.zrevrangeByScore(): " + jedis.zrevrangeByScore("salary", 1000, 4000));
  35.         //获取元素[起,止]分数区间的元素数量
  36.         Logger.info("jedis.zcount(): " + jedis.zcount("salary", 1000, 4000));
  38.         //获取元素score值：薪资
  39.         Logger.info("jedis.zscore(): " + jedis.zscore("salary", "u01"));
  40.         //获取元素下标
  41.         Logger.info("jedis.zrank(u01): " + jedis.zrank("salary", "u01"));
  42.         //倒序获取元素下标
  43.         Logger.info("jedis.zrevrank(u01): " + jedis.zrevrank("salary", "u01"));
  44.         //删除元素
  45.         Logger.info("jedis.zrem(): " + jedis.zrem("salary", "u01", "u02"));
  46.         //删除元素,通过下标范围
  47.         Logger.info("jedis.zremrangeByRank(): " + jedis.zremrangeByRank("salary", 0, 1));
  48.         //删除元素,通过分数范围
  49.         Logger.info("jedis.zremrangeByScore(): " + jedis.zremrangeByScore("salary", 20000, 30000));
  50.         //按照下标[起,止]遍历元素
  51.         Logger.info("jedis.zrange(): " + jedis.zrange("salary", 0, -1));
  53.         Map<String, Double> members2 = new HashMap<String, Double>();
  54.         members2.put("u11", 1136.0);
  55.         members2.put("u12", 2212.0);
  56.         members2.put("u13", 3324.0);
  57.         //批量添加元素
  58.         jedis.zadd("salary", members2);
  59.         //增加指定分数
  60.         Logger.info("jedis.zincrby(10000): " + jedis.zincrby("salary", 10000, "u13"));
  61.         //按照下标[起,止]遍历元素
  62.         Logger.info("jedis.zrange(): " + jedis.zrange("salary", 0, -1));
  64.         jedis.close();
  66.     }

14.4 JedisPool连接池的实践案例

14.4.1 JedisPool的配置

（1） maxTotal：资源池中最大的连接数，默认值为8。
（2） maxIdle：资源池允许最大空闲的连接数，默认值为8。
（3） minIdle：资源池确保最少空闲的连接数，默认值为0。
（4） blockWhenExhausted：当资源池用尽后，调用者是否要等待，默认值为true。
（5） maxWaitMillis：当资源池连接用尽后，调用者的最大等待时间（单位为毫秒）
（6） testOnBorrow：向资源池借用连接时，是否做有效性检测（ping命令），如果是无效连接，会被移除，默认值为false，表示不做检测。
（7） testOnReturn：向资源池归还连接时，是否做有效性检测（ping命令），如果是无效连接，会被移除，默认值为false，表示不做检测。
（8） testWhileIdle：如果为true，表示用一个专门的线程对空闲的连接进行有效性的检测扫描，如果连接的有效性检测失败，即表示监测到无效连接，会从资源池中移除。
（9） timeBetweenEvictionRunsMillis：表示两次空闲连接扫描的间隔时间， 默认为30000毫秒，也就是30秒钟。
（10） minEvictableIdleTimeMillis：表示一个Jedis连接至少停留在空闲状态的最短时间，然后才能被空闲连接扫描线程进行有效性检测，默认值为60000毫秒，即60秒。
（11） numTestsPerEvictionRun：表示空闲检测线程每次最多扫描的Jedis连接数，默认值为-1，表示扫描全部的空闲连接。
（12） jmxEnabled：是否开启JMX监控，默认值为true，建议开启。

14.4.2 JedisPool创建和预热

  1.     private static JedisPool buildPool() {
  2.         if (pool == null) {
  3.             long start = System.currentTimeMillis();
  4.             JedisPoolConfig config = new JedisPoolConfig();
  5.             config.setMaxIdle(MAX_IDLE);
  6.             config.setMaxTotal(MAX_TOTAL);
  7.             config.setMaxWaitMillis(1000 * 10);
  8.             // 在 borrow 一个 jedis 实例时，是否提前进行有效检测操作；
  9.             // 如果为 true，则得到的 jedis 实例均是可用的；
  10.             config.setTestOnBorrow(true);
  11.             pool = new JedisPool(config, "101.132.251.198", 6379, 10000);
  12.             long end = System.currentTimeMillis();
  13.             Logger.info("buildPool 毫秒数:", end - start);
  14.         }
  15.         return pool;
  16.     }

预热：

  1.     public static void hotPool() {
  2.         long start = System.currentTimeMillis();
  3.         List<Jedis> minIdleJedisList = new ArrayList<>(MAX_IDLE);
  4.         Jedis jedis = null;
  5.         for (int i = 0; i < MAX_IDLE; i++) {
  6.             try {
  7.                 jedis = pool.getResource();
  8.                 minIdleJedisList.add(jedis);
  9.                 jedis.ping();
  10.             }catch (Exception e) {
  11.                 Logger.error(e.getMessage());
  12.             }
  13.         }
  15.         for (int i = 0; i < MAX_IDLE; i++) {
  16.             try {
  17.                 jedis = minIdleJedisList.get(i);
  18.                 jedis.close();
  19.             }catch (Exception e) {
  20.                 Logger.error(e.getMessage());
  21.             }
  22.         }
  24.         long end = System.currentTimeMillis();
  25.         Logger.info("hotPool  毫秒数:", end - start);
  26.     }

创建好连接池实例，并且进行预热 

  1.     static {
  2.         buildPool();
  3.         hotPool();
  4.     }
  6.     public synchronized static Jedis getJedis() {
  7.         return pool.getResource();
  8.     }

14.4.3 JedisPool的使用

  1.     @Test
  2.     public void testDel() {
  3.         Jedis redis = null;
  4.         try {
  5.             redis = JedisPoolBuilder.getJedis();
  6.             long start = System.currentTimeMillis();
  7.             redis.del(ZSET_KEY);
  8.             long end = System.currentTimeMillis();
  9.             log.info("删除 zset1 毫秒数:", end - start);
  10.         }finally {
  11.             //使用后一定关闭，还给连接池
  12.             if (redis != null) {
  13.                 redis.close();
  14.             }
  15.         }
  16.     }

使用try-with-resources语句，在其隐藏的finally部分自动调用close方法。 

  1.     @Test
  2.     public void testSet() {
  3.         testDel();
  4.         try (Jedis redis = JedisPoolBuilder.getJedis()){
  5.             int loop = 0;
  6.             long start = System.currentTimeMillis();
  7.             while (loop < NUM) {
  8.                 redis.zadd(ZSET_KEY, loop, "field-" + loop);
  9.                 loop++;
  10.             }
  11.             long end = System.currentTimeMillis();
  12.             Logger.info("设置 Zset :", loop, "次, 毫秒数:", end - start);
  13.         }
  14.     }

14.5 使用spring-data-redis完成CRUD的实践案例

  1. <dependency>
  2.   <groupId>org.springframework.data</groupId>
  3.   <artifactId>spring-data-redis</artifactId>
  4.   <version>${springboot}</version>
  5. </dependency>

14.5.1 CRUD中应用缓存的场景

14.5.3 使用RedisTemplate模板API

（1） ValueOperations字符串类型操作API集合。
（2） ListOperations列表类型操作API集合。
（3） SetOperations集合类型操作API集合。
（4） ZSetOperations有序集合类型API集合。
（5） HashOperations哈希类型操作API集合。

在实际开发中，为了尽可能地减少对特定的第三方库的依赖，减少第三方库的“入侵”性，或者为了在不同的第三方库之间进行方便的切换，一般来说，要对第三方库进行 封装 

  1. public class CacheOperationService {
  4.     private RedisTemplate redisTemplate;
  6.     public void setRedisTemplate(RedisTemplate redisTemplate) {
  7.         this.redisTemplate = redisTemplate;
  8.     }
  9.     // --------------RedisTemplate 基础操作  --------------------
  12.     /**
  13.      * 取得指定格式的所有的key
  14.      *
  15.      * @param patens 匹配的表达式
  16.      * @return key 的集合
  17.      */
  18.     public Set getKeys(Object patens) {
  19.         try {
  20.             return redisTemplate.keys(patens);
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.             return null;
  24.         }
  25.     }
  27.     /**
  28.      * 指定缓存失效时间
  29.      *
  30.      * @param key  键
  31.      * @param time 时间(秒)
  32.      * @return
  33.      */
  34.     public boolean expire(String key, long time) {
  35.         try {
  36.             if (time > 0) {
  37.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  38.             }
  39.             return true;
  40.         } catch (Exception e) {
  41.             e.printStackTrace();
  42.             return false;
  43.         }
  44.     }
  46.     /**
  47.      * 根据key 获取过期时间
  48.      *
  49.      * @param key 键 不能为null
  50.      * @return 时间(秒) 返回0代表为永久有效
  51.      */
  52.     public long getExpire(String key) {
  53.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  54.     }
  56.     /**
  57.      * 判断key是否存在
  58.      *
  59.      * @param key 键
  60.      * @return true 存在 false不存在
  61.      */
  62.     public boolean hasKey(String key) {
  63.         try {
  64.             return redisTemplate.hasKey(key);
  65.         } catch (Exception e) {
  66.             e.printStackTrace();
  67.             return false;
  68.         }
  69.     }
  71.     /**
  72.      * 删除缓存
  73.      *
  74.      * @param key 可以传一个值 或多个
  75.      * @return 删除的个数
  76.      */
  78.     @SuppressWarnings("unchecked")
  79.     public void del(String... key) {
  80.         if (key != null && key.length > 0) {
  81.             if (key.length == 1) {
  82.                 redisTemplate.delete(key[0]);
  83.             } else {
  84.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  85.             }
  86.         }
  87.     }
  88.     // --------------RedisTemplate 操作 String --------------------
  91.     /**
  92.      * 普通缓存获取
  93.      *
  94.      * @param key 键
  95.      * @return 值
  96.      */
  97.     public Object get(String key) {
  98.         return key == null ? null : redisTemplate.opsForValue().get(key);
  99.     }
  101.     /**
  102.      * 普通缓存放入
  103.      *
  104.      * @param key   键
  105.      * @param value 值
  106.      * @return true成功 false失败
  107.      */
  108.     public boolean set(String key, Object value) {
  109.         try {
  110.             redisTemplate.opsForValue().set(key, value);
  111.             return true;
  112.         } catch (Exception e) {
  113.             e.printStackTrace();
  114.             return false;
  115.         }
  117.     }
  119.     /**
  120.      * 普通缓存放入并设置时间
  121.      *
  122.      * @param key   键
  123.      * @param value 值
  124.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  125.      * @return true成功 false 失败
  126.      */
  127.     public boolean set(String key, Object value, long time) {
  128.         try {
  129.             if (time > 0) {
  130.                 redisTemplate.opsForValue()
  131.                         .set(key, value, time, TimeUnit.SECONDS);
  132.             } else {
  133.                 set(key, value);
  134.             }
  135.             return true;
  136.         } catch (Exception e) {
  137.             e.printStackTrace();
  138.             return false;
  139.         }
  140.     }
  142.     /**
  143.      * 递增
  144.      *
  145.      * @param key   键
  146.      * @param delta 自增因子，要增加几(大于0)
  147.      * @return 自增的结果
  148.      */
  149.     public long incr(String key, long delta) {
  150.         if (delta < 0) {
  151.             throw new RuntimeException("自增因子必须大于0");
  152.         }
  153.         return redisTemplate.opsForValue().increment(key, delta);
  154.     }
  156.     /**
  157.      * 自减
  158.      *
  159.      * @param key   键
  160.      * @param delta 自减，  要减少几(小于0)
  161.      * @return
  162.      */
  163.     public long decr(String key, long delta) {
  164.         if (delta < 0) {
  165.             throw new RuntimeException("自减因子必须大于0");
  166.         }
  167.         return redisTemplate
  168.                 .opsForValue().increment(key, -delta);
  169.     }
  171.     // --------------RedisTemplate 操作 Map --------------------
  173.     /**
  174.      * HashGet
  175.      *
  176.      * @param key   键 不能为null
  177.      * @param field 项 不能为null
  178.      * @return 值
  179.      */
  180.     public Object hget(String key, String field) {
  181.         return redisTemplate.opsForHash().get(key, field);
  182.     }
  184.     /**
  185.      * 获取hashKey对应的所有键值
  186.      *
  187.      * @param key 键
  188.      * @return 对应的多个键值
  189.      */
  190.     public Map<Object, Object> hmget(String key) {
  191.         return redisTemplate.opsForHash().entries(key);
  192.     }
  194.     /**
  195.      * HashSet
  196.      *
  197.      * @param key 键
  198.      * @param map 对应多个键值
  199.      * @return true 成功 false 失败
  200.      */
  201.     public boolean hmset(String key, Map<String, Object> map) {
  202.         try {
  203.             redisTemplate.opsForHash().putAll(key, map);
  204.             return true;
  205.         } catch (Exception e) {
  206.             e.printStackTrace();
  207.             return false;
  208.         }
  209.     }
  211.     /**
  212.      * HashSet 并设置时间
  213.      *
  214.      * @param key  键
  215.      * @param map  对应多个键值
  216.      * @param time 时间(秒)
  217.      * @return true成功 false失败
  218.      */
  219.     public boolean hmset(String key, Map<String, Object> map, long time) {
  220.         try {
  221.             redisTemplate.opsForHash().putAll(key, map);
  222.             if (time > 0) {
  223.                 expire(key, time);
  224.             }
  225.             return true;
  226.         } catch (Exception e) {
  227.             e.printStackTrace();
  228.             return false;
  229.         }
  230.     }
  232.     /**
  233.      * 向一张hash表中放入数据,如果不存在将创建
  234.      *
  235.      * @param key   键
  236.      * @param field 项
  237.      * @param value 值
  238.      * @return true 成功 false失败
  239.      */
  240.     public boolean hset(String key, String field, Object value) {
  241.         try {
  242.             redisTemplate.opsForHash().put(key, field, value);
  243.             return true;
  244.         } catch (Exception e) {
  245.             e.printStackTrace();
  246.             return false;
  247.         }
  248.     }
  250.     /**
  251.      * 向一张hash表中放入数据,如果不存在将创建
  252.      *
  253.      * @param key   键
  254.      * @param field 项
  255.      * @param value 值
  256.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  257.      * @return true 成功 false失败
  258.      */
  259.     public boolean hset(String key, String field, Object value, long time) {
  260.         try {
  261.             redisTemplate.opsForHash().put(key, field, value);
  262.             if (time > 0) {
  263.                 expire(key, time);
  264.             }
  265.             return true;
  266.         } catch (Exception e) {
  267.             e.printStackTrace();
  268.             return false;
  269.         }
  270.     }
  272.     /**
  273.      * 删除hash表中的值
  274.      *
  275.      * @param key   键 不能为null
  276.      * @param field 项 可以使多个 不能为null
  277.      */
  278.     public void hdel(String key, Object... field) {
  279.         redisTemplate.opsForHash().delete(key, field);
  280.     }
  282.     /**
  283.      * 判断hash表中是否有该项的值
  284.      *
  285.      * @param key   键 不能为null
  286.      * @param field 项 不能为null
  287.      * @return true 存在 false不存在
  288.      */
  289.     public boolean hHasKey(String key, String field) {
  290.         return redisTemplate.opsForHash().hasKey(key, field);
  291.     }
  293.     /**
  294.      * hash自增 如果不存在,就会创建一个 并把新增后的值返回
  295.      *
  296.      * @param key   键
  297.      * @param field 项
  298.      * @param by    要增加几(大于0)
  299.      * @return
  300.      */
  301.     public double hincr(String key, String field, double by) {
  302.         return redisTemplate.opsForHash().increment(key, field, by);
  303.     }
  305.     /**
  306.      * hash自减
  307.      *
  308.      * @param key   键
  309.      * @param field 项
  310.      * @param by    要减少记(小于0)
  311.      * @return
  312.      */
  313.     public double hdecr(String key, String field, double by) {
  314.         return redisTemplate.opsForHash().increment(key, field, -by);
  315.     }
  317.     // --------------RedisTemplate 操作 Set --------------------
  319.     /**
  320.      * 根据key获取Set中的所有值
  321.      *
  322.      * @param key 键
  323.      * @return
  324.      */
  325.     public Set<Object> sGet(String key) {
  326.         try {
  327.             return redisTemplate.opsForSet().members(key);
  328.         } catch (Exception e) {
  329.             e.printStackTrace();
  330.             return null;
  331.         }
  332.     }
  334.     /**
  335.      * 根据value从一个set中查询,是否存在
  336.      *
  337.      * @param key   键
  338.      * @param value 值
  339.      * @return true 存在 false不存在
  340.      */
  341.     public boolean sHasKey(String key, Object value) {
  342.         try {
  343.             return redisTemplate.opsForSet().isMember(key, value);
  344.         } catch (Exception e) {
  345.             e.printStackTrace();
  346.             return false;
  347.         }
  348.     }
  350.     /**
  351.      * 将数据放入set缓存
  352.      *
  353.      * @param key    键
  354.      * @param values 值 可以是多个
  355.      * @return 成功个数
  356.      */
  357.     public long sSet(String key, Object... values) {
  358.         try {
  359.             return redisTemplate.opsForSet().add(key, values);
  360.         } catch (Exception e) {
  361.             e.printStackTrace();
  362.             return 0;
  363.         }
  364.     }
  366.     /**
  367.      * 将set数据放入缓存
  368.      *
  369.      * @param key    键
  370.      * @param time   时间(秒)
  371.      * @param values 值 可以是多个
  372.      * @return 成功个数
  373.      */
  374.     public long sSetAndTime(String key, long time, Object... values) {
  375.         try {
  376.             Long count = redisTemplate.opsForSet().add(key, values);
  377.             if (time > 0)
  378.                 expire(key, time);
  379.             return count;
  380.         } catch (Exception e) {
  381.             e.printStackTrace();
  382.             return 0;
  383.         }
  384.     }
  386.     /**
  387.      * 获取set缓存的长度
  388.      *
  389.      * @param key 键
  390.      * @return
  391.      */
  392.     public long sGetSetSize(String key) {
  393.         try {
  394.             return redisTemplate.opsForSet().size(key);
  395.         } catch (Exception e) {
  396.             e.printStackTrace();
  397.             return 0;
  398.         }
  399.     }
  401.     /**
  402.      * 移除值为value的
  403.      *
  404.      * @param key    键
  405.      * @param values 值 可以是多个
  406.      * @return 移除的个数
  407.      */
  408.     public long setRemove(String key, Object... values) {
  409.         try {
  410.             Long count = redisTemplate.opsForSet().remove(key, values);
  411.             return count;
  412.         } catch (Exception e) {
  413.             e.printStackTrace();
  414.             return 0;
  415.         }
  416.     }
  417.     // --------------RedisTemplate 操作list --------------------
  419.     /**
  420.      * 获取list缓存的内容
  421.      *
  422.      * @param key   键
  423.      * @param start 开始
  424.      * @param end   结束 0 到 -1代表所有值
  425.      * @return
  426.      */
  427.     public List<Object> lGet(String key, long start, long end) {
  428.         try {
  429.             return redisTemplate.opsForList().range(key, start, end);
  430.         } catch (Exception e) {
  431.             e.printStackTrace();
  432.             return null;
  433.         }
  434.     }
  436.     /**
  437.      * 获取list缓存的长度
  438.      *
  439.      * @param key 键
  440.      * @return
  441.      */
  442.     public long lGetListSize(String key) {
  443.         try {
  444.             return redisTemplate.opsForList().size(key);
  445.         } catch (Exception e) {
  446.             e.printStackTrace();
  447.             return 0;
  448.         }
  449.     }
  451.     /**
  452.      * 通过索引 获取list中的值
  453.      *
  454.      * @param key   键
  455.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  456.      * @return
  457.      */
  458.     public Object lGetIndex(String key, long index) {
  459.         try {
  460.             return redisTemplate.opsForList().index(key, index);
  461.         } catch (Exception e) {
  462.             e.printStackTrace();
  463.             return null;
  464.         }
  465.     }
  467.     /**
  468.      * 将list放入缓存
  469.      *
  470.      * @param key   键
  471.      * @param value 值
  472.      * @return
  473.      */
  474.     public boolean lSet(String key, Object value) {
  475.         try {
  476.             redisTemplate.opsForList().rightPush(key, value);
  477.             return true;
  478.         } catch (Exception e) {
  479.             e.printStackTrace();
  480.             return false;
  481.         }
  482.     }
  484.     /**
  485.      * 将list放入缓存
  486.      *
  487.      * @param key   键
  488.      * @param value 值
  489.      * @param time  时间(秒)
  490.      * @return
  491.      */
  492.     public boolean lSet(String key, Object value, long time) {
  493.         try {
  494.             redisTemplate.opsForList().rightPush(key, value);
  495.             if (time > 0)
  496.                 expire(key, time);
  497.             return true;
  498.         } catch (Exception e) {
  499.             e.printStackTrace();
  500.             return false;
  501.         }
  502.     }
  504.     /**
  505.      * 将list放入缓存
  506.      *
  507.      * @param key   键
  508.      * @param value 值
  509.      * @return
  510.      */
  511.     public boolean lSet(String key, List<Object> value) {
  512.         try {
  513.             redisTemplate.opsForList().rightPushAll(key, value);
  514.             return true;
  515.         } catch (Exception e) {
  516.             e.printStackTrace();
  517.             return false;
  518.         }
  519.     }
  521.     /**
  522.      * 将list放入缓存
  523.      *
  524.      * @param key   键
  525.      * @param value 值
  526.      * @param time  时间(秒)
  527.      * @return
  528.      */
  529.     public boolean lSet(String key, List<Object> value, long time) {
  530.         try {
  531.             redisTemplate.opsForList().rightPushAll(key, value);
  532.             if (time > 0)
  533.                 expire(key, time);
  534.             return true;
  535.         } catch (Exception e) {
  536.             e.printStackTrace();
  537.             return false;
  538.         }
  539.     }
  541.     /**
  542.      * 根据索引修改list中的某条数据
  543.      *
  544.      * @param key   键
  545.      * @param index 索引
  546.      * @param value 值
  547.      * @return
  548.      */
  549.     public boolean lUpdateIndex(String key, long index, Object value) {
  550.         try {
  551.             redisTemplate.opsForList().set(key, index, value);
  552.             return true;
  553.         } catch (Exception e) {
  554.             e.printStackTrace();
  555.             return false;
  556.         }
  557.     }
  559.     /**
  560.      * 移除N个值为value
  561.      *
  562.      * @param key   键
  563.      * @param count 移除多少个
  564.      * @param value 值
  565.      * @return 移除的个数
  566.      */
  567.     public long lRemove(String key, long count, Object value) {
  568.         try {
  569.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  570.             return remove;
  571.         } catch (Exception e) {
  572.             e.printStackTrace();
  573.             return 0;
  574.         }
  575.     }
  578. }

redisTemplate提供了5个方法，取得不同类型的命令集合，具体为：
（1） redisTemplate.opsForValue()取得String类型命令API集合。
（2） redisTemplate.opsForList()取得List类型命令API集合。
（3） redisTemplate.opsForSet()取得Set类型命令API集合。
（4） redisTemplate.opsForHash()取得Hash类型命令API集合。
（5） redisTemplate.opsForZSet()取得Zset类型命令API集合

15.5.4 使用Redis Template模板API完成CRUD的实践案例

  1. public class UserServiceImpleWithTemplate implements UserService{
  2.     public static final String USER_UID_PREFIX = "user:uid:";
  3.     protected CacheOperationService cacheOperationService;
  4.     private static final long CASHE_LONG = 60 * 4;
  7.     @Override
  8.     public User saveUser(User user) {
  9.         String key = USER_UID_PREFIX + user.getUid();
  10.         Logger.info("user:", user);
  11.         cacheOperationService.set(key, user, CASHE_LONG);
  12.         return user;
  13.     }
  15.     @Override
  16.     public User getUser(long id) {
  17.         String key = USER_UID_PREFIX + id;
  18.         User value = (User) cacheOperationService.get(key);
  19.         if (null == value) {
  20.             return null;
  21.         }
  22.         return value;
  23.     }
  25.     @Override
  26.     public void deleteUser(long id) {
  27.         String key = USER_UID_PREFIX + id;
  28.         cacheOperationService.del(key);
  29.         Logger.info("delete User: ", id);
  30.     }
  31. }

14.5.5 使用RedisCallback回调完成CRUD的实践案例

如果不需要RedisTemplate配置的序列化、反序列化的工具类，或者由于其他的原因，需要直接使用RedisConnection去操作Redis，怎么办呢？可以使用RedisCallback的doInRedis回调方法，在doInRedis回调方法中直接使用实参RedisConnection连接类实例来完成Redis的操作。

14.6 Spring的Redis缓存注解

在Spring中，通过合理的添加缓存注解，也能实现和前面示例程序中一样的缓存功能。
为了方便地提供缓存能力， Spring提供了一组缓存注解。但是，这组注解不仅仅是针对Redis， 这组注解本质上并不是一种具体的缓存实现方案（例如Redis、 EHCache等），而是对缓存使用的统一抽象。通过这组缓存注解，然后加上与具体缓存相匹配的Spring配置，不用编码就可以快速达到缓存的效果。

14.6.1 使用Spring缓存注解完成CRUD的实践案例

  1. @CachePut作用是设置缓存。先执行方法，并将执行结果缓存起来。
  2. @CacheEvict的作用是删除缓存。在执行方法后，删除缓存。

  3. @Cacheable的作用更多是查询缓存。首先检查注解中的Key键是否在缓存中，如果是，则返回Key的缓存值，不再执行方法；否则，执行方法并将方法结果缓存起来。从后半部分来看， @Cacheable也具备@CachePut的能力。 

    1. public class UserServiceImplWithAnno implements UserService{
    2.  public static final String USER_UID_PREFIX = "'userCache:'+";
    4.  @CachePut(key = USER_UID_PREFIX + "T(String).valueOf(#user.uid)")
    5.  @Override
    6.  public User saveUser(User user) {
    7.      Logger.info("user: save to redis");
    8.      return user;
    9.  }
    11.  @Cacheable(key = USER_UID_PREFIX + "T(String).valueOf(#id)")
    12.  @Override
    13.  public User getUser(long id) {
    14.      //如果缓存没有,则从数据库中加载
    15.      Logger.info("user: is null");
    16.      return null;
    17.  }
    19.  @CacheEvict(key = USER_UID_PREFIX + "T(String).valueOf(#id)")
    20.  @Override
    21.  public void deleteUser(long id) {
    22.      Logger.info("delete User:", id);
    23.  }
    24. }

    14.6.3 详解@CachePut和@Cacheable注解

  4. @CachePut负责增加缓存。

  5. @Cacheable负责查询缓存，如果没有查到， 才去执行被注解的方法，并将方法
    的结果增加到缓存。

    14.6.4 详解@CacheEvict注解

    注解@CacheEvict主要用来清除缓存，可以指定的属性有value、 key、 condition、allEntries和beforeInvocation。其中value、 key和condition的语义与@Cacheable对应的属性类似。 value表示清除哪些Cache（对应Cache的空间名称）； key表示清除哪个Key键；condition表示清除的条件。

  6. allEntries属性：表示是否全部清空

  7. beforeInvocation属性：表示是否在方法执行前操作缓存

    14.6.5 详解@Caching组合注解

    @Caching注解，是一个缓存处理的组合注解。通过@Caching，可以一次指定多个Spring Cache注解的组合。 @Caching注解拥有三个属性：cacheable、 put和evict。

  8. cacheable属性：用于指定一个或者多个@Cacheable注解的组合，可以指定一个，也可以指定多个。

  9. put属性：用于指定一个或者多个@CachePut注解的组合，可以指定一个，也可以指定多个，用于设置一个或多个key的缓存。
  10. evict属性：用于指定一个或者多个@CacheEvict注解的组合，可以指定一个，也可以指定多个，用于删除一个或多个key的缓存。

    14.7 详解SpringEL（SpEL）

    Spring表达式语言全称为“Spring Expression Language”，缩写为“SpEL”。 SpEL提供一种强大、简洁的Spring Bean的动态操作表达式。