Procesando XML para obtener Objetos Java

En un articulo anterior vimos la forma de pasar un Objeto Java a XML; para terminar de brindar funcionalidad a la pequeña utilidad ahora veremos la forma de utilizar este archivo generado, es decir tomar un archivo XML y con los elementos que este tenga poblar una lista que contenga elementos a los que haga referencia el XML.

Naturalmente esta utilidad tiene también algunas limitaciones que se podrían ir corrigiendo en tanto la utilidad se mejore.

Estas limitaciones son por ejemplo :
los atributos de los objetos deben ser String.
Las clases de los objetos deben estar en el mismo paquete que la librería.
Los objetos deben tener un constructor por defecto explicito.

Inicialmente debemos crear un objeto con el cual tengamos acceso al XML

public void parsearArchivoXml() {
        // 1. Obteher el objeto DocumentBuilderFactory
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        try {
            // 2. Usar DocumentBuilderFactory para crear un DocumentBuilder
            DocumentBuilder db = dbf.newDocumentBuilder();
            // 3. Parsear a partir de un archivo
            dom = db.parse("document.xml");
        } catch (ParserConfigurationException pce) {
            pce.printStackTrace();
        } catch (SAXException se) {
            se.printStackTrace();
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }

Una vez que tenemos un administrador para el xml lo que hacemos es extraer el nodo raíz.
Partiendo del nodo raíz obtenemos los elementos hijos de este iterando sobre la raíz que se ha obtenido.

//Parsea el documento XML y extrae los datos
    public void parsearDocumento() {
        // 1. Obtener el documento raiz
        Element docEle = dom.getDocumentElement();
        // 2. Obtener un nodelist de elementos <descarga>
        NodeList nl = docEle.getChildNodes();

        if (nl != null && nl.getLength() > 0) {
            for (int i = 0; i < nl.getLength(); i++) {

                try {

                    Element elemento = (Element) nl.item(i);

                    String name = elemento.getNodeName();
                    name = name.replaceFirst(name.substring(0, 1), name.substring(0, 1).toUpperCase());

                    name = this.getClass().getPackage().getName() + "." + name;

                    // b. Obtener el objeto empleado
                    Object myObject = getObject(elemento, name);

                    // c. Anidarlo a la lista
                    objectList.add(myObject);

                } catch (Exception e) {
                    System.out.println(e);
                }

            }
        }
    }

El método getObjecto es el que realiza la magia por medio del api Reflection para obtener los datos del XML y mapearlos contra un objeto específico. Naturalmente la cantidad de atributos de cada objeto debe coincidir con el numero de elementos que tiene cada uno de los nodos del XML

private Object getObject(Element elemento, String cName) {
        Class obj;
        String methodName;
        Object myInstance = null;
        try {
            obj = Class.forName(cName);

            myInstance = obj.newInstance();

            Method[] metList = obj.getDeclaredMethods();

            for (int i = 0; i < metList.length; i++) {
                methodName = (metList[i].getName().startsWith("set")) ? metList[i].getName() : "";
                if (methodName.equals("setId")) {
                    metList[i].invoke(myInstance, elemento.getAttribute("id"));
                } else if (!methodName.equals("")) {
                    String tempAtribute = methodName.substring(3);

                    metList[i].invoke(myInstance, obtenerTexto(elemento, tempAtribute.replace(tempAtribute.substring(0, 1), tempAtribute.substring(0, 1).toLowerCase())));
                }
            }

        } catch (Exception e) {
            System.out.println(e);
        }
        return myInstance;
    }

La utilización de reflection nos permite convertir los elementos en cualquier tipo de objeto claro esta con las limitaciones mencionadas anteriormente.

Como pueden apreciar en el método principal el resultado del getObject es la instancia de una clase, la misma que se almacena en una lista de Objetos para alguna manipulación posterior.

En el método getObject utiliza para el id el método getAttribute que es parte de la implementación del parser para obtener el id que en el XML por razones practicas al desarrollo que tengo se encuentra como atributo del elemento y no así como uno de sus valores.

Así mismo el método getObject llama al método obtenerTexto quien es el que se encarga concreta mente de obtener el valor que encierra un elemento dentro el XML

private String obtenerTexto(Element elemento, String nombreEtiqueta) {
        String texto = null;
        NodeList nl = elemento.getElementsByTagName(nombreEtiqueta);
        if (nl != null && nl.getLength() > 0) {
            Element el = (Element) nl.item(0);
            texto = el.getFirstChild().getNodeValue();
        }
        return texto;
    }

El comportamiento es sencillo y para poder probar el método utilizaremos temporalmente el siguiente método main:

    public static void main(String args[]) {
        ProcessXML procesador = new ProcessXML();
    }

Esto por supuesto implica que debemos tener previamente el archivo XML al que nos estamos refiriendo en la carpeta donde estamos ejecutando las librerías.

El archivo XML debe coincidir necesariamente con los objetos que se encuentran en el XML con la diferencia de que la primer letra debe estar en mayúscula es decir si el nodo del XML es descarga, la clase debe llamarse Descarga.

También es importante mencionar que el XML debe estar construido con indentado adecuado.

No han sido realizadas muchas pruebas pero no se detectaron errores utilizando el generador y este procesador.

Para generar facilmente los XML consulta con este post.

El proyecto final está disponible para descargar desde el siguiente enlace. El mismo esta construido como proyecto Netbeans para su fácil revisión.

Alguna Duda?