java - close - select_node jstree

Recursivamente construyendo una cadena JSON para jsTree con Jackson

Question

He intentado construir una cadena JSON en Java usando la biblioteca Jackson (v.1.7.4, es la única que puedo usar para este proyecto) con el formato aceptado por jsTree ( https: //www.jstree .com / docs / json / ). Solo me importan las propiedades de "texto" y "niños". El problema es que no estoy obteniendo un método recursivo funcional para hacerlo.

Si tengo un árbol simple como este:

    Tree<String> tree = new Tree<String>();
    Node<String> rootNode = new Node<String>("root");
    Node<String> nodeA = new Node<String>("A");
    Node<String> nodeB = new Node<String>("B");
    Node<String> nodeC = new Node<String>("C");
    Node<String> nodeD = new Node<String>("D");
    Node<String> nodeE = new Node<String>("E");

    rootNode.addChild(nodeA);
    rootNode.addChild(nodeB);
    nodeA.addChild(nodeC);
    nodeB.addChild(nodeD);
    nodeB.addChild(nodeE);

    tree.setRootElement(rootNode);

Esperaría que mi Cadena fuera:

 {text: "root", children: [{text:"A", children:[{text:"C", children: []}]}, {text:"B", children: [{text: "D", children: []}, {text:"E", children:[]}]}] }

Estoy tratando de construir la cadena JSON utilizando el Tree Model de Jackson. Mi código hasta ahora se parece a esto:

 public String generateJSONfromTree(Tree<String> tree) throws IOException{
    String json = "";

    ObjectMapper mapper = new ObjectMapper();
    JsonFactory factory = new JsonFactory();
    ByteArrayOutputStream out = new ByteArrayOutputStream(); // buffer to write to string later
    JsonGenerator generator = factory.createJsonGenerator(out, JsonEncoding.UTF8);

    JsonNode rootNode = mapper.createObjectNode();
    JsonNode coreNode = mapper.createObjectNode();          

    JsonNode dataNode = (ArrayNode)generateJSON(tree.getRootElement()); // the tree nodes

    // assembly arrays and objects
    ((ObjectNode)coreNode).put("data", dataNode);
    ((ObjectNode)rootNode).put("core", coreNode);       
    mapper.writeTree(generator, rootNode);

    json  = out.toString();
    return json;
}

 public ArrayNode generateJSON(Node<String> node, ObjectNode obN, ArrayNode arrN){
    // stop condition ?
    if(node.getChildren().isEmpty()){
        arrN.add(obN);
        return arrN;
    }

    obN.put("text", node.getData());
    for (Node<String> child : node.getChildren()){

        // recursively call on child nodes passing the current object node
        obN.put("children", generateJSON(child, obN, arrN));
    }

}

Probé algunas variaciones de eso, pero no tuve éxito hasta ahora. Sé que la respuesta es probablemente más simple de lo que intento, pero estoy atascado. Tal vez la condición de detención no es apropiada o la lógica misma (mi idea es intentar y reutilizar los objetos ObjectNode y ArrayNode en la próxima llamada, para "insertar" el elemento "niños" (desde el json) en el siguiente nodo secundario en el árbol, por lo que sería construido hacia atrás, pero al final tengo variables nulas).

Mi árbol y las clases de nodo se basan en lo siguiente: http://sujitpal.blogspot.com.br/2006/05/java-data-structure-generic-tree.html

Answer 1

No es el mejor enfoque, pero hace el trabajo:

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Iterator;

import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class TreeApp {

    public String generateJSONfromTree(Tree<String> tree) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        JsonFactory factory = new JsonFactory();
        ByteArrayOutputStream out = new ByteArrayOutputStream(); // buffer to write to string later
        JsonGenerator generator = factory.createJsonGenerator(out, JsonEncoding.UTF8);

        ObjectNode rootNode = generateJSON(tree.getRootElement(), mapper.createObjectNode());
        mapper.writeTree(generator, rootNode);

        return out.toString();
    }

    public ObjectNode generateJSON(Node<String> node, ObjectNode obN) {
        if (node == null) {
            return obN;
        }

        obN.put("text", node.getData());

        ArrayNode childN = obN.arrayNode();
        obN.set("children", childN);        
        if (node.getChildren() == null || node.getChildren().isEmpty()) {
            return obN;
        }

        Iterator<Node<String>> it = node.getChildren().iterator();
        while (it.hasNext()) {  
            childN.add(generateJSON(it.next(), new ObjectMapper().createObjectNode()));
        }
        return obN;
    }

    public static void main(String[] args) throws IOException {
        Tree<String> tree = new Tree<String>();
        Node<String> rootNode = new Node<String>("root");
        Node<String> nodeA = new Node<String>("A");
        Node<String> nodeB = new Node<String>("B");
        Node<String> nodeC = new Node<String>("C");
        Node<String> nodeD = new Node<String>("D");
        Node<String> nodeE = new Node<String>("E");

        rootNode.addChild(nodeA);
        rootNode.addChild(nodeB);
        nodeA.addChild(nodeC);
        nodeB.addChild(nodeD);
        nodeB.addChild(nodeE);

        tree.setRootElement(rootNode);

        System.out.println(new TreeApp().generateJSONfromTree(tree));
    }
}