Twittern ist doch sehr trendig. Seit 2007 gibt es die Twitter API – hier soll ein kleines Script vorgestellt werden, mit welchem ihr munter von eurer Webseite loszwitschern könnt. Das alles läuft mit ein paar Zeilen PHP Code und einem Zugang zur Twitter API.

Die API von Twitter wurde 2007 veröffentlicht. Mittlerweile gibt es natürlich auch eine PHP Programmbibliothek, mit der Sie Twitter z.B. in Ihr Blog integrieren können. Auf Dr.Web.de wurde ein kleines Wordpress Plugin vorgestellt, mit dem man automatisch Nachrichten an Twitter senden kann. Das ganze Skript können Sie hier herunterladen.

Es besteht aus einer Datei. Einem Script, um die Nachrichten an Twitter zu senden und einem Formular, über welches die Nachrichten eingegeben werden.

Der PHP Code für das Senden der Message ist wie folgt:

insertTwitterMsg.php
<?php
$twitter_username ='yourTwitterUserName';
$twitter_psw ='yourTwitterPassword';
require('twitterAPI.php');
if(isset($_POST['twitter_msg']))
{
$twitter_message=$_POST['twitter_msg'];
if(strlen($twitter_message)<1){
$error=1;
} else {
$twitter_status=postToTwitter($twitter_username, $twitter_psw, $twitter_message);
}
}
?>

Hier müssen Sie lediglich ihren Twitter-Benutzername sowie ihr Twitter Passwort anpassen. In der ersten Zeile wird die Twitter API eingefügt. Diese ist ebenfalls in der ZIP Datei enthalten. Daraufhin folgt eine Überprüfung ob die Message auch mindestens ein Zeichen enthält. Wenn nicht, spuckt das Skript eine Fehlermeldung us.

Ansonsten wird die Nachricht an Twitter über die Funktion postToTwitter() gesendet; diese steckt in der Twitter API. Das Formular, über welches die Messages eingegeben werden ist ebenfalls in der insertTwitterMsg.php implementiert.

<!-- Send message to Twitter -->
<?php
if(isset($_POST['twitter_msg']) && !isset($error)){?>
<div><?php echo $twitter_status ?></div>
<?php } else if(isset($error)){?>
<div>Error: please insert a message!</div>
<?php }?>
<p><strong>What are you doing?</strong></p>
<form action="insertTwitterMsg.php" method="post">
<input name="twitter_msg" type="text" id="twitter_msg" size="40" maxlength="140"/>
<input type="submit" name="button" id="button" value="post" />
</form>

Sofern in der Umgebungsvariable $_POST[''] die Message noch nicht definiert ist, oder ein Fehler entstanden ist – etwa weil die Nachricht weniger als ein Zeichen hatte, so wird die Fehlermeldung ausgegeben. Ansonsten wird der Twitter Status ausgegeben, welcher besagt, ob die Message erfolgreich übertragen wurde. Daruner wird das Formular ausgegeben. So einfach gehts!

Weiterführende Links:

1. Diese Seite weiterempfehlen…

Vielleicht kennen Sie das Problem? Sie möchten, dass in viel HTML Code, z.B. aus einer Datenbank, automatisch die src-Attribute an img-Tags angepasst werden. Sei es z.B., dass aus

<img src="/images/bild.jpg" alt="Ein Bild" /> automatisch <img src="http://www.testseite.de/images/bild.jpg" alt="Ein Bild" /> werden soll.

Jetzt sind Sie sich aber nicht sicher, ob sie wirklich nur valides HTML verwendet haben? Also es soll auch folgendes ersetzt werden:

<IMG src="test/images/bild.jpg" alt="Ein Bild" /> oder

<imG SRC='mein_blog/images/bild.jpg' alt="Ein Bild">

Folgende Zeilen PHP Code erledigen das gewünschte:


$old = "Alter HTML Code, etwa <img src="/images/bild.jpg" alt="Ein Bild" />
$neue_url = "http://www.testseite.de";
$pattern = '/(<img.+?src=)(["\']?)([^\'"]+?)([^\/]+)(\2.*?\/?>)/is';
$replace = "$1$2".$neue_url."$4$5";
$new = preg_replace($pcre, $replace, $old);

Zu dem Code gibt es noch eine kurze Erklärung. Das zweite Subpattern fängt das linke Quote-Zeichen auf, oder eben keins, wenn keins da ist – falls der HTML code nicht valide ist. Das dritte passt auf den Pfad und wird deshalb ersetzt. Das vierte Subpattern erfasst alles nach dem letzten Slash bis zum Ende des Dateinamens. ‘\2′ ist eine Rückreferenz (”back reference”) und passt auf exakt das gleiche Zeichen wie das zweite Subpattern, also ‘”‘, “‘” oder kein Zeichen. Der Rest versucht alle möglichen Arten von img-Tags zu erfassen: “<img …>”, “<img …/>” und “<img … />”.

So sollte es fuktioieren

Weiterführende Links:

1. Browserkompatibilität – Problematische Tags
2. Meta Tags nach Dublin Core

Ein schlichter Onlinechat ist eigentlich schwierig zu realisieren, da die neu eingegangenen Messages stets vom Server geladen werden müssen. Dies bedeutete bisher, dass die Seite neu geladen werden musste. Um dies zu umgehen, hat man auf andere Möglichkeiten gesetzt, wie zum Beispiel JavaApplets. Mit AJAX wird die Sache erleichtert, da man die Seiten nicht mehr neu im Browser laden muss. Die periodische Überprüfung nach neuen Messages kann über JavaScript und XMLHttpRequests mit der setTimeOut-Funktion gesteuert werden.

Hört sich einfach an – ist es im Grunde auch so. Bei Dr.Web wurde bereits einmal von mir ein Skript vorgestellt, mit dem auf einfache Art eine Shoutbox programmiert wurde. Dieses Skript soll nun Schritt-für-Schritt AJAX tauglich gemacht werden und zu einem Chat umfunktioniert werden.

Im Internet gibt es bereits OpenSource-AJAX-Chat-Anwendungen, zum Beispiel Lace und Treehouse. Unser Beispiel wurde entwickelt, um im Rahmen dieser Artikelserie AJAX näher zu bringen. Das Beispiel weist längst nicht alle Features auf, die möglich wären, ist so aber besser verständlich.

Rollen wir das Feld von hinten auf und beginnen wir mit dem so genannten Server Backend. In unserem Fall ist das eine MySQL Datenbank. Für unsere kleine Anwendung verwenden wir eine Tabelle Namens "ajaxChat", welche die Felder id, name, nachricht und date hat; diese kann mit folgender SQL-Anweisung erzeugt werden:

CREATE TABLE `ajaxChat` (
`id` LONGINT NOT NULL AUTO_INCREMENT ,
`name` VARCHAR( 60 ) NOT NULL ,
`nachricht` VARCHAR( 120 ) NOT NULL ,
`date` VARCHAR( 30 ) NOT NULL ,
PRIMARY KEY ( `id` )
);

Zunächst wird das Backend angegangen; zum einen die Datenbank, zum anderen das PHP-Skript, welches die XML-Antworten auf die http-Anfragen erzeugt.

Das PHP-Skript (nennen wir es ajaxchat.php) auf der Serverseite muss folgende Funktionalitäten aufweisen:

• Verbindung zur Datenbank öffnen und schließen.
• Nneue Einträge müssen in die Datenbank eingefügt werden können.
• Neue Einträge müssen abgeholt werden können; als Erkennung dient eine eindeutige ID.

Die Ausgabe der Daten, das heißt die asynchrone Antwort des Servers erfolgt über XML; dieses wird dann über JavaScript und CSS im Browser dargestellt.

Die Datenbankverbindung kann über folgenden Zeilen-Code geöffnet werden; die Variablen müssen an die jeweilige Serverumgebung angepasst werden.

<?php
//wichtig; damit nicht gecached wird!
header( "Cache-Control: no-cache, must-revalidate" );
header( "Pragma: no-cache" );
//damit unser JavaScript die Daten auch als XML erkennt
header("Content-Type: text/xml");

$db_host = "localhost"; // Host
$db_user = "root"; // User
$db_password = ""; // Passwort
$db_name = "test"; // Datenbank

mysql_connect($db_host,$db_user,$db_password) or die(mysql_error());
mysql_select_db($db_name) or die(mysql_error());

Nachrichten auslesen
Die Funktion, mit der stets die aktuellsten Nachrichten aus der Datenbank extrahiert werden:

function getLatestEntries($latestID) {

$query = "SELECT id, name, nachricht, date FROM ajaxchat WHERE id > $latestID ORDER BY id DESC LIMIT 20";
$erg = mysql_query($query);
echo "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
echo "<messages>";
while($erg2=mysql_fetch_array($erg)) //Erzeugung der XML Ausgabe
{
echo "<message><id>".$erg2['id'];
echo "</id><name>".$erg2['name'];
echo "</name><nachricht>".$erg2['nachricht'];
//Formatierung des Timestamps
echo "</nachricht><date>".date("d.m.Y H:i",$erg2['date']);
echo "</date></message>";
}
echo "</messages>";
}

Bei dieser Funktion kommt es insbesondere auf die SQL-Abfrage an; über die Bedingung id > $latestID, werden lediglich die Einträge ermittelt, deren ID größer (d.h. deren Einträge "frischer" sind), ermittelt. Die Variable latestID wird, wie wir weiter unten sehen werden, bei dem http Requests über JavaScript übergeben.

Durch den Zusatz ORDER BY id DESC in der SQL Abfrage wird sichergestellt, dass die Einträge absteigend ausgegeben werden; LIMIT 20 beschränkt die Ausgabe auf die letzten zwanzig Einträge. Die Erzeugung des XML-Codes erfolgt schlicht über die echo-Funktion (eine Verwendung der DOMXML Funktionen von PHP wäre bei dem geringen Aufwand nicht gerechtfertigt).

Neue Einträge
Das erzeugen von neuen Einträgen in die Tabelle erfolgt über folgende Funktion:

function createNewEntry($name, $nachricht) {

//HTML Tags entfernen
$name = strip_tags($name, '');
$nachricht = strip_tags($nachricht,'');

$query = "INSERT INTO ajaxchat(name, nachricht, date)
VALUES ('$name','$nachricht','".time()."')";
echo "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
if (!mysql_query($query)) {
//nicht notwendig, dient nur der Fehlerkontrolle
echo "<createNewEntry>0</createNewEntry>";}
else {
echo "<createNewEntry>1</createNewEntry>";
}
}

Dabei erzeugt die Funktion createNewEntry wiederum eine XML-Antwort; dieser schenken wir aber keine Beachtung. Sie wurde lediglich zur Fehlerüberprüfung implementiert, so dass man über JavaScript, falls es einen MySQL-Fehler beim Erzeugen eines neuen Eintrag gäbe, dies entsprechend im Browser anzeigen könnte - wenn man denn wollte.

Skriptsteuerung
Da alle Anfragen an ein und dasselbe Skript geschickt werden (ajaxchat.php), benötigen wir noch ein paar Zeilen-Code, mit denen sichergestellt wird, dass bei den Aufrufen auch die jeweils angesprochene Funktion ausgeführt wird. Wir arbeiten hierbei mit Parametern, die in die http Anfragen über das XMLHttpRequest Objekt eingebaut sind.

//falls action=createNewEntry, Erzeugung eines neuen Eintrages
if ($_GET['action'] == "createNewEntry") {
createNewEntry($_GET['name'], $_GET['nachricht']);
}
//falls action=getLatestEntries, Ausgabe der neuesten Einträge
elseif ($_GET['action'] == "getLatestEntries") {
getLatestEntries($_GET['latestID']);
}
mysql_close(); //schließen der PHP Verbindung
?>

Das PHP-Skript, der gesamte Backend ist noch relativ harmlos. Bei unserer AJAX-Engine wird es kniffliger.

Die AJAX Engine


Im zweiten Schritt wird die AJAX-Engine aufgebaut; mit ihr werden die http-Anfragen erzeugt und die Ergebnisse im Browser dargestellt

Die AJAX-Engine hat folgende Aufgaben:

• Erzeugung der http-Anfragen um neue Nachrichten vom Server zu erfragen-
• Erzeugung der http-Anfragen, über die neue Einträge in der Datenbank gespeichert werden.

Da später das Empfangen von Daten automatisiert wird beziehungsweise über die setTimeOut-Funktion gesteuert wird, ist es notwendig, dass wir für unsere Anwendung zwei XMLHttpRequest-Objekte erzeugen. Damit wird sichergestellt, dass man gleichzeitig sowohl Daten empfangen als auch senden kann.

Erzeugung zweier XMLHttpRequest-Objekte
Das JavaScript zur Erzeugung der XMLHttpRequest-Objekte ist identisch mit dem aus Teil 2 dieser Artikelserie:

<script type="text/javascript">
var latestID = 0; //latestID als globale Variable; wichtig!

function createXMLHttpReqObj() { //erzeugt die XMLHttpRequest Objekte

// für Mozilla etc.
if(window.XMLHttpRequest) {
try { //Fehler abfangen
req = new XMLHttpRequest();
} catch(e) {
req = false;
}
// für den InternetExplorer
} else if(window.ActiveXObject) {
try {
req = new ActiveXObject("Msxml2.XMLHTTP");
} catch(e) {
try {
req = new ActiveXObject("Microsoft.XMLHTTP");
} catch(e) {
req = false;
}
}
}
return req;
}
// Initialisierung der beiden Objekte
var httpGetLatestEntries= createXMLHttpReqObj();
var httpCreateNewEntry = createXMLHttpReqObj();

Neueste Einträge abfragen
Bei der Abfrage nach den neuesten Einträgen wird die LatestID in der http-Anfrage mit übergeben. Diese ist eine globale Javascript-Variable, da ihr Wert aus Funktionen heraus geändert wird. Initialisiert wird sie mit dem Wert null. Die URL zu dem Skript ajaxchat.php müssen Sie natürlich an Ihre Umgebung anpassen.

Die Funktion getLatestEntries sieht wie folgt aus:

//Funktion, mit der Anfragen nach neuen Einträgen gesendet wird
function getLatestEntries() {
//Anfrage senden, wenn Status der letzten Anfrage "completed" ist, bzw. "nicht initialisiert" (d.h. erster Aufruf)
if (httpGetLatestEntries.readyState == 4 || httpGetLatestEntries.readyState == 0) {
//Übergabe der latestID
httpGetLatestEntries.open("GET","
http://localhost/ajax/ajaxchat.php?
action=getLatestEntries&latestID="+latestID, true);
httpGetLatestEntries.onreadystatechange = handleHttpGetLatestEntries;
httpGetLatestEntries.send(null);
}
}

Als Funktion, mit welcher der Browser die Serverantwort behandelt ist die Funktion handleHttpGetLatestEntries angegeben:

//Behandelt die Serverantwort
function handleHttpGetLatestEntries() {

//wenn Anfrage den Status "completed" hat
if (httpGetLatestEntries.readyState == 4) {
//ermitteln der Antwort
response = httpGetLatestEntries.responseXML.documentElement;
//ermitteln der Messages; Überführung in ein Array
messages = response.getElementsByTagName('message');

//wenn es mindestens eine neue Nachricht hat, dann wird diese angezeigt!
if(messages.length > 0) {

for (var i=messages.length-1; i>=0; i--) {
//Darstellung im Browser mit dem DOM
showEntry= document.getElementById("showEntries");
neuSpan = document.createElement('span');
neuSpan.setAttribute('class','entry'); //CSS Klasse
neuSmall = document.createElement('small');
neuNameDate = document.createTextNode(messages[i].getElementsByTagName
('date')[0].firstChild.nodeValue + ': ' + messages[i].getElementsByTagName('name')[0].firstChild.nodeValue +': ');
neuSmall.appendChild(neuNameDate);
neuSpan.appendChild(neuSmall);
neuSpan.appendChild(document.createElement('br'));
neuNachricht = document.createTextNode(messages[i].getElementsByTagName
('nachricht')[0].firstChild.nodeValue);
neuSpan.appendChild(neuNachricht);
neuSpan.appendChild(document.createElement('br'));
showEntry.insertBefore(neuSpan, showEntry.firstChild);
}

//Festlegung der neuen latestID; Zugriff auf die Werte über das DOM
latestID = messages[0].getElementsByTagName('id')[0].firstChild.nodeValue;
}
//erneuter periodischer Aufruf (eine Art Rekursion)
setTimeout('getLatestEntries();',3000); //Erneute Anfrage in drei Sekunden
}
}

Über diese wird, sofern die Anfrage erfolgreich war, die XML-Daten vom Server in ein Array (messages) überführt und im Browser dargestellt. Dies findet jedoch nur statt, wenn es auch neue Nachrichten zum Anzeigen gibt (wenn messages.length >0), das heißt wenn die Anfrage an das PHP-Skript auch eine neue Nachricht zurückgegeben hat. Ist dies der Fall, wird die latestID nach der Darstellung der neuen Nachrichten im Browser aktualisiert. Da dies aus einer Funktion heraus geschieht, wird klar, weshalb latestID eine globale Variable sein muss.

Über die setTimeOut-Funktion wird nun unsere periodische Überprüfung nach neuen Einträgen durch den Aufruf der Funktion getLatestEntries alle drei Sekunden initialisiert; dabei handelt es sich um eine Art "verzögerte Rekursion".

Neue Nachrichten eintragen
Die JavaScript Funktionen, über welche neue Einträge an den Server gesendet werden, sind ähnlich aufgebaut, wie die vorherigen Funktionen. Mit der ersten Funktion createNewEntry wird die http-Anfrage erzeugt, wobei ihr die Werte für die Felder name und nachricht aus dem HTML-Formular übergeben werden.

//neue Nachricht auf dem Server erzeugen; die Übergabe der Werte erfolgt über das HTML Formular
function createNewEntry(name, nachricht) {

//Anfrage senden, wenn Status der letzten Anfrage "completed" ist, bzw. "nicht initialisiert" (d.h. erster Aufruf)
if (httpCreateNewEntry.readyState == 4 || httpCreateNewEntry.readyState == 0) {
//URL für HTTP Anfrage; muss angepasst werden
url = 'http://localhost/ajax/ajaxchat.php?action=createNewEntry&name=' + name + '&nachricht=' + nachricht;
httpCreateNewEntry.open("GET", url, true);
httpCreateNewEntry.onreadystatechange = handleHttpCreateNewEntry;
httpCreateNewEntry.send();
}
}

Die Antwort vom Server wird über die Funktion handleHttpCreateNewEntry abgearbeitet; diese ist relativ kurz:

//behandelt die Antwort des Servers
function handleHttpCreateNewEntry() {
if (httpCreateNewEntry.readyState == 4) {
//nachdem eine neue Nachricht erfolgreich erzeugt wurde, wird diese angezeigt
getLatestEntries();
}
}

Nachdem die Daten erfolgreich in der Datenbank hinterlegt wurden, wird die Funktion getLatestEntries() wiederum aufgerufen, um sicherzustellen, dass die neue Nachricht auch sofort angezeigt wird.

Das Frontend
Nachdem nun die AJAX-Engine aufgestellt ist, wenden wir uns dem Frontend zu. Auch hier ist JavaScript gefragt. So können die Eingaben über JavaScript überprüft werden; die Darstellung der Nachrichten kann über eine CSS-Klasse beeinflusst werden.

Das Formular
Das Formular ist simpel gehalten; es gibt lediglich Eingabefelder und einen Submit-Button:

<form name="form1" method="post" action="">
<p>Name<br />
<input type="text" name="name" id="name">
<br />
<br />
Nachricht<br />
<input type="text" name="nachricht" id="nachricht">
</p>
<p>
<input type="submit" name="Submit" value="Submit" onclick="checkInput(document.form1.name.value, document.form1.nachricht.value)" >
</p>
</form>

Nachdem man auf den Submit-Button geklickt hat, wird die JavaScript-Funktion checkInput aufgerufen; an diese werden die eingegebenen Daten weitergegeben. In ihr wird die Eingabe überprüft.

Eine solche Überprüfung könnte im einfachsten Fall wie folgt aussehen:

function checkInput(name, nachricht) {
if(name != "" && nachricht != "") {
//Falls alles OK ist, kann der neue Eintrag erzeugt werden
createNewEntry(name, nachricht);
}
else {
alert("Bitte sowohl einen Namen, als auch eine Nachricht eingeben!");
}
}

Die Darstellung der Ergebnisse kann mit Hilfe von CSS beeinflusst werden. Dazu greifen wir auf die über das DOM zugewiesene CSS-Klasse "entry" zurück; über folgende Zeilen könnte man die Darstellung im Browser ein wenig ansehnlicher machen.

<style type="text/css">
.entry {
width: 100%;
background-color: #F5F5F5;
border: 1 dotted #666666;
font-family: Verdana;
}
.entry#small {
color: #CCCCCC;
}
</style>

So könnte das Ergebnis im Browser aussehen:

AJAX Chat in der konkreten Anwendung

Der Aufruf des Skriptes kann über einen onLoad-Event im Body-Tag der HTML-Seite (<body onload="getLatestEntries()">), in welcher das Formular eingebettet ist, eingeleitet werden; dabei wird die Funktion getLatestEntries das erste mal aufgerufen, wodurch die setTimeOut-Endlosschleife gestartet wird.

Alles in allem, war es ein langer Weg von der Idee zur konkreten Umsetzung. AJAX bedeutet nicht nur, dass die Webseiten in Zukunft in ihrem Verhalten normalen Desktop-Anwendung ähneln können, sondern bringt auch viel Arbeit mit sich. Vor allem das Zusammenspiel von JavaScript und XML klappt bislang nicht immer reibungslos.

Das hier vorgestellte Beispiel besitzt zudem einen Bug, der nicht verschwiegen werden darf. Auf der JavaScript Seite kann nicht mit Umlauten oder anderen Sonderzeichen umgegangen werden; diese verursachen einen Fehler. Alle Dateien gibt es wie immer als Paket zum Download.

(tf)
Dieser Artikel ist ebenfalls bei Dr.Web erschienen

Weiterführende Links:

1. AJAX: Die Zukunft des Webs?
2. AJAX: Das XMLHttpRequest Objekt
3. Twitter API – Nachrichten senden

In herkömmlichen Webanwendungen werden Formulare ausgefüllt und abgeschickt. Bis dies geschieht, bleiben die Daten auf der Clientseite, der Server bekommt nicht mit, dass Daten in das Formular gefüllt werden. Stürzt nun der Browser mitten während des Ausfüllens ab, sind die Daten verloren, da sie ja nicht abgeschickt wurden.

Ein solches Szenario kann man mit dem Ansatz von AJAX verhindern. Dabei werden bereits während des Ausfüllens von Formularen asynchron die Daten zum Server über das Javascript Objekt XMLHttpRequest geschickt.

Die Kommunikation kann auch anders herum erfolgen; das heißt, wenn der Benutzer zum Beispiel Daten eingibt, wie die Postleitzahl, so kann der Server direkt nach dem Eingeben der Postleitzahl in einer Datenbank nach dem korrespondierenden Ortsnamen suchen und diese im Formular anzeigen. Das heißt man muss Änderungen im Formular nicht mehr explizit abschicken, das wird im Hintergrund erledigt.

Zum einen wird damit die Serverlast ein wenig heruntergeschraubt, da die Daten in kleinen Paketen gesendet werden, zum anderen wird das Ausfüllen und Absenden von Formularen beschleunigt. Dieser Ansatz wird als Asynchronous Javascript and XML bezeichnet – kurz AJAX; dabei ist AJAX keine eigene Technologie, sondern lediglich eine Kombination von bereits existierenden und profilierten Technologien. AJAX wird bereits ausgiebig im Internet, unter anderem von Google und Co. verwendet.

Das wohl bekannteste Beispiel ist Google Suggest. Dabei wird bereits während der Eingabe eines Suchstrings nach etwaigen Ergänzungen gesucht und die voraussichtliche Ergebniszahl zu dem Suchbegriff angezeigt. Das Ganze funktioniert, während man im Suchfeld Suchbegriffe eingibt. So kann man schon vorweg sehen, ob es sich lohnt, die Suche genauer zu spezifizieren, sollten sich etwa zu viele Suchergebnisse finden.

Google Suggests - Während der Eingabe werden von Google Vorschläge für die Suche angezeigt

Mit dem AJAX-Ansatz könnte man das Stop-and-Go-Verhalten von Webapplikationen umgehen; der Benutzer muss nicht mehr auf den Server warten, da alles im Hintergrund geregelt wird.

Über das XMLHttpRequest Objekt ist es möglich, über JavaScript und XML mit Webapplikationen, die auf dem Server laufen, zu interagieren. Dabei werden die Daten, zum Beispiel aus Formularen in Form von HTTP-Anfragen versendet. Das funktioniert ähnlich wie mit SOAP oder generell wie bei Webservices, nur das hier über JavaScript mit einer Applikation asynchron kommuniziert wird. Die Antworten des Servers werden in Form von XML versandt.

Im Modell sieht die klassische Client-Server Interaktion im zeitlichen Verlauf etwa wie folgt aus.

Klassisches Modell der Client-Server-Kommunikation; Dateneingabe und Datenverarbeitung auf dem Server verlaufen synchron

Dabei werden die Zeitverzögerungen, die sich aufgrund des Sendens und Empfangens von Anfragen beziehungsweise Antworten deutlich.

Mit dem AJAX-Ansatz wird eine weitere Engine eingebaut, die den Versand der Daten asynchron regelt. Wie man aus der Modellskizze erkennen kann, werden zum Beispiel die Daten aus der ersten Eingabe noch serverseitig verarbeitet, während zur selben Zeit bereits wieder neue Daten eingegeben werden können. Der Versand wird über die AJAX-Engine geregelt.

AJAX-Modell - Dateneingabe und Datenverarbeitung auf dem Server verlaufen asynchron

Das für die Kommunikation notwendige XMLHttpRequest-Objekt wurde zunächst von Microsoft als ActiveX entwickelt, ist aber heutzutage in allen gängigen Browsern integriert. Es ist der Kern des AJAX-Ansatzes, da mit ihm die Client-Server Kommunikation, die im Hintergrund abläuft, ermöglicht wird. Jedoch liegt der Fokus bei AJAX nicht allein bei XMLHttpRequest, sondern grundsätzlich bei der Idee des Zusammenspiels der verschiedenen Technologien.


Ablauf einer Anfrage über XMLHttpRequest

Im InternetExplorer wird XMLHttpRequest immer noch über ein AcitiveX-Objekt initialisiert, während es in Browsern wie Mozilla als einfaches Objekt abgeleitet werden kann.

Da AJAX verstärkt über XMLHttpRequest Javascript als Technologie integriert, ergeben sich jedoch auch Probleme. So muss, zum Beispiel gerade schon bei der Initialisierung eines Objektes auf die Besonderheiten der verschiedenen Browser geachtet werden. Dadurch können die Skripte mitunter recht komplex ausfallen und man muss sich fragen, ob sich der Aufwand überhaupt lohnt. Der "Zurück"-Button des Browsers wird ebenfalls bei der Verwendung einer solchen AJAX Technologie unnutzbar, da dieser ja nur über die direkten Anfragen des Clients funktioniert.

Des Weiteren ergeben sich mit AJAX auch Probleme etwa für die barerierearmen Gestaltung von Webformularen, da AJAX nicht den Anforderungen der Web Accesibility Initiative des W3C entspricht und auch nur schwer kompatibel gemacht werden kann.

Dennoch ergeben sich den Programmierern von Webapplikationen mit AJAX viele neue Möglichkeiten. Die Webapplikationen werden immer ähnlicher zu herkömmlichen Desktop-Applikationen, was auch zu deren Emanzipation beitragen kann. Auf jeden Fall unterstützt AJAX die weitergehende Entwicklung von Webtechnologien. (tm)

(tf)
Dieser Artikel ist ebenfalls bei Dr.Web erschienen

Weiterführende Links:

1. AJAX: Ein einfacher Chat wie bei Facebook und co!
2. AJAX: Das XMLHttpRequest Objekt

Dieser Artikel ist ebenfalls bei Dr.Web erschienen!

Im Endeffekt braucht es hierfür nur ein wenig JavaScript und natürlich PHP – von da aus kann man Wikipedia auf die vielseitigsten Arten verwenden. Grundsätzlich hat man drei Optionen. Zum einen kann man die ganze Wikipedia MySQL Datenbank kopieren und auf dem eigenen Server samt Wikisoftware zum laufen bringen. Da die Datenbank nunmehr schon ein Gigabyte an Größe erreicht hat, ist das nicht unbedingt eine Option die wirklich jedem offen steht. Zudem wird der Inhalt nicht von der großen Wikipedia Usergemeinde auf dem Laufendem gehalten.
Eine zweite Möglichkeit ist die Verwendung des XML Exports, der neuerdings von Wikipedia unter http://de.wikipedia.org/wiki/Spezial:Export/ bereitgestellt wird. Dabei wird hinter das Spezial:Export/ schlicht der Name des Wikipedia-Artikels eingetragen. Die XML Antwort sieht dann in etwa so aus:

Man wird aus dem zurückgegebenen Text nur schwer schlau. Das liegt daran, dass man den Inhalt zwar schön als XML zurückgeliefert bekommt, jedoch mit sämtlichen WikiTax. Das sind die wikimediaeigenen Tags, die vor jeder Ausgabe der Seite durch die Wikisoftware gerendert und in HTML umgesetzt werden. Zur Zeit gibt es noch Probleme bei dem XML Export von Wikipedia Daten, da es noch keine einheitliche Document Type Definition für die WikiTax gibt – deshalb kann man den XML Export noch nicht vollständig umsetzen. Zudem müsste man selbst etwa mit Redirects in Wikipedia umgehen – ruft man z.B. den Artikel "XML", so erhält man:

<text xml:space="preserve">#REDIRECT [[Extensible_Markup_Language]]</text>

Es gibt jedoch noch eine dritte Möglichkeit die Daten von Wikipedia direkt zu ermitteln – nämlich komplett mit allen HTML Formatierungen. Der Inhalt jeder Wikipedia-Seite ist von HTML Kommentaren eingeschlossen, nämlich den Kommentaren <!-- start content --> und <!-- end content -->. Über reguläre Ausdrücke und ein wenig PHP kann man diesen Inhalt vom Rest der Seite trennen und dann ausgeben. Ein solcher Ansatz wurde in der com!-Online Zeitschrift Ausgabe 8/05 vorgestellt. Das dabei verwendete PHP Skript von Stefan Kuhn und Andreas Dumont liest die Inhalte zwischen den beiden Kommentaren aus, passt die Verweise zu weiterführenden Artikel an das Skript an und stellt die Inhalte im Browser dar. Dabei wird auch auf die PHP eigene gzip-Kompression zurückgegriffen, um die Ladezeiten und die Last für den Wikipedia-Server zu reduzieren. Dies hat auch den Vorteil, dass man immer die aktuellste Version des Wikipedia-Eintrags auf der Seite dargestellt bekommt.

wikistatic.php
<?php
$query = $_SERVER['QUERY_STRING'];
$search = $_GET['search'];
?>
<h1><?php if (isset($search)) echo $search; ?></h1>
<?php
/*************************************************************
* Wikipedia-Skript : Version 1.05 : Mai 2005
* wikipedia.php
* Stefan Kuhn, Andreas Dumont
*
* erweitert für Wikipedia-Suche von Thiemo Fetzer am 22.
* Juli 2005
/*************************************************************/
function callback( $puffer ) { //zum Puffern!

$puffer = substr( $puffer, strpos( $puffer, '<!-- start content -->' ) ); // sucht erstes Vorkommen des Suchstrings und liefert die Position
$puffer = substr( $puffer, 0, strpos( $puffer, '<div class="printfooter">' ) );
$puffer = str_replace( "/w/index.php", "/wikipedia/wikistatic.php", $puffer ); //macht die Links für das Skript kompatibel
$puffer = str_replace( "/wiki/", "/wikipedia/wikistatic.php?title=Spezial:Search&search=", $puffer );
$puffer = '<style>.editsection {display:none;}</style>'.$puffer; //blendet die Bearbeiten-Links aus
($puffer);
return $puffer;
}
if(eregi("Spezial:Search",$query) or eregi("Spezial%3aSearch",$query) or eregi("Special:Search",$query)) { //falls kein Artikel gefunden wird, dann automatischer Fallback zur normalen Suche
$search = str_replace( " ", "+", $search ); //Leerzeichen HTTP konform umwandeln
ob_start("callback"); //Einschalten der Pufferung von Ausgaben (für Suchen)
include 'http://de.wikipedia.org/w/index.php?'.$query; //der Query wird wieder angehaengt
ob_end_flush();
}
print( '<small><p>
Text und Bilder dieses Beitrags stammen aus dem Artikel
<a href="http://de.wikipedia.org/wiki/'.$begriff.'" title="http://de.wikipedia.org/wiki/'.$begriff.'" target="_blank">'.$search.'</a>
der freien Enzyklop&auml;die <a href="http://de.wikipedia.org" title="http://de.wikipedia.org" target="_blank">Wikipedia</a>
und stehen unter der <a href="http://www.gnu.org/licenses/fdl.txt" target="_blank">GNU Free Documentation License</a>.
Die Liste der Autoren ist in der Wikipedia unter
<a href="http://de.wikipedia.org/w/wiki.phtml?title='.$search.'&action=history" target="_blank" title="http://de.wikipedia.org/w/wiki.phtml?title='.$search.'&action=history">dieser Seite</a> verf&uuml;gbar, der Original-Artikel l&auml;sst sich
<a href="http://de.wikipedia.org/w/wiki.phtml?title='.$search.'&action=edit" target="_blank" title="hierhttp://de.wikipedia.org/w/wiki.phtml?title='.$search.'&action=edit">hier</a>
bearbeiten.
</p></small>');
?>

Bei dem Skript handelt es sich im Endeffekt nur um einen gewöhnliche PHP Webseitengrabber, bei dem Inhalte von fremden Webseiten extrahiert werden um dann auf der eigenen Seite dargestellt zu werden. Das Skript wurde dahingehend erweitert, dass es nun auch die Wikipedia-Suche vollständig unterstützt. Falls zu einem gesuchten Begriff kein Artikel direkt gefunden wird, so wird automatisch die Wikipedia Suche gestartet und die Suchergebnisse dargestellt.

Man kann das Design der Ergebnisseite über CSS und etwas HTML komplett den eigenen Wünschen anpassen. Dafür könnte man das komplette Skript per PHP Include in eine andere Seite einbinden – etwa an die Stelle, an der man ohnehin den Inhalt dargestellt haben möchte. Da die deutschen Sonderzeichen in der Wikipedia-Datenbank nicht durch HTML Entitäten ersetzt werden, muss man im Head-Bereich der Ergebnisseite den verwendeten Zeichensatz auf utf-8 einstellen. Dies geschieht mit folgender meta-Anweisung:

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

Screenshot – Wikipedia in Dr.Web Design integriert (mit herkömmlichen Dr.Web Stylesheet)

Zudem müssen Sie das PHP Skript so abändern, dass nicht mehr auf die Datei "wikistatic.php" verwiesen wird. In unserem Fall heißt die PHP Datei, in die wikistatic.php per Include eingefügt wurde "drweb.php". Wir müssen nun in der Datei wikistatic.php alle Verweise in drweb.php umbenennen.

$puffer = str_replace( "/w/index.php", "/wikipedia/drweb.php", $puffer ); //ersetzt alle Vorkommen eines Strings in einem anderen String
$puffer = str_replace( "/wiki/", "/wikipedia/drweb.php?title=Spezial:Search&search=", $puffer );

CSS Stylesheet
Grundsätzlich kann man das Design der Seiten einfach über Änderungen am Wikipedia Stylesheet nach den eigenen Wünschen anpassen. Man muss in dem Skript lediglich den Verweis auf das Stylesheet verändern. Da Wikipedia wenig mit CSS Klassen arbeitet, muss man die generellen Tag-Formatierungen verwenden. D.h. die Darstellung von Blocksätzen definieren etc. Das Standardstylesheet von Wikipedia gibt’s hier zum downloaden...

Eine Suchbox für Wikipedia
Eine einfache Suchbox für unser Wikipedia-Skript kann über folgende paar Zeilen HTML Code erzeugt werden:

<div class="wiki_suchbox">
<h4>Suchen in der Wikipedia Datenbank!</h4>
<form name="searchform" action="/wikipedia/drweb.php" method="get"><input type="hidden" name="title" value="Spezial:Search" />
<input id="searchInput" name="search" type="text" value="" />
<input type="submit" name="go" class="searchButton" value="Artikel" />&nbsp;
<input type="submit" name="fulltext" class="searchButton" value="Suche" />
</form>
</div>

Auch hier müssten Sie etwa den action-Parameter des Formular anpassen. Im nächsten Teil sollen weitere Möglichkeiten vorgestellt werden, wie Sie Wikipedia für ihre Besucher möglichst nützlich integrieren können.

Weiterführende Links:

1. Wikipedia für die eigene Webseite – Teil 2
2. Eigene Web Services mit PHP5 bereitstellen? Kein Problem!

Dieser Artikel ist ebenfalls bei Dr.Web erschienen!

Bestimmt ist er Ihnen auch schon mal bei einer Reise durch das WWW begegnet – der kleine Mr. Check der Firma Xpolis.Das kleine Tool hat jedoch auch seinen Preis – anfangs war er noch kostenlos zu haben, heute muss man ordentlich dafür bezahlen (ab 14 € pro Monat). Mit ein wenig Aufwand kann man jedoch ein ähnlich funktionierendes System für umsonst programmieren.
Dabei verwenden wir wiederum unser Wikipedia-Skript und ein wenig JavaScript. Grundsätzlich soll der Benutzer wie bei Mr.Check sich ein Stichwort markieren können und daraufhin nach Klick auf den kleinen Helfer einen passenden Wikipedia Artikel zu sehen bekommen. So in etwa könnte unser kleiner Helfer bei Dr.Web aussehen:

Um zu ermitteln, welches Wort ein Benutzer markiert hat, muss man mit ein wenig JavaScript herumhantieren; für den Internet Explorer gibt es hierfür das document.selection-Objekt, für Mozilla kann man direkt die document.getSelection() Funktion verwenden.

<script type="text/javascript">
<!--
function getString() {
var str;
if (document.selection) // fuer IE
{
str = document.selection.createRange().text;
if(str == "") {
str = prompt("Bitte geben Sie den gesuchten Fachbegriff ein","");
}
}
else if(document.getSelection()) { //fuer Mozilla, etc.
str = document.getSelection();
if(str == "") {
str = prompt("Bitte geben Sie den gesuchten Fachbegriff ein","");
}
}
else { //falls anderer Browser
str = prompt("Bitte geben Sie den gesuchten Fachbegriff ein","");
}
//PopUp wird geöffnet
wikipedia = window.open("http://localhost/wikipedia/wikistatic.php?begriff="+str, "Wikipedia", "width=500,height=500,scrollbars=yes,resizable=yes,toolbar=yes");
wikipedia.focus(); //Fokus auf PopUp setzen
}
// -->
</script>

Falls die Funktionen nicht unterstützt werden (Probleme gibt es eventuell mit Opera), so wird schlicht ein Javascript prompt-Fenster geöffnet, in das der Besucher den Fachbegriff manuell eintippen kann. Nachdem der Begriff erfolgreich in der Variablen str hinterlegt wurde, wird ein PopUp geöffnet. Die Größe des PopUps und die angezeigten Toolbars kann man natürlich nach belieben anpassen.
Über den Query-String der Anfrage lädt es die entsprechenden Seiten von Wikipedia. Findet sich im Query-String z.B. die Anfrage search=php, so wird der Wikipedia Artikel über PHP ausgegeben. Sollte es sich bei dem Begriff um einen mit Leerzeichen verbundenen Begriff handeln, so wird das Leerzeichen http konform umgewandelt. Falls es zu einem bestimmten Begriff keinen Artikel geben, so wird die Suche bemüht und die Suchergebnisse daraufhin angezeigt.

Unser BiblioBulo kann über folgenden Code in die Seite integriert werden:

<a href="#" onclick="javascript:getString()"><img src="bibliobulo.gif" alt="BiblioBulo"></a>

Und so sieht das Beispiel dann aus:


Fachbegriff XML wurde markiert, das Wikipedia-Skript liefert den passenden Artikel

Fachbegriffe mit Wikipedia verlinken
Mit HTML 4.0 wurden viele neue Textauszeichnungen eingeführt, z.B. der acronym-Tag, der eine Abkürzung bzw. ein Akronym auszeichnet. Wer sich dieser Tags bedient hat, und seine Fachbegriffe oder Abkürzungen stets mit solchen Textauszeichnungen ausgezeichnet hat, der soll nun davon auch ein wenig profitieren. Mithilfe von JavaScript und dem DOM soll nun anhand der acronym-Tags jedes Acronym auf verdacht mit unserem Wikipedia-Skript verlinkt werden.

Das hierzu notwendige JavaScript funktioniert mit allen gängigen Browsern (außer Opera 6).

<script type="text/javascript">
function showFachbegriffe() {
if(document.getElementsByTagName && document.getElementById) { //nur wenn der Browser das DOM unterstützt

var acronym = document.getElementsByTagName("acronym"); //alle Akronyme ermitteln

for (var l = 0; l < acronym.length; l++) {
var link = document.createElement("a"); //Erzeugung des Links
var link_text = document.createTextNode(acronym[l].firstChild.nodeValue);
link.href="http://localhost/wikipedia/wikistatic.php?title=Spezial:Search&search="+acronym[l].firstChild.nodeValue;
link.target="_blank";
link.appendChild(link_text);
acronym[l].appendChild(link);
acronym[l].firstChild.nodeValue=""; //damit das Akronym nicht zweimal dasteht
}
} //Ende Browser-if
}//Ende Funktion
</script>

Die Verweise auf das Skript müssten natürlich angepasst werden. Die Funktion muss beim laden der Seite aufgerufen werden. Dies kann über den onLoad-Eventhandler im body-Tag erreicht werden.

<body onLoad="showFachbegriffe()">

Man kann das ganze noch ein wenig weiter verzieren. Man könnte z.B. neben jedes Akronym noch ein kleines Icon setzen, das anzeigt, dass der Link auf die Wikipedia Datenbank verweist.

Hierzu müsste man den JavaScript-Code um ein paar Zeilen erweitern:

for (var l = 0; l < acronym.length; l++) {
var icon = document.createElement("img");
icon.src="wikipedia-favicon.png";
icon.alt="Fachbegriff: " + acronym[l].firstChild.nodeValue;
var link = document.createElement("a"); //Erzeugung des Links
var link_text = document.createTextNode(acronym[l].firstChild.nodeValue);
link.href="http://localhost/wikipedia/wikistatic.php?title=Spezial:Search&search="+acronym[l].firstChild.nodeValue;
link.target="_blank";
link.appendChild(link_text);
acronym[l].appendChild(link);
acronym[l].firstChild.nodeValue=""; //damit das Akronym nicht zweimal dasteht
acronym[l].appendChild(icon); //Icon hinzufügen
}

Das Ergebnis könnte im Browser etwa wie folgt aussehen:


 Jedes Akronym wurde mit Wikipedia verlinkt und entsprechend gekennzeichnet

Weiterführende Links:

1. Wikipedia für die eigene Webseite – Teil 1
2. Eigene Web Services mit PHP5 bereitstellen? Kein Problem!
3. Formulare mit Links statt Buttons

Schon der Begriff "Webservices" enthält eine eigentliche Definition. Webservices sind Dienste, die über das Internet bereitgestellt werden. Trotz dieser scheinbar recht einfachen Definition, haben sich die "Großen", Microsoft, IBM, Hewlett Packard, Sun etc. noch nicht auf eine einheitliche Definition geeinigt. Unter http://www.jeckle.de/webServices/ finden Sie eine Auflistung der verschiedensten Definitionen von, was Webservices eigentlich sind.
Als kleinster gemeinsamer Nenner kann man sagen, dass über Webservices dem Client (das ist der Nutzer) Funktionen, Daten und Anwendungen bereitgestellt werden können.
Dabei ist der Client nicht mehr der vor seinem Computer sitzende Surfer – es sind eigenständige Anwendungen, welche Webservices für die eigene Programmfunktion nutzen.
Ein einfaches Beispiel dafür sind die Google Webservices. Dabei kann ein Programmierer über Webservices auf die mächtige Google Suchfunktionen zurückgreifen, und diese in die eigene Anwendung integrieren. So können z.B. siteinterne Suchmaschinen ohne viel Aufwand erstellt werden; dies soll im dritten Teil dieses Workshops beleuchtet werden.
Über Webservices kann man folglich ganze Anwendungen modellieren. Doch wie funktioniert die Kommunikation zwischen den verschiedenen Anwendungen? Die Daten müssen ja in irgendeiner Form von einem Programm zum anderen geschickt werden.
Das versenden der Daten wird über das http Protokoll bewerkstelligt. Die Anfragen und Antworten werden in Form von XML gesendet. Man hat sich auf diese beiden Standards geeinigt, da sie quasi überall "verstanden" werden. Sie sind plattform- und insbesondere programmiertechnisch unabhängig.
Die Anfragen an den Webservice werden folglich in XML verpackt und über http versendet. Die XML Nachricht wird vom Webservice interpretiert und wiederum in Form von XML beantwortet.
Da Webservices für die Integration von Programmfunktionen in anderen Anwendungen gedacht sind, musste man sich auch hier auf eine einheitliche Form der Datenübertragung zum Nutzen aller einigen. So entstand SOAP, das Simple Object Access Protocol, basierend auf XML. Dadurch wurde erreicht, dass alle Webservice Anfragen und Antworten eine einheitliche Form haben. Zwar gibt es auch Webservices, die nicht auf SOAP zurückgreifen, jedoch wird sich SOAP in Zukunft durchsetzen, da nur durch eine einheitliche Datenübertragung die Nutzung von Webservices eine allgemeine Bedeutung erlangen kann.
Ein Anfrage besteht, wie man im folgenden Diagramm sehen kann aus einem festen Grundgerüst.


Struktur einer SOAP Nachricht

Das Grundgerüst ähnelt sehr dem einer HTML Seite, bestehend aus einem Head- und einem Body-Bereich, in welchem die Antwort- bzw. Anfragedaten abgelegt sind.

In der folgenden Abbildung ist ein einfaches Schema für den Datenfluss bei der Nutzung von Webservices abgebildet. Dabei besitzt die Anwendung welche auf den Webservice zurückgreift ebenfalls einen XML Interpreter, über welchen die XML Daten in ein Format überführt werden, in welchem sie weiterverarbeitet werden können. Die SOAP Antwort muss folglich von der Anwendung verarbeitet werden. Auf diese Weise wird die Nutzung von Webservices nicht nur auf einzelne Programmiersprachen beschränkt. Man kann Webservices über jede Programmiersprache verwenden, die eine XML bzw. SOAP Schnittstelle besitzt.


Einfaches Datenflussdiagramm für die Nutzung von Webservices

Man kann dieses einfache Modell noch erweitern, indem man sich den Webservice auf welchen man zurückgreift selbst als eine Anwendung betrachtet welche auf verschiedene andere Webservices zurückgreift.

Man kann sich das an einem einfachen Beispiel veranschaulichen. Bei einer Buchbestellung möchten Sie den Status ihrer Bestellung verfolgen. So können sie bei dem Verkäufer den Status bis zum versenden betrachten. Bei dem Zusteller (z.B. der Post) können sie den weiteren Verlauf verfolgen.
Durch Webservices ist es nun möglich, dass der Verkäufer den Status der Bestellung auch über die eigenen Systemgrenzen verfolgen kann, indem er auf einen Webservice des Zustellers zurückgreift und dort den Status des Versandes ermitteln kann und diesen an den Käufer weitergeben kann.

Das ist nur ein einfaches Beispiel der Integration von Webservices in andere Anwendungen.

Nachdem die grundlegende Funktion von Webservices geklärt ist, müssen noch weitere Aspekte in Betracht gezogen werden, die sich insbesondere für den Programmierer ergeben, der von Webservices gebrauch machen möchte.
Den woher weiß der Programmierer auf welche Funktionen er bei der Nutzung von Webservices zurückgreifen kann, bzw. welche Parameter diese brauchen.
Hierzu wurde von IBM und Microsoft gemeinsam die Webservice Description Language, kurz WSDL, entwickelt. Sie basiert auf XML und ermöglicht die standarisierte Beschreibung von Webservices – sie wird auch vom W3C als möglicher Standard diskutiert.

Ein weiteres Problem, welches Auftritt ist, dass bei einer Vielzahl von Webservices unklar ist, wer überhaupt was anbietet. Die Webservices müssen irgendwo verzeichnet sein. Idealerweise sollte der Webservicenutzer nur noch eine Anfrage an das Webserviceverzeichnis machen müssen; dieses leitet ihn dann direkt weiter an den für die Anfrage passenden Webservice. Ein solches "Telefonbuch" für Webservices wurde durch UDDI (Universal Description, Discovery and Integration) geschaffen. In ihm sind die Webservice Anbieter und die von ihnen angebotenen Webservices verzeichnet. Bereits viele Anbieter haben UDDI implementiert.

Doch was für Chancen oder Zukunftsaussichten liegen in Webservices? Der Nutzen für Unternehmen ist eindeutig, da sie bei ihren Anwendungen einfach gesagt, nicht mehr alles selbst programmieren müssen. Die einzelnen Firmen werden sich durch ihre Webservices stärker als bisher vernetzen und so insbesondere in den Beziehungen zu den Kunden verbessern.

Doch was bedeutet das für den Internetnutzer?

Eine Vision ist, dass man über Webservices eine Personalisierung des ganzen Internets einführen kann. So hat Microsoft bereits über ihr .NET Passport einen ersten Schritt dahingehend getan. Über einen .NET Passport kann man auf die verschiedensten Angebote von Microsoft zugreifen ohne jedes Mal ein neuen Account anlegen zu müssen. Das heißt man müsste seine persönlichen Daten nur noch in einem virtuellen Pass hinterlegen, über welchen man dann auf die verschiedensten Internetdienste zurückgreifen kann.
Dies wird jedoch auch heftig diskutiert, da damit erhebliche Sicherheitsbedenken verbunden sind.

Webworker selbst können Webservices bisher nur in beschränkten Maße nutzen. Bei den in diesem Workshop betrachteten Webservices von Google und Amazon können Webworker auf die Produktpalette von Amazon bzw. auf die Suchfunktion von Google zurückgreifen und diese in die eigene Webseite integrieren. Es bleibt also noch zu erwarten in wie weit Webservices das Leben eines Webworkers beeinflussen wird – im Rahmen dieses Workshops soll der Nutzen der beiden betrachteten Webservices für den Webworker in den Vordergrund gestellt werden.

(tf)

No related posts.

XML ist als reine Datensprache viel mächtiger als einfache SQL basierende Datenbanken, die sich auf dem zweidimensionalen Rahmen beschränken. Mit XML sind vielfach ineinander verschachtelte Datensysteme möglich.

Die Erkennung der einzelnen Daten aus XML Dateien, und deren dynamische Veränderung ist ungemein wichtig, da man ohne diese Funktionalität nicht effektiv auf XML Datenbanken zurückgreifen kann.
Speziell für Webanwendungen ist es in dieser Hinsicht schwierig mit XML umzugehen.
Eine einfache Möglichkeit mit XML Daten umzugehen bietet Expat. Expat ist in die PHP 4 Version integriert, und kann bei der Installation durch die Option "-with-xml" installiert werden.
Expat ist ereignisorientiert. Das bedeutet, das zunächst einzelne Funktionen für die verschiedene Ereignisse definiert werden.
Ein Ereignis kann z.B. ein öffnendes Element, ein schließendes Element oder der Inhalt, der von einem öffnenden, und einem schließendem Element eingeklammert ist, sein.

Für folgende Elemente können Funktionen definiert werden.

• Startendes Element, mit Attributen (<inhalt nr="10">)
• Normaler Text "Character Data", zwischen den öffnendem und schließendem Element
• Abschließendes Element (</inhalt>)
• Kommentare
• DTD Anweisungen
• Procession Instructions - eingebettete PHP Anweisungen

Wichtig ist, das man die Arbeitsweise von Expat versteht. Expat untersucht ein XML Dokument zeilenweise. Aufgrund dessen muss das Dokument Zeile für Zeile, also über eine Schleife von Expat geparset werden.
Expat erkennt das öffnende Element, z.B. <inhalt>, und übergibt es an die definierte Funktion für öffnende Elemente. Darauf entdeckt er den Inhalt dazwischen. Ist dies einfacher Text, dann wird dieser an die entsprechende Funktion überreicht, die die Inhalte behandelt. Diese Inhalte, die nicht weiter in andere Tags verschachtelt sind, nennt man CDATA, Character Data. Zum Schluss wird das schließende Element gefunden, und entsprechend über die definierte Funktion behandelt.

Einen XML Parser erzeugen

Ein XML Parser wird immer für das XML Dokument individuell erzeugt.

$parser = xml_parser_create();
Der Parser wird erzeugt. Die Variable $parser verweist auf den erzeugten Parser, sodass dieser einmalig gekennzeichnet ist.

xml_set_element_handler($parser,"startElement","endElement");
Hiermit werden die Funktionen für das öffnende, und das schließende Element angegeben. "startElement" verweist auf die entsprechende Funktion startElement(), und endElement verweist auf die entsprechende Funktion "endElement".

xml_set_character_data_handler($parser, "characterdata");
Hiermit wird auf die Funktion für CDATA (normaler Text) verwiesen.

xml_set_processing_instruction_handler($parser, "pi");
Hier wird auf die Funktion verwiesen, die Processing Instructions behandelt (mehr dazu im zweiten Teil).

xml_set_default_handler($parser, "default");
Diese Funktion wird aufgerufen, wenn für das Ereignis keine andere Funktion definiert ist. Man kann sagen, das die default-Funktion aufgerufen wird, wenn ein Fehler aufgetreten ist, z.B. wenn man sich verschrieben hat usw.

Der erste eigene Parser

Die Arbeitsweise von Expat sollte nun im kleinen zumindest klar sein. Hier nun unser erster kleiner Parser, der auf das folgende XML Dokument zugeschnitten ist.

inhalt.xml
<?xml version="1.0"?>
<inhalt>
Irgend ein Text, der nur dasteht, um
Platz zu verschwenden.
</inhalt>

Diese XML Datei wird von dem folgendem Parser geparsed.

inhalt.php

<?php

function startElement($parser, $element_name, $element_attribute) {
global $ausgabe;
//Umwandeln in Kleinbuchstaben
$element_name = strtolower($element_name);
//Überprüfung des Elementnames
if ($element_name=="inhalt") {
$ausgabe .= "<h3>Inhalt</h3><p>";
}
}
function endElement($parser, $element_name) {
global $ausgabe;
// in Kleinbuchstaben umwandeln
$element_name = strtolower($element_name);
// Überprüfung des Names eines Elementes
if ($element_name=="inhalt") {
$ausgabe .= "</p>";
}
}
function cdata($parser, $element_inhalt) {
global $ausgabe;
// Der normale Text wird an $ausgabe angehängt
$ausgabe .= $element_inhalt;
}
$xmlFile = file("inhalt.xml");
$parser = xml_parser_create();
xml_set_element_handler($parser, "startElement", "endElement");
xml_set_character_data_handler($parser, "cdata");

foreach($xmlFile as $elem)
{
xml_parse($parser, $elem);
}
xml_parser_free($parser);

echo $ausgabe;
?>

Die Ausgabe nach dem Aufruf des Skriptes sieht wie folgt aus:


Ihr erstes von PHP geparstes XML Dokument

Um die Arbeitsweise des Skriptes zu verstehen, sollte jede der definierten Funktionen einzelne bearbeitet werden.

Zunächst behandeln wir die Funktion, die aufgerufen wird, wenn Expat ein öffnendes Element findet. In unserem Beispiel ist das <inhalt>.
An die Funktion wird die Variable $parser übergeben. In ihr wird auf den erzeugten XML Parser verwiesen. Über die Variable $element_name wird der Names des Elementes übergeben. In unserem Beispiel ist der Name des Elementes "inhalt". Zudem kann an die Funktion die Attribute, und deren Werte übergeben werden. Wie Sie diese mit XML Parsen erfahren Sie im zweiten Teil des Workshops.
In der ersten Zeile der Funktion selbst wird auf die Variable $ausgabe verwiesen, und ihr Globale Eigenschaften gegeben. D.h. die Variable ist nicht nur in der Funktion vorhanden, sondern auf außerhalb. So kann man direkt auf den Wert der Variablen zugreifen, ohne diesen an die Funktion zu übergeben. Zudem kann der Wert auf direkt aus der Funktion heraus verändert werden.

function startElement($parser, $element_name, $element_attribute) {
global $ausgabe;
//Umwandeln in Kleinbuchstaben
$element_name = strtolower($element_name);
//Überprüfung des Elementnames
if ($element_name=="inhalt") {
$ausgabe .= "<h3>Inhalt</h3><p>";
}
}

Die nächste Anweisung wandelt den Namen des Elementes in Kleinbuchstaben um, da Expat die Namen eines Elementes immer in Großbuchstaben übergibt. Dies muss nicht gemacht werden, dient aber zu einem einfacheren Verständnis des Codes.
Im nächsten Teil wird überprüft, ob der Name des Elementes "inhalt" ist. Ist dies der Fall, dann wird an die Globale Variable $ausgabe der Inhalt "<h3>Inhalt</h3><p>" über den Stringoperator "." angehängt.

Eigentlich ist eine Überprüfung auf den Namen des Elementes nicht notwendig, da in der XML Datei sowieso nur ein Element vorkommt. Da wir jedoch in den nächsten Teil des Workshops mit etwas komplexeren Beispielen in die Materie einsteigen, sollte auf diese zwei Zeilen Code nicht verzichtet werden.

Nun, wollen wir uns mit der Funktion für den normalen Fließtext, CDATA kümmern. Diese hat nur eine Aufgabe. Sie muss den Inhalt des Elemenets an die Globale Variable $ausgabe anhängen.

function cdata($parser, $element_inhalt) {
global $ausgabe;
// Der normale Text wird an $ausgabe angehängt
$ausgabe .= $element_inhalt;
}

Der Inhalt des aktuell geparten Element wird über die Variable $element_inhalt übergeben. Dieser wird an die Variable $ausgabe angehängt.

Die letzte Funktion ist für die schließenden Elemente zuständig. Diese Funktion arbeitet auf der gleichen Weise, wie die Funktion für das öffnende Element.

function endElement($parser, $element_name) {
global $ausgabe;
// in Kleinbuchstaben umwandeln
$element_name = strtolower($element_name);
// Überprüfung des Names eines Elementes
if ($element_name=="inhalt") {
$ausgabe .= "</p>";
}
}

Das sind die Funktionen, die in diesem Beispiel benötigt werden. Nun muss die XML Datei eingelesen werden, und daraufhin der Parser definiert bzw. erzeugt werden.

$xmlFile = file("inhalt.xml");
$parser = xml_parser_create();
xml_set_element_handler($parser, "startElement", "endElement");
xml_set_character_data_handler($parser, "cdata");

foreach($xmlFile as $elem)
{
xml_parse($parser, $elem);
}
xml_parser_free($parser);

echo $ausgabe;

In der ersten Zeile wird die Datei über die file() Funktion in ein Array gelesen. In der zweiten Zeile wird der Parser erzeugt. Darauf werden die einzelnen Handler festgelegt.
Der letzte und wichtigste Teil des Skriptes ist, das der Inhalt des Arrays über eine foreach-Schleife einzeln über die Funktion xml_parse() geparsed wird.
In der vorletzten Zeile wird der Parser wieder "zerstört", d.h. alle belegten Resourcen werden wieder frei gegeben. In der letzten Zeile wird nun der Inhalt der Variablen $ausgabe ausgegeben. In ihr befindet sich der Inhalt, der über die einzelnen Funktionen "dynamisch" aus der XML Datei extrahiert wurde.
(tf)

No related posts.

Es gibt verschiedene Arten von Template Systemen in PHP. FastTemplate ist ein Template System, welches blockartig aufgebaut ist. D.h. der Designer kann einzelne Blöcke oder Bereiche einer Seite designen, das System kombiniert diese Blöcke dann entsprechend mit den aufzufüllenden Daten. FastTemplate ist eine PHP Klasse, die von http://www.thewebmasters.net/php/ heruntergeladen werden kann. Diese Klasse muss in das PHP Programm eingebunden, und ein Objekt davon abgeleitet werden.

template.tpl

<html><head>
<title>{title}</title>
</head>
<body>
<h1>{title}</h1>
<p><b>{teaser}</b></p>
<p>{inhalt}</p>
</body>
</html>

Die Platzhalter bei diesem Template sind in geschweiften Klammern. Dadurch werden Sie eindeutig. Man kann die Platzhalter auch anders gestalten, sodass es zu keinen Konflikten zwischen den {} der Platzhalter, und z.B. den {} Klammern eines JavaScripts kommt. Die Platzhalter könnten z.B. auch wie folgt aussehen {(title)}. Wie Platzhalter aussehen ist also egal, die Platzhalter müssen nur als solche an die FastTemplate Klasse übergeben werden, da FastTemplate ja sonst die Platzhalter nicht "entdecken" könnte, und dadurch nichts ersetzen würde.

Nun aber zurück zu unserem Beispiel. Wir möchten, dass die einzelnen Platzhalter des Templates durch die entsprechenden Inhalte ersetzt werden.

1. Zunächst muss, wie bereits erläutert die Klasse "class.FastTemplate.php" in das Skript eingebunden werden.

<?php
include "class.FastTemplate.php3";

2. Daraufhin muss von dieser Klasse ein Objekt erzeugt werden. Über dieses Objekt wird mit der Klasse "kommuniziert", und die einzelnen Methoden aufgerufen, und die Ergebnisse empfangen.

$tpl = new FastTemplate(".");

Die Pfadangabe in der Klammer (der Punkt) verweist auf den Ordner, aus dem die verschiedenen HTML Templates geladen werden. Der Punkt steht hierbei für das aktuelle Verzeichnis.

3. Jetzt wird das Template, bzw. die Templates, die verwendet werden, definiert. Dabei wird die define() Methode von FastTemplate verwendet.
$tpl->define(array(
"template" => "template.tpl"
));
Es wird ein assoziatives Array erzeugt. Dabei ist der Index, hier im Beispiel "template", der Name des Templates. Über diesen Namen wird das Template im weiteren angesprochen.
Wie Sie sehen können Sie mehrere Templates definieren, und diese auch gleichzeitig nutzen. So ist es möglich über mehrere Templates eine Seite in einzelnen Blöcken aufzubauen.

4. Im nächsten Schritt werden die verschiedenen Platzhalter definiert, und angegeben, mit welchen Werten diese gefüllt werden sollen. Es wird hierzu die assign() - Methode von FastTemplate verwendet.

$tpl->assign("{title}", "Der Titel");
$tpl->assign("{teaser}", "Der Teaser");
$tpl->assign("{inhalt}", "Der Inhalt");

Es ist klar, das die Anwendung so kaum Sinn macht, da man hierbei die Inhalte innerhalb der PHP Funktion definieren müsste.
Ein Verweis auf eine Variable, mit dem Inhalt macht mehr Sinn. Dieser Inhalt kann zuvor z.B. aus einer Datenbank, oder einer Textdatei ausgelesen worden sein. Die Defintion des Inhalts könnte also auch wie folgt aussehen:
$tpl->assign("{title}", $title);
Mit diesem Schritt kennt FastTemplate die einzelnen Platzhalter, und weiß, mit welchen Werten diese zu ersetzen sind.

5. Nun kann eigentlich der letzte Schritt in Angriff genommen werden. Es muss nur noch der Inhalt mit dem Template kombiniert werden. Dies muss auch explizit angewiesen werden.
$tpl->parse("ausgabe", "template");
$tpl->FastPrint("ausgabe");
?>
Es wird die FastTemplate Funktion parse() aufgerufen. An diese Funktion werden zwei Parameter übergeben. Der erste Parameter ist ein Name. Über diesen Namen wird der Output, also das Ergebnis aus dem Parsen des Templates und des Inhaltes zugegriffen. Er ist notwendig, da man über ihn z.B. die Ausgabefunktion in der nächsten Zeile aufrufen muss. Dadurch wird sichergestellt, dass das Ergebnis ein einzelner Block ist, der noch weiter bearbeitet kann.
Der zweite Parameter verweist auf das Template. Hierbei wird der Name des Templates verwendet, welcher im Schritt 3 definiert wurde.
Das Ergebnis wird nun in der letzten Zeile ausgegeben.

Das komplette PHP Skript:

<?php
include "class.FastTemplate.php3";
$tpl = new FastTemplate(".");
$tpl->define(array(
"template" => "template.tpl"
));
$tpl->assign("{title}", "Der Titel");
$tpl->assign("{teaser}", "Der Teaser");
$tpl->assign("{inhalt}", "Der Inhalt");
$tpl->parse("ausgabe", "template");
$tpl->FastPrint("ausgabe");
?>

Nützliche Anwendung von FastTemplate

Dieses Beispiel hat ja noch kaum die Stärke von FastTemplate gezeigt. Das folgende Beispiel hat die Aufgabe, einzelne Artikel mit einer ID aus einer Datenbank zu laden, und die Werte den Platzhaltern zuzuweisen. Das Ergebnis ist folglich ein kleines CMS. Die Daten der Artikel werden in der Datenbank gespeichert, über die ID des Artikels im URL werden diese über das Skript geladen, und schlussendlich über FastTemplate mit dem Template kombiniert, und ausgegeben.

Die Datenbank-Tabelle "article" wird über folgendes SQL Statement erzeugt.

CREATE TABLE article (id INT not null AUTO_INCREMENT, title VARCHAR (30) not null , teaser VARCHAR (250) not null , inhalt TEXT not null , PRIMARY KEY (id))

In ihr wird die ID des Artikels, der Titel, der Teaser, sowie der Inhalt selbst gespeichert.

Nun das PHP Programm, das auf diese Daten in der Datenbank zurückgreift, und über FastTemplate ausgibt.
Es wird das gleiche Template wie oben verwendet, nur das die Datenbank-Funktionen hinzugefügt worden sind.

show_article.php

<?php
// FastTemplate Klasse wird geladen
include "class.FastTemplate.php3";

//Variablen für die Datenbankverbindung
$user = "";
$pass = "";
$host = "localhost";
$db = "cms";

//Verbindung wird aufgebaut
$connid = mysql_connect($host, $user, $pass);

//Template Objekt wird erzeugt, Templates definiert
$tpl = new FastTemplate(".");
$tpl->define(array(
"template" => "template.tpl"
));

//wenn die $ID in dem URL vorhanden ist...
if (isset($ID)) {

//Daten werden aus der Datenbank geladen
$sql = "Select*From article where id='$ID'";
if (!$erg = mysql_db_query($db, $sql, $connid)) {
echo "Artikel nicht in DB vorhanden!<br>"; }
else {
$erg2 = mysql_fetch_array($erg, MYSQL_ASSOC);

//Daten und Platzhalter werden definiert
$tpl->assign("{title}", $erg2["title"]);
$tpl->assign("{teaser}", $erg2["teaser"]);
$tpl->assign("{inhalt}", $erg2["inhalt"]);

//Parsing-Schritt
$tpl->parse("ausgabe", "template");
$tpl->FastPrint("ausgabe");
}
}
echo "Sie haben keinen Artikel ausgewählt!<br>";
mysql_close($connid);
?>

Nun, die Erklärung der Arbeitsweise ist eigentlich leicht zu erkennen.
In der ersten Zeile wird wiederum die FastTemplate Klasse eingebunden. In den folgenden Zeilen werden die Daten für die MySQL Verbindung angegeben.
Daraufhin wird die Verbindung zur MySQL Datenbank aufgebaut.
Daraufhin wird von der Template Klasse ein Objekt erzeugt, und das Template definiert.
Dem Aufruf des PHP Skripts "show_article.php", wird als Parameter eine ID gegeben (z.B. show_article.php?ID=1). Über diese ID wird der Artikel aus der Datenbank gelesen. Ist diese ID nicht im URL vorhanden, oder kann über diese ID kein Artikel aus der Datenbank gelesen werden, dann wird das Programm vorzeitig beendet.
Das SQL Statement, welches den Artikel aus der Datenbank ließt wird dynamisch generiert, da die ID ja vom URL abhängig ist, macht dies ja auch nur Sinn.
$sql = "Select*From article where id='$ID'";
Daraufhin wird der Query an die Datenbank gesendet. Wird kein Ergebnis zurückgegeben, wird das die Fehlermeldung "Artikel nicht in DB vorhanden!" ausgegen. Ansonsten wird aus den Ergebnissen über die mysql_fetch_array() Funktion ein Array erzeugt. Die Konstante "MYSQL_ASSOC" besagt, dass es sich bei dem Array um ein assoziatives Array handelt, dessen Index der Name der MySQL Tabellenspalte ist.
$erg2 = mysql_fetch_array($erg, MYSQL_ASSOC);
//Daten und Platzhalter werden definiert
$tpl->assign("{title}", $erg2["title"]);
$tpl->assign("{teaser}", $erg2["teaser"]);
$tpl->assign("{inhalt}", $erg2["inhalt"]);

Ist dies geschafft, so ist der größte Teil der Arbeit schon gemacht worden. Jetzt werden die Werte in dem Array noch den passenden Platzhaltern zugewiesen, FastTemplate parsed das Template, und gibt das Ergebnis aus.
$tpl->parse("ausgabe", "template");
$tpl->FastPrint("ausgabe");

Volià - Ein kleines System zum Laden von Artikeln aus der Datenbank, und das Anzeigen über das Template System FastTemplate ist fertig.

Das Programm gibt es auch zum downloaden und Testen. (tf)

No related posts.

Bisher ist SimpleXML auf experimenteller Basis veröffentlicht worden, so dass sich bis zur Erscheinung der finalen Version von PHP 5 noch einiges verändern kann. Insbesondere Funktionsnamen und ähnliches könnten betroffen sein. SimpleXML muss nicht mehr mitinstalliert werden. In den neuen PHP5 Distributionen wird SimpleXML standardmäßig mitkonfiguriert.
 
Und simpel ist SimpleXML in der Tat. Ein einfaches XML Dokument, wie z.B. artikel.xml kann in wenigen Schritten mit SimpleXML verarbeitet werden.

artikel.xml:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<artikel>
<titel>Der Titel</titel>
<teaser>Der Teaser, eine kurze Beschreibung</teaser>
<inhalt>Der Artikelinhalt an sich</inhalt>
</artikel>
 
Um beispielsweise an den Inhalt des <teaser> Elementes zu gelangen, bedarf es nur weniger Zeilen Code:

simplexml_1.php:
 
<?php
 
if (file_exists('artikel.xml')) {
$xml = simplexml_load_file('artikel.xml');
 
echo $xml->teaser[0];
 
} else {
exit('Konnte Datei nicht laden.');
}
?>
 
Durch die simplexml_load_file() Funktion wird die XML Datei eingelesen und direkt in ein Objekt überführt. Auf die Elemente des Objektes kann jetzt wie auf normale Objekte zugegriffen werden. Die Ausgabe erfolgt über das $xml Objekt, welches nichts anderes als das Wurzelelement <artikel> darstellt.

Dabei erfolgt der Zugriff auf die Elemente jeweils über Arrays. Da in unserem Fall nur ein Element innerhalb des Wurzelelementes <artikel> als <teaser> Element verwendet wird, geschieht der Zugriff auf den Inhalt dieses Elementes mit dem Arrayindex 0. Wären zwei <teaser> Elemente verwendet, würde man über den Index 1 auf das zweite Element zugreifen.

Um zu verstehen, wie bei SimpleXML die Daten in Objekten gespeichert werden, kann man sich mit der var_dump() Funktion von PHP schlicht den gesamten Inhalt des Objektes ausgeben lassen. Man ändert den Code einfach wie folgt ab:

simplexml_1.php:

<?php
 
if (file_exists("artikel.xml")) {
$xml = simplexml_load_file("artikel.xml"');
 
var_dump($xml);
}
else {
exit("Konnte Datei nicht laden. ");
}
?>

Die Ausgabe nach Aufruf des Skriptes sieht wie folgt aus:

object(SimpleXMLElement)#1 (3)
{
["titel"]=> string(9) "Der Titel"
["teaser"]=> string(35) "Der Teaser, eine kurze Beschreibung"
["inhalt"]=> string(25) "Der Artikelinhalt an sich"
}
 
Darin erkennt man die gesamte Struktur des XML Dokumentes wieder. SimpleXML erkennt, dass das Dokument genau aus einem Element object(SimpleXMLElement)#1 besteht, welches drei object(SimpleXMLElement)#1 (3) untergeordnete Elemente beherbergt. Diese Elemente, ihr Datentyp und deren Inhalte werden dann in geschweiften Klammern angegeben.

Wenn man bedenkt, dass zum Parsen eines XML Dokumentes mit dem ereignisorientierten Parser Expat mindestens drei Funktionen definiert werden mussten, ist der hierzu notwendige Aufwand mit SimpleXML nicht vergleichbar.

Komplexere XML Dokumente und SimpleXML?
Auch komplexe XML Dokumente lassen sich mit SimpleXML rasch bearbeiten. Folgendes XML Dokument ist fast identisch mit dem Beispiel oben, es wurde jedoch mit Attributen und weiteren Elementen versehen.
 
artikel_2.xml:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<content>
<artikel id="1">
<meta>
  <keywords>ein,netter,artikel</keywords>
  <description>ein,lustiger,artikel</description>
  </meta>
  <titel>Der Titel</titel>
  <teaser>Der Teaser, eine kurze Beschreibung</teaser>
  <inhalt>Der Artikelinhalt</inhalt>
  </artikel>
<artikel id="2">
<meta>
  <keywords>ein,zweiter,netter,artikel</keywords>
  <description>ein,zweiter,lustiger,artikel</description>
  </meta>
  <titel>Der zweite Titel</titel>
  <teaser>Der zweite Teaser, eine kurze Beschreibung</teaser>
  <inhalt>Der zweite Artikelinhalt</inhalt>
  </artikel>
  </content>
 
Da SimpleXML ausgesprochen modular aufgebaut ist und viele Schnittstellen zu weiteren PHP- beziehungsweise XML Technologien aufweist, können komplexe Untersuchungen von XML Dokumenten zum Beispiel über den in SimpleXML integrierten XPath Prozessor durchgeführt werden. Das heißt, man kann über die Pfadangaben in XPath auf die gesuchten Elemente zugreifen.

Dies soll im folgenden Beispiel geschehen – es soll lediglich der vom Besucher angefragte Artikel angezeigt werden. Der gewünschte Artikel wird durch die ID identifiziert, die im <artikel> Element als Attribut definiert ist. Diese ID wird über den URL an das PHP Programm übergeben.

simplexml2.php

<?php

$id = $_GET['id'];

if (file_exists("test.xml")) {

$xml = simplexml_load_file("test.xml");

$path ="/content/artikel[@id=".$id."]";

if (!$res = $xml->xpath($path)) {
echo "Artikel nicht vorhanden!";
}
else {
echo "<h1>".$res[0]->titel."</h1>";
echo "<p><b>".$res[0]->teaser."</b></p>";
echo "<p>".$res[0]->inhalt."</p>";
}
}
else {
exit("Konnte Datei nicht laden.");
}
?>
 
Auf den gewünschten Artikel wird über den XPath Pfad /content/artikel[@id=".$id."] zugegriffen. Die Anfrage wird über die xpath() Methode verarbeitet und das Ergebnis der Variable $res zurückgegeben. In diesem Array sind nun alle Elemente des gesuchten Artikel-Objektes gespeichert. Auf diese kann wie auf ein Objekt zugegriffen werden.

Das Ergebnis beim Aufruf mit id=1

Natürlich kann man ein solches Problem auch ohne XPath lösen, SimpleXML stellt die dazu notwendigen Funktionen zur Verfügung – doch bietet SimpleXML gerade durch die Schnittstelle zu XPath viele weitere Möglichkeiten für die dynamische Programmierung. SimpleXML sollte also nicht unterschätzt werden.

Weitere Informationen zu SimpleXML und PHP5.

Weiterführende Links:

1. XML Schema – Elemente und Attribute
2. Was ist XML Schema? – Einführung in XML Schema
3. XML Einführung