ingångInternetreseguide - allt det roliga på webben. Använda XML -dokumentobjektmodell Hur man skapar en delphi xml -fil
BESTÄLL EN LÖSNING TILL DELPHI
Delphi är det näst viktigaste programmeringsspråket som eleverna oftast introduceras för i inlärningsprocessen. Detta är början på att lära sig om objektorienterad programmering. Som student kom jag fram till att det inte finns någon enklare metod att lära sig ett språk än att skriva en miniräknare i det. Även om du implementerar en rudimentär funktion för att lägga till två nummer, kommer det att belysa mycket.
CodeGaear, Delphi 7, Lazarus är olika kompilatorer, program som överför koden du skriver till maskinen, konverterar den till enor och enor. Dessa är alla program för att skapa program, inte separata programmeringsspråk. Dessa kompilatorer använder Object Pascal -programmeringsspråket, som är grunden för Delphi -språket, som i syntax liknar vanligt Pascal, men skiljer sig funktionellt avsevärt.
Vad är syntaxen för ett programmeringsspråk?
Detta är formatet för att skriva olika operatörer. Till exempel har en Pascal for loop följande format: för n: = 1 till k do, och så vidare.
I programmeringsspråket C ++ skrivs samma slinga lite annorlunda: för (n = 1; n Vi skriver en räknare
Detta kommer att ge dig en förståelse för hur objekt interagerar med programkod, vad "variabler" är och hur matematiska funktioner fungerar. Varje programmering kommer i alla fall att vara en beräkning. Ett spel är också ett program som ständigt beräknar något, arbetar med siffror och numeriska funktioner. Programmering är oskiljaktigt från matematik.
Låt oss använda utvecklingsmiljön för Lazarus för att skriva. Dess funktionalitet är inte lika rik som CodeGear, men den är fritt tillgänglig och är avsedd för träning.
När vi öppnar utvecklingsmiljön ser vi formen och verktygslådan. Här är formuläret.
Här är verktygslådan.
Det första vi ska göra är att lägga till de tre elementen vi behöver för att implementera funktionen för att lägga till två tal. Vi behöver: "Tedit" i mängden tre stycken och "TButton". På bilden nedan visas de på panelen med pilar. Vi klickar på dem en gång och sedan en gång på formuläret så visas de på den.
Det här är textfält för inmatning och en vanlig knapp. Du stöter på dessa element med nästan alla Windows -program... Ta en titt.
Låt oss nu rensa dessa etiketter. Klicka på fliken "Visa". Och klicka på objektet "Object Inspector. Ett fönster som detta kommer att visas.
Vi klickar en gång på vårt "Knapp" -element i formuläret och ändrar värdet "Bildtext" i inspektörsfönstret till något annat. Till exempel ordet "Ok". Vi trycker på Enter. Vi ser på formuläret hur elementet har bytt namn.
Låt oss göra samma sak med Edit's, byt bara inte namn på dem, utan gör dem utan innehåll. Välj dem i tur och ordning och rensa textvärdet i inspektören. Glöm inte att trycka på Enter.
Som ett resultat ser vår form ut så här.
Nu, för att vår räknare ska fungera, måste du registrera det som krävs programkod för vår knappprocedur. Klicka på knappelementet två gånger och öppna källredigeraren.
Ser? Förfarandeknapp1Klicka. Detta är proceduren som är ansvarig för vad som händer när vi klickar på knappen en gång. Och följande bör hända: programmet måste visa summan av siffrorna som anges i de två första fälten i den tredje redigeringen. Vi skriver koden.
Vi måste skriva så enkla 5 rader kod. Kommentarer och förklaringar kan ses på bilden ovan. Efter det trycker vi på den här knappen.
Vårt projekt kommer att sammanställas. Det kommer att sammanställas till ett program. Vi anger siffror i de två första fälten, klicka på knappen och få värdet av summan.
Slutsats
Du kan klicka på "Arkiv" -knappen, sedan "Spara alla", välja en mapp att spara och du får ett fullfjädrat program som kan startas från skrivbordet. Försök nu själv räkna ut vad du behöver skriva om i den här koden så att programmet delar två nummer och inte lägger till. Tips: du måste ändra datatypen. Videon nedan visar ett liknande exempel, men i Delphi 7 -miljön, inte Lazarus.
För många Delphi -programmerare är sparande inställningar associerade med användning INI filer i sina program. Ansökan den här metoden, i mer eller mindre seriösa projekt, bör undvikas, eftersom detta begränsar flexibiliteten, vilket förhindrar ytterligare expansion av programmet. Det bör sägas att detta tillvägagångssätt är ganska populärt på grund av dess användarvänlighet och närvaron av inbyggda verktyg i utvecklingsmiljön.
Dock strukturerad XML filer. Deras fördel är att antalet parametrar kanske inte är fastställda. För att förstå detta bättre, överväg ett specifikt exempel.
I programmet USearch, när du klickar på en post, visas en snabbmeny där en lista med objekt visas. Dessa objekt är kommandon, som i sin tur laddas från inställningsfilen. Om inställningarna lagras i INI filen, kan programmet spara och ladda ett visst antal kommandon, till exempel 10 eller 50. Så snart ett större värde krävs måste du skriva om koden och kompilera om den därefter.
Tillämpa en metod med XML filer, kommer vi att kunna ladda alla sektionsparametrar dynamiskt. Dessutom blir konfigurationsfilen mer elegant utan redundant parameternummerering. Men, standardmedel att arbeta med XML Delphi har många nackdelar, så jag rekommenderar att använda standardbibliotek MSXML... Det ingår vanligtvis som standard i operativsystem Windows -familj.
Att ansluta MSXML, måste vi skapa en gränssnittsfil med en lista över alla funktioner genom att importera den från COM -servern. Många detaljerade artiklar har skrivits om hur man importerar gränssnittet, men jag föreslår att du laddar ner filen MSXML2_TLB.PAS redo att använda. När filen har laddats ner placerar du den bredvid ditt projekt eller släpper den i mappen lib i Delphi -miljön. Så alla skapade program kommer att kunna använda modulen MSXML, du behöver bara lägga till MSXML2_TLB -raden till användningsområden.
För klarhet, överväg följande exempel på hur du använder det här biblioteket:
Procedur LoadData; var XMLDoc: DOMDocument; Root: IXMLDOMElement; börja XMLDoc: = CoDOMDocument.Create; XMLDoc.Load ("settins.xml"); Root: = XMLDoc.DocumentElement; ShowMessage (Root.SelectSingleNode ("storlek / bredd"). Text); Rot: = noll; XMLDoc: = noll; slutet;
Först skapas en instans av DOMDocument -klassen och sedan laddas innehållet i filen settings.xml till minnet. Eftersom, enligt standarden, eventuella XML filen måste innehålla rottaggen (i det här fallet config), då måste vi få det med funktionen DocumentElement... Därefter visas innehållet mellan taggarna.
Här tillämpas SelectSingleNode -metoden, som tar en sträng som parameter
Välkommen! Den här bloggen handlar om Internet och datorer, eller snarare den var tillägnad dem.
Förmodligen är det omedelbart klart att inga nya artiklar har dykt upp på webbplatsen på många år. Ja, det är ödet för de flesta bloggar. Detta projekt var en gång ett ambitiöst företag, och författaren, liksom många andra som skrev på den tiden, hade ambitiösa planer på att bli en av de bästa ryska bloggarna. Tja, om du tittar nu, av de bloggar som skapades samtidigt med mina, har de flesta redan försvunnit in i evigheten. Och jag hade bara inte tid att blogga. Så ja, det uppdateras inte längre. Även om vi en gång med den här webbplatsen vann tävlingen "Blog of Runet 2011".
Jag hade till och med en idé att radera allt detta, men sedan reviderade jag det gamla materialet och insåg att det fortfarande kan vara användbart för läsarna. Ja, vissa artiklar är föråldrade (om jag har tillräckligt med styrka kommer de att få lämpliga anteckningar), men webbplatsen kan till exempel vara användbar för nybörjare - här kan du läsa om grundläggande koncept Internet, lär dig hur du konfigurerar Internet, Windows eller till och med bestämmer dig för att byta till Linux. Så titta på rubrikerna och välj den som är rätt för dig.
Och ändå, jag hoppas att detta är mer än bara en blogg, men en riktig guide till Internet. Webbplatsen kan ses i katalogläget, där alla tillgängliga artiklar är strukturerade efter kategori. Och vem vet, kanske en dag kommer nya högkvalitativa artiklar att dyka upp här.
Sander
Picodi.ru är en rabattportal från International Coupons, en polsk expert på besparingar och billig shopping. Polacker betraktas som en av de mest ekonomiska länderna i världen, så det är inte förvånande att denna typ av projekt växte fram från den polska starten kodyrabatowe.pl. Hur kan denna portal vara användbar för en vanlig Internetanvändare i Ryssland?
Moderna Android -telefoner är mer än telefoner. Man vänjer sig vid att skriva installerade program, till din samtals- och sms -historik, fotosamling och mer. Men tiden går, och den enhet som passar dig börjar sakta ner, glida eller helt enkelt förlora sitt presentabla utseende på grund av marker på fodralet eller repor på skärmen. Frågan uppstår om att välja en ny telefon och byta Android telefon... Och om vi nu kringgår frågan om val, sedan "flytta" till ny telefonär fortfarande ett allvarligt problem - du vill absolut inte starta all data från början. Detta är vad vi ska prata om idag.
De flesta läsare av denna blogg har troligtvis aldrig stött på versionskontrollsystem och kommer inte att stöta på några inom en snar framtid. Det är synd. Denna extremt bekväma uppfinning används i stor utsträckning av programmerare, men enligt min mening kan den vara mycket användbar för dem som aktivt arbetar med texter. Men förmodligen finns det inte ett enda versionskontrollsystem som skulle vara lätt att börja använda för "kontoret" ( Microsoft Office) arbete. Ändå tror jag att materialet som presenteras i artikeln kan vara intressant för alla läsare.
Om du har tänkt på hur du tittar på filmer i nätverket från din TV och går online, är den här artikeln för dig. Nej, jag vet att vissa TV -apparater redan har Smart TV -funktionalitet, men jag har aldrig sett att det fungerar som det ska. Uppenbarligen visade därför Google -företaget nyligen en helt fantastisk enhet, som omedelbart blev en sensation. Vi pratar om Chromecast media streamer (Chromcast), en mer avancerad och prisvärd version av förra årets katastrofala Nexus Q.
Dongle Chromcast, som är mindre än 2 tum stor, ansluts till porten HDMI -TV och låter dig njuta av att titta på strömmande webbinnehåll. För att styra streameren kan du använda vilken enhet som helst (surfplatta, PC, smartphone) baserad på operativplattformen iOS, Windows, Android eller Mac OS.
Den här artikeln handlar om enhetssystemet minne android, problem som kan uppstå på grund av dess brist och sätt att lösa dem. För inte så länge sedan mötte jag själv det faktum att min Android -telefon regelbundet började ge ut meddelanden om otillräckligt minne när jag försökte installera ett program. Vilket var väldigt konstigt för mig, med tanke på att det enligt beskrivningen på marknaden borde ha varit cirka 16 GB, och jag har också ökat denna volym med ett extra minneskort. Det var dock ett problem, och jag var tvungen att pyssla mycket innan jag hittade rätt lösning som inte krävde root -åtkomst eller full återhämtning telefonen tillbaka till fabriksskick.
Nyligen har mycket uppmärksamhet ägnats åt konstruktionen av e -affärssystem, eller som de också kallas - B2B (business to business). Med beaktande av rekommendationerna för konstruktion av utbytesströmningssystem för det samordnande organet för internetteknik - WWW Consortium: tyngdpunkten ligger på XML -teknik och konstruktion av system för utbyte av XML -dokument.
Fördelen med att använda XML in elektronisk verksamhet- hög effektivitet för B2B -system till låga kostnader för dess skapande på grund av en tydlig och visuell presentation av strukturerad information, möjligheten att använda modern nätverksprotokoll och skapandet av affärssystem i realtid.
Oberoende av presentationen av information i formuläret XML -dokument tillåter olika företag som är involverade i e-business att producera mjukvara oberoende av varandra.
I alla system är växeln som regel byggd enligt samma schema med HTTP -förfrågningar. SSL -protokollet används som informationssäkerhetsprotokoll (men detta är ett separat ämne).
En av möjliga alternativ XML -meddelandebehandling är konstruktionen av BIN / CGI (ISAPI) applikationer eller COM (server) komponenter som bildar eller bearbetar XML -dokument.
Å ena sidan fungerar programmet som en klient, som utfärdar en HTTP -begäran i POST -läge, å andra sidan finns det en WEB -server på vilken sidan begäran behandlas och ett svar utfärdas. Informationsutbytet använder XML -dokument.
Ett av de mest effektiva implementeringsalternativen är att använda en befintlig XML -parser som stöder DOM -modellen. En sådan parser är en distributionsfördelning av Win'98 eller del av IE 4.7 och högre (för Win`95) och representerar COM -servern i msxml.dll -biblioteket.
Component Object Model (COM) - presenterar inkapslade data och metoder i en enda enhet och ett sätt att komma åt dem via ett system av gränssnitt. Med Delphi -verktyg är det ganska enkelt att komma åt klasserna för ett COM -objekt (flera klasser kan inkluderas i en COM -server). Objekt nås genom att initiera en instans av klassen via gränssnittssystemet. Beskrivningen av gränssnitt utförs av gränssnittsdefinitionsspråket (IDL), som kan utföras automatiskt med hjälp av miljön.
Delphi -verktyg används för att importera från en COM -server msxml.dll, filerna för beskrivningen av IDL -gränssnittet och filen för den binära beskrivningen av bibliotekstyperna - TLB är byggda. Denna operation utförs via systemmenyn: Projekt | Skriv biblioteksimport:(bild 1). Därefter visas en dialogruta (figur 2), där du måste välja ett COM -objekt (i vårt fall är objektet registrerat under namnet "Microsoft.XMLDom (version 2.0)") och skapa en TLB -fil (knapp Skapa enhet). Med TLB -filen genererar ramverket en Pascal COM -serverbeskrivningsfil - MSXML_TLB.pas
Filen MSXML_TLB.pas beskriver alla gränssnitt, konstanter och coclasses för COM -servern.
För att komma åt objekt för ett COM -element behöver du i direktivet ANVÄNDNINGAR lägg till namnet på biblioteksbeskrivningsfilen (MSXML_TLB.pas). Nedan finns ett enkelt program som använder standard DOM -parser msxml.dll, som laddar ett XML -dokument och visar det i ett Memo1 -textfältelement.
användningsområden Windows, meddelanden, SysUtils, klasser, grafik, kontroller, formulär, dialogrutor, OleServer, MSXML_TLB, StdCtrls; typ TForm1 = klass(TForm) Knapp1: TBknapp; Memo1: TMemo; procedur Button1Click (Avsändare: TObject); slutet; var Form1: TForm1; genomförande($ R * .DFM) Procedur TForm1.Button1Click (Avsändare: Tobject); // deklaration av SOM -klassen för DOMDocument -objektet; var coDoc: CoDOMDocument; // klass som överensstämmer med IDOMDocument -gränssnittet; var Doc: IXMLDOMDocument; Börja // skapa en instans av DOMDocument -objektet; Doc: = coDoc.Create; // anropa Load -metoden för en instans av DOMDocument -objektet; Doc.load ("data.xml"); // få tillgång till xml -egenskapen för DOMDocument -instansen; Memo1.Text: = Doc.xml; slutet; slutet.DOM Concept - Dokumentobjektmodell
Varje XML -dokument representeras som en uppsättning av många objekt (klasser), med hjälp av vilka det är möjligt att komma åt enskilda element(objektfält). DOM - gränssnittet beskriver åtkomst både till enkla objekt av typen DOMString eller CharacterData, och till delar eller separata XML -element dokument: DOMFragmentElement, DOMNode, DOMElement.
Följande är de viktigaste egenskaperna och metoderna för XMLDOMDocument, XMLDOMNode, XMLDOMNodeList -objekt. Det bör noteras att metoderna och funktionerna för DOM -objekt som presenteras nedan (dokumentobjektmodell) används av Microsoft XML -parsern msxml.dll och är något bredare än modellen som godkänts av W3C DOM -konsortiet.
Mer Full beskrivning DOM -objektgränssnitt finns på
| XMLDOMDocument -objekt | |
| Representerar den översta nivån i objekthierarkin och innehåller metoder för att arbeta med ett dokument: ladda det, analysera det, skapa element, attribut, kommentarer etc. ... | |
| Egenskaper | |
| Asynk | Egenskap som identifierar det aktuella behandlingsläget |
| ParseError | Returnerar en referens till XMLDOMParseError felhanteringsobjekt |
| Aktivera - inaktivera dokumentverifiering. | |
| url | Returnerar dokumentets URL |
| documentElement | Innehåller en referens till dokumentets rotelement som ett XMLDOMElement -objekt. |
| Metoder | |
| ladda (url) loadXML (xmlString) |
Läser in ett XML -dokument, |
| spara (objTarget) | Sparar XML -dokument i filen |
| avbryta | Avbrott i processen för att ladda och bearbeta dokumentet. |
| createAttribute (namn) | Skapar ett nytt attribut med det angivna namnet för det aktuella elementet. |
| createNode (Typ, namn, namnSpaceURI) | Skapar en nod av angiven typ och namn |
| createElement (tagName) | Skapar ett dokumentelement med det angivna namnet. |
| createTextNode (data) | Skapar text i ett dokument |
| getElementsByTagName (tagnamn) | Returnerar en referens till samlingen av dokumentelement med det angivna namnet |
| nodeFromID (idString) | Hitta ett element efter ID |
| XMLDOMNode -objekt | |
| Ett XMLDOMNode -objekt som implementerar det underliggande DOM -gränssnittet Nod, är avsedd för att manipulera en separat nod i dokumentträdet. Dess egenskaper och metoder gör att du kan få och ändra fullständig information om den aktuella noden - dess typ, namn, fullständiga namn, dess innehåll, lista med underordnade element etc. | |
| Egenskaper | |
| nodnamn, basnamn | Returnerar namnet på den aktuella noden. |
| prefix | Returnerar prefixet Namespace. |
| data typ | Anger innehållstypen för den aktuella noden |
| nodeType, nodeTypeString | Returnerar typen av den aktuella noden: |
| attribut | Hämtar en lista över attributen för den aktuella noden som en XMLDOMNamedNodeMap -samling. |
| text | Returnerar innehållet i det aktuella delträdet som text |
| xml | Returnerar en XML -representation av det aktuella delträdet. |
| nodvärde | Returnerar innehållet i den aktuella noden. |
| barnNoder | Returnerar en lista med underordnade element som XMLDOMNodeList. |
| första barn, sista barn | Returnerar det första / sista barnet |
| föregåendeSibling, nästaSibling | Returnerar föregående / nästa syskonelement. |
| parentNode | Innehåller en länk till det överordnade elementet. |
| ägareDokument | Returnerar en pekare till dokumentet som innehåller den aktuella noden. |
| Metoder | |
| appendChild (newChild) | Lägger till ett nytt barn i den aktuella noden. |
| insertBefore (newChild, refChild) | Infogar en underordnad nod och placerar den i det aktuella delträdet "till vänster" för noden som anges av refChild -parametern. |
| cloneNode (djup) | Skapar en kopia av det aktuella objektet. |
| getAttribute(namn) getAttributeNode(namn) setAttribute (namn, värde) setAttributeNode (XMLDOMAttribute) |
Åtkomst till objektets attribut (skapa, läsa, skriva). Namn är namnet på attributet, värdet är dess värde. Returnerar värdet för ett XMLDOMAttribute -objekt. |
| ErsättChild (newChild, oldChild) removeChild (oldChild) | Ersätter oldChild -objektet i den aktuella listan med underordnade objekt med newChild. Tar bort oldChild -objekt |
| selectNodes (patternString) selectSingleNode (patternString) | Returnerar XMLDOMNodeList -objekt, valt efter sökmönster eller första nod |
| transformNode (formatmall) transformNodeToObject (stylesheet, outputObject) |
Tilldelar ett stilark till delträdet för den aktuella noden och returnerar en sträng som är resultatet av bearbetningen. Parametern är en referens till DOMDocument -objektet som innehåller XSL -satserna. |
Använda XML i företag.
För en tydligare bild behövs en förklaring och varför allt detta behövs för att förstå hur det fungerar:
När man bygger ett B2B- eller företags ERP-system, när man organiserar informationsutbyte av XML-dokument mellan företag eller grenar av pr-I, används ett effektivt bevisat system för informationsöverföring baserat på befintliga WEB-servrar över HTTP-protokoll.
Å ena sidan fungerar programmet som en klient, som utfärdar en HTTP -begäran i POST -läge, å andra sidan finns det en WEB -server, på vilken sidan begäran behandlas och ett svar utfärdas. XML -dokument används som utbyte.
Till exempel, i ett enkelt företags ERP -system, ett redovisningsprogram (ACS Accounting), är det nödvändigt att bilda en begäran om en faktura och skicka den till en filial som har ett lager (ACS Warehouse). AWP Ett liknande problemmeddelande när du skapar ett B2B -system, när Enterprise A begär att produkterna är tillgängliga (gör en beställning för köpet) från leverantör B.
Enterprise A och dess program fungerar som en klient. Lagret betjänas av leverantör B, som har ett lagerkomplex med en databas på en SQL -server. Utbytet utförs via företagets WEB -server hos leverantören V.
Nedan följer följande typiska utbytesalgoritm:
Figur 3.
- Företag A initierar process A(produktorder), som fungerar som en WEB -klient.
- Process A genererar ett XML -dokument (till exempel en fakturaförfrågan) och överför det som en POST http -begäran till WEB -servern hos leverantör B. Som en URI används bearbetningsprogrammets resursidentifierare. URI: en kan vara densamma för alla typer av dokument, eller individuell för varje typ. Allt beror på strukturen hos B2B (WEB) -servern.
- WEB -server analyserar begäran och genererar en server Process B genom att skicka XML -dokumentets brödtext som en parameter.
Process B startas av WEB -servern och bearbetas antingen som en ASP -sida, CGI (ISAPI) - applikation eller JAVA -server (serverapplikation) - Process B- genererar en begäran till SQL -databasservern.
- SQL -servern utför nödvändiga operationer i databasen, genererar ett svar och returnerar det Process B.
- Enligt svaret från SQL -servern Process B genererar ett XML -dokument (svar) och returnerar det som ett svar på en http -begäran till klientprogrammet.
- Beroende på situationen på klientsidan bildas vidare antingen en ny http -begäran eller så avslutas sessionen.
Några ord om organisationen av dokumentflöde.
Den allmänna regeln för att utveckla ett system för utbyte av XML -dokument är:
- I början- Utveckling av ett flödesschema över elektroniska dokument och deras struktur.
- För det andra- utveckling av tabeller över processfunktioner (delprocesser), dvs. vilken funktion varje process kommer att implementera med avseende på vilket XML -dokument.
Varje XML -dokument, liksom ett HTML -dokument, måste bestå av ett meddelandehuvud (information som omges av taggar) och ett meddelandetext (för en begäran är denna information inramad med taggar för att svara på en begäran). För att ett XML -dokument ska vara välformat är det nödvändigt att till exempel ramma in dess två komponentdelar "Titel" och "Begäran" med taggar. Typen av ett typiskt dokument presenteras nedan:
Rubriken (Figur 4) måste, till skillnad från ett HTML -dokument, innehålla olika typer av serviceinformation, inklusive information om typen av det överförda dokumentet och processen för dess behandling. Dokumentets kropp går in i informationsbehandling, d.v.s. innehåll inramat av taggar. Det bör noteras att strukturen på rubrikerna bör vara densamma för alla typer av dokument.
För processen som startas av servern är det att föredra (men inte nödvändigt) att bygga behandlingsalgoritmen enligt följande:
Figur 6.
Några grundläggande punkter när du skapar klientsidan
Som redan förklarats används dess representation i form av en DOM -modell när man skapar ett XML -dokument. Nedan är ett exempel på en Delphi -textdel av ett meddelande xml -rubrikgenereringsprogram.
procedur TThread1.HeaderCreate (Avsändare: Tobject); var // klassdeklaration, behövs för att skapa coDoc: CoDomDocument; // XMLDomDocument -objekt Doc: DomDocument; r: IXMLDOMElement; Nod: IXMLDOMElement; // DOMText txt: IXMLDOMText; // DOMAttribute attr: IXMLDOMAttribute; Börja // skapa DOM -dokument Doc: = coDoc.Create; Doc.Set_async (false); // första initiering av DOM -dokumentet Doc.LoadXML ("Det bör noteras att deklarationen av variabeln coDoc: CoDomDocument och Doc: DomDocument, liksom dess skapande med metoden Create (Doc: = coDoc.Create;) görs en gång. Variabeldeklarationen finns i avsnittet som beskriver globala variabler, och inte i det lokala förfarandet, som det visades för tydlighet i detta exempel (det vill säga en global variabel av typen DomDocument per programmodul).
Resultatet av arbetet med ovanstående program blir det skapade huvudet, tillämpat på vårt exempel xml -dokument: visas i figur 5.
Figur 5.
Figur 6.
Den största fördelen med att överföra information i form av XML -dokument är att det är möjligt att skapa ett meddelande med hjälp av oberoende tabellstrukturer i DBMS både på den mottagande och på den överförda sidan. Antag att med vårt exempel att det är nödvändigt att överföra information om fakturorna för Enterprise A från DBMS med strukturen som visas i figur 6
För att generera ett xml -dokument som innehåller en faktura byggs initialt en SQL -fråga (fråga A) med information om fakturan själv:
VÄLJ* FRÅN Faktura_Generellt VAR FakturaNum =: num VÄLJ Varor, Kvalitet, Pris, HZ_cod FRÅN Varor VAR FakturaNum =: num //: num är en parameter som anger fakturanumret.Nedan är en del av programmet som genererar xml -dokumentets brödtext:
procedur TThread1.DataBodyCreate (Avsändare: Tobject); var // deklaration av klassen och XMLDomDocument -objektet// coDoc: CoDomDocument; // måste vara global för hela modulen.// Doc: DomDocument; // deklarera DOMElement -objekt r: IXMLDOMElement; // DOMElement; Node, Node2: IXMLDOMElement; Node3, Node4: IXMLDOMElement; // DOMText txt: IXMLDOMText; str: Sträng; // Fakturanummer: heltal;- global variabel - // har värdet 987654 // queryA, queryB: Sträng;- en global variabel, // har ett värde som motsvarar begäran // fråga A - begäran A med allmän information om fakturan // fråga B - begär B information om de varor som beskrivs i // fakturan (se text) Börja Fråga.Stäng; // se texten "begäran A" Fråga.Text: = frågaA; // utföra förfrågan Query.ExecSQL; Fråga.Öppna; // få adressen till rotelementet r: = Doc.Get_documentElement; Node2: = Doc.createElement ("Begäran"); // skapa DOMElement (tagg) Nod: = Doc.createElement ("Faktura"); // lägg till ett element i roten r.appendChild (Node2); // lägg till ett objekt i Nod2. appendChild (Node); // skapa DOMElement (tagg) Node3: = Doc.createElement ("Depurture"); // lägg till ett objekt i Nod. appendChild (Node3); // ring till fältet "Depurture" för begäran str: = Query.FieldByName ("Depurture"). AsString; // skapa textnod = fältvärde// tilldela noden ett värde // textnod, variabel str Node.appendChild (txt); // liknande operationer för taggenSom ett resultat av detta förfarande genereras följande text i ett XML -dokument:
 |
För att skapa en begäran används objektets öppna metod IXMLHttpRequest:
procedurÖppna (const bstrMethod, - method type = "POST" bstrUrl, - Server url varAsync, - asynkron / synkron kommunikationsläge = true bstrUser, - användarnamn för autentisering bstrPassword) - lösenordSkapa serversidan för dokumentbehandling
Som nämnts tidigare, bearbetning HTTP -begäran kan implementeras med antingen CGI -applikationer eller Java servlets. Varianten att skriva ASP-sidor är också möjlig. Men i det här fallet är dataöverföring endast möjlig med "GET" -metoden genom frågesträngen. Att hantera en HTTP -begäran för ASP -sidor är dock mer effektivt än en CGI -applikation. Men enligt min mening spelar det ingen roll hur det ska behandlas, men det är viktigare att lösa frågan - hur man bygger ett bearbetningsprogram, och inte med vilka medel.
Om vi från föregående kapitel undersökte alternativen för att skapa ett XML -dokument, är uppgiften för serverprogrammet det motsatta - analys av XML -dokument. Nedan finns en del av programmet som analyserar ett xml -dokument:
procedur Tthread1.DataParser (Avsändare: Tobject); var // deklarera DOMElement -objekt r, FNode: IXMLDOMElement; Str, filnamn: String; parm: sträng; // soclass deklaration och CoDocXML, CoDocXSL, CoDocResult: CoDomDocument; // XMLDomDocument -objekt XMLDoc, XSLDoc, ResultDoc: DomDocument; // HttpStr: String; - en global variabel som innehåller HTTP -begärningssträngen Börja XMLDoc: = coDocXML.Create; XMLDoc.LoadXML (HttpStr); // få adressen till rotelementet r: = Doc.Get_documentElement; // få elementets värde FNode: = r.SelectSingleNode ("// TypeDocument"); // få värdet på attributet id = "Order" Filnamn: = FNode.GetAttibute ("id"); // och bildar filnamnet Order.xsl Filnamn: = Filnamn + ". Xsl"; // skapa XSLDoc -dokument XSLDoc: = coDocXSL.Create; XSLDoc.LoadXML (filnamn); // skapa XMLDoc -dokument ResultDoc: = coDocResult.Create; // ställ in synkron bearbetningsläge ResultDoc.Set_async (false); // ställ in kontroll av analys ResultDoc.validateOnParse: = true; // analysera XMLDoc med XSL -mall XMLDoc.transformNodeToObject (XSLDoc, ResultDoc); // Str -variabeln tilldelas ett textvärde // av det resulterande dokumentet. Str: = ResultDoc.text; // hitta ett element FNode: = r.SelectSingleNode ("// InvoiceNumber"); // och få värdet på elementet parm: = FNode.text; // stäng begäran om åtkomst Fråga.Stäng; Fråga.Text: = Str; // tilldelning av parametervärde Query.Params.AsString: = parm; // utföra förfrågan Query.ExecSQL; slutet;Hela höjdpunkten i analysen är användningen av en XSL -mall som genereras individuellt för varje typ av dokument. Resultatet av analysen är en SQL -frågesträng. Därefter kommer utförandet av den genererade SQL -frågesträngen att göra nödvändiga ändringar av data i DBMS.
Fördelen med att analysera genom en mall är också att du får någon form av dataflexibilitet, och du får fullständig oberoende av algoritmen från programkoden. Nedan är texten i XSL -mallen som används för att behandla ett BESTÄLLNINGSDokument:
För att förklara exemplet ovan bör det noteras att användningen av ett par taggar är formell, eftersom efter analys måste det resulterande XML -dokumentet formellt innehålla minst en nod. Metoden ResultDoc.text tilldelar textvärdet för ResultDoc som erhållits vid analys av XML -dokumentet. I detta fall är värdet allt som är inramat av ett par taggar och d.v.s. SQL -frågan vi har genererat.
En annan funktion för att skriva programmet bör noteras möjligheten att använda SQL -parametern : num. Att använda parametern förenklar texten i xsl -mallen. Definitionen av värdet på motsvarande element i noderna i XML -dokumentet bestäms initialt av valet med namnet på motsvarande nod, till exempel:
XSL en överblick
Förkortningen XSL kommer från eXtensible Stylesheet Language - ett formateringsspråk för stilark (XML -data). Som du kan se från rubriken används eXtensible Stylesheet Language (XSL) för att formatera XML -data. Per definition består W3C XSL av två delar:
- XSLT - XSL -transformation. Språket som används för att transformera eller formatera (transformera) XML -dokument. Således kan vi med hjälp av XSLT få olika nedskärningar av en uppsättning data och former för datapresentation.
- Formatera element. Dessa element inkluderar alla typografiska element i data efter bearbetning med XSL. Används endast för formning HTML -sidor.
Med hjälp av XSLT kan vi välja den data vi behöver från en XML -fil och ordna den i ett formulär för presentation för användaren. Till exempel har vi i vårt fall transformerat XML -data som SQL -fråga... Den klassiska användningen av XSL är vanligtvis formatering av data i form av HTML -sidor eller, mer sällan, i form av RTF -filer.
XSL -filen beskriver en mall enligt vilken transformationen av XML -data kommer att utföras. När vi återgår till xsl -mallar kan följande element (direktiv) särskiljas i XSLT:
| XSL -direktiv | beskrivning |
|---|---|
| xsl: Apply-mallar | Ett direktiv som anger användningen av matchande mallar för select attribute = "mallnamn" |
| xsl: attribut | skapar ett attributträd och lägger till det i utmatningselementet, parameternamn = "attributnamn", namnutrymme är namnutrymme URI (namnutrymme prefix) |
| xsl: call-mall | kallar en mall, attributnamn = "URI till mall" |
| xsl: välj xsl: när xsl: annars |
urval efter villkor xsl: när expr = "utvärdering av uttryck på skript", språk = "språk-namn" test = "utvärderat uttryck" |
| xsl: kommentar | genererar en kommentar i utskriftsdokumentet |
| xsl: kopiera xsl: kopia av |
kopierar den aktuella noden till utmatningskällan eller infogar ett dokumentfragment i en nod där selectattribut = "källnodnamn" |
| xsl: element | skapar ett utmatningselement med namn, attributnamn = "elementnamn", namnrymd = "uri -namnutrymme -referens" |
| xsl: för-varje | tillämpar mallen igen på alla noder i nodlistan, specificerar select -attributet listan över noder |
| xsl: om | tillståndskontroll, inställd av testattributet som ett uttryck |
| xsl: inkludera | innehåller extern mall, attribut href = "URI -referens" |
| xsl: utmatning | anger utdata, metodattributet kan vara "xml", "html" eller "text" |
| xsl: param | anger parametrarnas värde, attributnamn = "parameternamn", välj = "värde" |
| xsl: bearbetningsinstruktion | skapar en behandlingsinstruktion, attributnamn = "namn på instruktionsprocessen" |
| xsl: sortera | sorterar en uppsättning noder, attribut select = "nodnamn", datatyp = datatyp ("text" | "nummer" | Qnamn), ordning = sorteringsriktning ("stigande" | "fallande") |
| xsl: formatmall | definierar ett xsl -malldokument, är rotelementet för XSLT |
| xsl: mall | definierar en xsl-mall, attributnamn = "URI-prefix till mallnamnet", match = "en indikation på noden som mallen tillämpas på" |
| xsl: text | genererar text till utmatningsströmmen, attribut disable-output-escaping = "ja" eller "nej", indikerar möjligheten att generera ESC-tecken |
| xsl: värde-av | infogar värdet för den valda noden som text, attribut select = "pekare till nod" från vilket värdet tas |
| xsl: variabel | anger värdet på variabelgränser, attributnamn = "variabelnamn", välj = "beräkning av variabelvärde" |
| xsl: med-param | tillämpar parameter på mall, attributnamn = "parameternamn", välj = uttryck för att utvärdera det aktuella sammanhanget, standardvärde "." |
Slutsats
Slutligen bör det noteras att med standard XML -parser msxml.dllär inte det enda verktyget för att analysera och skapa XML -dokument. Till exempel, för att skapa XML -dokument effektivt använda komponenterna TPageProduser och TableProduser... Men den här artikeln betonar bara bredden och tillämpningen av DOM -modellen i praktiken.
Författaren kommer att vara mycket tacksam för feedback om ämnets relevans, allmänt innehåll, presentationsstil, liksom alla andra kommentarer som kommer att bidra till att ytterligare förbättra kvaliteten på att skriva en samling artiklar och släppa en bok som täcker ämnet den praktiska sidan med att använda XML-dokument i e-handel. Mer detaljerad information om den praktiska sidan av användningen av elektroniska dokument finns på författarens webbplats www.eDocs.al.ru Det är också planerat att placera källtexter och exempel på författarens webbplats.
XML används alltmer för att lagra information och utbyta den mellan applikationer och webbplatser. Många applikationer använder detta språk som grundspråk för lagring av data, medan andra använder det för att exportera och importera XML -data. Så det är dags för utvecklare att tänka på hur XML -data kan användas i sina egna applikationer.
I den här artikeln kommer vi att titta på XML Document Object Model (DOM) och Microsofts implementering av XML DOM.
XML DOM är en objektmodell som förser en utvecklare med objekt för att ladda och bearbeta XML -filer. Objektmodellen består av följande kärnobjekt: XMLDOMDocument, XMLDOMNodeList, XMLDOMNode, XMLDOMNamedNodeMap och XMLDOMParseError. Var och en av dessa objekt (utom XMLDOMParseError) innehåller egenskaper och metoder som gör att du kan få information om objektet, manipulera objektets värden och struktur och navigera i strukturen i ett XML -dokument.
Låt oss titta på de viktigaste XML DOM -objekten och visa några exempel på deras användning i Borland Delphi.
Använda XML DOM i Borland Delphi
För att kunna använda Microsoft XML DOM i Delphi -program måste du ansluta rätt bibliotek till projektet. För att göra detta kör vi kommandot Project | Importera typbibliotek och i dialogrutan Importera typbibliotek väljer du biblioteket Microsoft XML version 2.0 (version 2.0), som vanligtvis finns i filen Windows \ System \ MSXML.DLL
Efter att ha klickat på knappen Skapa enhet skapas gränssnittsmodulen MSXML_TLB, som gör att vi kan använda XML DOM -objekten: DOMDocument, XMLDocument, XMLHTTPRequest och ett antal andra, implementerade i MSXML.DLL -biblioteket. Referensen till modulen MSXML_TLB måste finnas i listan Användningar.
XML DOM -enhet
Dokumentobjektmodellen representerar ett XML -dokument i en trädstruktur av grenar. XML DOM API: er tillåter applikationer att navigera i dokumentträdet och manipulera dess grenar. Varje gren kan ha en specifik typ (DOMNodeType), enligt vilken förälder- och undergrenarna bestäms. De flesta XML -dokument innehåller grenar av typelement, attribut och text. Attribut är en speciell sorts gren och är inte undergrenar. Speciella metoder som tillhandahålls av XML DOM -objekt används för att manipulera attribut.
Förutom att implementera World Wide Web Consortium (W3C) rekommenderade gränssnitt innehåller Microsoft XML DOM metoder som stöder XSL, XSL -mönster, namnområden och datatyper. Till exempel kan SelectNodes -metoden använda XSL -mönstersyntax för att hitta grenar i ett specifikt sammanhang, och TransformNode -metoden stöder att använda XSL för att utföra transformationer.
Testa XML -dokument
Som ett exempel XML-dokument, låt oss ta en musik-CD-ROM-katalog, som har följande struktur:
Vi är nu redo att börja titta på XML DOM -objektmodellen, med början på XMLDOMDocument -objektet.
XML -dokument - XMLDOMDokumentobjekt
Arbetet med ett XML -dokument börjar med att ladda det. För att göra detta använder vi Load -metoden, som bara har en parameter som anger URL: en för det laddade dokumentet. När du läser in filer från en lokal hårddisk anges endast det fullständiga filnamnet (protokollet: /// kan i detta fall utelämnas). Om XML -dokumentet är lagrat som en sträng använder du LoadXML -metoden för att ladda dokumentet.
Egenskapen Async används för att styra hur dokumentet laddas (synkron eller asynkron). Som standard är den här egenskapen inställd på True, vilket indikerar att dokumentet läses in asynkront och kontrollen returneras till programmet innan dokumentet laddas helt. Annars laddas dokumentet synkront och sedan måste du kontrollera värdet på ReadyState -egenskapen för att se om dokumentet har laddats eller inte. Du kan också skapa en händelsehanterare för OnReadyStateChange -händelsen som tar kontroll när värdet för egenskapen ReadyState ändras.
Följande visar hur du laddar ett XML -dokument med Load -metoden:
Använder ... MSXML_TLB ... procedur TForm1.Button1Click (Avsändare: TObject); var XMLDoc: IXMLDOMDocument; börja XMLDoc: = CoDOMDocument.Create; XMLDoc.Async: = Falskt; XMLDoc.Load (‘C: \ DATA \ DATA.xml’); // // Det är här koden som manipulerar // XML -dokumentet och dess grenar // XMLDoc: = Nil; slutet;
När dokumentet har laddats kan vi komma åt dess egenskaper. Egenskapen NodeName kommer att innehålla värdet #document, egenskapen NodeTypeString innehåller dokumentvärdet och egenskapen URL innehåller filen: /// C: /DATA/DATA.xml.
Felhantering
Av särskilt intresse är egenskaper relaterade till dokumentbehandling vid laddning. Till exempel returnerar egenskapen ParseError ett XMLDOMParseError -objekt som innehåller information om ett fel som uppstod under bearbetning av dokumentet.
För att skriva en felhanterare kan du lägga till följande kod:
Var XMLError: IXMLDOMParseError; ... XMLDoc.Load (‘C: \ DATA \ DATA.xml’); XMLError: = XMLDoc.ParseError; Om XMLError.ErrorCode<>0 Sedan // // Här hanterar vi felet // Else Memo1.Lines.Add (XMLDoc.XML); ... XMLDoc: = Nil;
För att ta reda på vilken information som returneras i händelse av ett fel, ändra följande katalogpost:
ta bort stängningselementet
Låt oss nu lägga till en ny gren. Nedan är koden som visar hur du lägger till en ny musik-CD-ROM-post:
Var NewNode: IXMLDOMNode; Barn: IXMLDOMNode; ... // Skapa en ny gren -