redis保存数据时都有key和value,key和value要么是String类型的,要么是byte[]类型的。在此都是讲的String类型的,所用的jar主要有:
commons-pool-1.6.jar
jedis-2.1.0.jar
1.保存数据之String
要把一个String保存到redis中,用set(key,value),获取值用get(key)
2.保存数据之List
要把一个List保存到redis中,遍历List<String>,逐个调用lpush(key,value),获取值用lrange(key,start,end),start代表开始位置,end代表结束位置,如果为-1则代表到未尾。
这里lpush的意思是从左边保存,也就是后来居上。
3.保存数据之Set
要把一个Set保存到redis中,遍历Set<String>,逐个调用sadd(key,value),获取值用smembers(key)
4.保丰数据之SortedSet
SortedSet的意思是他的每一个元素是有顺序的,顺序根据其score来决定,如果socre一样,则按value排序。保存到redis的方法是,对每一个要保存的元素,
调用zadd(key,score,value),获取值用zrange(key,satrt,end),start代表开始位置,end代表结束位置,如果为-1则代表到未尾。
5.保存数据之Hash
要把一个Hash保存到redis中,遍历Map<String,String>,逐个调用hset(key,hashKey,hashValue),获取所有值有hgetAll(key)
下面来说说怎么保存对象到redis中,我们知道,redis支持的value要么是String类型,要么是byte[]类型,那么思路就是把我们想要保存的对象序列化成String类型或byte[]类型,然后保存之,取值时再反序列化成对象。
最后粘下我的测试代码:
package com.syz.jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class RedisClient {
private static final int MAX_ACTIVE = 20;
private static final int MAX_IDLE = 5;
private static final int MAX_WAIT = 1000;
private static final String HOST = "127.0.0.1";
private static final int PORT = 6379;
private static JedisPool jedisPool;
private RedisClient() {
}
/**
* 初始化非切片池
*/
private static void initialPool() {
// 池基本配置
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxActive(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWait(MAX_WAIT);
jedisPool = new JedisPool(config, HOST, PORT);
}
public static JedisPool getJedis() {
if (jedisPool == null) {
synchronized (RedisClient.class) {
if (jedisPool == null) {
initialPool();
}
}
}
return jedisPool;
}
}
package com.syz.jedis;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
public class RedisTest {
public static void main(String[] args) {
JedisPool jedisPool = RedisClient.getJedis();
Jedis jedis = jedisPool.getResource();
jedis.select(10);
try {
System.out.println("testString=================begin");
testString(jedis);
System.out.println("testString=================end");
System.out.println("testList=================begin");
testList(jedis);
System.out.println("testList=================end");
System.out.println("testSet=================begin");
testSet(jedis);
System.out.println("testSet=================end");
System.out.println("testSortedSet=================begin");
testSortedSet(jedis);
System.out.println("testSortedSet=================end");
System.out.println("testHash=================begin");
testHash(jedis);
System.out.println("testHash=================end");
}
catch (Exception e) {
e.printStackTrace();
}
finally {
jedisPool.returnResource(jedis);
}
}
private static void testString(Jedis jedis) {
String key = "test:string:a";
// 为了保持多次测试结果一样,每次开始时都删除
jedis.del(key);
String value = "hello redis";
jedis.set(key, value);
String val = jedis.get(key);
System.out.println(val);
// 结果:hello redis
}
private static void testList(Jedis jedis) {
String key = "test:list:a";
// 为了保持多次测试结果一样,每次开始时都删除
jedis.del(key);
List<String> values = new ArrayList<>();
for (int i = 0; i < 10; i++) {
char c = (char) (65 + i);
values.add(String.valueOf(c));
}
for (int i = 0; i < values.size(); i++) {
jedis.lpush(key, values.get(i));
}
List<String> val = jedis.lrange(key, 0, -1);
System.out.println(val);
// 结果:[J, I, H, G, F, E, D, C, B, A]
}
private static void testSet(Jedis jedis) {
String key = "test:set:a";
// 为了保持多次测试结果一样,每次开始时都删除
jedis.del(key);
Set<String> values = new HashSet<>();
for (int i = 0; i < 10; i++) {
char c = (char) (65 + i);
values.add(String.valueOf(c));
}
Iterator<String> ite = values.iterator();
while (ite.hasNext()) {
String value = ite.next();
jedis.sadd(key, value);
}
Set<String> val = jedis.smembers(key);
System.out.println(val);
// 结果:[D, E, F, G, A, B, C, H, I, J]
}
private static void testSortedSet(Jedis jedis) {
String key = "test:sortedset:a";
// 为了保持多次测试结果一样,每次开始时都删除
jedis.del(key);
String[] values = { "C", "B", "G", "D", "d" };
jedis.zadd(key, 10, "E");
for (int i = 0; i < values.length; i++) {
jedis.zadd(key, i + 10, values[i]);
}
jedis.zadd(key, 10, "F");
Set<String> val = jedis.zrange(key, 0, -1);
System.out.println(val);
// 结果:[C, E, F, B, G, D, d]
}
private static void testHash(Jedis jedis) {
String key = "test:hash:a";
// 为了保持多次测试结果一样,每次开始时都删除
jedis.del(key);
Map<String, String> values = new HashMap<>();
for (int i = 0; i < 10; i++) {
String s = String.valueOf((char) (i + 'A'));
values.put(s, s + "_val");
}
Iterator<Entry<String, String>> ite = values.entrySet().iterator();
while (ite.hasNext()) {
Entry<String, String> entry = ite.next();
String k = entry.getKey();
String v = entry.getValue();
jedis.hset(key, k, v);
}
Map<String, String> val = jedis.hgetAll(key);
System.out.println(val);
// 结果:{D=D_val, E=E_val, F=F_val, G=G_val, A=A_val, B=B_val, C=C_val,
// H=H_val, I=I_val, J=J_val}
}
}
几种保存结果用Redis Desktop Manager查看的截图: