XML::SAX: Die zweite Generation

(Auszug aus "Perl & XML" von Erik T. Ray & Jason McIntosh)

Die Entwicklung der SAX-Parser warf ein Problem auf: Wie sollte man sie alle synchron mit der Standardschnittstelle halten? XML::SAX, ein hervorragendes Gemeinschaftswerk von Matt Sergeant, Kip Hampton und Robin Berjon, löst dieses Problem und unterstützt nebenbei auch noch SAX Level 2, was die anderen Module nicht taten.

"Was meinen Sie mit 'synchron mit der Standardschnittstelle halten'?" werden Sie fragen. Die ganze Zeit haben wir die Wunder einer Standardschnittstelle wie SAX gepredigt, die sicherstellen sollte, daß SAX-basierte Module wirklich austauschbar sind. Aber leider gibt es da ein kleines Problem: In Perl gibt es mehr als eine Möglichkeit, SAX zu implementieren. SAX wurde ursprünglich für Java entwickelt, eine wundervoll typsichere Sprache, in der man jedes einzelne Argument eines Handlers präzise festlegen kann. Derlei gibt es in Perl nicht.

Das war kein großes Problem für die älteren SAX-Module, über die wir bisher gesprochen haben. Sie unterstützen alle das relativ einfache SAX 1. Inzwischen bahnt sich aber eine neue Gruppe von Modulen den Weg, die allesamt SAX2 unterstützen. SAX2 ist erheblich komplizierter, weil hier die Unterstützung von Namensräume eingeführt wurde. Der Eventhandler eines Elements sollte jetzt sowohl das Präfix des Namensraums erhalten als auch den lokalen Namen. Wie soll diese zusätzliche Information in Parametern übergeben werden? In einem einzigen String, foo:bar? Oder in zwei Parametern?

Darüber entstand eine hitzige Debatte auf der Mailingliste perl-xml , bis sich einige Mitglieder entschlossen, die Spezifikation einer SAX-»Perle« zu entwickeln. (Wir werden gleich sehen, wie diese neue API für SAX2 eingesetzt wird.) Um andere zu ermuntern, sich an diesen neuen Standard zu halten, enthält XML::SAX eine Klasse namens XML::SAX::ParserFactory. Eine Factory ist ein Objekt, das nur einen einzigen Zweck hat: Objekte einer bestimmten Klasse zu generieren – in diesem Falle Parser. XML::SAX::ParserFactory ist nützlich, um Parsern ihre Hausarbeit zu erleichtern, zum Beispiel die Änderung von Optionen und andere Initialisierungsaufgaben. Sag der Factory, was für einen Parser Du möchtest, und sie erzeugt Dir eine Kopie.

XML::SAX hat das Zusammenwirken von XML und Perl deutlich verändert und geprägt. Das Modul baut auf den älteren auf, indem es die besten Eigenschaften übernimmt, vermeidet aber einige der Fehler. Um die Kompatibilität der Module sicherzustellen, gibt es zum Beispiel eine Basisklasse für Parser, die viele der eher uninteressanten Aufgaben eines Parsers abstrahiert. Der Entwickler kann sich dadurch auf die wirklich wichtigen Aufgaben konzentrieren. Auch für die Benutzer bietet diese abstrakte Schnittstelle einiges, insbesondere die Katalogisierung einer Unmenge von Modulen und ihrer Eigenschaften sowie die Möglichkeit, mit einer einfachen Query (Abfrage) zu gegebenen Eigenschaften ein Modul zu finden, das diese erfüllt. Das ist ein kühner Schritt und erfordert eine Menge neues Wissen. Seien Sie also auf viele neue Informationen und Details in diesem Abschnitt vorbereitet. Sie werden sehen: Es lohnt sich!

XML::SAX::ParserFactory

Wir beginnen mit dem Modul XML::SAX::ParserFactory, einer Schnittstelle zur Auswahl von Parsern. Wenn Sie bereits einmal mit DBI gearbeitet haben: Diese Klasse hat viel Ähnlichkeit damit. Sie ist ein Frontend für alle auf Ihrem Rechner installierten SAX-Parser. Sie verlangen einen Parser von der Factory, und diese erzeugt einen geeigneten. Nehmen wir einmal an, wir hätten ein Package XML::SAX::MyHandler erzeugt und wollten einen SAX-Parser, der die Events liefert.

Das folgende Beispiel zeigt, wie man den Parser bekommt und ihn zum Lesen einer Datei verwendet:

use XML::SAX::ParserFactory;
use XML::SAX::MyHandler;
my $handler = new XML::SAX::MyHandler;
my $parser = XML::SAX::ParserFactory->parser( Handler => $handler );
$parser->parse_uri( "foo.xml" );

Welchen Parser man genau bekommt, hängt unter anderem von der Reihenfolge ab, in der die Module installiert wurden. Der zuletzt installierte Parser (mit all den eventuell durch RequiredFeatures spezifizierten Fähigkeiten) wird standardmäßig zurückgegeben. Aber möglicherweise wollen Sie genau diesen nicht. Auch das ist kein Problem; XML::SAX betreut einen Katalog von SAX-Parsern, aus dem Sie wählen können. Jedesmal wenn Sie einen neuen SAX-Parser installieren, trägt er sich selbst in den Katalog der ParserFactory ein. Wenn Sie eine Parserklasse XML::SAX::BobsParser installiert haben, können Sie eine Instanz dieser Klasse bekommen, indem Sie die Variable $XML::SAX::ParserPackage wie folgt verwenden:

use XML::SAX::ParserFactory;
use XML::SAX::MyHandler;
my $handler = new XML::SAX::MyHandler;
$XML::SAX::ParserPackage = "XML::SAX::BobsParser( 1.24 )";
my $parser = XML::SAX::ParserFactory->parser( Handler => $handler );

Da die Variable $XML::SAX:ParserPackage den Wert XML::SAX::BobsParser(1.24) enthält, wird eine Instanz dieser Klasse erzeugt. Intern lädt die ParserFactory die Klasse mit Hilfe von require( ) und ruft dann deren new( )-Methode auf. Die Nummer 1.24 gibt die minimale Version an, die die geladene Klasse haben soll. Wenn die Klasse nicht auf Ihrem Rechner installiert ist oder nur in einer älteren Version, dann wird eine Ausnahme ausgelöst.

Um eine Liste aller bei XML::SAX registrierten Parserklassen zu bekommen, verwendet man die Methode parsers( ):

use XML::SAX;

my @parsers = @{XML::SAX->parsers( )};

foreach my $p ( @parsers ) {
   print "\n", $p->{ Name }, "\n";
   foreach my $f ( sort keys %{$p->{ Features }} ) {
      print "$f => ", $p->{ Features }->{ $f }, "\n";
   }
}

Die Methode liefert eine Referenz auf eine Liste von Hashes. Jeder Hash enthält Informationen über eine Parserklasse, unter anderem den Namen der Klasse und einen weiteren Hash mit ihren Fähigkeiten. Wenn wir das obige Programm ausführen, erfahren wir zum Beispiel, daß zwei Parserklassen bei XML::SAX registriert sind, die beide Namensräume unterstützen:

XML::LibXML::SAX::Parser
http://xml.org/sax/features/namespaces => 1

XML::SAX::PurePerl
http://xml.org/sax/features/namespaces => 1

Als diese Seiten geschrieben wurde, waren die beiden genannten Parser die einzigen, die in der XML::SAX-Distribution enthalten waren. XML::LibXML::SAX::Parser ist eine SAX-Schnittstelle, die auf der libxml2-Bibliothek aufbaut und die wir in Baumorientierte Verarbeitung noch näher kennenlernen werden. Um sie zu benutzen, benötigt man libxml2, eine kompilierte und dynamisch ladbare Bibliothek, die in C geschrieben ist. Sie ist sehr schnell, aber wenn man keine passende Binärdatei findet und keinen Compiler hat, dann wird man die mangelnde Portabilität dieses Moduls beklagen. XML::SAX::PurePerl ist dagegen komplett in Perl geschrieben, wie der Name schon sagt. Damit ist dieses Modul voll portabel, sofern ein Perl-Interpreter vorhanden ist. Damit stehen schon einmal die wichtigsten Möglichkeiten zur Verfügung.

Die explizit genannten Fähigkeiten eines Parsers sind sehr wichtig, weil sie einem Benutzer garantieren, daß ein Parser die verlangten Eigenschaften hat. Nehmen wir zum Beispiel an, Sie wollen einen validierenden Parser, der Namensräume unterstützt. Die Methode require_feature( ) der Factory sorgt dafür, daß Sie ihn bekommen:

my $factory = new XML::SAX::ParserFactory;
$factory->require_feature( 'http://xml.org/sax/features/validation' );
$factory->require_feature( 'http://xml.org/sax/features/namespaces' );
my $parser = $factory->parser( Handler => $handler );

Alternativ können Sie dieselbe Information auch im Konstruktor der Factory übergeben:

my $factory = new XML::SAX::ParserFactory(
           Required_features => {
                  'http://xml.org/sax/features/validation' => 1
                  'http://xml.org/sax/features/namespaces' => 1
           }
);
my $parser = $factory->parser( Handler => $handler );

Falls mehrere passende Parserklassen gefunden werden, wird die zuletzt installierte verwendet. Wenn die Factory allerdings keinen Parser mit den genannten Eigenschaften findet, dann löst sie eine Ausnahme aus.

Um weitere SAX-Module in den Katalog aufzunehmen, müssen Sie sie einfach per Download auf Ihr System übertragen und installieren. Die Installationsprozedur der Module muß natürlich XML::SAX kennen und die Module selbst im Katalog eintragen. Die Eintragung des Moduls geschieht durch den Aufruf der XML::SAX-Methode add_parser( ) mit einer Liste von Modulnamen als Argumente. Um sicherzustellen, daß die genannten Klassen die Konventionen eines SAX-Moduls erfüllen, implementiert man sie am besten als Subklassen von XML::SAX::Base. Wir werden Ihnen später noch ausführlicher zeigen, wie man einen Parser schreibt, installiert und in den Katalog einträgt.

Handlerschnittstelle von SAX2

Nachdem Sie einen Parser ausgewählt haben, müssen Sie als nächstes – wie gehabt – eine Klasse mit Handlermethoden schreiben. Diese Methoden haben die Aufgabe, die Eventströme eines SAX-Moduls zu verarbeiten, genau wie bei den SAX-Modulen, die wir bereits kennengelernt haben. XML::SAX spezifiziert die Events und deren Properties sehr genau. Dem Handler gewährt die Spezifikation beträchtliche Kontrolle bei gleichzeitiger strikter Einhaltung der geforderten Richtlinien.

Die unterstützten Eventhandler sind in verschiedene Gruppen aufgeteilt. Die uns am besten bekannten sind die Content-Handler , die zum Beispiel für Elemente und allgemeine Informationen über das Dokument verantwortlich sind. Kennengelernt haben wir auch schon die Entity-Resolver und die lexikalischen Handler, die CDATA-Abschnitte und Kommentare betreuen. DTD-Handler und Declaration-Handler kümmern sich um außerhalb des eigentlichen Dokuments stehenden Markup, vor allem um Deklarationen von Elementen und Entities. XML::SAX kennt darüber hinaus eine neue Gruppe namens Error-Handler . Diese werden im Falle von Fehlern aufgerufen.

Die wichtigste neue Eigenschaft dieser Art von Parsern ist die Unterstützung von Namensräumen, der wesentlichen Innovation von SAX2. Bis dato behandelten SAX-Parser einen qualifizierten Namen als einen einzelnen String: Das Präfix des Namensraums und der lokale Name waren stets miteinander verbunden. Nun bekommt man die Namensräume detailliert geliefert, wird über Beginn und Ende ihrer Gültigkeit informiert. Die Arbeit mit Namensräumen wird dadurch wesentlich erleichtert.

Content-Handler

Diese Gruppe von Handlern konzentriert sich auf den eigentlichen Inhalt eines Dokuments. Sie werden von den meisten Programmen implementiert, die SAX benutzen. Beachten Sie als nützliche Neuigkeit die Referenz auf einen Lokator, die dem Handler Einblick in wichtige Details des Parsers erlaubt. Die einzelnen Handlermethoden unterstützen außerdem neuerdings Properties für Namensräume.

set_document_locator( Lokator )
Wird zu Beginn vom Parser aufgerufen, um dem Handler Informationen über die Datenquelle zu verschaffen. Der Parameter Lokator ist eine Referenz auf einen Hash mit den folgenden Properties:

PublicID
Die Public-ID des aktuell vom Parser gelesenen Entity.

SystemID
Die System-ID des aktuell vom Parser gelesenen Entity.

LineNumber
Die Zeilennummer innerhalb des aktuell gelesenen Entity.

ColumnNumber
Die Spaltennummer innerhalb des aktuell gelesenen Entity.

Dieser Hash wird laufend aktualisiert und mit den neuesten Informationen versehen. Wenn Ihr Handler die gelesenen Daten nicht akzeptiert, kann der Lokator verwendet werden, um eine Fehlermeldung zu erzeugen, die unter anderem angibt, wo die fehlerhaften Daten stehen. Ein SAX-Parser sollte einen Lokator übergeben, muß es aber nicht. Aus diesem Grund sollte die Verwendung eines Lokators stets mit der Prüfung einhergehen, ob überhaupt einer vorhanden ist. Ferner sollten Sie den Lokator ausschließlich innerhalb eines Eventhandlers verwenden, das Ergebnis ist andernfalls nicht vorhersagbar.

start_document( Dokument )
Diese Handlermethode wird unmittelbar im Anschluß an set_document_locator( ) aufgerufen, bevor der Parser tatsächlich mit der Arbeit beginnt. Der Parameter Dokument ist eine Referenz auf einen leeren Hash, da dieses Event zur Zeit keine Properties hat.

end_document( Dokument )
Diese Handlermethode wird als allerletztes aufgerufen. Der Parser signalisiert damit ein Ende der zu lesenden Daten oder einen Fehler, der zum Abbruch des Parsens führt. Der Rückgabewert dieser Methode wird vom Parser seinerseits als Ergebnis der Methode parse( ) zurückgegeben. Der Parameter Dokument ist wiederum leer.

start_element( Element )
Wenn der Parser das Start-Tag eines Elements findet, ruft er diese Methode auf. Der Parameter Element ist ein Hash mit den Properties des Elements, unter anderem den folgenden:

Name
Der Name des Elements, einschließlich eines eventuellen Namensraum-Präfixes.

Attributes
Eine Referenz auf einen Hash mit Attributen. Jedes Attribut erscheint unter dem Schlüssel { NamespaceURI } LocalName. Der Wert ist wiederum eine Referenz auf einen Hash mit den Properties des Attributes.

NamespaceURI
Der Namensraum des Elements.