fastjson:javabean按字段(field)序列化存储为Map并反序列化改进

比眉伴天荒 2022-06-08 01:11 172阅读 0赞

# 需求说明 #

最近的项目应用到redis数据库，需要将java bean存储在redis数据库。因为需要对数据库中的某个字段进行修改，所以在redis上不能用简单的string类型存储，而要以hash类型存储。这就需要在向数据库写入java bean对象之前要将java bean按字段序列化为一个`Map<String,String>` 。  
而在从数据库读取后，又需要将所有字段合并反序列化还原成一个java bean对象。

上一篇博客[《fastjson:javabean按字段(field)序列化存储为Map并反序列化》][fastjson_javabean_field_Map]实现了 java bean按字段序列化和反序列化，但在文章结尾总结时也说明了这种方式的缺点，就是存在反复序列化的过程，会在一定程度上影响效率，不够完美。

刚才进一步研究了fastjson的代码,找到了更好的方案，减少序列化过程。

# 序列化 #

实现步骤：  
1.用`JSON.toJSON(Object)`将java bean解析为JSONObject对象(其实也是一个`Map<String,Object>`,JSONObject实现了Map接口).  
2.对上一步中的JSONObject中每个字段调用`JSON.toJSONString(Object)`进行序列化，最终生成符合redis数据库hash类型存储要求的`Map<String,String>`。

> 与前文[《fastjson:javabean按字段(field)序列化存储为Map并反序列化》][fastjson_javabean_field_Map]的方法相比，只有两个步骤，没有多余的序列化和反序列化过程。

# 反序列化 #

反序列化阶段与与前文[《fastjson:javabean按字段(field)序列化存储为Map并反序列化》][fastjson_javabean_field_Map]的方法相同  
实现步骤：  
1.从redis获取所有字段数据,也就是一个`Map<String,String>`.对Map中每个字段的json string调用 `JSON.parse(String)`反序列化，生成一个`Map<String,Object>`,其中的Object就是字段反序列化生成的对象  
2.调用 `com.alibaba.fastjson.util.TypeUtils.cast(Object , Type , ParserConfig)`方法将上一步的`Map<String,Object>`还原为java bean对象

# 实现代码及测试 #

package net.gdface.facelog.message;
    
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    
    import org.junit.Test;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.TypeReference;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    
    public class TestFastjson {
    
    
        @Test
        public void testJSONObject() {
            Group group = new Group();
            group.setId(0L);
            group.setName("admin");
    
            User guestUser = new User();
            guestUser.setId(2L);
            guestUser.setName("guest");
    
            User rootUser = new User();
            rootUser.setId(3L);
            rootUser.setName("root");
    
            group.addUser(guestUser);
            group.addUser(rootUser);
            {
                ////////// 按字段序列化 ///////////////
                // 序列化步骤1
                JSONObject jsonObject = (JSONObject) JSON.toJSON(group);
                Map<String, String> jsonObj = new HashMap<String, String>();
                // 序列化步骤2
                for (Entry<String, Object> entry : jsonObject.entrySet()) {
                    Object value = entry.getValue();
                    if(null !=value){
                        String jsonValue=JSON.toJSONString(value);
                        jsonObj.put(entry.getKey(), jsonValue);
                    }
                }
                ////////// 按字段反序列化 ///////////////
                // 反序列化步骤1
                Map<String, Object> deJsonMap = new HashMap<String, Object>();
                for (Entry<String, String> entry : jsonObj.entrySet()) {
                    String json = (String) entry.getValue();
                    String key = entry.getKey();
                    Object field = JSON.parse( json);
                    deJsonMap.put(entry.getKey(), field);
                }
                // 循环结束时 Map<String, Object>中的每个字段对应的Object都是反序列化后的对象
                // 反序列化步骤2
                Group dgroup = com.alibaba.fastjson.util.TypeUtils.cast(deJsonMap, Group.class, null);
                System.out.println(JSON.toJSONString(dgroup));
            }       
        }
        public interface Person<T>{
    
        }
        public static class User implements Person<String>{
    
            private Long   id;
            private String name;
    
    
            public Long getId() {
                return id;
            }
    
            public void setId(Long id) {
                this.id = id;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
        }
        public static  class Group {
    
            private Long       id;
            private String     name;
            private List<User> users = new ArrayList<User>();
            public Date date=new Date();
            public java.sql.Date sqldate=new java.sql.Date(date.getTime());
            public byte[] array=new byte[]{
       22,33,3,2,3,1,5,-1};
            public String nullStr=null;
            private String privString="private string";
            public Long getId() {
                return id;
            }
    
            public void setId(Long id) {
                this.id = id;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public List<User> getUsers() {
                return users;
            }
    
            public void setUsers(List<User> users) {
                this.users = users;
            }
    
                public void addUser(User user) {
                    users.add(user);
                }
        }
    }

# 注意 #

与[《fastjson:javabean按字段(field)序列化存储为Map并反序列化》][fastjson_javabean_field_Map]的方法(简称方法1)相比，这种方式序列化出的json string是不同的。  
比如对于byte\[\]类型方法1会序列成base64格式的字符串`"FiEDAgMBBf8="`  
而本方法则会序列化成json数组`[22,33,3,2,3,1,5,-1]`,显然方法1对byte\[\]类型序列化的字符串体积要小。

总而言之，方法1序列化的字符串与用`JSON.toJSONString(Object)`方法对java bean整体序列化的结果保持一致。而本方法序列化的结果则不会。

[fastjson_javabean_field_Map]: http://blog.csdn.net/10km/article/details/77921162