Diferencia entre revisiones de «Prog Tratamientos de documentos XML»

De MediaWiki
Ir a la navegación Ir a la búsqueda
Línea 100: Línea 100:
 
* Los pasos a seguir son los siguientes:
 
* Los pasos a seguir son los siguientes:
  
::<syntaxhighlight lang="java" line enclose="div" highlight="" >
+
::<syntaxhighlight lang="java" line enclose="div" highlight="5,7" >
     // Construimos nuestro DocumentBuilder
+
     public static void main(String[] arg){
    DocumentBuilder documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+
       
    // Procesamos el fichero XML y obtenemos nuestro objeto Document
+
        try {
    Document doc = documentBuilder.parse(new InputSource(new FileInputStream("/ruta_a_fichero/fichero.xml")));
+
            // Construimos nuestro DocumentBuilder
 +
            DocumentBuilder documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
 +
            // Procesamos el fichero XML y obtenemos nuestro objeto Document
 +
            Document doc = documentBuilder.parse(new File("/tmp/fichero.xml"));
 +
 
 +
 
 +
 
 +
        } catch (FileNotFoundException ex) {
 +
            Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
 +
        } catch (SAXException ex) {
 +
            System.out.println("Fichero no pasa validación");
 +
            Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
 +
        } catch (IOException ex) {
 +
            Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
 +
        } catch (ParserConfigurationException ex) {
 +
            Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
 +
        }
 +
       
 +
       
 +
    }
 +
 
 
</syntaxhighlight>  
 
</syntaxhighlight>  
 +
 +
:* Línea 7: El [https://docs.oracle.com/javase/7/docs/api/javax/xml/parsers/DocumentBuilder.html#parse(java.io.File) método parse] está sobrecargado y podemos enviar un InputStream.
 +
:* Las excepciones son las conocidas y dos nuevas. La principal es SAXException, que se lanzará en caso de que el fichero esté mal formado (no cumpla con las reglas de XML vistas en el punto inicial).
  
  
  
  
 +
<br />
 +
==Manipulando un árbol DOM==
  
  

Revisión del 14:02 17 abr 2018

Introducción

  • XML viene de Extensible Markup Language.


  • Podéis consultar la historia y uso del XML en este enlace.


  • Uno de los usos del lenguaje XML es el intercambio de información entre sistemas heterogéneos.
La información se transmite en formato texto (normalmente unicode) con una estructura en forma de etiquetas muy parecida a la conocida por todos, HTML.


  • Veamos un ejemplo de fichero XML:
<?xml version="1.0" encoding="UTF-8" ?>
<pedidos num_pedidos="1">
 <pedido>
  <id>1</id>
  <productos>
    <producto>
     <codigo>221</codigo>
     <cantidad>10</cantidad>
    </producto>
    <producto>
     <codigo>231</codigo>
     <cantidad>10</cantidad>
    </producto>
   </productos>
 </pedido>
</pedidos>


  • Para que un documento cumpla el estándar XML tiene que cumplir las siguientes reglas:
  • Debe de tener una cabecera donde se especifica la versión de XML que cumple el documento. También suele aparecer tipo de codificación, normalmente UTF-8 o ISO-8859-1.
  • El documento debe estar estructurado en forma de etiquetas de apertura <etiqueta> y cierre </etiqueta>.
  • Un documento debe de tener al menos una etiqueta de apertura y otra de cierre.
  • Se pueden poner etiquetas que abran y cierren la etiqueta al mismo tiempo de la forma: <etiqueta />. Por ejemplo: <representante nombre="Angel" />
  • El orden de las etiquetas es importante. Se deben cerrar en el orden inverso a como fueron abiertas.
  • Se distingue mayúsculas y minúsculas en la apertura y cierre de etiquetas.
  • Una etiqueta puede llevar uno o más atributos. Por ejemplo: <pedidos num_pedidos="10" fecha_pedido="10/01/2012">
  • No puede haber atributos con el mismo nombre en la misma etiqueta.
  • Todos los atributos deben ir entre comillas dobles.
  • Se pueden añadir comentarios de la forma:
  • Los nombres de las etiquetas y atributos no pueden tener espacios en blanco.



  • En Java, cuando manejamos un documento XML o bien creamos uno nuevo, vamos a tener que recorrer / crear la estructura anterior.
En Java cada elemento de esa estructura recibe un nombre. Así:
  • Las etiquetas de apertura y cierre junto con su contenido se denomina Elements. En element puede tener otros 'element' en su contenido.
  • Los atributos se denominan Attr y sólo pueden existir dentro de element, en la etiqueta de apertura.
  • La información (el texto) que va entre las etiquetas de apertura y cierre se denomina Text.
  • Los comentarios pueden ir en cualquier lugar del documento y se denominan Comment.



Java: Procesando archivos XML

  • Cuando tratemos con documentos XML vamos a diferenciar dos fases:
  • Comprobar que el documento XML esté bien formado en base a las reglas que indicamos en la introducción.
  • Pasar dicho documento a un conjunto de objetos que podamos manejar desde Java. Este formato se denomina DOM (Document Object Model), modelo de objetos. En DOM cada etiqueta es un nodo de una rama de un árbol jerárquico a la que vamos podemos acceder obteniendo su contenido, atributos, nombre,...
  • Tanto el estándar XML como DOM, son estándares propuesto por W3C (World Wide Web Consortium)


  • Por lo tanto vamos a pasar el documento XML en formato texto a un árbol DOM desde donde poder acceder a cada uno de los elementos del documento XML.



Pasando de documento XML a árbol DOM

  • Lo primero que tenemos que hacer es verificar que el documento XML esté bien formado. Para ello se hace uso de un parser.
  • Hay dos tipos parser:
  • Sin validación: Comprueba que el documento esté bien formado de acuerdo a las reglas de sintaxis de XML.
  • Con validación: Además de comprobar que el documento está bien formado, comprueba el documento utilizando un DTD (ya sea interno o externo). Un DTD (Document Type Definition) es un documento en el que se indica cual es la estructura que tiene que tener el documento, sus elementos y atributos.
  • Nosotros vamos a hacer uso de un parser sin validación que además va a ser compatible con el modelo de objeto de documento (DOM) de XML


  • Vamos a hacer uso de las siguientes clases:


  • Los pasos a seguir son los siguientes:
 1     public static void main(String[] arg){
 2         
 3         try {
 4             // Construimos nuestro DocumentBuilder
 5             DocumentBuilder documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
 6             // Procesamos el fichero XML y obtenemos nuestro objeto Document
 7             Document doc = documentBuilder.parse(new File("/tmp/fichero.xml"));
 8 
 9 
10 
11         } catch (FileNotFoundException ex) {
12             Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
13         } catch (SAXException ex) {
14             System.out.println("Fichero no pasa validación");
15             Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
16         } catch (IOException ex) {
17             Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
18         } catch (ParserConfigurationException ex) {
19             Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
20         }
21         
22         
23     }
  • Línea 7: El método parse está sobrecargado y podemos enviar un InputStream.
  • Las excepciones son las conocidas y dos nuevas. La principal es SAXException, que se lanzará en caso de que el fichero esté mal formado (no cumpla con las reglas de XML vistas en el punto inicial).




Manipulando un árbol DOM


-- Ángel D. Fernández González -- (2017).