DOM API - tworzenie dokumentu XML
Co to jest DOM?
DOM (ang. Document Object Model – Obiektowy Model Dokumentu) to niezależny od platformy i języka programowania – sposób prezentacji dokumentów XML i HTML w postaci modelu obiektowego (a raczej struktury „drzewiastej”).
Wstrukturze DOM każdy węzeł zawiera jeden z komponentów struktury XML. Dwa najczęściej spotykane typy węzłów to węzły elementów i węzły tekstowe.
Kiedy używać DOM?
Standard DOM został opracowany głównie z myślą o dokumentach (artykuły, książki itp.). Jako, że DOM od początku projektowany był jako rozwiązania niezależne od jakiegokolwiek języka programowania, nie wykorzystuje możliwości obiektowych, jakie daje Java.
DOM w Javie
Interfejsy służące do obsługi i korzystania z DOM
Implementacja DOM w Javie została umieszczona w dwóch pakietach:
- org.w3c.dom – definiuje interfejs dla DOM API. DOM 2 Core API pozwla programom na dynamiczny dostęp i zmiany w treści i strukturze dokumentów XML i HTML.
- javax.xml.parser – definiuje klasy pozwalające na przetwarzanie dokumentów XML. Obsługuje dwa typy parserów – SAX i DOM. Dla DOM definiuje klasy DocumentBuilderFactory i DocumentBuilder, które służą do utworzenia obiektu implementującego interfejs Document.
Tworzenie dokumentu DOM
Aby stworzyć pusty obiekt typu Document, implementujący interfejs Document można użyć metody newDocument() obiektu DocumentBuilder. Można go też utworzyć przy pomocy jednej z metod parse() obiektu parsera, aby utworzyć obiekt Document z istniejących danych (plik XML) XML.
Klasa DocumentBuilderFactory jest odpowiedzialna za utworzenie nowego parsera DOM. Osiąga się to poprzez wywołanie metody statycznej klasy DocumentBuilderFactory – new.Istance(), która zwraca obiekt typu DocumentBuilderFactory – fabrykę która posłuży do utworzenia obiektu parsera. Aby utworzyć obiekt parsera należy wywołać metodę newDocumentBuilder() obiektu fabryki.
Budowęparsera DOM ilustruje przykład:
//tworzymy fabryke, która posluzy do „produkcji”obiektu klasy DocumentBuilder DocumentBuilderFactory fabryka = DocumentBuilderFactory.newInstance(); //tworzymy obiekt parsera wykorzystujac do tego utworzona wczesniej fabryke DocumentBuilder parser = fabryka.newDocumentBuilder();
Instancję klasy DocumentBuilder (parser) można wykorzystać do utworzenia pustego dokumentu. Aby tego dokonać należy wykonać metodę newDocument(), która zwróci pusty dokument DOM.
Document dokument = parser.newDocument();
Wcelu utworzenia dokumentu można także wykorzystać metodę parse() parsera. W takim wypadku utworzony zostanie dokument DOM, który będzie reprezentacją pliku XML poddanego parsowaniu. Oto przykładowy kod:
Document dokument = parser.parse(plikXML);
Trzeba jeszcze pamiętać o wyjątkach które mogą wystąpić przy tworzeniu fabryki, parsera i samego dokumentu. Oto możliwe wyjątki dla każdej z podanych wyżej metod:
DocumentBuilderFactory.newInstance() - FactoryConfigurationError – jeżeli niedostępna jest implementacja lub albo nie można utworzyć instancji.
DocumentBuilder.newDocumentBuilder() - ParserConfigurationException() - jeżeli DocumentBuilder nie może być utworzony w taki sposób żeby był zgodny z konfiguracją. DocumentBuilder.parse() - IOEception – w przypadku jakiegokolwiek błędu I/O oraz SAXException – jeżeli wystąpił błąd parsowania.
Pełen kod klasy która utworzy pusty dokument DOM będzie więc wyglądał tak:
import org.w3c.dom.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
public class MyDOMDocument {
public static void main(String[] args) {
try {
// tworzymy fabryke, która posluzy do „produkcji” obiektu klasy DocumentBuilder
DocumentBuilderFactory fabryka = DocumentBuilderFactory.newInstance();
// tworzymy obiekt parsera wykorzystujac do tego utworzona wczesniej fabryke
DocumentBuilder parser = fabryka.newDocumentBuilder();
// tworzymy pusty dokument DOM
Document dokument = parser.newDocument();
} catch (Exception exp) {
System.out.println(exp.getMessage());
}
}
}
Tworzenie elementu głównego
Dokument XML musi definiować dokładnie jeden element, nazywany elementem głównym. Wszystkie inne elementy dokumentu muszą być umieszczone wewnątrz elementu głównego.
Aby utworzyć element główny, posłużymy się metodą createElement(). Utworzony element dodamy do dokumentu przy pomocy metody appendChild(). Przykładowy kod wyglądać będzie zatem tak:
// tworzymy element główny (nie musi to być element o nazwie root)
Element root = dokument.createElement("root");
// dodajemy utworzony element do wcześniej utworzonego dokumentu
dokument.appendChild(root);
W ten sposób tworzony przez nas dokument posiada już element główny. Teraz zajmiemy się dodawaniem kolejnych elementów.
Dodawanie elementu komentarza do dokumentu DOM
Komentarze, tak jak znaczniki także są elementami dokumentu DOM. Ich notacja w XMLu jest taka sama jak w HTMLu - <!-- komentarz -->. Aby utworzyć komentarz posłużymy się metodą createComment().
Przykładowy kod:
//mtworzymy obiekt komentarza klasy Comment
Commentmkomentarz = dokument.createComment("Nasz pierszy komentarz");
//dodajemy go jako "dziecko" do elementu glownego
root.appendChild(komentarz);
Zauważmy, że jako parametr metody createComment podajemy tylko tekst komentarza, bez nawiasów otwierających i zamykających komentarz. Należy także zauważyć, że komentarz zostanie dodany jako pierwszy element wewnątrz elementu głównego.
Dodawanie elementu „dziecka” do dokumentu DOM
Dodawanie elementu dziecka odbywa się bardzo podobnie do dodawania elementu głównego. Użyjemy tych samych metod – createElement i appendChild. Dodatkowo istnieje możliwość dodania parametrów dla dodawanego „dziecka”. Umożliwia to metoda setAttribute.
Oto przykładowy kod:
// utworzenie elementu "dziecka"
Element dziecko = dokument.createElement("dziecko");
// nadanie mu atrybutu
dziecko.setAttribute("atrybut1","wartosc atrybutu 1");
// nastepnie tak skonstruowany element dodamy do elemetu glownego
root.appendChild(dziecko);
Dodawanie elementu tekstowego do dokumentu DOM
Dodawanie elementu tekstowego, tak jak w poprzednich przypadkach sprowadza się do utworzenia obiektu odpowiedniego typu i dodanie go do innego elementu. Oto przykład:
// utworzenie nowego elementu tekstowego
Text elementTekstowy = dokument.createTextNode("jakis tekst");
// dodanie go do elementu dziecka
dziecko.appendChild(elementTekstowy);
Tworzenie obiektu przekształcenia
Aby zobaczyć wyniki naszej pracy, użyjemy obiektu przekształcenia, który pomoże nam przekazać dane XML do strumienia wyjściowego (w tym przypadku wykorzystamy standardowy strumień wyjściowy System.out). Potrzebować będziemy obiektu przekształcenia (Transformer) i odpowiedniego dla niego obiektu fabryki (TransformerFactory). Ponieważ do dokonania przekształcenia potrzebujemy źródła danych (będzie nim DOM – wykorzystamy klasę DOMSource) i i strumień wynikowy (StreamResult), musimy wykorzystać odpowiednie klasy.
Kod programu powinien wyglądać następująco:
// utworzenie fabryki transformacji TransformerFactory fabrykaTransformacji = TransformerFactory.newInstance(); // utworzenie transformatora Transformer aTransformer = fabrykaTransformacji.newTransformer(); //utworzenie zrodla DOMSource zrodlo = new DOMSource(dokument); // i strumienia wynikowego Result dest = new StreamResult(System.out); // transformacja zrodla, poprzez transformator do strumienia wyjsciowego aTransformer.transform(src, dest);
Efekt końcowy
Utworzyliśmy dokument DOM zawierający wszystkie niezbędne elementy. Nasza klasa wyglądałaby następująco:
import org.w3c.dom.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
public class MyDOMDocument {
public static void
main(String[] args) {
try {
DocumentBuilderFactory fabryka =
DocumentBuilderFactory.newInstance();
DocumentBuilder parser = fabryka.newDocumentBuilder();
Document dokument = parser.newDocument();
Element root = dokument.createElement("root");
dokument.appendChild(root);
Comment komentarz = dokument.createComment("Nasz pierszy komentarz");
root.appendChild(komentarz);
Element dziecko = dokument.createElement("dziecko");
dziecko.setAttribute("atrybut1", "wartoscatrybutu 1");
root.appendChild(dziecko);
TextelementTekstowy = dokument.createTextNode("jakis tekst");
dziecko.appendChild(elementTekstowy);
TransformerFactory fabrykaTransformacji = TransformerFactory.newInstance();
Transformer aTransformer = fabrykaTransformacji.newTransformer();
DOMSource zrodlo = new DOMSource(dokument);
Result dest = new StreamResult(System.out);
aTransformer.transform(src, dest);
}
catch (Exception exp) {
System.out.println(exp.getMessage());
}
}
}
Podany kod wygeneruje dokument DOM, a następnie wypisze go w oknie konsoli jako dokument XML. Jeżeli wszystko zrobiliśmy dobrze, powinniśmy otrzymać następujący wynik działania programu:
<?xml version="1.0" encoding="UTF-8"?><root><!--Nasz pierszy komentarz--><dziecko atrybut1="wartosc atrybutu 1">jakis tekst</dziecko></root>
Wykorzystane materiały
- http://java.sun.com/j2ee/1.4/docs/tutorial/doc/J2EETutorialFront.html
- http://java.sun.com/j2se/1.5.0/docs/api/index.html
Aby dodawać komentarze musisz być zalogowany!