Analizar una estructura de datos de JSON

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.
  1. 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;
  2. Defina una clase MainScreen que implemente la interfaz TreeFieldCallback.
    public class JSONOutputScreen extends MainScreen implements TreeFieldCallback
    {
        private TreeField _treeField;
  3. 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);
        }
  4. Cree un método initializeTree() para borrar cualquier dato existente de TreeField.
        void initializeTree(Object obj)
        {
            int parentNode = 0;
            _treeField.deleteAll();
  5. 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);
                }
            }
  6. Revise cualquier error y especifique dónde debe agregar TreeField los nuevos datos.
            catch(JSONException e)
            {
                // Process error
            }
            _treeField.setCurrentNode(parentNode);
        }
  7. Implemente populateTreeArray(TreeField, JSONArray, int).
        int populateTreeArray(TreeField tree, JSONArray o, int p) throws JSONException
        {
            Object temp;
  8. Agregue un nodo a TreeField.
            int newParent = tree.addChildNode(p, "Array " + p);
  9. Itere a través de los elementos en este nodo de JSONArray.
            for(int i = 0; i < o.length(); ++i)
            {
  10. Recupere el JSONArray actual.
                temp = o.get(i);
  11. Si el nodo está vacío, vaya al siguiente nodo.
                if(temp == null || temp.toString().equalsIgnoreCase("null"))
                {
                    continue;
                }
  12. 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);
                }
  13. Este nodo debe contener datos. Agregue los datos al árbol.
                else
                {
                    newParent = tree.addSiblingNode(newParent, temp.toString());
                }
            }
            return newParent;
        }
  14. 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());
  15. 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);
                }
            }
        }
    }

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