@Test
public 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();
}
}
}
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注释的，请忽略）
