Question

所以我有一个java类Workspace，它有一个List of Product类型的字段，它包含Module类型字段，它包含List类型字段和对象。

所以我喜欢3级嵌套对象和列表。在JSON序列化和反序列化方面，最轻松的方法是什么？

Currentlly我正在使用GSON进行序列化，并且工作正常，但似乎没有优雅的方法来进行反序列化。

我阅读了关于这个主题的所有答案，但没有找到解决我问题的任何内容。

这就是问题

class Workspace{
List<Product> products;
}

class Product{
List<Module> modules;
}

class Module{
List<Parameter> parameters;
}

class Parameter{
String name;
String type;
}

有没有办法用几行代码进行反序列化？

Answer 1

如果值得改变，如果您愿意我建议您查看Jackson（https://github.com/FasterXML/jackson）。它可以开箱即用，很少或没有注释或自定义。

＆＃34; Jackson是处理JSON的几个可用库之一。其他一些是用于JSON处理的Boon，GSON和Java API。杰克逊相对于其他图书馆的一个优势是它的成熟度。杰克逊已经发展到足以成为一些主要Web服务框架的首选JSON处理库（...）＆＃34;

这篇优秀的DZone文章可能会给你一些亮点：https://dzone.com/articles/processing-json-with-jackson

尽管如此，因为你没有定义什么＆＃34;优雅＆＃34;对你而言，当你在谈论GSON时，我同意这个答案可能不适合你（并且可能会消失;））。

我阅读了关于这个主题的所有答案，但没有找到解决我问题的任何内容

如果您需要更多，您还需要向我们提供有关您的实际issue的详细信息。

编辑：为杰克逊添加了示例代码。这就是杰克逊看起来多么优雅（当然，通过工厂，建筑商，帮助者预先配置的地图制作者甚至可以做得更好......）。

public class Workspace {
    final ObjectMapper objMapper = new ObjectMapper();
    List<Product> products;

    public Workspace() {
    }

    public Workspace(List<Product> products) {
        this.products = products;
    }

    public List<Product> getProducts() {
        return products;
    }

    public void setProducts(List<Product> products) {
        this.products = products;
    }

    public String serialize() throws IOException {
        try {
            return objMapper.writerWithDefaultPrettyPrinter().writeValueAsString(this);
        }catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Workspace deserialize(String json) throws IOException {
        return new ObjectMapper().readValue(json, Workspace.class);
    }        
}

public class Product {
    List<Module> modules;

    public Product() {
    }

    public Product(List<Module> modules) {
        this.modules = modules;
    }

    public List<Module> getModules() {
        return modules;
    }

    public void setModules(List<Module> modules) {
        this.modules = modules;
    }
}


public class Module {
    List<Parameter> parameters;

    public Module() {
    }

    public Module(List<Parameter> parameters) {
        this.parameters = parameters;
    }

    public List<Parameter> getParameters() {
        return parameters;
    }

    public void setParameters(List<Parameter> parameters) {
        this.parameters = parameters;
    }      
}

public class Parameter {
    String name;
    String type;

    public Parameter() {
    }

    public Parameter(String name, String type) {
        this.name = name;
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }      
}

public class WorkspaceTest {        
    /**
     * Test of serialize method, of class Workspace.
     */
    @Test
    public void testSerDeserialize() throws Exception {
        // Build sample:
        Workspace instance = new Workspace(
                Collections.singletonList(new Product(
                        Collections.singletonList(new Module(
                            Collections.singletonList(new Parameter("Hello","World")))))));

        // SER
        String serialized = instance.serialize();        
        assertNotNull(serialized);
        System.out.println("Serialized JSON: \n"+serialized);

        // DSER
        Workspace deserialized = Workspace.deserialize(serialized);            

        // MATCH
        assertEquals(serialized, deserialized.serialize());
        System.out.println("Match!");
    }
}

输出：

Serialized JSON: 
{
  "products" : [ {
    "modules" : [ {
      "parameters" : [ {
        "name" : "Hello",
        "type" : "World"
      } ]
    } ]
  } ]
}
Match!

从JSON反序列化复杂的嵌套Java对象

1 个答案: