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

忘是亡心i 2022-06-08 01:07 533阅读 0赞

大部分json工具对java对象整体序列化都提供了简单的调用方式，以fastjson为例：

Model model = new Model();
    String json = JSON.toJSONString(model); // 序列化
    Model model2 = JSON.parseObject(json, Model.class); // 反序列化

# 需求说明 #

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

![这里写图片描述][SouthEast]

# 序列化 #

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

# 反序列化 #

实现步骤：  
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

# 实现代码及测试 #

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
                String jsonstr = JSON.toJSONString(group);
                System.out.println(jsonstr);
                // 序列化步骤2
                Map<String, Object> jsonObj = JSON.parseObject(jsonstr);
                // 序列化步骤3
                for (Entry<String, Object> entry : jsonObj.entrySet()) {
                    entry.setValue(JSON.toJSONString(entry.getValue()));
                }
                // 循环结束后 jsonObj 的数据类型为Map<String,String>
                ////////// 按字段反序列化 ///////////////
                Map<String, Object> deJsonObj = new HashMap<String, Object>();
                // 反序列化步骤1
                for (Entry<String, Object> entry : jsonObj.entrySet()) {
                    String json = (String) entry.getValue();
                    Object field = JSON.parse( json);
                    deJsonObj.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有更多的了解。

[SouthEast]: /images/20220608/666a27b5e20b453f825f3ca13f6b12b2.png