java redis hkeys_Java中Redis的基本使用

1、pom中引入所需jar包

redis.clients

jedis

3.0.1

org.apache.commons

commons-pool2

2.6.2

2、常用命令与方法

Redis支持五种数据类型：string(字符串)，hash(哈希)，list(列表)，set(集合)及zset(sorted set：有序集合)。

string：是redis最基本的类型，一个key对应一个value。 string类型是二进制安全的，它可以包含任何数据，如图片或者序列化的对象 ，一个键最大能存储512MB。

hash：是一个string类型的field和value的映射表，适合用于存储对象。

list：是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部(左边)或者尾部(右边)。

Set：无序集合，通过哈希表实现的，添加、删除、查找的复杂度都是O(1)。

Zset(sorted set)：是string类型的有序集合。zset和set一样也是string类型元素的集合，且不允许重复的成员。 不同的是每个元素都会关联一个double类型的分数。redis通过分数来为集合中的成员进行从小到大的排序。zset的成员是唯一的，分数(score)可以重复。

1)连接及持久化操作命令

quit：关闭连接

auth：简单密码认证

help cmd：查看cmd帮助

save：将数据同步保存到磁盘

bgsave：将数据异步保存到磁盘

lastsave：返回上次成功将数据保存到磁盘的Unix时间戳

shundown：将数据同步保存到磁盘，然后关闭服务

2)远程服务控制

info：提供服务器的信息和统计

monitor：实时转储收到的请求

slaveof：改变复制策略设置

config：在运行时配置redis服务器

3)对key的操作

exists(key)：判断key是否存在

del(key)：删除key

type(key)：返回值的类型

keys(pattern)：返回符合pattern的所有key

randomKey：随机返回key空间的一个

rename(oldname, newname)：重命名key

dbsize：返回当前数据库中key的数量

expire：设定key的活动时间(s)

ttl：获取key的活动时间

select(index)：按索引查询

move(key, dbindex)：移动当前数据库中的key到dbindex数据库

flushdb：删除当前选择数据库中的所有key

flushall：删除所有数据库中的所有key

4)String相关

set(key, value)：设置名称为key的值

get(key)：查询名称为key的值

getSet(key, value)：给名称为key的string赋予上一次的value

mget(key1, key2,…, key N)：查询多个key的值

setnx(key, value)：添加string，名称为key，值为value

setex(key, time, value)：添加string，名称为key，并设定过期时间

mset(key N, value N)：批量设置多个key的值

msetnx(key N, value N)：如果所有给定key都不存在时，同时设置一个或多个key-value对

incr(key)：对名称为key的string加1

incrby(key, integer)：对名称为key的string增加integer

decr(key)：对名称为key的string减1

decrby(key, integer)：对名称为key的string减少integer

append(key, value)：对名称为key的值追加value

substr(key, start, end)：返回名称为key的value的子串

5)List相关

rpush(key, value)：在名称为key的list尾添加一个值为value的元素

lpush(key, value)：在名称为key的list头添加一个值为value的元素

llen(key)：返回名称为key的list长度

lrange(key, start, end)：返回名称为key的list中start至end之间的元素

ltrim(key, start, end)：截取名称为key的list

lindex(key, index)：返回名称为key的list中index位置的元素

lset(key, index, value)：给名称为key的list中index位置的元素赋值

lrem(key, count, value)：删除count个key的list中值为value的元素

lpop(key)：返回并删除名称为key的list中的首元素

rpop(key)：返回并删除名称为key的list中的尾元素

rpoplpush(srckey, dstkey)：返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部

6)Set相关

sadd(key, member)：向名称为key的set中添加元素

srem(key, member) ：删除名称为key的set中的元素member

spop(key) ：随机返回并删除名称为key的set中一个元素

smove(srckey, dstkey, member) ：移到集合元素

scard(key) ：返回名称为key的set的基数

sismember(key, member) ：member是否是名称为key的set的元素

sinter(key1, key2,…key N) ：求交集

sinterstore(dstkey, (keys)) ：求交集并将交集保存到dstkey的集合

sunion(key1, (keys)) ：求并集

sunionstore(dstkey, (keys)) ：求并集并将并集保存到dstkey的集合

sdiff(key1, (keys)) ：求差集

sdiffstore(dstkey, (keys)) ：求差集并将差集保存到dstkey的集合

smembers(key) ：返回名称为key的set的所有元素

srandmember(key) ：随机返回名称为key的set的一个元素

7)Hash相关

hset(key, field, value)：向名称为key的hash中添加元素

hget(key, field)：返回名称为key的hash中field对应的value

hmget(key, (fields))：返回名称为key的hash中field i对应的值

hmset(key, (fields))：向名称为key的hash中添加元素

hincrby(key, field, integer)：将名称为key的hash中field的value增加integer

hexists(key, field)：名称为key的hash中是否存在键为field的域

hdel(key, field)：删除名称为key的hash中键为field的域

hlen(key)：返回名称为key的hash中元素个数

hkeys(key)：返回名称为key的hash中所有键

hvals(key)：返回名称为key的hash中所有键对应的值

hgetall(key)：返回名称为key的hash中所有的键及其对应的值

3、使用示例

import redis.clients.jedis.*;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

public class RedisClient {

private Jedis jedis; //非切片客户端连接

private JedisPool jedisPool; //非切片连接池

private ShardedJedis shardedJedis; //切片客户端连接

private ShardedJedisPool shardedJedisPool; //切片连接池

private static final String SERVER_HOST = "127.0.0.1";

private static final int SERVER_PORT = 6379;

private static final String ROOT = "master";

public RedisClient() {

// 初始化连接池

initPool();

initShardedPool();

jedis = jedisPool.getResource();

shardedJedis = shardedJedisPool.getResource();

}

/**

* 初始化非切片池

*/

private void initPool() {

// 池配置

JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

jedisPoolConfig.setMaxIdle(5);

jedisPoolConfig.setMaxWaitMillis(1000L);

jedisPoolConfig.setTestOnBorrow(false);

jedisPool = new JedisPool(jedisPoolConfig, SERVER_HOST, SERVER_PORT);

}

/**

* 初始化切片池

*/

private void initShardedPool() {

// 池配置

JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

jedisPoolConfig.setMaxIdle(5);

jedisPoolConfig.setMaxWaitMillis(1000L);

jedisPoolConfig.setTestOnBorrow(false);

// slave配置

List shardInfos = new ArrayList<>();

shardInfos.add(new JedisShardInfo(SERVER_HOST, SERVER_PORT, ROOT));

shardedJedisPool = new ShardedJedisPool(jedisPoolConfig,shardInfos);

}

/**

* Key相关的功能

*/

protected void keyOperate() {

jedis.append("key1", "test"); //追加键key1的值

jedis.del("key1"); //删除键key1

jedis.exists("key1"); //判断key1是否存在

jedis.expire("key1", 5); //设置key1的过期时间为5秒

jedis.set("key1", "abc"); //设置键key1的值

jedis.get("key1"); //获取键key1的值

jedis.type("key1"); //查看键key1的值类型

jedis.ttl("key1"); //查看键key1的剩余生存时间，单位秒，永久生存或不存在的都返回-1

jedis.persist("key1"); //移除键key1的生存时间

jedis.rename("key1", "key2"); //更名键key1为key2

jedis.move("foo", 1); //将当前DB的key移动到指定DB中

//输出所有的KEY

Set keys = jedis.keys("*");

Iterator it = keys.iterator();

while (it.hasNext()) {

System.out.println(it.next());

}

shardedJedis.append("key1", "test"); //追加键key1的值

shardedJedis.del("key1"); //删除键key1

shardedJedis.exists("key1"); //判断key1是否存在

shardedJedis.expire("key1", 5); //设置key1的过期时间为5秒

shardedJedis.set("key1", "abc"); //设置键key1的值

shardedJedis.get("key1"); //获取键key1的值

shardedJedis.type("key1"); //查看键key1的值类型

shardedJedis.ttl("key1"); //查看键key1的剩余生存时间，单位秒，永久生存或不存在的都返回-1

shardedJedis.persist("key1"); //移除键key1的生存时间

shardedJedis.move("foo", 1); //将当前DB的key移动到指定DB中

}

/**

* String相关的功能

*/

protected void stringOperate() {

jedis.set("key1", "value1"); //新增键key1

jedis.set("key1", "value2"); //覆盖键key1

jedis.mset("key1", "value1","key2", "value2","key3", "value3"); //新增多个key

jedis.get("key1"); //获取键key1的值

jedis.mget("key1","key2","key3"); //获取多个key

jedis.del("key1"); //删除键key1

jedis.del("key1","key2","key3"); //删除多个key

shardedJedis.set("key1", "value1"); //新增键key1

shardedJedis.set("key1", "value2"); //覆盖键key1

shardedJedis.get("key1"); //获取键key1的值

shardedJedis.del("key1"); //删除键key1

shardedJedis.setnx("key1", "value1"); //键key1不存在时，新增键key1

shardedJedis.setnx("key1", "value2"); //键key1存在时，尝试新增键key1

shardedJedis.setex("key1", 2, "aaa"); //新增键key1,并指定过期时间为2秒

shardedJedis.getrange("key1",2,4); //获取键key1对应值中指定位置的字符串

}

/**

* List相关的功能

*/

protected void listOperate() {

jedis.lpush("str1","a"); //新增list元素a

jedis.lpush("str1","b"); //新增list元素b

jedis.lrange("str1",0,-1); //输出list所有元素

jedis.lrem("str1",1,"a"); //删除列表指定的值，第二个参数为删除的个数(有重复时)

jedis.ltrim("str1",0,2); //删除区间以外的数据

jedis.lpop("str1"); //列表元素出栈

jedis.lset("str1",0,"abc"); //修改列表中指定下标的值

jedis.llen("str1"); //计算数组长度

jedis.lindex("str1",1); //获取列表指定下标的值

//排序

SortingParams sortingParams = new SortingParams();

sortingParams.alpha();

sortingParams.limit(0,3);

jedis.sort("str1", sortingParams);

shardedJedis.lpush("str1","a"); //新增list元素a

shardedJedis.lpush("str1","b"); //新增list元素b

shardedJedis.lrange("str1",0,-1); //输出list所有元素

shardedJedis.lrem("str1",1,"a"); //删除列表指定的值，第二个参数为删除的个数(有重复时)

shardedJedis.ltrim("str1",0,2); //删除区间以外的数据

shardedJedis.lpop("str1"); //列表元素出栈

shardedJedis.lset("str1",0,"abc"); //修改列表中指定下标的值

shardedJedis.llen("str1"); //计算数组长度

shardedJedis.lindex("str1",1); //获取列表指定下标的值

shardedJedis.sort("str1",sortingParams); //排序

}

/**

* Set相关的功能

*/

protected void setOperate() {

jedis.sadd("set1","a1"); //向set1集合中加入元素a1

jedis.smembers("set1"); //查看set1集合中所有元素

jedis.srem("set1","a2"); //删除set1集合中元素a2

jedis.sismember("set1","a3"); //判断set1集合中是否存在元素a3

//遍历集合set1的所有元素

Set set = jedis.smembers("set1");

Iterator it = set.iterator();

while (it.hasNext()) {

System.out.println(it.next());

}

jedis.sinter("set1","set2"); //获取集合set1和set2的交集

jedis.sunion("set1","set2"); //获取集合set1和set2的并集

jedis.sdiff("set1","set2"); //获取集合set1和set2的差集，set1中有，set2中没有的元素

shardedJedis.sadd("set1","a1"); //向set1集合中加入元素a1

shardedJedis.smembers("set1"); //查看set1集合中所有元素

shardedJedis.srem("set1","a2"); //删除set1集合中元素a2

shardedJedis.sismember("set1","a3"); //判断set1集合中是否存在元素a3

}

/**

* SortSet相关的功能

*/

protected void sortSetOperate() {

jedis.zadd("zset",1.0,"a1"); //向zset中添加元素a1

jedis.zrange("zset",0,-1); //查询zset中所有元素，按权重值排序

jedis.zrange("zset",1,5); //查看zset中下标1到5范围内的元素值

jedis.zrem("zset","a2"); //删除zset中元素a2

jedis.zcard("zset"); //统计zset中元素数量

jedis.zcount("zset",1.0,5.0); //统计zset中权重在某个范围内的元素数

jedis.zscore("zset","a2"); //查看zset中元素a2的权重

shardedJedis.zadd("zset",1.0,"a1"); //向zset中添加元素a1

shardedJedis.zrange("zset",0,-1); //查询zset中所有元素，按权重值排序

shardedJedis.zrange("zset",1,5); //查看zset中下标1到5范围内的元素值

shardedJedis.zrem("zset","a2"); //删除zset中元素a2

shardedJedis.zcard("zset"); //统计zset中元素数量

shardedJedis.zcount("zset",1.0,5.0); //统计zset中权重在某个范围内的元素数

shardedJedis.zscore("zset","a2"); //查看zset中元素a2的权重

}

/**

* hash相关的功能

*/

protected void hashtOperate() {

jedis.hset("hash1","key1","a"); //向hash1中添加键值对key1

jedis.hincrBy("hash1","key2",4L); //新增key2和4的Long型键值对

jedis.hdel("hash1","key2"); //删除hash1中key2键值对

jedis.hexists("hash1","key1"); //判断hash1中是否存在key1

jedis.hget("hash1","key1"); //获取key1的值

jedis.hmget("hash1","key1","key2"); //获取key1和key2对应的值

jedis.hkeys("hash1"); //获取hash1中的所有key

jedis.hvals("hash1"); //获取hash1中的所有值

shardedJedis.hset("hash1","key1","a"); //向hash1中添加键值对key1

shardedJedis.hincrBy("hash1","key2",4L); //新增key2和4的Long型键值对

shardedJedis.hdel("hash1","key2"); //删除hash1中key2键值对

shardedJedis.hexists("hash1","key1"); //判断hash1中是否存在key1

shardedJedis.hget("hash1","key1"); //获取key1的值

shardedJedis.hmget("hash1","key1","key2"); //获取key1和key2对应的值

shardedJedis.hkeys("hash1"); //获取hash1中的所有key

shardedJedis.hvals("hash1"); //获取hash1中的所有值

}

public static void main(String... args) {

RedisClient client = new RedisClient();

client.keyOperate();

client.stringOperate();

client.listOperate();

client.setOperate();

client.sortSetOperate();

client.hashtOperate();

}

}