用一个简单的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<Object, Object> map = new HashMap<Object, Object>();
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<Object, Object> 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<Object, Object> 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中存取值增加了新的开销。
