Analizar una estructura de datos de JSON

Guía de desarrollo

Search This Document

Descargar PDF

Esta tarea emplea un TreeField para mostrar los contenidos de una estructura de datos de JSON.

Antes de comenzar: Recupere un objeto Java que contenga una estructura de datos de JSON. Pase ese objeto al constructor de la clase desarrollada en esta tarea.

Importe las clases y las interfaces necesarias.

import net.rim.device.api.ui.*;
import net.rim.device.api.ui.component.*;
import net.rim.device.api.ui.container.MainScreen;

Defina una clase MainScreen que implemente la interfaz TreeFieldCallback.

public class JSONOutputScreen extends MainScreen implements TreeFieldCallback
{
    private TreeField _treeField;

Cree un constructor que acepte Object como parámetro, cree la IU e inicie el código de análisis.

    public JSONOutputScreen(Object JSONData)
    {
        _treeField = new TreeField(this, Field.FOCUSABLE);
        add(_treeField);
        initializeTree(JSONData);
    }

Cree un método initializeTree() para borrar cualquier dato existente de TreeField.

    void initializeTree(Object obj)
    {
        int parentNode = 0;
        _treeField.deleteAll();

Determine si el nodo actual del objeto JSON es JSONArray o JSONObject. Invoque el método populateTreeArray() apropiado.

        try
        {
            if(obj instanceof JSONArray)
            {
                parentNode = populateTreeArray
                                 (_treeField, 
                                  (JSONArray) obj, 
                                  parentNode);
            }
            else if(obj instanceof JSONObject)
            {
                parentNode = populateTreeObject
                                 (_treeField, 
                                  (JSONObject) obj, 
                                  parentNode);
            }
        }

Revise cualquier error y especifique dónde debe agregar TreeField los nuevos datos.

        catch(JSONException e)
        {
            // Process error
        }
        _treeField.setCurrentNode(parentNode);
    }

Implemente populateTreeArray(TreeField, JSONArray, int).

    int populateTreeArray(TreeField tree, JSONArray o, int p) throws JSONException
    {
        Object temp;

Agregue un nodo a TreeField.

        int newParent = tree.addChildNode(p, "Array " + p);

Itere a través de los elementos en este nodo de JSONArray.

        for(int i = 0; i < o.length(); ++i)
        {

Recupere el JSONArray actual.
```
            temp = o.get(i);
```

Si el nodo está vacío, vaya al siguiente nodo.

            if(temp == null || temp.toString().equalsIgnoreCase("null"))
            {
                continue;
            }

Si el nodo contiene una estructura anidada de JSON, analice el objeto de forma recursiva. Vuelva a seleccionar la versión más adecuada de populateTreeArray().

            if(temp instanceof JSONArray)
            {
                populateTreeArray(tree, (JSONArray) temp, newParent);
            }
            else if(temp instanceof JSONObject)
            {
                populateTreeObject(tree, (JSONObject) temp, newParent);
            }

Este nodo debe contener datos. Agregue los datos al árbol.

            else
            {
                newParent = tree.addSiblingNode(newParent, temp.toString());
            }
        }
        return newParent;
    }

Implemente populateTreeArray(TreeField, JSONObject, int). El código es similar al de los pasos del 7 al 13, con las siguientes diferencias:
1. Cambie la firma del método del paso 7.
```
    int populateTreeArray(TreeField tree, JSONObject o, int p) throws JSONException
    {
```
2. Cree un JSONArray que contenga los nombres de los elementos.
```
        JSONArray jsonArray = o.names();
```
3. Itere a través del recién creado JSONArray en lugar del JSONObject que se ha pasado como un parámetro. Para obtener más información consulte el paso 9.
```
        for(int i = 0; i < jsonArray.length(); ++i)
        {
```
4. En JSONObject, recupere el valor de cada nombre en jsonArray. Para obtener más información, consulte el paso 10.
```
            temp = o.get(jsonArray.getString(i));
```
5. Asegúrese de que agrega tanto el nombre como el valor al árbol. Para obtener más información, consulte el paso 13.
```
                tree.addSiblingNode(newParent, a.getString(i) + ": " + temp.toString());
```

Implemente DrawTreeItem().

    public void drawTreeItem(TreeField treeField, Graphics graphics, int node,
            int y, int width, int indent) {
        if(treeField == _treeField)
        {
            Object cookie = _treeField.getCookie(node);
            if(cookie instanceof String)
            {
                String text = (String) cookie;
                graphics.drawText(text, indent, y, Graphics.ELLIPSIS, width);
            }
        }
    }
}

Tema siguiente: Muestra de código: análisis de una estructura de datos de JSON

Tema anterior: Analizar un formato de datos común de Internet

¿Le ha resultado útil esta información? Envíenos sus comentarios.

Global Navigation

Guía de desarrollo

Local Navigation

Analizar una estructura de datos de JSON