Redis 存取 java 对象，用 hash 哈希命令保存对象的各个属性和采用 String 字符串命令保存序列化后的对象之开销对比

转自：http://www.jfinal.com/share/460

用一个简单的User对象做试验，共有4个属性，类型分别为整型，整型，字符串，字符串。

测试代码

public class TestRedis {
  private static final Cache testCache = Redis.use(Cons.TEST) ;
  private static int C = 0 ;
  //循环1百万次
  private static final int ROUND = 1000000 ;
  
//生成User对象
  private static User getUser() {
        User m = new User() ;
        m.setUserId(C) ;
        m.setAdminFlag(1) ;
        m.setAvatar("a" + C) ;
        m.setNickname("n" + C) ;
        return m ;
    }
  //生成1百万个User，用hset哈希命令保存对象的各个属性到1百万个Key中
    public static void setMap() {
        System.out.println("setMap ...") ;    
        C = 0 ;
        long t = System.currentTimeMillis() ;
        User m ;
        String key ;
        Map map = new HashMap();
        for (int i = 0 ; i< ROUND; i++) {
            m = getUser() ;
            key = "setMap" + C;
            map.put("userId", m.getUserId()) ;
            map.put("adminFlag",m.getAdminFlag()) ;
            map.put("avatar", m.getAvatar()) ;
            map.put("nickname", m.getNickname()) ;
            testCache.hmset(key, map);
            C++ ;
        }
        long now = System.currentTimeMillis() ;
        System.out.println("setMap use " + (now - t) / 1000 + "seconds") ;
    }
    
  //用hgetAll哈希命令把1百万个Key的所有field读出来，还原成1百万个User
    public static void readMap() {
        System.out.println("readMap ...") ;
        C = 0 ;
        long t = System.currentTimeMillis() ;
        User m ;
        String key ;
        Map map ;
        for (int i = 0 ; i< ROUND; i++) {
            key = "setMap" + C;
            map = testCache.hgetAll(key) ;
            m = new User() ;
            m.setUserId((Integer)map.get("userId"));
            m.setAdminFlag((Integer)map.get("adminFlag")) ;
            m.setAvatar((String)map.get("avatar")) ;
            m.setNickname((String)map.get("nickname")) ;
            //System.out.println(m.getUserId() + ", " + m.getAdminFlag()+ ", " + m.getAvatar() + ", " + m.getNickname());
            C++ ;
        }
        long now = System.currentTimeMillis() ;
        System.out.println("readMap use " + (now - t) / 1000 + "seconds") ;
    }
    
  //生成1百万个User，用set字符串命令保存序列化后的对象到1百万个Key中
    public static void setObj() {
        System.out.println("setObj ...") ;
        C = 0 ;
        long t = System.currentTimeMillis() ;
        User m ;
        String key ;    
        for (int i = 0 ; i< ROUND; i++) {
            m = getUser() ;
            key = "setObj" + C;
            testCache.set(key, m) ;
            C++ ;
        }
        long now = System.currentTimeMillis() ;
        System.out.println("setObj use " + (now - t) / 1000 + "seconds") ;
    }
    
   //用get字符串命令把1百万个Key的序列化字符串读出来，反序列化还原成1百万个User
    public static void readObj() {
        System.out.println("readObj ...") ;
        C = 0 ;
        long t = System.currentTimeMillis() ;
        User m ;
        String key ;
        Map map ;
        for (int i = 0 ; i< ROUND; i++) {
            key = "setObj" + C;
            m = testCache.get(key) ;
            //System.out.println(m.getUserId() + ", " + m.getAdminFlag()+ ", " + m.getAvatar() + ", " + m.getNickname());
            C++ ;
        }
        long now = System.currentTimeMillis() ;
        System.out.println("readObj use " + (now - t) / 1000 + "seconds") ;
    }
    
}

清空redis数据库，查看初始内存使用情况

注意redis的maxmemory配置， 至少要250mb，否则会出现OOM错误。在redis客户端执行：
`flushdb`
`info Memory`

测试用哈希命令方式存取1百万个User

UserCache.setMap();
UserCache.readMap();

运行结果：

setMap ...
setMap use 115seconds
readMap ...
readMap use 111seconds

查看内存占用：
`info Memory`

测试用字符串命令方式存取1百万个User

- 先清空redis数据库：
`flushdb`
- 执行测试

UserCache.setObj();
UserCache.readObj();

 - 运行结果：

setObj ...
setObj use 112seconds
readObj ...
readObj use 110seconds

- 查看内存占用：
`info Memory`

初步推断

Java对象的序列化和反序列化内存占用稍大，因为需要额外的字节去保存对象类型的信息。如果对象的属性更多，两者内存占用的差距估计会缩小（对象类型的信息占比被摊薄），但是时间开销差距估计会扩大（对象序列化反序列化的开销）。所以，如果需要在redis存取大量的对象类型的数据，如果需要节省内存，应该尽量使用Redis hash 方式。

进一步验证

刚才User的属性有点少，值也比较短。多加一点看看

private static User getUser() {
        User m = new User() ;
        m.setUserId(C) ;
        m.setAdminFlag(1) ;
        m.setUsername("username" + C) ;
        m.setPassword("password" + C) ;
        m.setAvatar("http://img.example.com/path/to/avatar" + C) ;
        m.setNickname("nickname" + C) ;
        m.setSignature("Adversity reveals genius, fortune conceals it.") ;
        return m ;
    }

 `setMap()` 和 `readMap()`也做增加对相应field的赋值和读取，代码略过。再次重复以上测试。得到新结果：

setMap ...
setMap use 142seconds
readMap ...
readMap use 122seconds

 redis内存消耗大约为313MB

setObj ...
setObj use 112seconds
readObj ...
readObj use 107seconds

redis内存消耗大约为375MB

结论

第二次测试的User对象比较接近生产环境中的实际情况，测试结果更加有参考价值。大致上来讲，String方式速度比hash方式快20%，但内存占用方面，String方式比hash方式多20%。hash方式比第一次测试慢，估计是Map和Hash中存取值增加了新的开销。