Aplikacje internetowe i rozproszone - laboratorium Przetwarzanie XML (DOM API, parser DOM, XPath) Do wykonania ćwiczeń wykorzystane zostanie środowisko programistyczne Eclipse SDK 3.1 (lub nowsza wersja; do pobrania z http://www.eclipse.org). Wymagane jest środowisko J2SE 5.0 (lub nowsza wersja).

Autor ćwiczeń: Paweł Boiński

Ćwiczenie 1 Celem ćwiczenia jest przygotowanie aplikacji w języku Java, która będzie służyła do stworzenia dokumentu XML za pomocą Java DOM API. Generowany dokument będzie zawierał spis części komputerowych wraz z ich cenami i stanami magazynowymi. Aplikacja powinna umożliwiać dodawanie i usuwanie części, wyświetlanie spisu części oraz transformację i zapis drzewa DOM do pliku XML.

Struktura drzewa DOM dla przechowywania informacji o częściach została przedstawiona na poniższym rysunku.

<computer_parts>

<part>

ID=10

korzeńwęzeł elementu

węzeł tekstowy

<name> <price> <quantity>

<poznan> <warszawa>procesorX 450

35 24

węzeł atrybutu

<?xml version="1.0" encoding="UTF-8"?> <computer_parts> <part ID="10"> <name>procesorX</name> <price>450</price> <quantity> <poznan>35</poznan> <warszawa>24</warszawa> </quantity> </part> <part ID="25"> <name>mysz</name> <price>65</price> <quantity> <poznan>5</poznan> <warszawa>16</warszawa> </quantity> </part> ... </computer_parts>

1. Uruchom środowisko Eclipse. Na ekranie wyświetlone zostanie okienko z pytaniem o przestrzeń roboczą (ang. workspace), czyli katalog dyskowy, który będzie używany w bieżącej sesji programu Eclipse. Załóżmy, że tym katalogiem będzie c:\programy. Jeśli taki katalog nie istniał, zostanie on założony automatycznie.

2. Z menu głównego wybierz File→New→Project.

3. Wybierz typ kreatora Java Project. Kliknij przycisk Next >.

4. Podaj nazwę projektu, np. „xmllab1”. Kliknij przycisk Next >.

5. Kolejne okienko pozwala na zdefiniowanie dodatkowych lub zmianę istniejących ustawień dla projektu. Dla budowanej aplikacji wystarczy domyślna konfiguracja. Kliknij przycisk Finish.

6. Z menu głównego wybierz Window→Open Perspective→Java. (Ta czynność nie powoduje otwarcia żadnego, nowego okienka).

7. Zamknij zakładkę Welcome w głównym oknie (jeśli była otwarta).

8. Kliknij prawym przyciskiem myszy na nazwie projektu w zakładce Package Explorer. Z menu kontekstowego wybierz New→Class.

9. Podaj nazwę pakietu, np. myXMLpackage oraz nazwę klasy, np. Shop. Zaznacz opcję public static void main(String [] args). Kliknij przycisk Finish.

10. Postępując podobnie jak w punktach 8-9, utwórz klasę XMLHandler. Uwaga! Nie zaznaczaj opcji public static void main(String [] args).

11. Klasa XMLHandler będzie odpowiedzialna za przechowywanie dokumentu XML w postaci drzewa DOM oraz za operacje wykonywane na tym dokumencie. Konstruktor klasy będzie tworzył nowy dokument XML. Wprowadź następujący kod do pliku tej klasy.

package myXMLpackage; import org.w3c.dom.*; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerFactory; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult; import java.io.FileOutputStream; public class XMLHandler { Document xmlDoc; public XMLHandler() { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); try { DocumentBuilder parser = factory.newDocumentBuilder(); xmlDoc = parser.newDocument(); } catch (Exception e) { System.out.println(e.toString()); } } }

12. Dokument XML musi posiadać główny węzeł, który obejmuje całość dokumentu. W przypadku modelowanej aplikacji jest to węzeł „computer_parts”. Dodaj do klasy XMLHandler poniższą metodę odpowiedzialną za jego utworzenie.

public void addRoot() { Element root = (Element) xmlDoc.createElement("computer_parts"); xmlDoc.appendChild(root); }

13. Kolejnym etapem ćwiczenia jest zdefiniowanie operacji służących do wstawiania i usuwania opisu podzespołów komputerowych z dokumentu XML. Dodaj poniższe definicje metod do klasy XMLHandler.

public void addPart(String r_id, String r_name, String r_price, String r_quantity1, String r_quantity2) { Node nameNode, priceNode, quantityNode, cityNode; Node rootNode = xmlDoc.getDocumentElement(); Element newPartNode = xmlDoc.createElement("part"); newPartNode.setAttribute("ID", r_id); rootNode.appendChild(newPartNode); nameNode = xmlDoc.createElement("name"); Node newTextNode = xmlDoc.createTextNode(r_name); nameNode.appendChild(newTextNode); newPartNode.appendChild(nameNode); priceNode = xmlDoc.createElement("price"); newTextNode = xmlDoc.createTextNode(r_price); priceNode.appendChild(newTextNode); newPartNode.appendChild(priceNode);

quantityNode = xmlDoc.createElement("quantity"); newPartNode.appendChild(quantityNode); cityNode = xmlDoc.createElement("poznan"); newTextNode = xmlDoc.createTextNode(r_quantity1); cityNode.appendChild(newTextNode); quantityNode.appendChild(cityNode); cityNode = xmlDoc.createElement("warszawa"); newTextNode = xmlDoc.createTextNode(r_quantity2); cityNode.appendChild(newTextNode); quantityNode.appendChild(cityNode); } public void delPart(String r_id) { Node rootNode = xmlDoc.getDocumentElement(); Node partNode, idNode; NodeList docNodeList = rootNode.getChildNodes(); for (int i = 0; i < docNodeList.getLength(); i++) { partNode = docNodeList.item(i); idNode = partNode.getAttributes().item(0); if (idNode.getNodeValue().equals(r_id)) { rootNode.removeChild(partNode); System.out.println("usunięto część z id=" + r_id); break; } } }

14. Użytkownik powinien mieć dostęp do wprowadzonych do dokumentu informacji na temat części komputerowych. Ponadto powinna istnieć możliwość zapisu dokument XML do pliku. Poniżej znajduje się implementacja dwóch metod służących do realizacji tych wymagań. Dodaj te metody do klasy XMLHandler.

public void showXML() { Node rootNode = xmlDoc.getDocumentElement(); Node myNode; Element tempElement; NodeList docNodeList = rootNode.getChildNodes(); String desc; for (int i = 0; i < docNodeList.getLength(); i++) { tempElement = (Element) docNodeList.item(i); desc = "[" + tempElement.getAttribute("ID") + "] "; myNode = tempElement.getElementsByTagName("name").item(0); desc += myNode.getFirstChild().getNodeValue(); desc += ", price:"; myNode = tempElement.getElementsByTagName("price").item(0); desc += myNode.getFirstChild().getNodeValue(); System.out.println(desc); } } public void saveXML() { try { TransformerFactory tf = TransformerFactory.newInstance(); Transformer t = tf.newTransformer(); t.transform(new DOMSource(xmlDoc), new StreamResult( new FileOutputStream("wynik.xml"))); } catch (Exception e) { System.out.println(e.toString()); } }

15. Budowana aplikacja będzie działała w trybie tekstowym. Po uruchomieniu użytkownik będzie mógł wydawać kolejne polecenia (do momentu wpisania komendy exit, co skutkuje zakończeniem działania programu). Dodaj polecenia importu pakietów i uzupełnij metodę main w klasie Shop.

import java.io.*; import java.util.StringTokenizer; ... public static void main(String[] args) { XMLHandler xml = new XMLHandler(); xml.addRoot(); try { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); String input = ""; while(true) { System.out.print("> "); input = in.readLine(); if (input.equals("")) continue; if ("exit".equals(input)) break; else parseJob(input, xml); } } catch(Exception e) { System.out.println(e.getMessage()); } }

16. Dodaj metodę, która będzie realizowała polecenia wpisywane przez użytkownika. Polecenie add wymaga podania pięciu parametrów opisujących część (identyfikator, nazwa, cena, ilość w sklepie w Poznaniu, ilość w sklepie w Warszawie) oddzielonych znakiem spacji. Polecenie del wymaga podania identyfikatora usuwanej części. Polecenie show wyświetla aktualną listę części, save zapisuje dane do pliku XML. Dodaj poniższy kod do klasy „Shop”.

public static void parseJob(String r_input, XMLHandler r_xml) { StringTokenizer st = new StringTokenizer(r_input," "); String command = st.nextToken(); if (command.equalsIgnoreCase("add")) r_xml.addPart(st.nextToken(), st.nextToken(), st.nextToken(), st.nextToken(), st.nextToken()); else if (command.equalsIgnoreCase("del")) r_xml.delPart(st.nextToken()); else if (command.equalsIgnoreCase("show")) r_xml.showXML(); else if (command.equalsIgnoreCase("save")) r_xml.saveXML(); }

17. Przejdź do edycji klasy Shop. Z głównego menu wybierz Run→ Run. W panelu Configurations zaznacz Java Application kliknij przycisk New.

18. Uruchom aplikację przez kliknięcie przycisku Run.

19. Przetestuj działanie programu używając wbudowanej w środowisko Eclipse konsoli. Dodaj klika podzespołów do dokumentu, wyświetl je, usuń wybrane, zapisz do pliku.

20. Zapisany plik XML możesz znaleźć w katalogu projektu (przy ustawieniach użytych w ćwiczeniu, ścieżka do pliku to C:\programy\xmllab1\wynik.xml). Sprawdź zawartość pliku, np. używając przeglądarki internetowej.

Ćwiczenie 2 Celem ćwiczenia jest przygotowanie aplikacji, która umożliwi odczyt i przetwarzanie pliku z zawartością XML. Aplikacja, napisana w języku Java, będzie korzystać z parsera DOM oraz języka zapytań XPath.

1. Utwórz plik data.xml z poniższą zawartością (struktura danych w pliku jest taka jak w wynikowym pliku z ćwiczenia 1).

<?xml version = '1.0' encoding = 'UTF-8'?> <computer_parts> <part ID="10"><name>procesorX</name><price>450</price> <quantity><poznan>4</poznan><warszawa>7</warszawa></quantity></part> <part ID="25"><name>mysz</name><price>65</price> <quantity><poznan>24</poznan><warszawa>56</warszawa></quantity></part> <part ID="40"><name>klawiatura</name><price>12</price> <quantity><poznan>12</poznan><warszawa>8</warszawa></quantity></part> <part ID="50"><name>monitorLCD</name><price>960</price> <quantity><poznan>5</poznan><warszawa>3</warszawa></quantity></part> <part ID="60"><name>monitorCRT</name><price>360</price> <quantity><poznan>1</poznan><warszawa>6</warszawa></quantity></part> </computer_parts>

2. Utwórz w środowisku Eclipse nowy projekt, np. o nazwie „xmllab2”. Sposób postępowania został opisany w krokach 1 – 5 poprzedniego ćwiczenia.

3. Utwórz klasę ShopBrowser w sposób, jaki pokazano w krokach 8, 9 poprzedniego ćwiczenia. Nowa klasa powinna posiadać metodę main.

4. Dodaj statyczne pole klasy typu Document, w którym przechowywany będzie odczytany dokument XML. Przykładową nazwą może być xmlDoc. Nie zapomnij o zaimportowaniu odpowiednich pakietów.

import org.w3c.dom.*; … public class ShopBrowser { private static Document m_xmlDoc; … }

5. Podstawowym zadaniem aplikacji jest wczytanie istniejącego dokumentu XML i utworzenie odpowiadającego mu drzewa DOM. Jednym ze sposobów rozwiązania tego problemu jest wykorzystanie parsera DOM. Klasy obiektów potrzebnych do parsowania pliku znajdują się w pakiecie javax.xml.parsers. Napisz metodę dla klasy ShopBrowser, która dla zadanego przez parametr pliku, dokona transformacji tego dokumentu do drzewa DOM. Poniższy kod realizuje postawione zdanie.

private static boolean readDocument(String r_fileName) { DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); try { DocumentBuilder builder = domFactory.newDocumentBuilder(); m_xmlDoc = builder.parse("file:" + r_fileName); return true; } catch (ParserConfigurationException px) { System.out.println(px.toString()); } catch (Exception iox) { System.out.println(iox.toString()); } return false; }

6. Dopisz wywołanie metody readDocument(String) w głównej metodzie klasy (metoda main). Nazwa pliku powinna być przekazywana z linii poleceń jako pierwszy argument. Kod sprawdzający dodatkowo poprawność wykonania operacji odczytu dokumentu XML znajduję się poniżej.

public static void main(String[] args) { if (readDocument(args[0])) System.out.println("File OK."); else { System.out.println("Problem reading XML file."); System.exit(0); } }

7. Umieść plik XML z danymi w głównym katalogu projektu.

8. Aplikacja jest gotowa do pierwszego uruchomienia. Zauważ, że wymagane jest przekazanie parametru przy wywołaniu programu. W środowisku Eclipse zadanie to można zrealizować tworząc odpowiednią konfigurację do uruchomienia programu. Z głównego menu wybierz Run→ Run...

9. W oknie menadżera konfiguracji w panelu Configurations zaznacz Java Application i kliknij przycisk New.

10. Przejdź do zakładki Arguments i w polu Program arguments wpisz nazwę pliku z danymi XML.

11. Uruchom program za pomocą przycisku Run. Możesz także powtarzać uruchomienia z tymi samymi parametrami za pomocą ikony w pasku narzędziowym lub wybierając z głównego menu Run-> Run Last Lunched. Efekt działania programu widoczny jest w zakładce konsoli.

12. Kolejnym krokiem jest odczyt zawartości, skonstruowanego na podstawie pliku, drzewa DOM. Można to zrobić poruszając się po tym drzewie, tak jak zostało to pokazane w zadaniu z poprzedniego laboratorium. Inną możliwością jest zastosowanie wyrażeń XPath do wyszukiwania pożądanych węzłów. W celu użycia wyrażeń XPath z biblioteki JAXP należy utworzyć odpowiedni obiekt korzystając z fabryki XPath. Ponieważ wyrażenia będą używane wielokrotnie w ramach aplikacji, warto utworzyć osobną klasę ułatwiającą korzystanie z tych wyrażeń. Utwórz klasę XPathEvaluator.

13. Uzupełnij klasę XPathEvaluator tak, aby odpowiadała poniższemu przykładowi. package myXMLpackage; import javax.xml.xpath.*; import org.w3c.dom.Document; import org.w3c.dom.NodeList; public class XPathEvaluator { XPath m_xPath; public XPathEvaluator() { XPathFactory factory = XPathFactory.newInstance(); m_xPath = factory.newXPath(); } public NodeList selectNodes(Document r_xmlDoc, String r_expr) { try { XPathExpression expr = m_xPath.compile(r_expr); return (NodeList) expr.evaluate(r_xmlDoc, XPathConstants.NODESET); } catch (XPathExpressionException xpe) { System.out.println(xpe.toString()); return null; } } }

14. W klasie ShopBrowser dodaj pole klasy przechowujące obiekt klasy XPathEvaluator. Dodaj do metody main polecenie utworzenia tego obiektu.

public class ShopBrowser { … private static XPathEvaluator m_xpe; … public static void main(String[] args) { … m_xpe = new XPathEvaluator(); … } … }

15. Zaimplementuj metodę printOverview(), która wyświetli na ekranie liczbę różnych części komputerowych oraz sumaryczną liczbę sztuk wszystkich części. Wykorzystaj klasę XPathEvaluator do znalezienia odpowiednich węzłów. Poniżej znajduje się jedna z możliwych implementacji tej metody.

W rozwiązaniu zastosowano dwa wyrażenia XPath. Pierwsze z nich to „//part”, które znajduje wszystkie węzły „part”. Drugie wyrażenie ma postać „//part/quantity/*/text()”. Biorąc pod uwagę znaczenie informacji w źródłowym pliku XML, możne je odczytać w następujący sposób: znajdź wszystkie wartości opisujące stan magazynu dla dowolnego miasta, dla dowolnego podzespołu komputerowego. Znając te wartości można je zsumować uzyskując łączny stan zapasów w magazynach.

public static void printOverview() { String result = "\n"; NodeList resultNodes = m_xpe.selectNodes(m_xmlDoc, "//part"); if (resultNodes != null) { result += "Number of parts: " + resultNodes.getLength() + "\n"; resultNodes = m_xpe.selectNodes(m_xmlDoc, "//part/quantity/*/text()"); int counter = 0; for (int i = 0; i < resultNodes.getLength(); i++) { counter += Integer.parseInt(resultNodes.item(i).getNodeValue()); } result += "Total number of items: " + counter + "\n"; System.out.println(result); } }

16. Dodaj wywołanie metody printOverview() na końcu metody main. Uruchom program i sprawdź efekt jego wykonania.

17. Następnym krokiem będzie implementacja metody wyszukującej podzespoły o zadanych parametrach, którymi będą: maksymalna cena podzespołu i minimalna liczba sztuk tego podzespołu w mieście Poznań. Zaimplementuj metodę w klasie ShopBrowser, np. o nazwie searchParts1, która będzie wykorzystywała tylko metody do poruszania się po drzewie oferowane przez DOM API. Przykładowa implementacja znajduje się poniżej.

public static void searchParts1(String r_maxPrice, String r_minQuantity) { Element rootNode = (Element) m_xmlDoc.getDocumentElement(); NodeList partNodes = rootNode.getElementsByTagName("part"); for (int i = 0; i < partNodes.getLength(); i++) { Element partElement = (Element) partNodes.item(i); Node priceNode = partElement.getElementsByTagName("price").item(0); int price = Integer.parseInt(priceNode.getFirstChild().getNodeValue()); if (price <= Integer.parseInt(r_maxPrice)) { Element quantityElement = (Element) partElement.getElementsByTagName("quantity").item(0); Node cityNode = quantityElement.getElementsByTagName("poznan").item(0); int q = Integer.parseInt(cityNode.getFirstChild().getNodeValue()); if (q >= Integer.parseInt(r_minQuantity)) { Node nameNode = partElement.getElementsByTagName("name").item(0); System.out.println(nameNode.getFirstChild().getNodeValue()); } } } }

18. Zaimplementuj metodę searchParts2, która będzie wykonywała te same czynności jak metoda searchParts1, ale z wykorzystaniem języka XPath. Przykładowa implementacja tej metody znajduje się poniżej. Wykorzystano w niej wyrażenie XPath w postaci „//part[price<=x]/quantity[poznan>=y]”, gdzie x i y to parametry.

public static void searchParts2(String r_maxPrice, String r_minQuantity) { String expr = "//part[price<=" + r_maxPrice + "]/quantity[poznan>=" + r_minQuantity + "]"; NodeList resultNodes = m_xpe.selectNodes(m_xmlDoc, expr); if (resultNodes != null) for (int i = 0; i < resultNodes.getLength(); i++) { Element partElement = (Element)resultNodes.item(i).getParentNode(); Node name = partElement.getElementsByTagName("name").item(0); System.out.println(name.getFirstChild().getNodeValue()); } }

19. Dodaj do metody main wywołania obu funkcji. Dobierz odpowiednie parametry na podstawie zawartości pliku XML tak, aby uzyskać sensowne wyniki. Ostatecznie metoda main powinna mieć zawartość zbliżoną do następującej.

public static void main(String[] args) { if (readDocument(args[0])) System.out.println("File OK."); else { System.out.println("Problem reading XML file."); System.exit(0); } m_xpe = new XPathEvaluator(); System.out.println("-----------------------"); printOverview(); System.out.println("-----------------------"); searchParts1("600", "4"); System.out.println("-----------------------"); searchParts2("600", "4"); }

20. Uruchom aplikację i sprawdź efekt jej działania.