AD_Practica10_xml

xml

 

El objetivo de esta práctica es añadir una entrada a la cartera de los archivos relacionados con el tratamiento

en formato XML en JAVA.

• Explicar qué es un archivo XML

La tecnología XML busca dar solución al problema de expresar información estructurada de la manera

más abstracta y reutilizable posible. Que la información sea estructurada quiere decir que se compone

de partes bien definidas, y que esas partes se componen a su vez de otras partes. Entonces se tiene un

árbol de pedazos de información. Ejemplos son un tema musical, que se compone de compases, que

están formados a su vez con notas. Estas partes se llaman elementos, y se las señala mediante etiquetas.

Una etiqueta consiste en una marca hecha en el documento, que señala una porción de este como un

elemento. Un pedazo de información con un sentido claro y definido.
Teniendo en cuenta esta definición podremos definir un XML para una lista de temas musicales de

esta manera: Tanto MUSICA como tema son ambas etiquetas!

1

 

Conclusion, indispensable nunca olvidarse:

1º Prólogo:

3

 

 

 

2º Cuerpo:

 

2

 

Es la etiqueta superior que abarcara todas las sub etiquetas y no abra ni existirá ninguna fuera de ella,

esta se declara y se cierra una sola vez.

 

3º Nodos:

4

Pueden existir cuanta cantidad de nodos necesiten pero siempre cuando se abre uno <“se deben cerra

r en alguna parte />”, estos nodos pueden tener el mismo nombre de nodo y cada uno será

interpretado como elementos diferentes.

4º Atributos: nombre=”Kevin Chuca”
Los atributos deben ir dentro del nodo y utilizar un nombre lo mas descriptivo posible y corto, su

contenido se escribe a continuación del signo = y entre comillas sean simples o dobles. Si usan

comillas dobles deberán usar dobles para el resto de sus atributos o viceversa.

 

5

 

 

• Cómo funcionan las clases de saxo y Dom ?

xml4

Con DOM, el documento XML se lee completamente antes de poder realizar ninguna acción en función de su contenido.

Esto es posible gracias a que, como resultado de la lectura del documento, el parser DOM devuelve todo su contenido

en forma de una estructura de tipo árbol, donde los distintos elementos del XML se representa en forma de nodos

y su jerarquía padre-hijo se establece mediante relaciones entre dichos nodos.

Como ejemplo, vemos un ejemplo de XML sencillo y cómo quedaría su representación en forma de árbol:

1
2
3
4
5
6
7
8
9
10
<noticias>
    <noticia>
        <titulo>T1</titulo>
        <link>L1</link>
    </noticia>
    <noticia>
        <titulo>T2</titulo>
        <link>L2</link>
    </noticia>
<noticias>

Este XML se traduciría en un árbol parecido al siguiente:

arbol-xml-dom

Como vemos, este árbol conserva la misma información contenida en el fichero XML pero en forma de nodos y

transiciones entre nodos, de forma que se puede navegar fácilmente por la estructura. Además, este árbol se

conserva persistente en memoria una vez leido el documento completo, lo que permite procesarlo en cualquier

orden y tantas veces como sea necesario (a diferencia de SAX, donde el tratamiento era secuencial y siempre de

principio a fin del documento, no pudiendo volver atrás una vez finalizada la lectura del XML).

Veamos como queda con codigo :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
public class RssParserDom
{
    private URL rssUrl;
    public RssParserDom(String url)
    {
        try
        {
            this.rssUrl = new URL(url);
        }
        catch (MalformedURLException e)
        {
            throw new RuntimeException(e);
        }
    }
    public List<Noticia> parse()
    {
        //Instanciamos la fábrica para DOM
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        List<Noticia> noticias = new ArrayList<Noticia>();
        try
        {
            //Creamos un nuevo parser DOM
            DocumentBuilder builder = factory.newDocumentBuilder();
            //Realizamos lalectura completa del XML
            Document dom = builder.parse(this.getInputStream());
            //Nos posicionamos en el nodo principal del árbol (<rss>)
            Element root = dom.getDocumentElement();
            //Localizamos todos los elementos <item>
            NodeList items = root.getElementsByTagName("item");
            //Recorremos la lista de noticias
            for (int i=0; i<items.getLength(); i++)
            {
                Noticia noticia = new Noticia();
                //Obtenemos la noticia actual
                Node item = items.item(i);
                //Obtenemos la lista de datos de la noticia actual
                NodeList datosNoticia = item.getChildNodes();
                //Procesamos cada dato de la noticia
                for (int j=0; j<datosNoticia.getLength(); j++)
                {
                    Node dato = datosNoticia.item(j);
                    String etiqueta = dato.getNodeName();
                    if (etiqueta.equals("title"))
                    {
                        String texto = obtenerTexto(dato);
                        noticia.setTitulo(texto);
                    }
                    else if (etiqueta.equals("link"))
                    {
                        noticia.setLink(dato.getFirstChild().getNodeValue());
                    }
                    else if (etiqueta.equals("description"))
                    {
                        String texto = obtenerTexto(dato);
                        noticia.setDescripcion(texto);
                    }
                    else if (etiqueta.equals("guid"))
                    {
                        noticia.setGuid(dato.getFirstChild().getNodeValue());
                    }
                    else if (etiqueta.equals("pubDate"))
                    {
                        noticia.setFecha(dato.getFirstChild().getNodeValue());
                    }
                }
                noticias.add(noticia);
            }
        }
        catch (Exception ex)
        {
            throw new RuntimeException(ex);
        }
        return noticias;
    }
    private String obtenerTexto(Node dato)
    {
        StringBuilder texto = new StringBuilder();
        NodeList fragmentos = dato.getChildNodes();
        for (int k=0;k<fragmentos.getLength();k++)
        {
            texto.append(fragmentos.item(k).getNodeValue());
        }
        return texto.toString();
    }
    private InputStream getInputStream()
    {
        try
        {
            return rssUrl.openConnection().getInputStream();
        }
        catch (IOException e)
        {
            throw new RuntimeException(e);
        }
    }
}

Como vemos, el modelo DOM nos permite localizar y tratar determinados elementos concretos del documento

XML, sin la necesidad de recorrer todo su contenido de principio a fin. Además, a diferencia de SAX, como tenemos

cargado en memoria el documento completo de forma persistente (en forma de objeto Document), podremos

consultar, recorrer y tratar el documento tantas veces como sea necesario sin necesidad de volverlo a parsear.

En un artículo posterior veremos como todas estas características pueden ser ventajas o inconvenientes según

el contexto de la aplicación y el tipo de XML tratado.

Anuncios

Publicado el 6 octubre, 2014 en Acceso a Datos en Java. Añade a favoritos el enlace permanente. Comentarios desactivados en AD_Practica10_xml.

Los comentarios están cerrados.

A %d blogueros les gusta esto: