在redis中有hset和hget方法可以直接序列化和反序列化集合，今天我自己试了下序列化，然后通过redis的set和get方法来存入缓存中。
redis的代码如下所示：
//存入redis缓存
public void hset(String key,Object object){
try {
Jedis jedis = jedisPool.getResource();
ByteArrayOutputStream bout;
try {
bout = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bout);
out.writeObject(object);
jedis.setex(key.getBytes(),3600,bout.toByteArray());
} finally {
jedis.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
//从redis缓存中取出数据
public Object hget(String key){
try {
Jedis jedis = jedisPool.getResource();
try {
byte[] b = jedis.get(key.getBytes());
ByteArrayInputStream bin = new ByteArrayInputStream(b);
ObjectInputStream in = new ObjectInputStream(bin);
return in.readObject();
} finally {
jedis.close();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
测试代码如下：
List list = new ArrayList<>();
musicList.setTopic("1");
list.add(musicList);
Date date1 = new Date();
redis.hset("qqq",list);
Date date2 = new Date();
List lists = (List) redis.hget("qqq");
Date date3 = new Date();
System.out.println("序列化并且存入缓存："+(date2.getTime()-date1.getTime()));
System.out.println("从缓存拿出并且反序列化："+(date3.getTime()-date2.getTime()));
测试结果的时间为：
image.png
redis命令窗口查询：
image.png
直接用hset和hget方法输出结果为：
image.png
为何二者会差距这么多呢，经过网上的资料和自己的测试，我发现是因为序列化和反序列中，hset和hget使用了ProtostuffIOUtil类，这个类进行序列化和反序列化中，他会创建一个RuntimeSchema，下面我分析测试的步骤：
首先我将前几天的代码略微的进行修改，将Schema的创建放到方法里边，redis代码为：
//设置缓存
public void setRedis(String key,MusicList o){
RuntimeSchema schema = RuntimeSchema.createFrom(MusicList.class);
try {
Jedis jedis = jedisPool.getResource();
try {
byte[] b = ProtostuffIOUtil.toByteArray(o,schema, LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
jedis.setex(key.getBytes(),3600,b);
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(),e);
}
}
测试代码为：
@Test
public void testRedis(){
musicList.setTopic("1");
Date date1 = new Date();
redisTime.setRedis("1",musicList);
Date date2 = new Date();
redisTime.getRedis("1");
Date date3 = new Date();
System.out.println("toRedis:"+(date2.getTime()-date1.getTime()));
System.out.println("fromRedis:"+(date3.getTime()-date2.getTime()));
}
控制台的输出结果为：
image.png
可以看出存入缓存的速度变慢了，因为创建了schema的原因，但是从缓存获取的速度没变，那么我们做另一个测试，就是直接从缓存中读取刚刚那个缓存，这个过程中重新创建一个schema，看下结果如何：
image.png
从这里我们可以看出来，如果你先前已经创建了一个类的schema，那么这个schema会被缓存下来，接下来从缓存中使用RuntimeSchema.createFrom(xxx)就不是直接创建这个schema,而是先查看缓存中是否有这个类的schema，如果有就直接拿出来，没有就再创建一个schema,所以我刚刚进行了另一次测试，之前已经向redis中缓存了一个key:1的数据，现在测试代码不向redis插入缓存，而是直接向缓存中取出key:1的数据，我们可以发现，这一次取数据的速度就比之前慢很多了。
下面还有一个测试，我在redis代码中添加了一个map，用于存储schema，代码如下
lic class MusicRedis {
private final JedisPool jedisPool;
private final Logger logger = LoggerFactory.getLogger(this.getClass());
private static Map,Schema> map = new ConcurrentHashMap<>();
public MusicRedis(JedisPoolConfig poolConfig,String ip,int port){
jedisPool = new JedisPool(poolConfig,ip,port,3000);
}
ublic static Schema getSchema(Class cls){
Schema schema = (Schema) map.get(cls);
if (schema==null){
schema = RuntimeSchema.createFrom(cls);
if (schema!=null){
map.put(cls,schema);
}
}
return schema;
}
public void Hset(String key,T t){
try {
Jedis jedis = jedisPool.getResource();
try {
byte[] b = ProtostuffIOUtil.toByteArray(t,getSchema((Class) t.getClass()),LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
jedis.setex(key.getBytes(),3600,b);
} finally {
jedis.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
public T Hget(String key,T t){
try {
Jedis jedis = jedisPool.getResource();
try {
byte[] b = jedis.get(key.getBytes());
if (b!=null){
Schema schema= (Schema) getSchema(t.getClass());
T message = schema.newMessage();
ProtostuffIOUtil.mergeFrom(b,message,schema);
return message;
}
} finally {
jedis.close();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
测试代码如下：
@Test
public void testRedis(){
List list = new ArrayList<>();
musicList.setTopic("1");
list.add(musicList);
Date date1 = new Date();
redis.Hset("1",list);
Date date2 = new Date();
List lists = redis.Hget("1",new ArrayList());
Date date3 = new Date();
redis.Hset("2",list);
Date date4 = new Date();
List lists2 = redis.Hget("2",new ArrayList());
Date date5 = new Date();
System.out.println("序列化并且存入缓存："+(date2.getTime()-date1.getTime()));
System.out.println("从缓存拿出并且反序列化："+(date3.getTime()-date2.getTime()));
System.out.println("创建完schema之后重新存入缓存");
System.out.println("序列化并且存入缓存："+(date4.getTime()-date3.getTime()));
System.out.println("从缓存拿出并且反序列化："+(date5.getTime()-date4.getTime()));
}
控制台的输出结果如下：
image.png
我们可以看到，如果我将schema缓存起来，那么取出缓存和下次缓存的时间几乎为零，这次我再对之前在类里边写的schema进行两次存入redis的测试，测试结果如下：
image.png
我们能看出，这个结果跟我在类外添加一个map进行缓存schema的结果差不多。
综合以上几种情况，我分析直接序列化和反序列的速度卡在了类似于schema创建的机制，在使用redis存取数据的时候，应该注意的是schema的创建位置，因为schema的创建相对于redis存取来说，极其消耗时间。
参考链接：
https://blog.csdn.net/wangfei8348/article/details/60140301