Redis基础学习(二)—数据类型
一、Redis支持的数据类型
Redis中存储数据是通过key-value存储的，对于value的类型有以下几种:
(1)字符串。
(2)Map
(3)List
(4)Set
public class RedisPoolManager{
// Redis服务器IP
private static String HOST = "192.168.109.157";
// Redis的端口号
private static int PORT = 6379;
// 可用连接实例的最大数目，默认值为8；
// 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;
// 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
private static int MAX_IDLE = 200;
// 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
private static int MAX_WAIT = 10000;
private static int TIMEOUT = 10000;
// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
private static boolean TEST_ON_BORROW = true;
private static JedisPool jedisPool = null;
/*
* 初始化Redis连接池
*/
static{
try{
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setMaxTotal(MAX_ACTIVE);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config,HOST,PORT,TIMEOUT);
}catch(Exception e){
e.printStackTrace();
}
}
/*
* 获取Jedis实例
*/
public synchronized static Jedis getJedis(){
try{
if(jedisPool != null){
Jedis resource = jedisPool.getResource();
return resource;
}else{
return null;
}
}catch(Exception e){
e.printStackTrace();
return null;
}
}
/*
* 释放jedis资源
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.returnResourceObject(jedis);
}
}
}
1.String类型
set: 设置key值。
get: 获取key值。
del: 删除key。
append: 追加key值。
incr: key值自增1。
incrBy: key值自增，指定步长。
decr: key值自减1。
decrBy: key值自减，指定步长。
expire: 为key设置过期时间（秒数）。
setex: 设置key值，可指定存活时间（秒数）。
setnx: 设置key值。key不存在才会设置，如果key存在则回滚操作，结果返回0，表示没有设置成功。
ttl: time to live，获取key的存活时间（秒），-1表示永不过期。
persist: 去掉key的expire设置，不再有失效时间。
/*
* set：设置key值
* get：获取key值
* del：删除key
* append：追加key值
* incr：key值自增1
* incrBy：key值自增，指定步长
* decr：key值自减1
* decrBy：key值自减，指定步长
* expire：为key设置过期时间（秒数）
* setex：设置key值，可指定存活时间（秒数）
* setnx：设置key值。key不存在才会设置，如果key存在则回滚操作，结果返回0，表示没有设置成功
* ttl：time to live，获取key的存活时间（秒），-1表示永不过期
* persist：去掉key的expire设置，不再有失效时间
*/
@Test
public void testString(){
Jedis jedis = RedisPoolManager.getJedis();
//设置key值
jedis.set("Tom","22");
//获取key值
String result = jedis.get("Tom");
System.out.println("Tom : " + result);
//删除key
jedis.del("Tom");
result = jedis.get("Tom");
System.out.println("Tom : " + result);
jedis.set("num","1");
//key值自增，并指定步长
jedis.incrBy("num",5);
jedis.incrBy("num",5);
System.out.println("nun : " + jedis.get("num"));
//key值自减，并指定步长
jedis.decrBy("num",5);
System.out.println("nun : " + jedis.get("num"));
//设置key值，可指定存活时间（秒数）
jedis.setex("AAA",5,"22");
System.out.println("5秒前---AAA : " + jedis.get("AAA"));
try{
TimeUnit.SECONDS.sleep(5);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println("5秒后---AAA : " + jedis.get("AAA"));
}
结果:
2.Map类型
hmset: 设置key值，值类型为map对象。
type: 返回key值的类型，可能值有none, string, hash, set, list, zset。
hkeys: 获取所有key。
hvals: 获取所有key对应的值。
hmget: 一次性获取多个field的值。
hexists: 判断field是否存在。
hset: 设置field的值。
hgetAll: 获取全部内容。
hget: 获取field的值。
hdel: 删除field。
hincrBy: field值自增1。
hlen: 计算field的数目。
hsetnx: 设置key值。field不存在才会设置，如果field存在则回滚操作，结果返回0，表示没有设置成功。可以用来实现分布式锁。
/*
* hmset：设置key值，值类型为map对象
* type：返回key值的类型，可能值有none, string, hash, set, list, zset
* hkeys：获取所有key
* hvals：获取所有key对应的值
* hmget：一次性获取多个field的值
* hexists：判断field是否存在
* hset：设置field的值
* hgetAll：获取全部内容
* hget：获取field的值
* hdel：删除field
* hincrBy：field值自增1
* hlen：计算field的数目
* hsetnx：设置key值。field不存在才会设置，如果field存在则回滚操作，结果返回0，表示没有设置成功。可以用来实现分布式锁
*/
@Test
public void testMap(){
Jedis jedis = RedisPoolManager.getJedis();
Map<String,String> map = new HashMap<String,String>();
map.put("username","AAA");
map.put("address","北京市昌平区");
map.put("age","22");
//设置key值，值类型为map对象
jedis.hmset("user",map);
//返回key值的类型，可能值有none, string, hash, set, list, zset
System.out.println("type: " + jedis.type("user"));
//获取所有key
System.out.println("hkeys: " + jedis.hkeys("user"));
//获取所有key对应的值
System.out.println("hvals: " + jedis.hvals("user"));
//一次性获取多个field的值
System.out.println("hmget: " + jedis.hmget("user","username","address"));
//判断field是否存在
System.out.println("hexists: " + jedis.hexists("user","username"));
//设置field的值
jedis.hset("user","username","AAA001");
//获取field的值
System.out.println("hget: " + jedis.hget("user","username"));
System.out.println("hgetAll: " + jedis.hgetAll("user"));
}
结果:
3.Set类型
sadd: 往set对象中添加一个值。
smembers: 取得set中所有的值。
sismember: 判断一个值是否在set中存在。
srandmember: 从set中随机取得一个值。
srem: 从set中删除一个值。
scard: 返回set的item个数。
/*
* sadd：往set对象中添加一个值
* smembers：取得set中所有的值
* sismember：判断一个值是否在set中存在
* srandmember：从set中随机取得一个值
* srem：从set中删除一个值
* scard：返回set的item个数
*/
@Test
public void testSet(){
Jedis jedis = RedisPoolManager.getJedis();
//往set对象中添加一个值
jedis.sadd("uid","u001");
jedis.sadd("uid","u002");
jedis.sadd("uid","u003");
System.out.println("type : " + jedis.type("uid"));
//取得set中所有的值
System.out.println(jedis.smembers("uid"));
//判断一个值是否在set中存在
System.out.println(jedis.sismember("uid","u003"));
//从set中随机取得一个值
System.out.println(jedis.srandmember("uid"));
//从set中删除一个值
jedis.srem("uid","u003");
System.out.println(jedis.smembers("uid"));
//返回set的item个数
System.out.println(jedis.scard("uid"));
}
结果:
4.List类型
rpush: 从列表尾部插入多个元素。
llen: 返回列表中的元素的数量。
lpop: 从列表头部移除并返回list的第一个元素。
lrem: 从头部开始找，删除n个值。
lrange: 从列表中获取指定范围的子集。
/*
* rpush：从列表尾部插入多个元素
* llen：返回列表中的元素的数量
* lpop：从列表头部移除并返回list的第一个元素
* lrem：从头部开始找，删除n个值
* lrange：从列表中获取指定范围的子集
*/
@Test
public void testList(){
Jedis jedis = RedisPoolManager.getJedis();
//从列表尾部插入多个元素
jedis.rpush("list","AAA","BBB","CCC","DDD");
//返回列表中的元素的数量
System.out.println("llen: " + jedis.llen("list"));
//从列表头部移除并返回list的第一个元素
String item = jedis.lpop("list");
System.out.println("lpop: " + item);
System.out.println("llen: " + jedis.llen("list"));
jedis.rpush("list","111","222","333","444","AAA");
//从头部开始找，删除n个值
jedis.lrem("list",1,"AAA");
System.out.println("llen: " + jedis.llen("list"));
}
结果:
5.工具类
public class RedisUtil {
private static String HOST = "192.168.109.157";
private static int PORT = 6379;
private static JedisPool pool = null;
static {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(128);
config.setMaxIdle(80);
config.setMaxWaitMillis(2001);
pool = new JedisPool(config, HOST, PORT, 2000);
}
/**
* 把key存入redis中
*
* @param key k
* @param value v
* @param seconds 过期时间（秒）
* @return boolean
*/
public static boolean set(byte[] key, byte[] value, int seconds) {
Jedis jedis = null;
try {
jedis = pool.getResource();
String result = jedis.set(key, value);
if (seconds > 0) {
Long r = jedis.expire(key, seconds);
}
} catch (Exception e) {
return false;
} finally {
if (null != jedis) {
jedis.close();
}
}
return true;
}
public static byte[] get(byte[] key) {
byte[] value = null;
Jedis jedis = null;
try {
jedis = pool.getResource();
value = jedis.get(key);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return value;
}
/**
* 向缓存中设置对象
*
* @param key key
* @param obj value
* @return boolean
*/
public static boolean set(String key, Object obj, Integer seconds) {
Jedis jedis = null;
try {
jedis = pool.getResource();
ObjectMapper mapper = new ObjectMapper();
String value = mapper.writeValueAsString(obj);
jedis.set(SafeEncoder.encode(key), SafeEncoder.encode(value));
if (seconds != null) {
jedis.expire(key, seconds);
}
return true;
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return false;
}
/**
* 向缓存中设置对象
*
* @param key key
* @param value value
* @return boolean
*/
public static boolean set(String key, String value, Integer seconds) {
Jedis jedis = null;
try {
jedis = pool.getResource();
jedis.set(SafeEncoder.encode(key), SafeEncoder.encode(value));
if (seconds != null) {
jedis.expire(key, seconds);
}
return true;
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return false;
}
/**
* 移除缓存中设置对象
*
* @param keys 被删除的KEYS
* @return Long 被删除个数
*/
public static Long del(String... keys) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.del(keys);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
/**
* 根据key 获取对象
*
* @param key key
* @return T
*/
public static <T> T get(String key, Class<T> clazz) {
Jedis jedis = null;
try {
jedis = pool.getResource();
String v = jedis.get(key);
if (StringUtils.isNotEmpty(v)) {
ObjectMapper mapper = new ObjectMapper();
return mapper.readValue(v, clazz);
}
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
/**
* 根据key值得到String类型的返回值
*
* @param key key
* @return String
*/
public static String get(String key) {
Jedis jedis = null;
try {
jedis = pool.getResource();
String v = jedis.get(key);
if (StringUtils.isNotEmpty(v)) {
return v;
}
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
public static Boolean exists(String key) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.exists(key);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
/**
* redis的list操作：
* 把元素插入到列表的尾部
*
* @param key KEY
* @param strings 要插入的值，变参
* @return 返回插入后list的大小
*/
public static Long rpush(String key, String... strings) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.rpush(key, strings);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
/**
* redis的list操作：
* 根据开始与结束下标取list中的值
*
* @param key KEY
* @param start 开始下标
* @param end 结束下标
* @return List<String>
*/
public static List<String> lrange(String key, int start, int end) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.lrange(key, start, end);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
/**
* redis的list操作：
* 取列表的长度
*
* @param key key
* @return Long
*/
public static Long llen(String key) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.llen(key);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
/**
* redis的list操作：
* 根据值移除list中的元素
*
* @param key KEY
* @param count ：
* count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
* count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
* count = 0 : 移除表中所有与 value 相等的值。
* @param value 要删除的值
* @return 返回被移除的个数
*/
public static Long lrem(String key, long count, String value) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.lrem(key, count, value);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
public static boolean setLong(String key, Long value) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return "OK".equals(jedis.set(key, String.valueOf(value)));
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return false;
}
public static Long getLong(String key) {
String result = get(key);
return result == null ? null : Long.valueOf(result);
}
public static Long incrBy(String key, Long increment) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.incrBy(key, increment);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
public static Long hashSet(String key, String field, String value) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.hset(key, field, value);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return -1L;
}
public static Long hashSetLong(String key, String field, Long value) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.hset(key, field, String.valueOf(value));
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return -1L;
}
public static Long hashIncrBy(String key, String field, Long increment) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.hincrBy(key, field, increment);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return -1L;
}
public static Map<String, String> hashGetAll(String key) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.hgetAll(key);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
public static Set<String> hashKeys(String key) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.hkeys(key);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
public static Long hashDelAll(String key, String... fields) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.hdel(key, fields);
} catch (Exception e) {
} finally {
if (null != jedis) {
jedis.close();
}
}
return null;
}
}
测试:
@Test
public void testObj(){
User user = new User("001","张三","朝阳区");
RedisUtil.set("user",user,3600000);
User user2 = RedisUtil.get("user",User.class);
System.out.println(user2);
}
结果:
User [id=001, username=张三, address=朝阳区]
越努力，越幸运！
