redis保存數據的幾種類型

java（13）

版權聲明：本文為博主原創文章，未經博主允許不得轉載。

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[]類型，然後保存之，取值時再反序列化成對象。

最後粘下我的測試代碼：

1. package com.syz.jedis;
3. import redis.clients.jedis.JedisPool;
4. import redis.clients.jedis.JedisPoolConfig;
6. public class RedisClient {
7. private static final int MAX_ACTIVE = 20;
9. private static final int MAX_IDLE = 5;
11. private static final int MAX_WAIT = 1000;
13. private static final String HOST = "127.0.0.1";
15. private static final int PORT = 6379;
17. private static JedisPool jedisPool;
19. private RedisClient() {
20. }
22. /**
23. * 初始化非切片池
24. */
25. private static void initialPool() {
26. // 池基本配置
27. JedisPoolConfig config = new JedisPoolConfig();
28. config.setMaxActive(MAX_ACTIVE);
29. config.setMaxIdle(MAX_IDLE);
30. config.setMaxWait(MAX_WAIT);
31. jedisPool = new JedisPool(config, HOST, PORT);
32. }
35. public static JedisPool getJedis() {
36. if (jedisPool == null) {
37. synchronized (RedisClient.class) {
38. if (jedisPool == null) {
39. initialPool();
40. }
41. }
42. }
43. return jedisPool;
44. }
46. }

1. package com.syz.jedis;
3. import java.util.ArrayList;
4. import java.util.HashMap;
5. import java.util.HashSet;
6. import java.util.Iterator;
7. import java.util.List;
8. import java.util.Map;
9. import java.util.Map.Entry;
10. import java.util.Set;
12. import redis.clients.jedis.Jedis;
13. import redis.clients.jedis.JedisPool;
15. public class RedisTest {
16. public static void main(String[] args) {
17. JedisPool jedisPool = RedisClient.getJedis();
18. Jedis jedis = jedisPool.getResource();
19. jedis.select(10);
20. try {
21. System.out.println("testString=================begin");
22. testString(jedis);
23. System.out.println("testString=================end");
24. System.out.println("testList=================begin");
25. testList(jedis);
26. System.out.println("testList=================end");
27. System.out.println("testSet=================begin");
28. testSet(jedis);
29. System.out.println("testSet=================end");
30. System.out.println("testSortedSet=================begin");
31. testSortedSet(jedis);
32. System.out.println("testSortedSet=================end");
33. System.out.println("testHash=================begin");
34. testHash(jedis);
35. System.out.println("testHash=================end");
36. }
37. catch (Exception e) {
38. e.printStackTrace();
39. }
40. finally {
41. jedisPool.returnResource(jedis);
42. }
43. }
45. private static void testString(Jedis jedis) {
46. String key = "test:string:a";
47. // 為了保持多次測試結果一樣，每次開始時都刪除
48. jedis.del(key);
49. String value = "hello redis";
50. jedis.set(key, value);
51. String val = jedis.get(key);
52. System.out.println(val);
53. // 結果：hello redis
54. }
56. private static void testList(Jedis jedis) {
57. String key = "test:list:a";
58. // 為了保持多次測試結果一樣，每次開始時都刪除
59. jedis.del(key);
60. List<String> values = new ArrayList<>();
61. for (int i = 0; i < 10; i++) {
62. char c = (char) (65 + i);
63. values.add(String.valueOf(c));
64. }
65. for (int i = 0; i < values.size(); i++) {
66. jedis.lpush(key, values.get(i));
67. }
68. List<String> val = jedis.lrange(key, 0, -1);
69. System.out.println(val);
70. // 結果：[J, I, H, G, F, E, D, C, B, A]
71. }
73. private static void testSet(Jedis jedis) {
74. String key = "test:set:a";
75. // 為了保持多次測試結果一樣，每次開始時都刪除
76. jedis.del(key);
77. Set<String> values = new HashSet<>();
78. for (int i = 0; i < 10; i++) {
79. char c = (char) (65 + i);
80. values.add(String.valueOf(c));
81. }
82. Iterator<String> ite = values.iterator();
83. while (ite.hasNext()) {
84. String value = ite.next();
85. jedis.sadd(key, value);
86. }
87. Set<String> val = jedis.smembers(key);
88. System.out.println(val);
89. // 結果：[D, E, F, G, A, B, C, H, I, J]
90. }
92. private static void testSortedSet(Jedis jedis) {
93. String key = "test:sortedset:a";
94. // 為了保持多次測試結果一樣，每次開始時都刪除
95. jedis.del(key);
96. String[] values = { "C", "B", "G", "D", "d" };
97. jedis.zadd(key, 10, "E");
98. for (int i = 0; i < values.length; i++) {
99. jedis.zadd(key, i + 10, values[i]);
100. }
101. jedis.zadd(key, 10, "F");
102. Set<String> val = jedis.zrange(key, 0, -1);
103. System.out.println(val);
104. // 結果：[C, E, F, B, G, D, d]
105. }
107. private static void testHash(Jedis jedis) {
108. String key = "test:hash:a";
109. // 為了保持多次測試結果一樣，每次開始時都刪除
110. jedis.del(key);
111. Map<String, String> values = new HashMap<>();
112. for (int i = 0; i < 10; i++) {
113. String s = String.valueOf((char) (i + ‘A‘));
114. values.put(s, s + "_val");
115. }
116. Iterator<Entry<String, String>> ite = values.entrySet().iterator();
117. while (ite.hasNext()) {
118. Entry<String, String> entry = ite.next();
119. String k = entry.getKey();
120. String v = entry.getValue();
121. jedis.hset(key, k, v);
122. }
123. Map<String, String> val = jedis.hgetAll(key);
124. System.out.println(val);
125. // 結果：{D=D_val, E=E_val, F=F_val, G=G_val, A=A_val, B=B_val, C=C_val,
126. // H=H_val, I=I_val, J=J_val}
127. }
128. }

redis數據結構