Redis 基本用法

package com.beijingserver.common.util;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Timer;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
* redis缓存服务器公用类
*
* @version 1.0
* @author 周化益
* @since 2016-02-15
*/
public class Redis {
//创建连接池
private static JedisPool pool;

//Redis 连接地址
private static String ip = "127.0.0.1";

//Redis 连接端口号
private static int port = 6379;

//Redis 连接密码
private static String pwd = "foobared";

//客户端Jedis对象
private static Jedis jedis;

//开启定时任务
public static Timer timer;

//初始化返回结果
private static Boolean bool = false;

//初始化返回值
private static String value = "";

//初始化 结果数
private static long num = 0;

//获取当前时间
private static Date date = new Date();

/**
* 获取连接池
*
* @author 周化益
* @param ip IP地址
* @param port 端口号
* @return JedisPool
*/
public static JedisPool getPool() {
if (pool == null) {
JedisPoolConfig config = new JedisPoolConfig();
//连接池最大使用连接数量
config.setMaxTotal(500);
//连接池最大空闲
config.setMaxIdle(5);
//连接等待时间
config.setMaxWaitMillis(1000 * 100);
//是否允许浏览器测试
config.setTestOnBorrow(true);
//初始化连接池
pool = new JedisPool(config, ip, port, 0, pwd);
//			pool = new JedisPool(config, ip, port, 0);
}
return pool;
}

/**
* 释放连接资源
*
* @author 周化益
* @param pool
* @param redis
*/
public static void returnResource(JedisPool pool, Jedis redis) {
if (redis != null) {
redis.close();
}
}

/**
* 返回jedis
*
* @param key
* @return
*/
public static Jedis getJedis() {
Jedis jedis = null;
try {

if(pool == null) {
pool = getPool();
}

jedis = pool.getResource();
} catch (Exception e) {
// 获取redis连接池
e.printStackTrace();
jedis.close();
} finally {
// 释放连接
returnResource(pool, jedis);
}
return jedis;
}

/**
* Redis key用法
*/
public static void testRedisKey() {
System.err.println("===================key测试开始===================");

//存储单个值
value = jedis.set("w3ckey", "redis");
if(value == null || value.trim().equals("")) {
System.out.println("添加失败！");
} else {
System.out.println("添加成功！");
}

//模糊查询w开头的所有key
System.out.println(jedis.keys("w*"));

//判断jedis是否存在key
bool = jedis.exists("w3ckey");

if(bool) {
System.out.println("存在改key！");
} else {
System.out.println("不存在该key！");
}

//删除单个key
num = jedis.del("w3ckey");

if(num > 0) {
System.out.println("删除成功！");
} else {
System.out.println("删除失败！");
}

//模糊查询w开头的所有key
System.out.println(jedis.keys("w*"));

//存储单个值
jedis.set("greeting", "redis");

//获取key对应的值
Syste
4000
m.out.println(jedis.get("greeting"));

//序列化key
value = jedis.dump("greeting").toString();

//打印序列化后的值
System.out.println(value);

//设置过去时间以秒计算
jedis.expire("greeting", 30);
timer = new Timer();
//在1秒后执行此任务,每次间隔2秒执行一次,如果传递一个Data参数,就可以在某个固定的时间执行这个任务.
timer.schedule(new MyTask(), 1000, 2000);

/*Expireat 命令 - EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置过期时间。
* 不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。 设置20秒后过期 */
jedis.expireAt("greeting", date.getTime()/1000 + 20);

//Redis PEXPIREAT 命令 - 设置 key 的过期时间亿以毫秒计。  设置5秒后过期
jedis.pexpireAt("greeting", date.getTime() + 5*1000);

//redis默认使用数据库 0，为了清晰起见，这里再显式指定一次
jedis.select(0);

jedis.set("song", "secret base - Zone");

//将 song 移动到数据库 1
jedis.move("song", 1);

bool = jedis.exists("song");
if(bool) {
System.out.println("数据库0存在改key！");
} else {
System.out.println("数据库0不存在该key！");
}

//指定数据库
jedis.select(1);

bool = jedis.exists("song");
if(bool) {
System.out.println("数据库1存在改key！");
} else {
System.out.println("数据库1不存在该key！");
}

//Redis PERSIST 命令 - 移除 key 的过期时间，key 将持久保持。
num = jedis.persist("greeting");
if(num > 0) {
System.out.println("移除成功！");
} else {
System.out.println("移除失败！");
}

//Redis RANDOMKEY 命令 - 从当前数据库中随机返回一个 key 。
System.out.println(jedis.randomKey());

//Redis Renamenx 命令 - 仅当 newkey 不存在时，将 key 改名为 newkey 。
System.out.println(jedis.renamenx("song", "songs"));

//Redis Type 命令 - 返回 key 所储存的值的类型。
System.out.println(jedis.type("songs"));

System.err.println("===================key测试结束===================");
}

/**
* Redis String用法
*/
public static void testRedisString() {
System.err.println("===================String测试开始===================");
//设置指定 key 的值
jedis.set("key", "value");

//获取指定 key 的值。
System.out.println(jedis.get("key"));

//Getrange 命令 - 返回 key 中字符串值的子字符 ,0-1查询所有
System.out.println(jedis.getrange("key", 0, 2));

//Getset 命令 - 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
System.out.println(jedis.getSet("key", "newValue"));

//Getbit 命令 - 对 key 所储存的字符串值，获取指定偏移量上的位(bit)。
jedis.setbit("bit", 10010, true);
System.out.println(jedis.getbit("bit", 10010));

//Mget 命令 - 获取所有(一个或多个)给定 key 的值。
jedis.set("key1", "value1");
System.out.println(jedis.mget("key","key1"));

//Setex 命令 - 将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。
System.out.println(jedis.setex("setex", 10, "setex11"));

//Setnx 命令 - 只有在 key 不存在时设置 key 的值。
System.out.println(jedis.setnx("key", "value"));
if(jedis.exists("key0")) {
jedis.del("key0");
}
System.out.println(jedis.setnx("key0", "value0"));

//Setrange 命令 - 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始。
jedis.set("mykey", "Hello World");
jedis.setrange("mykey", 6, "Redis");
System.out.println(jedis.get("mykey"));

//Strlen 命令 - 返回 key 所储存的字符串值的长度。
System.out.println(jedis.strlen("mykey"));

//Mset 命令 - 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
jedis.mset("key2","vlaue2","key3","vlaue3","key4","vlaue4","key5","vlaue5");
System.out.println(jedis.mget("key","key1","key2","key3","key4","key5"));

//Msetnx 命令 - 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
System.out.println(jedis.msetnx("key2","vlaue2","key3","vlaue3","key4","vlaue4","key5","vlaue5"));

//Psetex 命令 - 这个命令和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，而不是像 SETEX 命令那样，以秒为单位。
//		System.out.println(jedis.psetex("key6", 10000, "value6"));

//Incr 命令 - 将 key 中储存的数字值增一。
jedis.set("key7", "1");
System.out.println(jedis.incr("key7"));

//Incrby 命令 - 将 key 所储存的值加上给定的增量值（increment） 。
System.out.println(jedis.incrBy("key7",10));

//Incrbyfloat 命令 - 将 key 所储存的值加上给定的浮点增量值（increment） 。
System.out.println(jedis.incrByFloat("key7",1.01));

//Decr 命令 - 将 key 中储存的数字值减一。
jedis.set("key8", "15");
System.out.println(jedis.decr("key8"));

//Decrby 命令 - key 所储存的值减去给定的减量值（decrement） 。
System.out.println(jedis.decrBy("key8",10));

//Append 命令 - 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
jedis.set("key9", "value");
jedis.append("key9", "9");
System.out.println(jedis.get("key9"));

System.err.println("===================String测试结束===================");
}

/**
* Redis Hash用法
*/
public static void testRedisHash() {
System.err.println("===================Hash测试开始===================");

//Hset 命令 - 将哈希表 key 中的字段 field 的值设为 value 。
jedis.hset("map1", "mapKey1", "mapValue1");

//Hsetnx 命令 - 只有在字段 field 不存在时，设置哈希表字段的值。
System.out.println(jedis.hsetnx("map1", "mapKey1", "mapValue2"));
System.out.println(jedis.hsetnx("map1", "mapKey2", "mapValue2"));

//Hmset 命令 - 同时将多个 field-value (域-值)对设置到哈希表 key 中。
Map<String, String> map2 = new HashMap<String, String>();
map2.put("account", "admin");
map2.put("password", "123");
map2.put("userId", "1");
jedis.hmset("map2", map2);

//Hexists 命令 - 查看哈希表 key 中，指定的字段是否存在。
System.out.println(jedis.hexists("map1", "mapKey1"));

//Hkeys 命令 - 获取所有哈希表中的字段
System.out.println(jedis.hkeys("map2"));

//Hvals 命令 - 获取哈希表中所有值
System.out.println(jedis.hvals("map2"));

//Hget 命令 - 获取存储在哈希表中指定字段的值/td>
System.out.println(jedis.hget("map1", "mapKey1"));

//Hmget 命令 - 获取所有给定字段的值
System.out.println(jedis.hmget("map2", "account","password"));

//Hgetall 命令 - 获取在哈希表中指定 key 的所有字段和值
System.out.println(jedis.hgetAll("map2"));

//Hincrby 命令 - 为哈希表 key 中的指定字段的整数值加上增量 increment 。
System.out.println(jedis.hincrBy("map2", "password", 4));

//Hincrbyfloat 命令 - 为哈希表 key 中的指定字段的浮点数值加上增量 increment 。
System.out.println(jedis.hincrByFloat("map2", "password", 0.0));

//Hlen 命令 - 获取哈希表中字段的数量
System.out.println(jedis.hlen("map2"));

//hdel 命令 - 获取哈希表中的字段
System.out.println(jedis.hdel("map1", "mapKey2"));

System.err.println("===================Hash测试结束===================");
}

/**
* Redis List用法
*/
public static void testRedisList() {
System.err.println("===================List测试开始===================");

//Rpush 命令 - 在列表中添加一个或多个值
jedis.rpush("list1", "firstList1", "firstList2", "firstList3", "firstList4", "firstList5");
System.out.println(jedis.lrange("list1", 0, -1));
//Lset 命令 - 通过索引设置列表元素的值
jedis.lset("list1", 1, "value1");
System.out.println(jedis.lindex("list1", 0));
System.out.println(jedis.lrange("list1", 0, -1));

//Blpop 命令 - 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
//		System.out.println(jedis.blpop("list2"));
System.out.println(jedis.lrange("list1", 0, -1));

//Brpop 命令 - 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
//		System.out.println(jedis.brpop("list1"));
System.out.println(jedis.lrange("list1", 0, -1));

//Brpoplpush 命令 - 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
jedis.brpoplpush("list1", "list2", 500);

//Lindex 命令 - 通过索引获取列表中的元素
System.out.println(jedis.lindex("list1", 1));

//Linsert 命令 - 在列表的元素前或者后插入元素
System.out.println(jedis.linsert("list1", LIST_POSITION.BEFORE, "firstList1", "firstList0"));

//Llen 命令 - 获取列表长度
System.out.println(jedis.llen("list1"));

//Lpop 命令 - 移出并获取列表的第一个元素
System.out.println(jedis.lpop("list1"));

//Lpush 命令 - 将一个或多个值插入到列表头部
System.out.println(jedis.lpush("list1", "insert1","insert2","insert3"));

//Lrange 命令 - 获取列表指定范围内的元素
System.out.println(jedis.lrange("list1", 0, -1));

/*Lrem 命令 - 移除列表元素
* count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
* count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
* count = 0 : 移除表中所有与 VALUE 相等的值。
*/
System.out.println(jedis.lrem("list1", 0, "insert1"));

// Ltrim 命令 - 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
System.out.println(jedis.ltrim("list1", 5, 10));

//Rpop 命令 - 移除并获取列表最后一个元素
System.out.println(jedis.rpop("list1"));

//Rpoplpush 命令 - 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
System.out.println(jedis.rpoplpush("list1", "list2"));

//Rpushx 命令 - 为已存在的列表添加值
System.out.println(jedis.rpushx("list1", "hello"));

System.err.println("===================List测试结束===================");
}

/**
* Redis Set用法
*/
public static void testRedisSet() {
System.err.println("===================Set测试开始===================");
System.out.println(jedis.del("set1"));
System.out.println(jedis.del("set2"));
//Sadd 命令 - 向集合添加一个或多个成员
System.out.println(jedis.sadd("set1", "set1Value1", "set1Value2", "set1Value3", "set1Value4"));

//Redis Scard 命令 - 获取集合的成员数
System.out.println(jedis.scard("set1"));

//Sdiff 命令 - 返回给定所有集合的差集
jedis.sadd("set2", "set2Value1", "set2Value2", "set1Value3", "set1Value4");
System.out.println(jedis.sdiff("set1","set2"));

//Sdiffstore 命令 - 返回给定所有集合的差集并存储在 destination 中
System.out.println(jedis.sdiffstore("set3", "set1","set2"));
System.out.println(jedis.smembers("set3"));

//Sinter 命令 - 返回给定所有集合的交集
System.out.println(jedis.sinter("set1","set2"));

//Sinterstore 命令 - 返回给定所有集合的交集并存储在 destination 中
System.out.println(jedis.sinterstore("set4", "set1", "set2"));
System.out.println(jedis.smembers("set4"));

//Sismember 命令 - 判断 member 元素是否是集合 key 的成员
System.out.println(jedis.sismember("set1", "set1Value1"));

//Smembers 命令 - 返回集合中的所有成员
System.out.println(jedis.smembers("set4"));

//Smove 命令 - 将 member 元素从 source 集合移动到 destination 集合
System.out.println(jedis.smove("set3", "set4", "set1Value2"));

//Spop 命令 - 移除并返回集合中的一个随机元素
System.out.println(jedis.spop("set4"));

//Srandmember 命令 - 返回集合中一个或多个随机数
System.out.println(jedis.srandmember("set4"));

//Srem 命令 - 移除集合中一个或多个成员
System.out.println(jedis.srem("set4", "set1Value4"));

//Sunion 命令 - 返回所有给定集合的并集
System.out.println(jedis.sunion("set1", "set2", "set3"));

//Sunionstore 命令 - 所有给定集合的并集存储在 destination 集合中
System.out.println(jedis.sunionstore("set5", "set1", "set2", "set3","set4"));

//Sscan 命令 - 迭代集合中的元素
List<String> sr = jedis.sscan("set5", "1").getResult();

for (String string : sr) {
System.out.println(string);
}

System.err.println("===================Set测试结束===================");
}

/**
* main方法测试
*
* @param args
*/
public static void main(String[] args) {
//获取jedis
//		jedis = getJedis();
//		System.out.println(jedis.keys("*"));
//
//		String value = "111";
//
//		String aa = value;
//
//		System.out.println(aa);
//		value = "222";
//		System.out.println(aa);

Jedis jedis = getJedis();
System.out.println(jedis.setnx("aa", "aaa"));
jedis.expire("aa", 1);
System.out.println(jedis.setnx("aa", "bbb"));

//		System.out.println(jedis.hget("user", "1"));
//		JSONObject json = new JSONObject(jedis.hget("user", "1"));
//
//		System.out.println(json.get("account"));

//Rpush 命令 - 在列表中添加一个或多个值
//		jedis.rpush("list1", "firstList1", "firstList2", "firstList3", "firstList4", "firstList5");
//Lset 命令 - 通过索引设置列表元素的值
//		jedis.lset("list1", 1, "value1");

//		System.out.println(jedis.lrange("list1", 0, -1));
//		Set<String> keyList = jedis.keys("*");
//		for (String string : keyList) {
//
//			jedis.del(string);
//		}
//		System.out.println(keyList);
//		testRedisKey();

//		testRedisString();

//		testRedisHash();

//		testRedisList();

//		testRedisSet();
}
}

class MyTask extends java.util.TimerTask {
public void run() {
Jedis jedis = Redis.getJedis();
if(jedis.exists("greeting")) {
System.out.println(Redis.getJedis().get("greeting"));

//Redis TTL 命令 - 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
System.out.println(jedis.ttl("greeting"));

//Redis Pttl 命令 - 以毫秒为单位返回 key 的剩余的过期时间。
System.out.println(jedis.pttl("greeting"));
} else {
cancel();
System.out.println("取消定时任务");
Redis.timer.cancel();
System.out.println("取消定时器");
}
}
}