redis保存数据的几种类型

浅浅的花香味﹌ 2022-09-26 03:51 271阅读 0赞

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查看的截图：

![Center][]

![Center 1][]

![Center 2][]

![Center 3][]

![Center 4][]

[Center]: /images/20220717/669064ab9bc04cfa85718bfbae3047ba.png
[Center 1]: /images/20220717/78c7039a688b494eb0f32a411411fec3.png
[Center 2]: /images/20220717/9f4def52604e41b68476e9eda4822373.png
[Center 3]: /images/20220717/bc561fb66eca4af892fce8193a642149.png
[Center 4]: /images/20220717/d3f7385e5da146f1a11c2ef8d969583b.png