Meng Xianhui
Aufgrund der echten Plattformunabhängigkeit von XML (Extensible Markup Language: eXtensible Markup Language) wird es nach und nach zum Hauptmedium für die Datenübertragung. XML ist eine selbstbeschreibende Sprache und die Daten selbst enthalten bereits Metadaten, also Informationen über die Daten selbst. Zum Beispiel: „Mencius Chapter E 1757281793923net_lover1807581793923“ Dieser Datensatz ist schwer zu erkennen, was er wörtlich bedeutet, und es ist nicht klar, aus wie vielen Datensegmenten er besteht. Wenn wir jedoch XML verwenden, um ihn wie folgt zu beschreiben Sie können die Bedeutung jedes Datensegments deutlich erkennen:
<PersonData>
<Person>
<Name>Mencius Kapitel E</Name>
<Height>175</Height>
<Gewicht>72</Gewicht>
<Tel>81793923</Tel>
</Person>
<Person>
<name>net_lover</name>
<Höhe>180</Höhe>
<Gewicht>75</Gewicht>
<Tel>81793923</Tel>
</Person>
</PersonData>
Aus dem obigen XML-Teil können wir nicht nur klar erkennen, was die einzelnen Daten darstellen, sondern auch wissen, wo die Daten aufgeteilt sind. In unseren üblichen Anwendungen können die Ergebnisse in Form von Arrays, Sammlungen oder Recordsets vorliegen. Wie konvertieren wir sie in selbstbeschreibende Daten im XML-Format? Aus Sicht der Datenform ist XML ein einfaches Textformat für reine Zeichenfolgen. Die Übertragung von Arrays per Referenz ist manchmal sehr mühsam und die Verarbeitung und Aufzeichnung ist sehr aufwändig Sätze sind beide Objekte, was zu einer Verringerung der Computerleistung während der Verarbeitung führt, und diese Objekte sind mit einer bestimmten Plattform verknüpft, was erfordert, dass die Plattform über einen integrierten Verarbeitungsmechanismus zur Verarbeitung von Objektoperationen verfügt. XML ist bereits ein W3C-Standard und plattformunabhängig. Die einzige Voraussetzung für unsere Computer ist, dass sie einfache XML-Strings verarbeiten können, d. h. ein XML-Parser kann XML-Strings einfach zerlegen unabhängige Datensegmente, damit wir darauf zugreifen können. XML-Parser sind klein, leistungsstark und auf jeder Plattform zu finden. Sobald wir die XML-Daten erhalten und sie im Stil des obigen Beispiels analysieren, können wir sie über XSLT (eXstensible Stylesheet Language Transformations) in verschiedene Darstellungen konvertieren. Durch die Verwendung des XML-Datenformats für die Datenübertragung wird das Schreiben von Anwendungscode einfacher und einfacher und die Skalierbarkeit ist gut.
Schauen wir uns als Nächstes an, wie wir unsere Daten konvertieren. Unser Beispiel ist unter Microsoft Windows 2000, IIS5, MSXML3 und ADO2.6 geschrieben. Die Beispieldaten verwenden die Northwind-Beispieldatenbank, die mit Microsoft SQL Server 7.0 geliefert wird. Der Grund, warum wir SQL Server7 anstelle von SQL Server2000 verwenden, der XML unterstützt, besteht darin, das Prinzip der Universalität zu berücksichtigen. Unser Zweck besteht darin, die aus verschiedenen Arten von Datenquellen erhaltenen Datensätze zu verarbeiten, und nicht nur die XML-Ausgabe wie SQL Server2000 . Verwenden Sie ADO, weil es verschiedene Formen hat und verschiedene Arten von Datenquellen verarbeiten kann; verwenden Sie XML, weil es schnell übertragen und analysieren kann. Die Verarbeitungsmethode in diesem Beispiel eignet sich jedoch auch für jede Umgebung mit Microsoft XML-Parser, ADO2.5 oder einer höheren Windows-Version, IIS und SQL Server.
Der Einfachheit halber wählen wir nur Produkte aus, deren Stückpreis kleiner oder gleich 20 US-Dollar ist, deren Lagerbestand größer oder gleich 20 US-Dollar ist und deren Produktname kleiner oder gleich 6 Zeichen ist:
<%
Dimmen Sie objRecordset
Set objRecordset = Server.CreateObject("ADODB.Recordset")
objRecordset.open _
„SELECT ProductName, UnitPrice, UnitsInStock“ _
& „VON Produkten“ _
& "WHERE UnitPrice <= 20 " _
& "AND UnitsInStock >= 20 " _
& "AND LEN(ProductName) <= 6 " _
& "ORDNUNG NACH Produktname", _
„Anbieter=SQLOLEDB;“
& "Datenquelle=SomeSQLServer;"
& "Erstkatalog=Northwind;"
& "Benutzer-ID=MeinBenutzername;"
& "Passwort=MeinPasswort;"
%>
Jetzt verwenden wir drei Methoden, um den erhaltenen Datensatz in das XML-Format zu konvertieren.
Zunächst können wir den gesamten Datensatz durchlaufen, XML DOM (Document Object Model) verwenden und einen XML-Knotenbaum erstellen:
<%
Dimmen Sie objXMLDOM, objRootNode, objNode
Setze objXMLDOM = Server.CreateObject("MSXML2.DOMDocument")
Setze objRootNode = objXMLDOM.createElement("xml")
objXMLDOM.documentElement = objRootNode
Tun Sie dies NICHT objRecordset.EOF
Setze objRowNode = objXMLDOM.createElement("row")
Setze objNode = objXMLDOM.createElement("ProductName")
objNode.text = objRecordset.Fields.Item("ProductName").Value
objRowNode.appendChild(objNode)
Setze objNode = objXMLDOM.createElement("UnitPrice")
objNode.text = objRecordset.Fields.Item("UnitPrice").Value
objRowNode.appendChild(objNode)
Setze objNode = objXMLDOM.createElement("UnitsInStock")
objNode.text = objRecordset.Fields.Item("UnitsInStock").Value
objRowNode.appendChild(objNode)
objRootNode.appendChild(objRowNode)
objRecordset.MoveNext
Schleife
Setze objNode = Nothing
Setze objRowNode = Nothing
Setze objRootNode = Nothing
Setze objRecordset = Nothing
%>
Jetzt haben wir ein XML-DOM-Objekt. Die Leistung dieser Methode ist nicht optimal, wenn das Recordset groß ist, da das ADO-Recordset-Objekt und das XML-DOM-Objekt gleichzeitig im Systemspeicher gespeichert werden müssen.
Die zweite Methode besteht darin, den Datensatz zu durchlaufen und direkt die XML-Zeichenfolge selbst zu generieren:
<%
Dimmen Sie strXML
strXML = "<xml>"
objRecordset.MoveFirst
Tun Sie dies NICHT objRecordset.EOF
strXML = strXML & "<Zeile>"
strXML = strXML & "<Produktname>" _
& objRecordset.Fields.Item("ProductName").Value _
& "</ProductName>"
strXML = strXML & "<UnitPrice>" _
& objRecordset.Fields.Item("UnitPrice").Value _
& "</UnitPrice>"
strXML = strXML & "<UnitsInStock>" _
& objRecordset.Fields.Item("UnitsInStock").Value _
& "</UnitsInStock>"
strXML = strXML & "</row>"
objRecordset.MoveNext
Schleife
strXML = strXML & "</xml>"
Setze objRecordset = Nothing
%>
Der größte Fehler der beiden oben genannten Methoden besteht jedoch darin, dass der Code nicht wiederverwendet werden kann. Wenn wir verschiedene Felder abfragen, müssen wir unseren Code auch manuell ändern, um den Anforderungen verschiedener Knoten gerecht zu werden. Im Folgenden wird unser Ansatz allgemeiner.
Die dritte Methode: wiederverwendbare Methode.
<%
Dimmen Sie strXML
strXML = "<xml>"
objRecordset.MoveFirst
Tun Sie dies, während NICHT objRecordset.EOF
strXML = strXML & "<Zeile>"
Für jedes varItem in objRecordset.Fields
strXML = strXML _
& "<" & varItem.name & ">" _
&varItem.value_
& "</" & varItem.name & ">"
Nächste
strXML = strXML & "</row>"
objRecordset.MoveNext
Schleife
strXML = strXML & "</xml>"
Setze objRecordset = Nothing
%>
Eine effektivere Methode ist die direkte Verwendung der integrierten Speichermethode des Recordsets, die den Inhalt des Recordsets automatisch in das XML-Format konvertieren kann. Nachdem wir die Speichermethode aufgerufen haben, können wir die Recordset-Objektinstanz sofort im Speicher freigeben. . Die Speichermethode verfügt über zwei Parameter: Der eine ist der Ort, an dem das XML gespeichert werden soll, und der andere ist ein Indikator, der das Format angibt, in dem die Daten gespeichert werden. Wir können die Daten als XML-DOM-Objekt (ADO-STREAM-Objekt) oder direkt als ASP-RESPONSE-Objekt speichern. Der Allgemeinheit halber speichern wir sie als XML-DOM und verwenden die adPersistXML-ADO-Konstante für den zweiten Parameter . So geht's:
<%
Const adPersistXML = 1
Dimmen Sie objXMLDOM
Setze objXMLDOM = Server.CreateObject("MSXML2.DOMDocument.3.0")
objRecordset.save objXMLDOM, adPersistXML
Setze objRecordset = Nothing
%>
Diese Methode ist bequem, schnell und fehlerfrei. Es ist nicht erforderlich, den Knotennamen für verschiedene Abfragen manuell zu ändern. Das mit dieser Methode erzeugte XML ist jedoch nicht prägnant genug. Schauen Sie sich das Ergebnis an:
<xml
xmlns:s="uuid:BDC6E3F0-6DA3-11d1-A2A3-00AA00C14882"
xmlns:dt="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882"
xmlns:rs="urn:schemas-microsoft-com:rowset"
xmlns:z="#RowsetSchema">
<s:Schema id="RowsetSchema">
<s:ElementType
name="Zeile"
content="eltOnly"
rs:CommandTimeout="30">
<s:AttributeType
name="Produktname"
rs:number="1"
rs:writeunknown="true">
<s:datatype
dt:type="string"
dt:maxLength="40"
rs:maybenull="false"/>
</s:AttributeType>
<s:AttributeType
name="Einheitspreis"
rs:number="2"
rs:nullable="true"
rs:writeunknown="true">
<s:datatype
dt:type="Nummer"
rs:dbtype="Währung"
dt:maxLength="8"
rs:precision="19"
rs:fixedlength="true"/>
</s:AttributeType>
<s:AttributeType
name="UnitsInStock"
rs:number="3"
rs:nullable="true"
rs:writeunknown="true">
<s:datatype
dt:type="i2"
dt:maxLength="2"
rs:precision="5"
rs:fixedlength="true"/>
</s:AttributeType>
<s:extends type="rs:rowbase"/>
</s:ElementType>
</s:Schema>
<rs:data>
<z:row
Produktname="Chai"
UnitPrice="18"
UnitsInStock="39"/>
<z:row
Produktname="Konbu"
UnitPrice="6"
UnitsInStock="24"/>
<z:row
Produktname="Tofu"
UnitPrice="23,25"
UnitsInStock="35"/>
</rs:data>
</xml>
Das von ADO automatisch generierte XML enthält Schemainformationen, die beschreiben, welche Knoten und Attribute in diesem XML zulässig sind und welche Datentypen verwendet werden und welche Datenknoten vorhanden sind auch vergrößerter Namensraum. Schemainformationen können nützlich sein, wenn eine Datenvalidierung erforderlich ist oder eine komplexere Verarbeitung erforderlich ist. In den meisten Fällen verwenden wir jedoch Thin Clients und benötigen keine Schemainformationen. Wir können XSLT verwenden, um die gewünschten Informationen herauszutrennen und redundante Informationen zu entfernen. Daher schreiben wir folgendes „DataCleaner.xsl“:
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
xmlns:xsl=" http://www.w3.org/1999/XSL/Transform "
xmlns:s="uuid:BDC6E3F0-6DA3-11d1-A2A3-00AA00C14882"
xmlns:dt="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882"
xmlns:rs="urn:schemas-microsoft-com:rowset"
xmlns:z="#RowsetSchema">
<xsl:output omit-xml-declaration="yes"/>
<xsl:template match="/">
<xsl:element name="xml">
<xsl:for-each select="/xml/rs:data/z:row">
<xsl:element name="row">
<xsl:for-each select="@*">
<xsl:element name="{name()}">
<xsl:value-of select="."/>
</xsl:element>
</xsl:for-each>
</xsl:element>
</xsl:for-each>
</xsl:element>
</xsl:template>
</xsl:stylesheet>
Dieses XSLT verfügt über wiederverwendbare Funktionen und ist auf verschiedene Abfrageergebnisse anwendbar. Im Folgenden finden Sie ein Beispiel für die Verwendung dieses XSLT:
<%
Dimmen Sie strCleanXML, objXMLDOM_XSLT
Setze objXMLDOM_XSLT = CreateObject("MSXML2.DOMDocument")
objXMLDOM_XSLT.load(Server.MapPath("DataCleaner.xsl"))
strCleanXML = objXMLDOM.transformNode(objXMLDOM_XSLT)
Setze objXMLDOM = Nichts
Setze objXMLDOM_XSLT = Nichts
%>
Nach der obigen Verarbeitung ist strClaenXML die gewünschte XML-Zeichenfolge.
<xml>
<Zeile>
<ProductName>Chai</ProductName>
<UnitPrice>18</UnitPrice>
<UnitsInStock>39</UnitsInStock>
</row>
<Zeile>
<ProductName>Konbu</ProductName>
<UnitPrice>6</UnitPrice>
<UnitsInStock>24</UnitsInStock>
</row>
</xml>
Der XML-String im oben genannten Format ist der Knotensatzstil, den wir häufig sehen. Wenn Sie das Feld nicht in einen Knoten, sondern in einen Attributknoten verarbeiten möchten, müssen wir nur geringfügige Änderungen an DataCleaber vornehmen. xsl:
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
xmlns:xsl=" http://www.w3.org/1999/XSL/Transform "
xmlns:s="uuid:BDC6E3F0-6DA3-11d1-A2A3-00AA00C14882"
xmlns:dt="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882"
xmlns:rs="urn:schemas-microsoft-com:rowset"
xmlns:z="#RowsetSchema">
<xsl:output omit-xml-declaration="yes"/>
<xsl:template match="/">
<xsl:element name="xml">
<xsl:for-each select="/xml/rs:data/z:row">
<xsl:element name="row">
<xsl:for-each select="@*">
<xsl:attribute name="{name()}">
<xsl:value-of select="."/>
</xsl:attribute>
</xsl:for-each>
</xsl:element>
</xsl:for-each>
</xsl:element>
</xsl:template>
</xsl:stylesheet>
Das Folgende ist das Ergebnis der Verwendung des neuen Stils, der viel kürzer ist als die Verwendung von Knoten zur Darstellung der Feldlänge. Die Übertragungsgeschwindigkeit wird schneller sein:
<xml>
<row ProductName="Chai" UnitPrice="18" UnitsInStock="39"/>
<row ProductName="Konbu" UnitPrice="6" UnitsInStock="24"/>
</xml>
Bisher haben wir mehrere Möglichkeiten zum Abrufen von Daten im XML-Format aus ADO-Datensatzsätzen eingeführt und auch die einfachste Zeichenfolge erhalten. Es gibt jedoch noch einige Probleme, auf die Sie achten müssen. Einige Feldwerte enthalten Zeichen, die in XML nicht unterstützt werden, wie zum Beispiel: „'< >&, wie der Name von P&G Procter & Gamble, der Name von Das Gumbo Mix-Produkt von Chef Anton usw. Sie müssen dies beim Konvertieren durchführen. Führen Sie die Codierungsverarbeitung durch. Bei der Verwendung der Speichermethode im Microsoft ADO 2.6 SDK sind folgende Probleme zu beachten: 1. Die Speichermethode funktioniert nur bei geöffneten Recordsets mit Feldern der Typen adVariant, adIDispatch und adIUnknown werden nicht unterstützt. Beim Speichern hierarchischer Recordsets (Datenformen) können keine Parametrisierungen und Recordsets gespeichert werden.
Um die Leistung weiter zu verbessern, können Sie die Konvertierungsarbeit in COM/COM+-Komponenten verlagern und der ASP-Code führt nur die endgültige Darstellung der Daten durch. Trennen Sie die Geschäftsschicht, die Datenschicht und die Präsentationsschicht. ASP muss nur die gespeicherte Prozedur der Datenbank aufrufen, das Ergebnis in XML konvertieren und schließlich die einfache XML-Zeichenfolge an das ASP-Programm zurücksenden , und ASP kann XSLT verwenden, um das XML zu konvertieren und das Ergebnis an den Browser zu senden.