在java中将树结构从数据库转换为JSON对象？

Question

我在数据库中有一个父-子关系(树结构)，我想遍历它并在其中创建一个json对象。

我的数据库父级子关系结构(演示数据)。

child_id  parent_id   Item_Name
1         1           Country
2         1           Australia
3         2           Victoria
4         2           Queensland
5         1           Canada
6         5           British Columbia
7         6           Vancouver
8         8           Songs
9         8           Song1
10        8           Song2
11        10          lyrics 1st
12        10          lyrics 2nd
13        13          Germany
14        14          England
15        14          London

这是如何工作的

if(child_id == parent_id)
{
   // This item is parent. Like Country,Songs,Germany, England
} else {
  // This item is child. Like Australia, Song1, Vancouver etc.
}

现在，我知道如何遍历这样的结构，但很难将其转换为json对象。

伪码 DFS树

得到所有家长的

List data = fetch data from table where parent_id=child_id

现在遍历这个数据

Recursively iterate through child elements

get child_id from data object and query on database it as parent_id, to get its child elements and so on.

但是，如何将其转换为JSON对象，如下面的所示

    {
      "country": [
        {
          "Australia": [
            "Victoria",
            "Queensland"
          ]
        },
        {
          "Canada": [
            {
              "British Columbia": [
                "Vancouver"
              ]
            }
          ]
        }
      ]
    },
{
      "Songs": [
        "Songs1",
        {
          "Songs2": [
            "lyrics 1st",
            "lyrics 2nd"
          ]
        }
      ]
    },
{
      "Germany": null
    },
    {
      "England": ["London"]
    }

或者一个json对象，其中父-子关系在中保持。

Answer 1

首先，您提供的JSON不是有效的JSON。因此，在生成JSON时，我添加了一个父根节点。

如果您在dataset中定义了根节点，那么您的结构将发生小的更改，因为您不能将parent_Id = child_id关系作为当前数据set.So来维护，因此也会对解决方案进行修改。

首先，您需要将数据映射到由父-子支持的数据类型中。为此，我创建了Node.java。介绍了addChild方法，逐个添加子元素。

import java.util.ArrayList;
import java.util.List;

public class Node
{
    private String nodeName;
    private java.util.List<Node> children = new ArrayList<Node>();

    public Node( String nodeName )
    {
        this.nodeName = nodeName;
    }

    public List<Node> getChildren()
    {
        return children;
    }

    public void setChildren( List<Node> children )
    {
        this.children = children;
    }

    public String getNodeName()
    {
        return nodeName;
    }

    public void setNodeName( String nodeName )
    {
        this.nodeName = nodeName;
    }

    public void addChild( Node node )
    {
        this.children.add( node );
    }
}

对于原始数据类型，我创建了Mapping.java

public class Mapping
{
    private int parentId;
    private int childId;
    private String ItemName;

    public Mapping( int parentId, int childId, String itemName )
    {
        this.parentId = parentId;
        this.childId = childId;
        ItemName = itemName;
    }

    public int getParentId()
    {
        return parentId;
    }

    public void setParentId( int parentId )
    {
        this.parentId = parentId;
    }

    public int getChildId()
    {
        return childId;
    }

    public void setChildId( int childId )
    {
        this.childId = childId;
    }

    public String getItemName()
    {
        return ItemName;
    }

    public void setItemName( String itemName )
    {
        ItemName = itemName;
    }
}

现在，加载和数据，填充Node对象并获得最终的Json在这里完成。我在这里使用对象引用映射，因为我们不能保证数据库中映射的顺序。由于子对象被分配给父对象引用，在完成分配后，我们将具有父-子结构。这两个循环也是出于同样的原因使用的。在开始构建结构之前，我们需要确保map拥有所有节点。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ParentChild
{
    public static void main( String[] args )
    {
        List<Mapping> list = new ArrayList<Mapping>();
        list.add( new Mapping( 1, 1, "Country" ) );
        list.add( new Mapping( 1, 2, "Australia" ) );
        list.add( new Mapping( 2, 3, "Victoria" ) );
        list.add( new Mapping( 2, 4, "Queensland" ) );
        list.add( new Mapping( 1, 5, "Canada" ) );
        list.add( new Mapping( 5, 6, "British Columbia" ) );
        list.add( new Mapping( 6, 7, "Vancouver" ) );
        list.add( new Mapping( 8, 8, "Songs" ) );
        list.add( new Mapping( 8, 9, "Song1" ) );
        list.add( new Mapping( 8, 10, "Song2" ) );
        list.add( new Mapping( 10, 11, "lyrics 1st" ) );
        list.add( new Mapping( 10, 12, "lyrics 2nd" ) );
        list.add( new Mapping( 13, 13, "Germany" ) );
        list.add( new Mapping( 14, 14, "England" ) );
        list.add( new Mapping( 14, 15, "London" ) );

        Map<Integer, Node> map = new HashMap<Integer, Node>();

        map.put( -1, new Node( "root" ) ); // give index -1 for the root

        for( Mapping mapping : list )  // keep a map of nodes by child id
        {
            map.put( mapping.getChildId(), new Node( mapping.getItemName() ) );
        }

        for( Mapping mapping : list )
        {
            if( mapping.getParentId() == mapping.getChildId() )
            {
                map.get( -1 ).addChild( map.get( mapping.getChildId() ) ); // add to the root
            }
            else
            {
                Node node = map.get( mapping.getParentId() );
                Node childNode = map.get( mapping.getChildId() );
                node.addChild( childNode ); // add to the relevant parent
            }
        }

        StringBuilder json = new StringBuilder();
        writeJson( map.get( -1 ), json ); // root node is enough
        System.out.println( json );
    }

    private static void writeJson( Node node, StringBuilder json )
    {
        if( node.getChildren().isEmpty() ) // no children. return just the node name
        {
            json.append( "\"" ).append( node.getNodeName() ).append( "\"" );
        }
        else
        {
            json.append( "{\"" ).append( node.getNodeName() ).append( "\": [" );

            List<Node> children = node.getChildren();
            for( int i = 0; i < children.size(); i++ )
            {
                Node child = children.get( i );
                writeJson( child, json ); // call recursively
                if( i != children.size() - 1 ) // skip , for the last child
                {
                    json.append( "," );
                }
            }
            json.append( "]}" );
        }
    }
}

我使用了一种递归方法来构建json。

生成的JSON

{
   "root":[
      {
         "Country":[
            {
               "Australia":[
                  "Victoria",
                  "Queensland"
               ]
            },
            {
               "Canada":[
                  {
                     "British Columbia":[
                        "Vancouver"
                     ]
                  }
               ]
            }
         ]
      },
      {
         "Songs":[
            "Song1",
            {
               "Song2":[
                  "lyrics 1st",
                  "lyrics 2nd"
               ]
            }
         ]
      },
      "Germany",
      {
         "England":[
            "London"
         ]
      }
   ]
}

希望能帮上忙。