一直以来，Redis作为一种Nosql数据库，因其炒鸡牛逼的功能被广泛应用于各种项目中。本人之前不怎么看好Redis,如今是越来越喜欢它了。经常用它存储一些常用的数据，比如用户的id ，session ,用户菜单权限，消息队列等。不扯了，直接来总结。

• 安装和配置

  太简单了 不哔哔

  ---

• 在Java中使用

   @Testpublic void pool() {JedisPoolConfig config = new JedisPoolConfig();//最大连接数config.setMaxTotal(30);//最大连接空闲数config.setMaxIdle(2);JedisPool pool = new JedisPool(config, "192.168.101.3", 6379);Jedis jedis = null;try  {jedis = pool.getResource();jedis.set("name", "lisi");String name = jedis.get("name");System.out.println(name);}catch(Exception ex){ex.printStackTrace();}finally{if(jedis != null){//关闭连接jedis.close();}} } 

---

• Jedis中常用的API

1.Redis键操作

== 常用于存储一些变化不大的固定值 或者session等 ==

 /*** @return 被删除 key 的数量*/public Long delete(String... keys){return jedis.del(keys);}

/*** 返回 key 所储存的值的类型。*/public String type(String key){return jedis.type(key);}

/*** 获取键列表*/public Set<String> keys(String pattern){return jedis.keys(pattern);}

/** * 查看某个key的剩余生存时间:time to live (以秒为单位)*/public Long ttl(String key){return jedis.ttl(key);}

/*** 查看某个key是否存在*/public Boolean exists(String key){return jedis.exists(key);}

/*** 设置某一记录的生存时间，过期删除*/public Long expire(String key, int seconds){return jedis.expire(key, seconds);}

2.字符串操作

== 常用于存储一些固定的键值 ｛username:aaa ,password:111｝ ==

/*** 将设置某个key的值，如果 key 已经持有其他值，就覆写旧值，无视类型。*/public String set(String key, String value){return jedis.set(key, value);}

/**    * 将 key 的值设为 value ，当且仅当 key不存在，若给定的 key 已经存在，则 SETNX 不做任何动作。*/public Long setnx(String key, String value){return jedis.setnx(key, value);}

/*** 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。*/public String setex(String key, int seconds, String value){return jedis.setex(key, seconds, value);}

/*** 返回 key 所关联的字符串值。*/public String get(String key){return jedis.get(key);}

== 常用于统计一些总数量 ==

/*** 将 key 中储存的数字值增一。* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。* @param key* @return*/public Long incr(String key){return jedis.incr(key);}

== 常用于给特定的对象执行增加数量等操作 ==

/*** 将 key 中储存的数字值增加固定制。* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。*/public Long incrBy(String key, long increase){return jedis.incrBy(key, increase);}

/*** 将 key 中储存的数字值减一。* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误*/public Long decr(String key){return jedis.decr(key);}

/*** 将 key 中储存的数字值减少固定制。* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。*/public Long decrBy(String key, long decrease){return jedis.decrBy(key, decrease);}

3.Hash操作

== 不怎么用 ==

/*** 设置字段值* @return 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1；如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。*/public Long hset(String hkey, String field, String value){return jedis.hset(hkey, field, value);}

/*** 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在* 若域 field 已经存在，该操作无效。* 如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令* @return 设置成功，返回 1 。如果给定域已经存在且没有操作被执行，返回 0 。*/public Long hsetnx(String hkey, String field, String value){return jedis.hsetnx(hkey, field, value);}

/*** 同时将多个 field-value (域-值)对设置到哈希表 key 中* 此命令会覆盖哈希表中已存在的域* 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。*/public String hmset(String hkey, Map<String, String> hash){return jedis.hmset(hkey, hash);}

/*** 返回哈希表 key 中给定域 field 的值。*/public String hget(String hkey, String field){return jedis.hget(hkey, field);}

/*** 返回哈希表中，所有的域和值* @return 以列表形式返回哈希表的域和域的值*/public Map<String, String> hgetAll(String hkey){return jedis.hgetAll(hkey);}

/*** 删除哈希表中的一个字段，字段不存在将被忽略* @return 被成功移除的域的数量，不包括被忽略的域*/public Long hdel(String hkey, String field){return jedis.hdel(hkey, field);}

/*** 返回哈希表中字段的数量* @return 哈希表中域的数量，当 key 不存在时，返回 0 。*/public Long hlen(String hkey){return jedis.hlen(hkey);}

/*** 查看哈希表 key 中，给定field 是否存在*/public Boolean hexists(String hkey, String field){return jedis.hexists(hkey, field);}

/*** 为哈希表 key 中的域 field 的值加上增量 increment*/public Long hincrBy(String hkey, String field, long increment){return jedis.hincrBy(hkey, field, increment);}

/*** 返回哈希表 key 中的所有域*/public Set<String> hkeys(String hkey){return jedis.hkeys(hkey);}

/*** 返回哈希表 key 中所有域的值*/public List<String> hvals(String hkey){return jedis.hvals(hkey);}

4.List操作

== 常用于做消息队列 推送消息==

 /**** 将一个值 value 插入到列表 key 的表头* 当 key 存在但不是列表类型时，返回一个错误* @return 执行 LPUSH 命令后，列表的长度*/public Long lpush(String lkey, String value){return jedis.lpush(lkey, value);}

/*** 将一个值 value 插入到列表 key 的表尾(最右边)* 当 key 存在但不是列表类型时，返回一个错误* @return 执行 RPUSH 操作后，列表的长度*/public Long rpush(String lkey, String value){return jedis.rpush(lkey, value);}

== 常用于做消息队列 获取消息==

/*** 移除并返回列表 key 的头元素* @return 列表的头元素*/public String lpop(String lkey){return jedis.lpop(lkey);}

/*** 移除并返回列表 key 的尾元素* @return 列表的尾元素*/
public String rpop(String lkey){return jedis.rpop(lkey);
}

== 常用于 统计消息的数量==

/*** @return 返回列表的长度*/public Long llen(String lkey){return jedis.llen(lkey);}

/*** 返回列表中指定区间内的元素，区间以偏移量 start 和 end 指定* 也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推* @return*/public List<String> lrange(String lkey, int start, int end){return jedis.lrange(lkey, start, end);}

/*** 根据参数 count 的值，移除列表中与参数 value 相等的元素* count = 0 : 移除表中所有与 value 相等的值* count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count* count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值* @return 被移除元素的数量*/public Long lrem(String lkey, int count, String value){return jedis.lrem(lkey, count, value);}

/*** 将列表 key 下标为 index 的元素的值设置为 value*/public String lset(String lkey, long index, String value){return jedis.lset(lkey, index, value);}

5.Set操作

/*** 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略* 假如 key 不存在，则创建一个只包含 member 元素作成员的集合* 当 key 不是集合类型时，返回一个错误* @return 被添加到集合中的新元素的数量，不包括被忽略的元素*/public Long sadd(String skey, String member){return jedis.sadd(skey, member);}

 /*** 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略* @return 被成功移除的元素的数量，不包括被忽略的元素。*/public Long srem(String skey, String member){return jedis.srem(skey, member);}

/*** 返回集合 key 中的所有成员* 不存在的 key 被视为空集合* @return 集合中的所有成员*/public Set<String> smembers(String skey){return jedis.smembers(skey);}

/*** 判断 member 元素是否集合 key 的成员* @return 如果 member 元素是集合的成员，返回true*/public Boolean sismember(String skey, String member){return jedis.sismember(skey, member);}

/*** 返回集合 key 的基数(集合中元素的数量)* @return 集合的基数*/public Long scard(String skey){return jedis.scard(skey);}

/*** 移除并返回集合中的一个元素* @return 被移除的元素*/public String spop(String skey){return jedis.spop(skey);}

== 常用于做两种信息的分析比较 并集 交集等数学上的东西==

/*** 返回一个集合的全部成员，该集合是所有给定集合的交集* 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)* @return 交集成员的列表*/public Set<String> sinter(String... skeys){return jedis.sinter(skeys);}

/*** 返回一个集合的全部成员，该集合是所有给定集合的并集* @return 并集成员的列表*/public Set<String> sunion(String... skeys){return jedis.sunion(skeys);}

/*** 返回一个集合的全部成员，该集合是所有给定集合之间的差集* @return 交集成员的列表*/public Set<String> sdiff(String... skeys){return jedis.sdiff(skeys);}

6.有序集合操作

== 常用于排行榜 增加排行成员==

/*** 将一个 member 元素及其 score 值加入到有序集 key 当中* @return 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员*/public Long zadd(String zkey, double score, String member){return jedis.zadd(zkey, score, member);}

== 常用于排行榜 删除排行成员==

/*** 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略* 当 key 不是集合类型，返回一个错误* @return 被成功移除的元素的数量，不包括被忽略的元素*/public Long zrem(String zkey, String member){return jedis.zrem(zkey, member);}

/*** 返回有序集 key 的基数* @return 当 key 存在且是有序集类型时，返回有序集的基数；当 key 不存在时，返回 0*/public Long zcard(String zkey){return jedis.zcard(zkey);}

== 常用于排行榜 统计排名在某个区间内的成员数量==

/*** 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员* @return score 值在 min 和 max 之间的成员的数量*/public Long zcount(String zkey, double min, double max){return jedis.zcount(zkey, min, max);}

== 常用于排行榜 统计一个成员的分数==

 /*** 返回有序集 key 中，成员 member 的 score 值* @return member 成员的 score 值*/public Double zscore(String zkey, String member){return jedis.zscore(zkey, member);}

== 常用于排行榜 为某个成员增加值==

/*** 为有序集 key 的成员 member 的 score 值加上增量 increment* @return member 成员的新 score 值*/public Double zincrby(String zkey, double increment, String member){return jedis.zincrby(zkey, increment, member);}

== 常用于排行榜 统计从小到大前几名 ==

/*** 返回有序集 key 中，指定区间内的成员* 其中成员的位置按 score 值递增(从小到大)来排序* 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推* @return 指定区间内，有序集成员的列表*/public Set<String> zrange(String zkey, int start, int end){return jedis.zrange(zkey, start, end);}

== 常用于排行榜 统计从大到小前几名==

/*** 返回有序集 key 中，指定区间内的成员* 其中成员的位置按 score 值递减(从大到小)来排序* 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推* @return 指定区间内，有序集成员的列表*/public Set<String> zrevrange(String zkey, int start, int end){return jedis.zrevrange(zkey, start, end);}

 /*** 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。* @param zkey* @param min* @param max* @return*/public Set<String> zrangeByScore(String zkey, double min, double max){return jedis.zrangeByScore(zkey, min, max);}

 /*** 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。* @return 如果 member 是有序集 key 的成员，返回 member 的排名*/public Long zrank(String zkey, String member){return jedis.zrank(zkey, member);}

/*** 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序* @return 如果 member 是有序集 key 的成员，返回 member 的排名*/public Long zrevrank(String zkey, String member){return jedis.zrevrank(zkey, member);}

 /*** 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。* @return 被移除成员的数量*/public Long zremrangeByScore(String zkey, double start, double end){return jedis.zremrangeByScore(zkey, start, end);}

 /*** 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。* @param zkey* @param start 在不知道最小值时，可以用 -inf代替最小值* @param end 在不知道最大值时，可以用 +inf代替最大值*/public Long zremrangeByScore(String zkey, String start, String end){return jedis.zremrangeByScore(zkey, start, end);}

7.事务操作

/*** 事务块内的多条命令会按照先后顺序被放进一个队列当中，最后由 EXEC 命令原子性(atomic)地执行。* @param block*/public List<Object> multiResult(TransactionBlock block){return jedis.multi(block);}

/** 标记一个事务块的开始* @return Transaction对象，可基于Transaction操作*/public Transaction multi(){return jedis.multi();}

---

看了这些，你能说你完全会用这些API吗？？？？？？

---

• [atomic] ：原子性的意思 （测试MarkDown注释的，请忽略）
• [multi] ：多数的意思 （测试MarkDown注释的，请忽略）
• [Transaction] ：事务的意思（测试MarkDown注释的，请忽略）