Przetwarzanie dokumentów XML i zaawansowane …th.if.uj.edu.pl/~trom/XML/xml_07.pdfObiekt zawiera...

Plan

Przetwarzanie dokumentów XMLi zaawansowane techniki WWW

Wykład 07

T. Romanczukiewicz

Jagiellonian University

2009/2010

T. Romanczukiewicz XML 07

Plan

Plan

1 SAX


SAX Przypomnienie Wstep Typy danych Unmarshalling Dodawanie Nowych elementów

Plan

1 SAXPrzypomnienieWstepTypy danychUnmarshallingDodawanie Nowych elementów



XML, poprawnie sformuowanieSposoby opisu XML

DTDXML Schema

XPATHSposoby prezentacji

CSSXSLT

DOM

SAX



DOM

DOM i SAX

Parser DOM wczytuje cały dokument do pamieci i tworzy obiekt DOM przechoujacdane w strukturze drzewa.

DOM pozwala na swobone poruszanie sie po drzewie dokumentu.

W przypadku przetwarzania duzych i skomplikowanych plików XML moga zostaczuzyte spore zasoby pamieciowe.

SAX nie wczytuje całego dokoumentu lecz działa jak parser strumieniowysterowany zdarzeniami.

Zdarzenia sa zgłaszane gdy zostanie napotkany np element, dane tekstowe czyprzestrzen nazw.

Obsługe zdarzen nalezy zaimplementowac.

SAX nie umozliwia uzyskania swobodnego dostepu do dokumentu XML

Przetwarzanie z uzyciem SAX jest jednokierunkowe - wczesniej przetworzonedane nie moga byc ponownie odczytane bez ponownego uruchomienia całejprocedury.

Wymagania pamieciowe SAX sa znacznie mniejsze nizz DOM.



JAXB

JAXB - Java Architecutre for XML Binding

Kolejny standard definiujacy dostep do plików XML-owych z poziomu jezykaprogramowania.

Obecnie najbardzie promowany jest przez Suna, ale dostepne sa równiez inneimplementacje.

JAXB nie posiada nie ma tu ogólnego interfejsu do parsowania plików.

Interfejs tworzony na podstawie DTD lub XML-Schemy.

Dostajemy kompilator schematów (lub dtd), który z tych schematów generujeklasy - dla kazdego elementu XML powstaje jedna klasa.

Inne podobne narzedzia: Castor, XMLBeans (Apache),



JAXB a SAX i DOM

Zalety w stosunku do DOM-a:mniejsze wymagania pamieciowe, dzieki temu, ze nie ma narzutu na generycznoscDOM-a, w pamieci jest tylko to co trzebabardziej intuicyjny dostep do dokumentu, dzieki temu nie trzeba znac strukturydokumentuDTD nie jest interpretowane, tylko zaszyte w kodzie - dzieki temu wieksza wydajnosc

Zalety w stosunku do SAX-a:łatwiejszy dostep do pliku - cały plik jest w pamieciSAX jest read-only, a JAXB umozliwia modyfikacje i zapisywanie do pliku.Model danych w SAX trzeba było tworzyc samodzielnie.



Podstawowe operacje udostepniane przez JAXB

Generowanie klas. XML Schema jest uzywana przez kompilator JAXB bindingcompiler xjc do wygenerowania klas w oparciu o XML Schema

Kompilowanie klas.

Unmarshalling - zamiana pliku XML na obiekty Javove

Modyfikacja dokumentu XML (na kopii z pamieci)

Walidacja - sprawdzenie poprawnosci z DTD (takze dokonywane na dokumenciew pamieci)

Marshalling - zamiana obiektów Javy na dokument XML



JAXB - Przykład

https://jaxb.dev.java.net/tutorial/section_1_3-Hello-World.html

Listing 1: hello.xsd

1 <?xml version="1.0" encoding="UTF-8"?>2 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"3 xmlns:jxb="http://java.sun.com/xml/ns/jaxb" jxb:version="2.0">45 <xsd:element name="Greetings" type="GreetingListType"/>6 <xsd:complexType name="GreetingListType">7 <xsd:sequence>8 <xsd:element name="Greeting" type="GreetingType" maxOccurs="unbounded"/

>9 </xsd:sequence>

10 </xsd:complexType>1112 <xsd:complexType name="GreetingType">13 <xsd:sequence>14 <xsd:element name="Text" type="xsd:string"/>15 </xsd:sequence>16 <xsd:attribute name="language" type="xsd:language"/>17 </xsd:complexType>18 </xsd:schema>



Listing 2: Wywołanie kompilatora JAXB Schema

1 $ xjc -p hello hello.xsd2 parsing a schema...3 compiling a schema...4 hello/GreetingListType.java5 hello/GreetingType.java6 hello/ObjectFactory.java

Zostały wygenerowane trzy klasy (wraz z dokładnym javadociem), GreetingType iGreetingListType odpowiadajace zadeklarowanym typom w schemacie orazObjectFactory:

Listing 3: GreetingType

1 public class GreetingType {2 (...)3 public String getText() { return text; }4 public void setText(String value) { this.text = value; }5 public String getLanguage() { return language; }6 public void setLanguage(String value) { this.language = value; }7 (...)8 }

Klasa GreetingType posiada metody do odczytywania i modyfikowania zawartoscitekstowej elementu oraz atrybutu.



Listing 4: GreetingListType

1 public class GreetingListType {23 @XmlElement(name = "Greeting", required = true)4 protected List<GreetingType> greeting;56 public List<GreetingType> getGreeting() {7 if (greeting == null) {8 greeting = new ArrayList<GreetingType>();9 }

10 return this.greeting;11 }12 }

Aby dodac element do listy: getGreeting().add(newItem);



Listing 5: ObjectFactory

1 public class ObjectFactory {2 private final static QName _Greetings_QNAME = new QName("", "Greetings");3 public ObjectFactory() {}4 /∗ Cr ea t e an i n s t a n c e o f G r e e t i n g L i s t T y p e ∗ /5 public GreetingListType createGreetingListType()6 { return new GreetingListType(); }7 public GreetingType createGreetingType()8 { return new GreetingType(); }9

10 @XmlElementDecl(namespace = "", name = "Greetings")11 public JAXBElement<GreetingListType> createGreetings(GreetingListType value)12 { return new JAXBElement<GreetingListType>(_Greetings_QNAME,

GreetingListType.class, null, value); }1314 }

Obiekt zawiera metody wytwórcze (ang. factory methods) dla kazdego interfejsuzawartosci i elemetu

ObjectFactory pozwala tworzyc nowe instancje reprezentacji dokumentu XML



Przykładowe uzycie

Listing 6: Hello

1 public class Hello {23 private ObjectFactory of;4 private GreetingListType grList;56 public Hello(){7 of = new ObjectFactory();8 grList = of.createGreetingListType();9 }

1011 public void make( String t, String l ){12 GreetingType g = of.createGreetingType();13 g.setText( t );14 g.setLanguage( l );15 grList.getGreeting().add( g );16 }1718 public void marshal() {19 try {20 JAXBElement<GreetingListType> gl = of.createGreetings( grList );21 JAXBContext jc = JAXBContext.newInstance( "hello" );22 Marshaller m = jc.createMarshaller();23 m.marshal( gl, System.out );24 } catch( JAXBException jbe ){25 / / . . .26 }27 }28 }



Konstruktor tworzy obekt korzystajac z metody wytwórczej aby stworzyc elementgłówny XML typu GreetingListType.

Metoda make dodaje element do listy wraz z tekstem i atrybutem language.

wywołujac metode marshal lista zamieniana jest na XML i wypisywana nastandardowe wyjscie.

Listing 7: Uzycie

1 Hello h = new Hello();2 h.make( "Bonjour, madame", "fr" );3 h.make( "Hey, you", "en" );4 h.make( "Yo nopot, kivanok", "hu" );5 / / h t t p : / / demotywatory . p l / 1 0 6 8 8 3 6 / D z i e c i−w−Norweg i i6 h.marshal();



Co prawda dane w XML sa przechowywane zawsze jako tekst, ale dzieki schematommozna dokładniej okreslic typ tych danych. Dane te moga byc mapowane na typy Javy.Przykład:

Listing 8: Typy

1 <xsd:simpleType name="GroupType">2 <xsd:restriction base="xsd:int">3 <xsd:minInclusive value="1"/>4 <xsd:maxInclusive value="255"/>5 </xsd:restriction>6 </xsd:simpleType>

Listing 9: Wynik xjc

1 public class ElementType {2 protected int group;3 public int getGroup() { return group; }4 public void setGroup(int value) { this.group = value; }5 }

Typ <xsd:restriction base="xsd:int"> został zinterpretowany jako int, ale w całej klasienie ma obsługi ograniczen podanych w schemacie.

Uwaga!

JAXB nie dostarcza mechanizmów chroniacych zakres, pattern i inne zawezeniaschematu. Wszystko to jest sprawdzane dopiero w momencie walidacji.



XML Schema Type Java Data Typexsd:string java.lang.Stringxsd:integer java.math.BigIntegerxsd:int intxsd.long longxsd:short shortxsd:decimal java.math.BigDecimalxsd:float floatxsd:double doublexsd:boolean booleanxsd:byte bytexsd:QName javax.xml.namespace.QNamexsd:dateTime java.util.Calendarxsd:base64Binary byte[]xsd:hexBinary byte[]xsd:unsignedInt longxsd:unsignedShort intxsd:unsignedByte shortxsd:time java.util.Calendarxsd:date java.util.Calendarxsd:anySimpleType java.lang.String



Listing 10: Listy

1 <xsd:simpleType name="NumberListType">2 <xsd:list itemType="xsd:int"/>3 </xsd:simpleType>45 <xsd:simpleType name="StringListType">6 <xsd:list itemType="xsd:string"/> <!−− dangerous ! −−>7 </xsd:simpleType>

W pierwszym przypadku zostanie utworzona listaprotected List<Integer>numbers = new ArrayList<Integer>();

Analogiczie w drugim przypadku, ale w XML reprezentacja bedzie lista wartoscioddzielonych białymi znakami. Jesli wartosci beda posiadały białe spacje to moze bycproblem. Zaleca sie zatem stosowanie typów złozonych.



Równiez <xsd:all>, <xsd:union>, <xsd:choice> oraz <xsd:sequence> moga bycpowiazane z niektórymi strukturami danych Javy takimi jak array, list, structure (lubrecord) i union.

Listing 11: sequence

1 <xsd:complexType name="PointType">2 <xsd:sequence>3 <xsd:element name="X" type="xsd:int"/>4 <xsd:element name="Y" type="xsd:int"/>5 </xsd:sequence>6 </xsd:complexType>

wynik kompilowania

Listing 12: sequence w javie

1 public class PointType {2 protected int x;3 protected int y;45 public int getX() { return x; }6 public void setX(int value) { this.x = value; }7 public int getY() { return y; }8 public void setY(int value) { this.y = value; }9 }



Listing 13: xsd:union

1 <xsd:simpleType name="SpeedOrNumberType">2 <xsd:union>3 <xsd:simpleType>4 <xsd:restriction base="xsd:int">5 </xsd:restriction>6 </xsd:simpleType>7 <xsd:simpleType>8 <xsd:restriction base="xsd:string">9 <xsd:pattern value="+?d+"/>

10 </xsd:restriction>11 </xsd:simpleType>12 </xsd:union>13 </xsd:simpleType>

Jako typ prosty unia zostanie powiazana ze zmienna typu String.

Listing 14: xsd:all

1 <xsd:complexType name="DinnerType">2 <xsd:all>3 <xsd:element name="Starter" type="xsd:string" minOccurs="0"/>4 <xsd:element name="Soup" type="xsd:string" minOccurs="0"/>5 <xsd:element name="Entree" type="xsd:string"/>6 <xsd:element name="Dessert" type="xsd:string" minOccurs="0"/>7 </xsd:all>8 </xsd:complexType>

Zostanie utworzona klasa zawierajaca zmienne starter, soup itd.Uwaga! maxOccurs nie moze miec wartosci wiekszej niz 1.



Listing 15: xsd:enumeration

1 <xsd:simpleType name="IXLType">2 <xsd:restriction base="xsd:string">3 <xsd:enumeration value="eStwA"/>4 <xsd:enumeration value="eStwS"/>5 <xsd:enumeration value="SpDrL"/>6 <xsd:enumeration value="SpDrS"/>7 <xsd:enumeration value="VGS80"/>8 </xsd:restriction>9 </xsd:simpleType>

10 \begin{lstlisting}

Listing 16: xsd:enumeration w Javie

1 public enum IXLType {23 E_STW_A("eStwA"),4 E_STW_S("eStwS"),5 SP_DR_L("SpDrL"),6 SP_DR_S("SpDrS"),7 VGS_80("VGS80");89 private final String value;

1011 IXLType(String v) {12 value = v;13 }1415 public String value() {16 return value;17 }18 }




1 <xsd:simpleType name="IXLType">2 <xsd:restriction base="xsd:string">3 <xsd:enumeration value="eStwA"/>4 <xsd:enumeration value="eStwS"/>5 <xsd:enumeration value="SpDrL"/>6 <xsd:enumeration value="SpDrS"/>7 <xsd:enumeration value="VGS80"/>8 </xsd:restriction>9 </xsd:simpleType>


1 public enum IXLType {23 E_STW_A("eStwA"),4 E_STW_S("eStwS"),5 SP_DR_L("SpDrL"),6 SP_DR_S("SpDrS"),7 VGS_80("VGS80");89 private final String value;

10 IXLType(String v) { value = v;}11 public String value() { return value; }12 }

Nazwy zostały zmienione.



Mozna tez w taki sposób:


1 <xsd:simpleType name="IXLType">2 <xsd:restriction base="xsd:string">3 <xsd:enumeration value="eStwA"/>4 <xsd:annotation><xsd:appinfo>5 <jxb:typesafeEnumMember name="eStwA"/>6 </xsd:appinfo></xsd:annotation>7 ...8 </xsd:restriction>9 </xsd:simpleType>

Uwaga: w schemacie musi zostac dołaczona przestrzen nazwxmlns:jxb="http://java.sun.com/xml/ns/jaxb"


1 public enum IXLType {23 eStwA,4 eStwS,5 SpDrL,6 SpDrS,7 VGS80;89 public String value() { return name(); }

10 ...11 }



UnmarshallingPo powiazaniu klas Javy z typami XML Schema przy pomocy xjc mozna przystapic dowczytywania danych.

Unmarshalling

czyli zamiana pliku XML na obiekty Javy

Najporosciej utworzyc obiekt JAXBContext, nastepnie Unmarshaller i wywołacmetode unmrshal.

Obiekt JAXBContext zawiera informacje wiazace informacje pomiedzy XML i Java.

Mozna go utworzyc przy pomocy metody newInstance z parametrem bedacymnazwa pakietu utworzonego przez xjc

Z tego kontekstu mozna utworzyc obiekt Unmarshaller, którego metoda unmarshal

zwraca obiekt JAXBElement powiazany z elementem głównym dokumentu.


1 public <T> T unmarshal( Class<T> docClass, InputStream inputStream )2 throws JAXBException {3 String packageName = docClass.getPackage().getName();4 JAXBContext jc = JAXBContext.newInstance( packageName );5 Unmarshaller u = jc.createUnmarshaller();6 JAXBElement<T> doc = (JAXBElement<T>)u.unmarshal( inputStream );7 return doc.getValue();8 }



Walidacja

Przed wprzekształceniem danych z dokumentu XML na obiekty Javy mozna wykonacwalidacji.Sam JAXB nie stosuje sie do ograniczen narzuconych przez schemat. Nalezy zatem teoperacje przeprowadzic przed porocedura unmarshal i po marshal.Słuza do tego obiekt klasy javax.xml.validation.Schema, który zostaje przekazany doobiektu Unmarshaller.

Listing 22: Walidacja

1 Schema mySchema;2 SchemaFactory sf =3 SchemaFactory.newInstance( XMLConstants.W3C_XML_SCHEMA_NS_URI );4 try {5 mySchema = sf.newSchema( file );6 } catch( SAXException saxe ){7 / / . . . ( e r r o r h a n d l i n g )8 mySchema = null;9 }

1011 JAXBContext jc = JAXBContext.newInstance( packagePath );12 Unmarshaller u = jc.createUnmarshaller();13 u.setSchema( mySchema );

W przypadku gdy walidacja zawiedzie zostanie rzucony wyjatek. Wyjatki takie mogebyc obsługiwane przez interfejs javax.xml.bind.ValidationEventHandler



Kontekst JAXB

Obiekt JAXBContext tworzony jest na samym poczatku operacji wczytywania plikuXML.

Mozna go utworzyc np.JAXBContext ctxt = JAXBContext.newInstance( "some foo:more.bar"); gdziedwukropkiem oddziela sie pakiety.

Kazdy pakiet musi zawierac klase ObjectFactory lub plik jaxb.index:

Listing 23: jaxb.index

1 # package some . f o o2 # c l a s s some . f o o . Foo3 Foo4 # i n n e r c l a s s some . f o o . Foo . Boo5 Foo.Boo

zawierajacy liste klas w danym pakiecie.

Klasy ObjectFactory sa generowane ze schematu

Innym sposoblem utworzenia kontekstu jest podanie listy wszystkich klas:JAXBContext ctxt = JAXBContext.newInstance( Foo.class, Bar.class );



Uzycie danych

Dane mozna odczytywac przy pomocy metod typu get a zapisywac przy pomocymetod typu set. Wygodniej jest jednak stworzyc klasy obsługujace poszczególne typyschematu. Ich metody moga przetwarzac atrybuty i elementy potomne wywołujac ichhandlery.

Listing 24: XML Schema

1 <xsd:complexType name="PersonType">2 <xsd:sequence>3 <xsd:element name="Name" type="NameType">4 <xsd:element name="Addr" type="AddrType" minOccurs="0">5 <xsd:element name="Child" type="ChildType" minOccurs="0" maxOccurs="

unbounded">6 </xsd:sequence>7 <xsd:attribute name="resident" type="xsd:boolean"/>8 </xsd:complexType>9

10 <xsd:complexType name="ChildType">11 <xsd:complexContent>12 <xsd:extension base="PersonType"/>13 </xsd:complexContent>14 </xsd:complexType>



Uzycie danych c.d

Listing 25: Handler classes

1 abstract class Handler {2 protected static Map<Class<?>,Handler> ourClass2Conv = new HashMap<Class<?>,

Handler>();34 static {5 ourClass2Conv.put( PersonType.class, new PersonHandler() );6 ourClass2Conv.put( NameType.class, new NameHandler() );7 ourClass2Conv.put( AddrType.class, new AddrHandler() );8 ourClass2Conv.put( ChildType.class, new ChildHandler() );9 / / . . .

10 }11 public abstract void handle( Object o );12 protected void process( Object obj ){13 if( obj != null ){14 Handler h = ourClass2Conv.get( obj.getClass() );15 if( h != null ){ h.handle( obj ); }16 }17 }1819 protected <T> void processList( List<T> list ){20 for( T obj: list ){21 Handler h = this.getHandler( obj );22 h.process( obj );23 }24 }25 }



Uzycie danych c.d

Listing 26: Handler classes

1 class PersonHandler extends Handler {2 public void handle( Object o ){3 PersonType p = (PersonType)o;4 process( p.getName() );5 if( p.isResident() ){ process( p.getAddr() ); }6 processList( p.getChild );7 }8 }



ObjectFactoryJedna z klas wygenerowanych przez xjc jest klasa ObjectFactory. Klasa ta zawierametody do tworzenia celementów reprezentowanych przez objekty JAXBElement<?>:


1 ObjectFactory objFact = new ObjectFactory();2 RulebaseType rulebase = objFact.createRulebaseType();3 JAXBElement<RulebaseType> doc = objFact.createRulebase( rulebase );

rulebase - znacznik elementu głównego.proste elementy nie potrzebuja JAXBElement<?>. Mozna je utworzyc bezposrednio zwywołania metody:ModuleType module = objFact.createModuleType();

Objekt JAXBElement<?> jest wymagany w przypadku elementów zawierajacychsekwencje elementów tego samego typu ale o innych znacznikach:

Listing 28: Przykład

1 <xsd:complexType name="FooBarListType">2 <xsd:sequence>3 <xsd:choice minOccurs="0" maxOccurs="unbounded">4 <xsd:element name="foo" type="FooBarType"/>5 <xsd:element name="bar" type="FooBarType"/>6 </xsd:choice>7 </xsd:sequence>8 </xsd:complexType>



ObjectFactory c.d.


1 FooBarListType fblElem = objFact.createFooBarListType();2 List<JAXBElement<FooBarType>> fbList = fblElem.getFooOrBar();34 / / c r e a t e a " f o o " e l e m e n t5 FooBarType foo = objFact.createFooBarType();6 / / . . . ( add a t t r i b u t e s and components t o f o o )7 / / Cr ea t e t h e e l e m e n t <foo > . . . < / foo >8 JAXBElement<FooBarType> fooElem = objFact.createFooBarTypeFoo( foo );9 / / Add i t t o i t s p a r e n t ’ s l i s t .

10 fbList.add( fooElem );1112 / / c r e a t e a " bar " e l e m e n t13 FooBarType bar = objFact.createFooBarType();14 / / . . . ( add a t t r i b u t e s and components t o bar )15 / / Cr ea t e t h e e l e m e n t <bar > . . . < / bar >16 JAXBElement<FooBarType> barElem = objFact.createFooBarTypeBar( bar );17 / / Add i t t o i t s p a r e n t ’ s l i s t .18 fbList.add( barElem );



Aby dodac element potomny x wewnatrz elementu current (np. głównego) nalezy

Stworzyc element xElem przy pomocy metody createX.

Dodac nowo stworzony current.setX( xElem ).

Powtórzyc ten proces rekurencyjnie dla elementów potomnych nowego elementu

Listing 30: Dodawanie nowych obiektów

1 / / Cr ea t e o r d e r and i n s e r t i n top−l e v e l document , a l i s t o f o r d e r s2 OrderType orderElem = objFact.createOrderType();3 folder.getOrders().add( orderElem );45 / / Cr ea t e and i n s e r t t h e c u s t o m e r e l e m e n t .6 CustomerType custElem = objFact.createCustomerType();7 orderElem.setCustomer( custElem );8 / / Comple te c u s t o m e r .9 custElem.setId( custId );

10 custElem.setName( custName );1112 / / Cr ea t e and add i t e m e l e m e n t s .13 List<ItemType> itemList = orderElem.getItems();14 for( Item item: items ){15 ItemType itemElem = objFact.createItemType();16 itemList.add( itemElem );17 itemElem.setId( item.id );18 itemElem.setQuantity( item.qtty );19 }



Dodawanie Nowych elementów c.d.

Listing 31: schemat

1 <xsd:complexType name="CustomerType">2 <xsd:sequence>3 <xsd:element name="id" type="xsd:int"/>4 <xsd:element name="name" type="xsd:string"/>5 </xsd:sequence>6 </xsd:complexType>78 <xsd:complexType name="ItemType">9 <xsd:sequence>

10 <xsd:element name="id" type="xsd:string"/>11 <xsd:element name="quantity" type="xsd:int"/>12 </xsd:sequence>13 </xsd:complexType>1415 <xsd:complexType name="OrderType">16 <xsd:sequence>17 <xsd:element name="customer" type="CustomerType"/>18 <xsd:element name="items" type="ItemType" maxOccurs="unbounded"/>19 </xsd:sequence>20 </xsd:complexType>2122 <xsd:element name="folder">23 <xsd:complexType>24 <xsd:sequence>25 <xsd:element name="orders" type="OrderType" maxOccurs="unbounded"/>26 </xsd:sequence>27 </xsd:complexType>28 </xsd:element>



Marshalling

Koncowym etapem tworzenia lub modyfikowania dokumentu XML jest procedurazwana Marshalling.Po utworzeniu oblektu Marshaller z obiektu JAXBContext mozna ustawic szeregwłasciwosci (np ustawianie formatowania wydruku, sposobu dołaczenia schematu,strony kodowej itp.)

Listing 32: Marshalling

1 import java.io.*;2 import javax.xml.bind.*34 void writeDocument( Object document, String pathname )5 throws JAXBException, IOException {6 Class<T> clazz = document.getValue().getClass();7 JAXBContext context =8 JAXBContext.newInstance( clazz.getPackage().getName() );9 Marshaller m = context.createMarshaller();

10 m.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE );11 m.marshal( document, new FileOutputStream( pathname ) );12 }



JAXB

JAXB jest architektura powiazan pomiedzy XML i klasami Javy

Najpierw na poodstawie XML Schema generowane sa klasy odpowiadajacetypom zadeklarowanym w schemacie.

Klasy te zawieraja metody do czytania i manipulacji obiektami reprezentujacymielementy XML

Typy Javy nie zachowuja restrykcji nakładanych w schemacie.

Przed wczytaniem danych lub po ich zapisaniu do pliku mozliwa jest walidacja.

Generowana jest tez klasa ObjectFactory pozwalajaca tworzyc nowe instancjereprezentacji dokumentu XML

Dokument XML wczytywany jest w trakcie procedury Unmarshalling na podstawiekontekstu zawierajacego informacje o pakiecie.

Po modyfikacji zmiennych mozna zapisac dane do pliku przy pomocy metodyMarshalling



JAXB a DOM i SAX

DOM wczytywał cały dokument do pamieci

Dane przechowywane były w uniwerslanej strukturze drzewa

Dzieki odpowiednim metodom mozna sie było poruszac po całym drzewiedokumentu

SAX przetwarzał dokument w trakcie czytania.

Aby stworzyc model danych nalezało samemu go zaimplementowac.

SAX przetwarzał dokument jednokierunkowo.

JAXB sam tworzy strukture danych na podstawie istniejacego juz schematu.

Do danych jest dostep cały czas.


Przetwarzanie dokumentów XML i zaawansowane …th.if.uj.edu.pl/~trom/XML/xml_07.pdfObiekt zawiera...

Documents

Transcript of Przetwarzanie dokumentów XML i zaawansowane …th.if.uj.edu.pl/~trom/XML/xml_07.pdfObiekt zawiera...