`
ssxxjjii
  • 浏览: 950406 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Redis 存储List对象

 
阅读更多

http://blog.csdn.net/gstormspire/article/details/7653095

如果需要用到Redis存储List对象，而list又不需要进行操作，可以按照MC的方式进行存储，不过Jedis之类的客户端没有提供API，可以有两种思路实现：

1.      分别序列化 elements ,然后 set 存储

2.    序列化List对象，set存储

这两种方法都类似MC的 Object方法存储，运用这种方式意味着放弃Redis对List提供的操作方法。

 

[java] view plaincopyprint?
  1. import net.spy.memcached.compat.CloseUtil;  
  2. import net.spy.memcached.compat.log.Logger;  
  3. import net.spy.memcached.compat.log.LoggerFactory;  
  4. import redis.clients.jedis.Client;  
  5. import redis.clients.jedis.Jedis;  
  6. import redis.clients.jedis.JedisPool;  
  7. import redis.clients.jedis.JedisPoolConfig;  
  8.   
  9. import java.io.*;  
  10. import java.util.ArrayList;  
  11. import java.util.List;  
  12. import java.util.Random;  
  13.   
  14. /** 
  15.  * Created by IntelliJ IDEA. 
  16.  * User: lifeng.xu 
  17.  * Date: 12-6-11 
  18.  * Time: 上午11:10 
  19.  * To change this template use File | Settings | File Templates. 
  20.  */  
  21. public class JedisTest {  
  22.   
  23.     private static Logger logger = LoggerFactory.getLogger(JedisTest.class);  
  24.   
  25.     /** 
  26.      * Jedis Pool for Jedis Resource 
  27.      * @return 
  28.      */  
  29.     public static JedisPool buildJedisPool(){  
  30.         JedisPoolConfig config = new JedisPoolConfig();  
  31.         config.setMaxActive(1);  
  32.         config.setMinIdle(50);  
  33.         config.setMaxIdle(3000);  
  34.         config.setMaxWait(5000);  
  35.         JedisPool jedisPool = new JedisPool(config,  
  36.                 "*****", ****);  
  37.         return jedisPool;  
  38.     }  
  39.   
  40.     /** 
  41.      * Test Data 
  42.      * @return 
  43.      */  
  44.     public static List<User> buildTestData(){  
  45.         User a = new User();  
  46.         a.setName("a");  
  47.         User b = new User();  
  48.         b.setName("b");  
  49.         List<User> list = new ArrayList<User>();  
  50.         list.add(a);  
  51.         list.add(b);  
  52.         return list;  
  53.     }  
  54.   
  55.     /** 
  56.      * Test for 
  57.      */  
  58.     public static void testSetElements(){  
  59.         List<User> testData = buildTestData();  
  60.         Jedis jedis = buildJedisPool().getResource();  
  61.         String key = "testSetElements" + new Random(1000).nextInt();  
  62.         jedis.set(key.getBytes(), ObjectsTranscoder.serialize(testData));  
  63.   
  64.         //验证   
  65.         byte[] in = jedis.get(key.getBytes());  
  66.         List<User> list = ObjectsTranscoder.deserialize(in);  
  67.         for(User user : list){  
  68.             System.out.println("testSetElements user name is:" + user.getName());  
  69.         }  
  70.     }  
  71.   
  72.     public static void testSetEnsemble(){  
  73.         List<User> testData = buildTestData();  
  74.         Jedis jedis = buildJedisPool().getResource();  
  75.         String key = "testSetEnsemble" + new Random(1000).nextInt();  
  76.         jedis.set(key.getBytes(), ListTranscoder.serialize(testData));  
  77.   
  78.         //验证   
  79.         byte[] in = jedis.get(key.getBytes());  
  80.         List<User> list = (List<User>)ListTranscoder.deserialize(in);  
  81.         for(User user : list){  
  82.             System.out.println("testSetEnsemble user name is:" + user.getName());  
  83.         }  
  84.     }  
  85.   
  86.     public static void main(String[] args) {  
  87.         testSetElements();  
  88.         testSetEnsemble();  
  89.     }  
  90.   
  91.     public static void close(Closeable closeable) {  
  92.         if (closeable != null) {  
  93.             try {  
  94.                 closeable.close();  
  95.             } catch (Exception e) {  
  96.                 logger.info("Unable to close %s", closeable, e);  
  97.             }  
  98.         }  
  99.     }  
  100.   
  101.     static class User implements Serializable{  
  102.         String name;  
  103.   
  104.         public String getName() {  
  105.             return name;  
  106.         }  
  107.   
  108.         public void setName(String name) {  
  109.             this.name = name;  
  110.         }  
  111.     }  
  112.   
  113.     static class ObjectsTranscoder{  
  114.           
  115.         public static byte[] serialize(List<User> value) {  
  116.             if (value == null) {  
  117.                 throw new NullPointerException("Can't serialize null");  
  118.             }  
  119.             byte[] rv=null;  
  120.             ByteArrayOutputStream bos = null;  
  121.             ObjectOutputStream os = null;  
  122.             try {  
  123.                 bos = new ByteArrayOutputStream();  
  124.                 os = new ObjectOutputStream(bos);  
  125.                 for(User user : value){  
  126.                     os.writeObject(user);  
  127.                 }  
  128.                 os.writeObject(null);  
  129.                 os.close();  
  130.                 bos.close();  
  131.                 rv = bos.toByteArray();  
  132.             } catch (IOException e) {  
  133.                 throw new IllegalArgumentException("Non-serializable object", e);  
  134.             } finally {  
  135.                 close(os);  
  136.                 close(bos);  
  137.             }  
  138.             return rv;  
  139.         }  
  140.   
  141.         public static List<User> deserialize(byte[] in) {  
  142.             List<User> list = new ArrayList<User>();  
  143.             ByteArrayInputStream bis = null;  
  144.             ObjectInputStream is = null;  
  145.             try {  
  146.                 if(in != null) {  
  147.                     bis=new ByteArrayInputStream(in);  
  148.                     is=new ObjectInputStream(bis);  
  149.                     while (true) {  
  150.                         User user = (User) is.readObject();  
  151.                         if(user == null){  
  152.                             break;  
  153.                         }else{  
  154.                             list.add(user);  
  155.                         }  
  156.                     }  
  157.                     is.close();  
  158.                     bis.close();  
  159.                 }  
  160.             } catch (IOException e) {  
  161.                 logger.warn("Caught IOException decoding %d bytes of data",  
  162.                         in == null ? 0 : in.length, e);  
  163.             } catch (ClassNotFoundException e) {  
  164.                 logger.warn("Caught CNFE decoding %d bytes of data",  
  165.                         in == null ? 0 : in.length, e);  
  166.             } finally {  
  167.                 CloseUtil.close(is);  
  168.                 CloseUtil.close(bis);  
  169.             }  
  170.             return list;  
  171.         }  
  172.     }  
  173.       
  174.     static class ListTranscoder{  
  175.         public static byte[] serialize(Object value) {  
  176.             if (value == null) {  
  177.                 throw new NullPointerException("Can't serialize null");  
  178.             }  
  179.             byte[] rv=null;  
  180.             ByteArrayOutputStream bos = null;  
  181.             ObjectOutputStream os = null;  
  182.             try {  
  183.                 bos = new ByteArrayOutputStream();  
  184.                 os = new ObjectOutputStream(bos);  
  185.                 os.writeObject(value);  
  186.                 os.close();  
  187.                 bos.close();  
  188.                 rv = bos.toByteArray();  
  189.             } catch (IOException e) {  
  190.                 throw new IllegalArgumentException("Non-serializable object", e);  
  191.             } finally {  
  192.                 close(os);  
  193.                 close(bos);  
  194.             }  
  195.             return rv;  
  196.         }  
  197.   
  198.         public static Object deserialize(byte[] in) {  
  199.             Object rv=null;  
  200.             ByteArrayInputStream bis = null;  
  201.             ObjectInputStream is = null;  
  202.             try {  
  203.                 if(in != null) {  
  204.                     bis=new ByteArrayInputStream(in);  
  205.                     is=new ObjectInputStream(bis);  
  206.                     rv=is.readObject();  
  207.                     is.close();  
  208.                     bis.close();  
  209.                 }  
  210.             } catch (IOException e) {  
  211.                 logger.warn("Caught IOException decoding %d bytes of data",  
  212.                         in == null ? 0 : in.length, e);  
  213.             } catch (ClassNotFoundException e) {  
  214.                 logger.warn("Caught CNFE decoding %d bytes of data",  
  215.                         in == null ? 0 : in.length, e);  
  216.             } finally {  
  217.                 CloseUtil.close(is);  
  218.                 CloseUtil.close(bis);  
  219.             }  
  220.             return rv;  
  221.         }  
  222.     }  
  223. }  
import net.spy.memcached.compat.CloseUtil;
import net.spy.memcached.compat.log.Logger;
import net.spy.memcached.compat.log.LoggerFactory;
import redis.clients.jedis.Client;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * Created by IntelliJ IDEA.
 * User: lifeng.xu
 * Date: 12-6-11
 * Time: 上午11:10
 * To change this template use File | Settings | File Templates.
 */
public class JedisTest {

    private static Logger logger = LoggerFactory.getLogger(JedisTest.class);

    /**
     * Jedis Pool for Jedis Resource
     * @return
     */
    public static JedisPool buildJedisPool(){
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxActive(1);
        config.setMinIdle(50);
        config.setMaxIdle(3000);
        config.setMaxWait(5000);
        JedisPool jedisPool = new JedisPool(config,
                "*****", ****);
        return jedisPool;
    }

    /**
     * Test Data
     * @return
     */
    public static List<User> buildTestData(){
        User a = new User();
        a.setName("a");
        User b = new User();
        b.setName("b");
        List<User> list = new ArrayList<User>();
        list.add(a);
        list.add(b);
        return list;
    }

    /**
     * Test for
     */
    public static void testSetElements(){
        List<User> testData = buildTestData();
        Jedis jedis = buildJedisPool().getResource();
        String key = "testSetElements" + new Random(1000).nextInt();
        jedis.set(key.getBytes(), ObjectsTranscoder.serialize(testData));

        //验证
        byte[] in = jedis.get(key.getBytes());
        List<User> list = ObjectsTranscoder.deserialize(in);
        for(User user : list){
            System.out.println("testSetElements user name is:" + user.getName());
        }
    }

    public static void testSetEnsemble(){
        List<User> testData = buildTestData();
        Jedis jedis = buildJedisPool().getResource();
        String key = "testSetEnsemble" + new Random(1000).nextInt();
        jedis.set(key.getBytes(), ListTranscoder.serialize(testData));

        //验证
        byte[] in = jedis.get(key.getBytes());
        List<User> list = (List<User>)ListTranscoder.deserialize(in);
        for(User user : list){
            System.out.println("testSetEnsemble user name is:" + user.getName());
        }
    }

    public static void main(String[] args) {
        testSetElements();
        testSetEnsemble();
    }

    public static void close(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (Exception e) {
                logger.info("Unable to close %s", closeable, e);
            }
        }
    }

    static class User implements Serializable{
        String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

    static class ObjectsTranscoder{
        
        public static byte[] serialize(List<User> value) {
            if (value == null) {
                throw new NullPointerException("Can't serialize null");
            }
            byte[] rv=null;
            ByteArrayOutputStream bos = null;
            ObjectOutputStream os = null;
            try {
                bos = new ByteArrayOutputStream();
                os = new ObjectOutputStream(bos);
                for(User user : value){
                    os.writeObject(user);
                }
                os.writeObject(null);
                os.close();
                bos.close();
                rv = bos.toByteArray();
            } catch (IOException e) {
                throw new IllegalArgumentException("Non-serializable object", e);
            } finally {
                close(os);
                close(bos);
            }
            return rv;
        }

        public static List<User> deserialize(byte[] in) {
            List<User> list = new ArrayList<User>();
            ByteArrayInputStream bis = null;
            ObjectInputStream is = null;
            try {
                if(in != null) {
                    bis=new ByteArrayInputStream(in);
                    is=new ObjectInputStream(bis);
                    while (true) {
                        User user = (User) is.readObject();
                        if(user == null){
                            break;
                        }else{
                            list.add(user);
                        }
                    }
                    is.close();
                    bis.close();
                }
            } catch (IOException e) {
                logger.warn("Caught IOException decoding %d bytes of data",
                        in == null ? 0 : in.length, e);
            } catch (ClassNotFoundException e) {
                logger.warn("Caught CNFE decoding %d bytes of data",
                        in == null ? 0 : in.length, e);
            } finally {
                CloseUtil.close(is);
                CloseUtil.close(bis);
            }
            return list;
        }
    }
    
    static class ListTranscoder{
        public static byte[] serialize(Object value) {
            if (value == null) {
                throw new NullPointerException("Can't serialize null");
            }
            byte[] rv=null;
            ByteArrayOutputStream bos = null;
            ObjectOutputStream os = null;
            try {
                bos = new ByteArrayOutputStream();
                os = new ObjectOutputStream(bos);
                os.writeObject(value);
                os.close();
                bos.close();
                rv = bos.toByteArray();
            } catch (IOException e) {
                throw new IllegalArgumentException("Non-serializable object", e);
            } finally {
                close(os);
                close(bos);
            }
            return rv;
        }

        public static Object deserialize(byte[] in) {
            Object rv=null;
            ByteArrayInputStream bis = null;
            ObjectInputStream is = null;
            try {
                if(in != null) {
                    bis=new ByteArrayInputStream(in);
                    is=new ObjectInputStream(bis);
                    rv=is.readObject();
                    is.close();
                    bis.close();
                }
            } catch (IOException e) {
                logger.warn("Caught IOException decoding %d bytes of data",
                        in == null ? 0 : in.length, e);
            } catch (ClassNotFoundException e) {
                logger.warn("Caught CNFE decoding %d bytes of data",
                        in == null ? 0 : in.length, e);
            } finally {
                CloseUtil.close(is);
                CloseUtil.close(bis);
            }
            return rv;
        }
    }
}

 

 

PS：Redsi中存储list没有封装对Object的API，是不是也是倾向于只存储用到的字段，而不是存储Object本身呢？Redis是一个In-Mem的产品，会觉得我们应用的方式。

分享到：
| Jedis使用总结【pipeline】【分布式的id生 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    redis存储List集合

    标题中的“redis存储List集合”指的是使用Redis数据库来存储列表数据结构。Redis是一个开源的、高性能的键值存储系统，支持多种数据结构，包括字符串、哈希、列表、集合、有序集合等。在这个示例中，重点是利用Redis...

    JOhm 是一个 Java 的对象哈希映射库，用于在 Redis 中存储对象.zip

    JOhm 是一个 Java 的对象哈希映射库，用于在 Redis 中存储对象约翰JOhm 是一个速度超快的 Java 对象哈希映射库，其灵感来自超棒的Ohm。JOhm OHM 是 Hibernate 等旧 ORM 的现代化身，不同之处在于我们这里处理的不是 ...

    redis 增删（obj,list）

    在本项目中，我们关注的是Redis如何处理对象（obj）和列表（list）的增删操作，以及如何结合Spring框架进行集成使用。下面我们将深入探讨这两个主题。 首先，让我们了解Redis中的对象存储。在Redis中，对象可以被...

    java操作redis

    - **内存存储与持久化**：虽然 Redis 主要在内存中运行以确保高性能，但它也提供了多种持久化策略，如 RDB 快照和 AOF（Append Only File）日志，以防止数据丢失。 - **主从同步**：支持主从架构，可以进行数据同步...

    redis字节码存压缩对象

    这些工具可能包括序列化/反序列化方法，用于将Java对象转换为适合Redis存储的字节码格式，以及压缩和解压缩方法。 - 这样的工具类能够帮助开发者更高效地与 Redis 交互，提高代码的可读性和可维护性，同时降低出错...

    使用.Net 技术操作Redis缓存技术，对Redis缓存进行存储增删改查等相关操作

    1. **存储数据**：Redis支持多种数据结构，如字符串（String）、哈希（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）。例如，存储一个字符串键值对： ```csharp var db = redis.GetDatabase(); db...

    c#操作Redis的5种基本类型汇总

    接下来是Hash类型，它允许我们将多个键值对存储在同一个Redis键中，适合存储具有多个字段的对象。使用Hash类型可以更细粒度地管理数据，避免了数据的冗余存储。例如，使用以下代码来操作Hash类型数据： ```csharp ...

    Redis启动，数据结构存储系统

    - **哈希（Hash）**：键值对的集合，适合存储对象。每个键对应一个字段，值是另一个键值对。 - **列表（List）**：双向链表结构，支持LPOP、RPOP、LPUSH、RPUSH等操作，常用于实现消息队列。 - **集合（Set）**：...

    WPF操作Redis简单实例

    2. **Redis数据类型操作**：C#中可以操作Redis的多种数据类型，如字符串（String）、哈希（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）。例如，使用`StringSet`和`StringGet`方法操作字符串，`...

    Redis实战_Redis实战中文完整版_Redis快速入门_Redis数据类型及操作_Redis常用

    - **哈希(Hash)**：用于存储键值对集合，适用于存储对象。 - **列表(List)**：有序的元素集合，支持两端插入和弹出元素。 - **集合(Set)**：无序的不重复元素集合，支持成员的添加、删除、检查等操作。 - **有序...

    ServiceStack.Redis 3.9

    6. **序列化**：库内置了对多种序列化器的支持，包括Json.NET、protobuf等，这使得在Redis中存储和检索对象变得容易。 7. **高级功能**：如脚本（Lua Scripting）支持，可以执行预编译的Lua脚本来提高性能，以及...

    redis的实战教学.pdf

    散列（Hash）：键值对集合，适合存储对象。每个散列可以存储多个字段和值之间的映射。 集合（Set）：无序集合，用于存储多个不重复的字符串元素，支持集合间的交集、并集和差集等操作。 有序集合（Sorted Set）：与...

    redis存储数据.rar

    本篇文章将深入探讨如何通过Java代码在Redis缓存数据库中存储和检索数据，以及项目配置中需注意的关键点。 首先，为了在Java项目中使用Redis，我们需要在项目配置文件（如`application.properties`或`application....

    redis的list，set，hash，sorted set，skiplist 1

    哈希表是一种键值对的存储结构，特别适合存储对象。每个键对应一个字段，值为该字段的值。Redis 提供了 `HSET` 用于设置键值对，`HGET` 获取单个值，`HGETALL` 获取所有键值对，`HDEL` 删除指定字段，以及 `HINCRBY...

    Redis 命令参考手册中文完整版chm

    以上只是Redis命令参考手册中的一部分内容，完整的CHM文档包含了更详尽的命令介绍、参数解析和使用示例，对于深入理解和使用Redis有着极大的帮助。无论你是初学者还是经验丰富的开发者，这份中文版的Redis命令参考...

    redis学习笔记Redis.md

    - **键值存储**: Redis 是一种键值存储类型的 NoSQL 数据库，提供高性能的键值存储服务。 - **支持的数据类型**: - `String`: 普通的字符串类型。 - `Hash`: 类似 Map 的结构，适合存储对象。 - `List`: 类似链表...

    redis数据类型指令整理

    字符串是Redis中最基本的数据类型，它能够存储任何形式的字符串，包括二进制数据、数字甚至是图片。 - set命令可以用于字符串设置，setnx命令用于只有当key不存在时才设置。 - get命令用于获取key对应的值。 - mset...

    Redis在java中的使用示例

    在实际应用中，Redis的这四种数据类型可以根据需求灵活组合，比如使用List实现发布订阅、使用Set做唯一性校验、使用Hash存储用户信息等。了解并熟练掌握这些基本操作，有助于提升Java应用的性能和可扩展性。 在`...

Magicbox
Global site tag (gtag.js) - Google Analytics