11 Lyhyesti XML-sovellusohjelmoinnista Jos sopivaa XML-sovellusta ei löydy valmiina, voi sellaisen ohjelmoida itse. XML-sovellusohjelmointi ei oleellisesti poikkea "muusta sovellusohjelmoinnista"; kyse on vain tiettyjen annettujen rajapintojen (yl. SAX/ DOM-variantteja) parissa tapahtuvasta työskentelystä. Tässä yhteydessä tarkastelemme asiaa varsin pintapuolisesti. Kuten ohjelmoinnissa yleensä, myös XML-sovelluksen ohjelmoinnin helppous tai vaikeus riippuu lähinnä sovelluksesta (reunaehdot ja riippuvuudet). 213
11.1 XML-sovellusohjelmoinnin arkkitapaukset Kaikki sovellukset on joku tietenkin ohjelmoinut XMLsovellusohjelmoinnin avulla voidaan siis "tehdä mitä tahansa" Käytännössä pihvi käy ilmi tyypillisistä käyttötapauksista: 1. halutaan lukea tietyn tekstiformaatin mukainen XML-dokumentti ja kansoittaa sen sisältämien tietojen avulla oman ohjelman tietorakenne 2. halutaan toteuttaa oma (standardinmukainen) käsittelijä esim. XSLTprosessoriin, Cocooniin, tms. 3. halutaan hyödyntää jonkun toisen tekemää XML-ohjelmaa/sovellusta 4. halutaan tuottaa XML-dokumentteja ohjelmallisesti (!) On tietenkin melko hankalaa esim. kirjoittaa uusi verkkoselain tai hyvä XMLeditori (tyhjästä) sovellusten pulmat eivät siis usein liity XML:ään sinänsä 214
11.2 Pari sanaa suunnittelumalleista Suunnittelumalli (design pattern) on ohjelmistosuunnittelun menetelmällinen työväline jonka avulla pyritään ratkomaan usein toistuvia ohjelmointitehtäviä hyväksi havaittujen (abstraktien) ratkaisumallien avulla - esim. delegation, interface, factory, filter, treewalker - esim. m2csv.xsl voidaan tulkita adapter-suunnittelumallin mukaan XML-ohjelmoinnissa esim. (1) event listener ja (2) iterator - 1: Olio R lukee tietovirtaa. Olio EL rekisteröityy kuuntelijaksi (kiinnostunut tapahtumista a ja b). Kun A havaitsee tapahtuman a tai b, se välittää tiedon rekisteröityneille kuuntelijoille (myös EL:lle). - 2: Olio IT käy tietorakenteen (esim. lista) T läpi sopivassa järjestyksessä. IT:tä käyttävä sovellus voi läpikäydä T:n ilman sen sisäistä tuntemusta. Periaatteessa jopa itse XML-prosessori voidaan tulkita suunnittelumalliksi 215
11.3 XML-sovellusohjelmoinnin "kaksi tasoa" (1/2) "Matalan tason" ohjelmointi lähtee liikkeelle XML-dokumenteista tietorakenteina: ohjelmointia tavallisilla C/C++/Java/... -kehitysvälineillä 1. Tapahtumapohjainen ohjelmointi (SAX-rajapinta [Simple API for XML]) 2. DOM-pohjainen ohjelmointi (DOM-rajapinta [Document Object Model]) xml-dok. XML-prosessori (non-validating/ validating/ns/no-ns) SAX DOM Sovellus 1 Sovellus 2... 216
11.4 XML-sovellusohjelmoinnin "kaksi tasoa" (2/2) "Korkeamman tason" sovelluskehitys hyödyntää standardisovelluksia (?- prosessorit,?-komponentit) - sovelluksen kuvaaminen prosessorin/komponentin avulla tai sen syötteenä/vasteena (esim. XQuery, XSLT, Web Services,...; kyselyt/filtterit/ muunnokset/viestit/...) "Tasot" eivät tietenkään ole poissulkevia (vrt. juuri XSLT & SAXohjelmointi) 217
11.5 XML-sovellusohjelmoinnista (1/2): Välineet Leijonaosa XML-sovelluksista kirjoitetaan Java-kielellä (vrt. kurssikirjan esimerkit) Muita yleisesti käytettäviä välineitä ovat esim. C/C++, Python, Perl, PHP,... Huomaa että esim. ohjelmointikieli ja kehitysympäristö (resurssienhallinta, työtila, editorit, yms.) voidaan yleensä vaihtaa toisistaan riippumatta XML-ohjelmointi eri ohjelmointikielillä on perusidealtaan samanlaista, mutta välinekohtaiset toteutukset (ja lisät) tuovat työhön omia erityispiirteitään - Esim. Java/C++: Xerces, Perl: XML::Parser, Python: xml.* - eri toteutusten taustalta löytyy usein samoja (alun perin C-kielellä kirjoitettuja) jäsentimiä 218
11.6 XML-sovellusohjelmoinnista (2/2): Suunnittelu XML-sovelluskehityksen taustalla on (jo nimensä mukaisesti) sisäänrakennettu kytkös XMLteknologiaperheen ja välineiden kanssa (XML-sovellus)ohjelmoinnissa voidaan nähdä kaksi keskeistä sovelluskenttää (vrt. käyttötapaukset): - prosessorimaiset sovellukset (esim. tuotetietojen koostaminen osana putkilinjastoa) - reaktiiviset sovellukset (esim. interaktiivinen, käyttöliittymätapahtumiin reagoiva XHTML- tai SVG-sovellus, taustalla erillinen sovelluslogiikka) Web-taustastaan huolimatta XML-tekniikka ei vaadi sovelluksilta esim. Internet-yhteyttä. Kaikki välineet eivät myöskään ole ilmaisia (!) Integroitujen Web-sovellusten näkökulma tarjoaa runsaasti mahdollisuuksia kehittäjälle; samalla sovellusten näkökulma tyypillisesti kasvaa yrityksen ja yksilön tasolta organisaation tai yhteisön tasolle 219
11.7 SAX: Simple API for XML SAX (1/2) on tapahtumapohjainen rajapinta XML-dokumenttien käsittelyyn <?xml version="1.0" encoding="iso-8859-1"?> <muistio pvm="2004-03-22"> <luokitus>hpn-projekti</luokitus> <otsikko>uusi tilaus tulossa?</otsikko> <kirjoittaja>teuvo Oinas</kirjoittaja> <asia> Brasilian tehdas on pyytänyt arvion Soijakattilan uusimisen kustannuksista. <!-- Sirpa korjasi kirjoitusvirheet 2004-03- 23. --> </asia> </muistio> - lähdedokumentin loogiset osat nähdään siinä järjestyksessä kun ne tulevat dokumenttia luettaessa vastaan (v1 ei osaa tallettaa tiedostoja, eikä ymmärrä nimiavaruuksia) SAX-pohjaisen XMLohjelman idea ~ startdocument() startelement("muistio") startelement("luokitus") characters("hpnprojekti") endelement("luokitus") startelement("otsikko")... endelement("muistio") enddocument() 220
11.8 SAX-ohjelmoinnin tyypillisiä käyttötapauksia Tyypillinen motiivi - ohjelman nopea suoritus ja pieni koko (myös muistinkulutuksen osalta) - käsittelijöiden kirjoittamisen helppous ("suurin pulma on etsiä dokumentaatiosta miten oma SAX-käsittelijä rekisteröidään") Esimerkkejä - Halutaan lukea XML-dokumentin tietoja konfiguraatiotiedostojen hengessä - Halutaan kirjoittaa SAX-käsittelijä johonkin XML-prosessoriin (esim. laajennuksena SAX-käsittelijä XSL-muuntimeen) Hankaluuksia: - vähääkään monimutkaisempi sovellus edellyttää oman (...puumaisen?) tietorakenteen rakentamista (tai assosiatiivisia taulukoita ) Tarkastellaan seuraavassa havainnollisuuden vuoksi XML-sovelluksen kirjoittamista aluksi Perl-kielellä, XML::Parser-moduulin nojautuen 221
11.9 Yksinkertaista XML-sovellusohjelmointia Perlillä Perl (Practical Expression Report Language) on erittäin suosittu (tulkattava) ohjelmointikieli (suosittu "skriptikieli") joka soveltuu hyvin esim. *nixtyyppisten käsittelijöiden toteuttamiseen - useita versioita - hyvä ja dokumentoitu pakettikirjasto, moduulit - dynaaminen tyypitys, nopea (käännös tavukoodiksi ennen suoritusta) - olio-ohjelmoinnin piirteet (niin haluttaessa...) Perlin "erikoisuus" on mahdollisuus kirjoittaa hyvin tiivistä syntaksia (=rivimäärässä lyhyitä mutta monipuolisia ohjelmia) sekä säännönmukaisten lausekkeiden (regular expression) vahva rooli sovelluksissa Perl-ohjelmoinnin vahvuus (ja heikkous) on dynaamisten tietorakenteiden avulla (skalaarit, taulukot ja listat, assosiatiiviset taulukot) helposti ja nopeasti toteutettavat tietorakenteet (yms. quick and dirty -ohjelmoinnin riskit) 222
11.10 Pieni tapahtumaohjattu XML-käsittelijä (Perl) Huomaa dokumentin lukujärjestykseen sidottu käsittely (kirjanpito!) use XML::Parser; $parser = new XML::Parser( Handlers => { Start => \&element_start, End => \&element_end, Char => \&characters}); $in_right_album = 0, @lens=(), $in_right_name, $name=""; sub element_start { my ($xp, $element, %attr) = @_; if ($element eq "album" && $attr{id} eq "ds") { $in_right_album = 1; } if ($element eq "track" && $in_right_album==1) { $v = $attr{len}; $v =~ s/m/\./; $v =~ s/s//; push(@lens, $v+0); } if ($element eq "name" && $in_right_album==1) { $in_right_name = 1; 223
} } sub element_end { my ($xp, $element) = @_; if ($element eq "album" && $in_right_album==1) { $in_right_album = 0; } if ($element eq "name" && $in_right_name==1) { $in_right_name = 0; } } sub characters { my ($xp, $text) = @_; if ($in_right_name==1) { $name.= $text; } } $parser->parsefile('music.xml'); print "$name \n"; foreach my $k (@lens) { print "$k "; } 224
11.11 DOM: Document Object Model DOM (1/2/3) on objektipohjainen rajapinta XML-dokumenttien käsittelyyn - dokumentti jäsennetään ensin objektipuuksi, jossa voidaan liikkua solmusta toiseen kyselyjen ja iteraattoreiden avulla - vapaa liikkuminen puurakenteessa (monimutkaisuus ja muistinkulutus) DOM-pohjaisen XML-ohjelman idea ~ <muistio> @pvm <luokitus> <otsikko> 2004-03... HPN-pro... Uusi while( (child=iterator.nextnode())!=null) { } process(child); <kirjoittaja <asia> Teuvo O... Brasilian..... Element liiteelement = doc.createelement("liite"); inode.appendchild(liiteelement);... 225
11.12 Yksinkertaista XML-sovellusohjelmointia Pythonilla Python (nimi tulee Monty Pythonista...) on korkean tason ohjelmointikieli - useita versioita - hyvä ja dokumentoitu pakettikirjasto, moduulit - dynaaminen tyypitys, melko nopea (oletusarvoisesti tulkattava) - todella selkeä oliokieli, helppo kehittää myös olio-ohjelmia iteratiivisesti - suosio vahvassa kasvussa Python "erikoisuuksia" ovat syntaksi (pakotettu ohjelmakoodin sisennys) ja esim. tehokas listojen käsittely (esim. taulu[:1]) Python-ohjelmoinnin vahvuus on olio-ohjelmoinnin ja skriptikielen "hyvien piirteiden" onnistunut yhdistäminen, keskeisin heikkous lienee hitaiden ohjelmien kirjoittamisen helppous (koska paljon korkean tason välineitä on käytössä jo itse kielen tasolla) 226
11.13 Pieni DOM-pohjainen sovellus (Python) import xml.dom; Lask. kpl pituudet yhteen ja lisätään attr @total from xml.dom.minidom import Node, Attr from fpformat import fix; doc = xml.dom.minidom.parse("music.xml"); nodes = doc.getelementsbytagname("album"); # Taas karseita olettamuksia kappaletietojen formaatin suhteen...(mitä?) for k in range(len(nodes)): total = 0 for node in nodes[k].getelementsbytagname("track"): tlen = node.getattribute("len"); if len(tlen)<1: continue; # lasketaan levyn pituus sekunteina total = total + float(tlen[:1])*60 + float(tlen[2:4]); total = fix(total/60,0) + "M" + fix(total-float(fix(total/60,0))*60,0) + "S"; nodes[k].setattribute("total",total); print doc.toxml(); doc.unlink(); 227
11.14 Yksinkertaista XML-sovellusohjelmointia Javalla Java on korkean tason ohjelmointikieli - useita versioita - hyvä ja dokumentoitu pakettikirjasto, "kaikki löytyy", runsas välinetuki - suoritus erillisen Java-koneen avulla (tavukoodi), "alustariippumaton" - selkeä ja monipuolinen mutta melko jäykkä oliokieli, kehitystyö vaatii usein eksplisiittisen määrittelyvaiheen - erittäin tunnettu, suosittu, "kaikki käyttävät", kritisoidaan yleensä raskaudesta (kun esim. käytetään skriptityyppisiin sovelluksiin) Varsin värikäs historia (mm. JavaStationeista kännyköihin), Java-koneita toteutettu kaikenlaisiin laitteisiin, taipuu suuriinkin projekteihin Javan "erikoisuus" on koodin pakottaminen luokkien mukaisiin tiedostoihin, sovellukset koostuvat usein suuresta joukosta tiedostoja 228
11.15 Sovellusohjelmointia Javalla a la Eclipse Monimutkaiset XMLsovellukset kirjoitetaan usein Javalla (tai C++:lla, tms.) Java-ohjelmointi sujuu mukavimmin sopivan kehitysympäristön avulla Tarkastellaan seuraavassa triviaalin XML-lukijan toteuttamista Eclipsessä, Xerces-parseriin perustuen 229
11.16 DOM2 pähkinänkuoressa (1/4): Node-rajapinta DOM-jäsennyspuun tunnistamat solmutyypit (*_NODE) ovat - ELEMENT, ATTRIBUTE, TEXT, CDATA_SECTION, ENTITY_REFERENCE, ENTITY, PROCESSING_INSTRUCTION, COMMENT, DOCUMENT, DOCUMENT_TYPE, DOCUMENT_FRAGMENT ja NOTATION DOM määrittelee oleellisesti joukon rajapintoja erityyppisten solmujen käsittelyyn. Perusrajapinta on Node (vrt. DOM 2 Core) interface Node { // NodeType (nyt tunnistenimien määrittely [ks. yllä] leikattu pois)... readonly attribute DOMString nodename; attribute DOMString nodevalue; // raises(domexception) on setting // raises(domexception) on retrieval 230
readonly attribute unsigned short nodetype; readonly attribute Node parentnode; readonly attribute NodeList childnodes; readonly attribute Node firstchild; readonly attribute Node lastchild; readonly attribute Node previoussibling; readonly attribute Node nextsibling; readonly attribute NamedNodeMap attributes; // Modified in DOM Level 2: readonly attribute Document ownerdocument; Node insertbefore(in Node newchild, in Node refchild) Node replacechild(in Node newchild, in Node oldchild) Node removechild(in Node oldchild) Node appendchild(in Node newchild) boolean haschildnodes(); Node clonenode(in boolean deep); 231
// Modified in DOM Level 2: void normalize(); boolean issupported(in DOMString feature, in DOMString version); readonly attribute DOMString namespaceuri; attribute DOMString prefix; // raises(domexception) on setting readonly attribute DOMString localname; boolean hasattributes(); }; 232
11.17 DOM2 pähkinänkuoressa (2/4): Document-rajapinta Kullekin solmutyypille on lisäksi oma erikoistunut rajapintansa, näistä (yleensä) tärkeimmät ovat Document (ks. alla) ja Element interface Document : Node { readonly attribute DocumentType doctype; readonly attribute DOMImplementation implementation; readonly attribute Element documentelement; Element createelement(in DOMString tagname) DocumentFragment createdocumentfragment(); Text createtextnode(in DOMString data); Comment createcomment(in DOMString data); CDATASection createcdatasection(in DOMString data) ProcessingInstruction createprocessinginstruction(in DOMString target, in DOMString data) Attr createattribute(in DOMString name) 233
EntityReference createentityreference(in DOMString name) NodeList getelementsbytagname(in DOMString tagname); Node importnode(in Node importednode, in boolean deep) Element createelementns(in DOMString namespaceuri, in DOMString qualifiedname) Attr createattributens(in DOMString namespaceuri, in DOMString qualifiedname) NodeList getelementsbytagnamens(in DOMString namespaceuri, in DOMString localname); Element getelementbyid(in DOMString elementid); }; 234
11.18 DOM2 pähkinänkuoressa (3/4): Element-rajapinta interface Element : Node { readonly attribute DOMString tagname; DOMString getattribute(in DOMString name); void setattribute(in DOMString name, in DOMString value) void removeattribute(in DOMString name) Attr getattributenode(in DOMString name); Attr setattributenode(in Attr newattr) Attr removeattributenode(in Attr oldattr) NodeList getelementsbytagname(in DOMString name); DOMString getattributens(in DOMString namespaceuri, in DOMString localname); void setattributens(in DOMString namespaceuri, 235
in DOMString qualifiedname, in DOMString value) void removeattributens(in DOMString namespaceuri, in DOMString localname) Attr getattributenodens(in DOMString namespaceuri, in DOMString localname); Attr setattributenodens(in Attr newattr) NodeList getelementsbytagnamens(in DOMString namespaceuri, in DOMString localname); boolean hasattribute(in DOMString name); boolean hasattributens(in DOMString namespaceuri, in DOMString localname); }; 236
11.19 DOM2 pähkinänkuoressa (4/4) Kuten SAX2:n tapauksessa, DOM2:n myötä DOM-rajapinta mahdollistaa nimiavaruuksien käsittelyn DOM 2 koostuu itse asiassa neljästä osasta: - (1) DOM Level 2 Core Specification - (2) DOM Level 2 Traversal and Range Specification - (3) DOM Level 2 Events Specification - (4) DOM Level 2 Style Specification -...joista (1) esiteltiin edellä, (2) sisältää kulkurajapintoja ja mahdollistaa DOM-puun manipuloinnin ns. valinnan (range) avulla, (3) luo pohjan esim. skripteihin nojautuvien selainten toteutukseen (vrt. XHTML+Ecmascript) ja (4) määrittele CSS2:n DOM-puun Myös DOM 3 on olemassa; yleensä DOM2 kuitenkin riittää (paitsi esim. näppäimistötapahtumien osalta) 237
11.20 XML-pohjaista skriptiohjelmointia? DOM kehitettiin alun perin esim. selaimissa esitettävien XML-dokumenttien skriptiohjelmoinnin tarpeisiin - DOM sisältää tätä varten GUIrajapintamäärittelyn (& XML Events) Skritpiohjelmointi mahdollistaa periaatteessa minkä tahansa selaimen läpi näkyvän (skriptejä tukevan) XML-sovelluksen ohjelmoinnin - esim. SVG-esitysten manipulointi Ecmascriptillä - yleisesti ottaen kesk. ongelma ovat eri selaintoteutusten eroavaisuudet (toteutusten puutteet ja versiointi) ja sekä esim. saavutettavuuspulmat XML-sovellusohjelmoinnin näkökulmasta (selaimen) läpi tapahtuva skriptiohjelmointi voi olla pulmallista (paitsi jos selain tms. katseluohjelma voidaan kiinnittää hyvin tarkasti, esim. plugin-tekniikoin) 238
11.21 XML, DOM ja ohjelmointi Esimerkkejä - SVG ja DOM-puun rakenne - yksinkertaista DOM-ohjelmointia (SVGfraktaaliesimerkki) - tapahtumankäsittelijöistä (DOM2 vs. DOM3) - yms. 239
11.22 Vielä XSLT-ohjelmoinnista: XSLT 2 XSLT 2:n myötä XSLT-kielen sovellusala on laajentunut siten, että prosessorisovellusten toteuttaminen onnistuu XSLT:n avulla entistä paremmin. Keskeisiä uusia piirteitä ovat mm.: - muunnos voi kohdistaa sääntöjä myös sisäisten, itse tuottamiensa (puu)tietorakenteiden käsittelyyn - muunnos voi tuottaa useita tulosdokumentteja - tietotyyppien käyttö on mahdollista mm. muuttujissa ja hahmoissa - käytössä on laaja funktiokirjasto, myös omien funktioiden määrittely on mahdollista - kieltä on rikastettu mm. ryhmittelyn, sarjallistuksen ja hahmonsovituksen hallinnan osalta - ks. http://www.w3.org/tr/xslt20/ 240
11.23 XSLT2-esimerkki: "RSS Burger 0.1" +==============+ /===============================\ +========+ rss-config.xml ==> /========\ +====+ /=========\ => out.html +==============+ populate => tree => printhtml +========+ \========/ +====+ \=========/ +==>\===============================/=+ debug? +=============================+ +========+ /secondary input files (RSS)/ +==> tree.xml +=============================+ +========+ Figure 1: A conceptual perspective to the internal XSLT Ks. esimerkki l20-xslt2-rss 241
11.24 Lopuksi XML-sovellusohjelmoinnin näkökulmasta "XML" näyttäytyy lähinnä standardinmukaisena tietorakenteena sekä valmiina saatavina jäsentiminä, sovelluksina ja rajapintoina -- XML-sovelluskehityksessä pyritäänkin yleensä hyödyntämään mahdollisimman paljon valmiskomponentteja Hyvä strategia oman sovelluksen toteuttamiseen: Onko valmista toteutusta saatavilla/ostettavissa? Mikä on keskeisesti puuttuva komponentti? Onko (osa)tehtävä kierrettävissä esim. muunnoksella sopivan sovelluksen kautta ja kuinka paljon koodia kirjoitetaan itse? Kannattaa muistaa, että yksinkertainen perustekniikka mahdollistaa usein monimutkaisten sovellusten ymmärtämisen; monimutkainen perustekniikka taas saattaa tehdä yksinkertaistenkin sovellusten ymmärtämisen vaikeaksi (paitsi muutaman oppikirjamaisen erikoistapauksen osalta). Tasapainon löytäminen monimutkaisuuden hallinnassa on erittäin vaikeaa ja rajatuissakin sovelluksissa edellyttää yleensä kokemuksen myötä tulevaa "ammattitaitoa" 242