Eine interessante Alternative zu AJAX-Funktionen auf XML-Message-Basis bietet die JSON-Technologie an. Die Übertragung der Nachrichten vom Browser zum Server erfolgt dabei auf Basis einer einfachen Datenstruktur, die am besten beschrieben werden kann als Verschachtelung von Arrays und Hashes. In den meisten Programmiersprachen werden diese Strukuren nativ unterstützt, was die Verbreitung der Technologie extrem vereinfacht.

Der Overhead des durch die XML-Strukturen anfallenden Codes entfällt, somit wird die Übertragung und das Verarbeiten der Nachrichten vereinfacht. Weder auf der Seite des Clients noch auf der des Severs muss eine Transformation der Daten über XSLT oder aber ein Zusammensuchen der Daten durch aufwändiges Navigieren durch das DOM erfolgen. Zudem muss sich der Programmierer keine Gedanken um das Finden einer geeigneten XML-Struktur machen um die Daten hin- und her zu transportieren.

Eine Besonderheit ist dabei, daß die Daten auf der Client-Seite direkt als gültiger Javascript-Code vorliegen. Sie können direkt mit Javascript weiterverarbeitet werden.

JSON Nachrichtenstruktur

Die Strutur der zu übetragenden Nachrichten sind ausführlich auf www.json.org beschrieben.

Beispiel für eine JSON-Nachricht:

{
"glossary": {
"title": "example glossary",
"GlossDiv": {
"title": "S",
"GlossList": [{
"ID": "SGML",
"SortAs": "SGML",
"GlossTerm": "Standard Generalized Markup Language",
"Acronym": "SGML",
"Abbrev": "ISO 8879:1986",
"GlossDef":
"A meta-markup language, used to create markup languages such as DocBook.",
"GlossSeeAlso": ["GML", "XML", "markup"]
}]
}
}
}


Implementieren auf Client-Seite

Um die AJAX-Funktionalität auf der Client-Seite zu implementieren, benötigt man eine Javascript-Library. Eine solche ist auch über die oben genannte Seite www.json.org zu beziehen, allerdings nicht besonders leicht zu finden.

Deshalb hier die direkten Links:

• Open source code des JSON parser und JSON stringifier
• Minimierte Version (only about 1K)

Weiterhin ist eine Library HTTP.Request hilfreich, mit deren Hilfe die HTTP-Übertragung selbst Browsertransparent durchgeführt werden kann. Sie kann hier bezogen werden. Allerdings ist zu beachten, daß in der aktuellen Version dieser Library zur Übertragung immer automatisch der Content-Type application/x-www-form-urlencoded verwendet wird. Dies führt z.B. bei einem Perl-Backend auf dem Server dazu, daß der Request nicht mehr korrekt ankommt sondern nur zerteilt. Zum Beheben dieses Problems sollte die folgende Zeile in Request.js geändert werden von:


this.transport.setRequestHeader( "Content-type", "application/x-www-form-urlencoded" );


in

this.transport.setRequestHeader( "Content-type", "plain/text" );


Mit diesen Vorraussetzungen kann nun der Client implementiert werden:

<script type="text/javascript" src="/global/lib/json.js"></script>
<script type="text/javascript" src="/global/lib/HTTP/Request.js"></script>
<script type="text/javascript">
var req, id = 0, since_msg = new Date();
// vor 5 Stunden
since_msg.setTime(new Date().getTime() - 1000 * 60 * 60 * 5);

Die wichtigsten Code-Stellen:


JSON.stringify( {
method : 'finduser',
id : id++,
params : [ txt.value, since_msg.getTime() ]
}


Hier wird ein Hash der die Nachrichtenbestandteile enthält mittels JSON.stringify zu einem JSON-String umgewandelt. Die RPC-Methode, die dabei auf dem Server aufgerufen wird, nennt sich finduser. Sie bekommt die Parameter txt.value, since_msg.getTime(). id ist eine fortlaufende Nummer, die zur Identifizierung des Requests bei asynchron eintreffenden Ergebnissen dient.

Der erzeugte JSON-String zur Übertragung sieht dann so aus:

{"method":"finduser","id":0,"params":["micha",1140627355276]}


Mittels der Anweisung:

req = new HTTP.Request({
uri: '/test/testajax',
postbody: JSON.stringify( {
method : 'finduser',
id : id++,
params : [ txt.value, since_msg.getTime() ]
}),
onSuccess: function (trans) {
var data;
try {
var data = eval('('+trans.responseText+')'); // JSON "parsen"
} catch(e) {
alert('eval: Ungültiges JSON: ' + e);
return;
}
// hier kann ggf. noch auf data.error geprüft werden
nachrichten(data.result);
}
});


wird der HTTP-Request übetragen. onSuccess beinhaltet eine Funktion, die bei einem erfolgreichen Request ausgeführt wird. Hier wird die Antwort verarbeitet und dynamisch in die dargestellte Seite eingebaut.

Implementierung auf der Server-Seite

Auf der Server-Seite ist die Implementierung natürlich abhängig von der Programmiersprache der Wahl. JSON-Implementierungen sind in zahlreichen gängigen Programmiersprachen vorhanden, Links dazu sind auch über www.json.org zu finden.

Hier soll die Implementierung in Perl betrachtet werden. Wie man es von Perl gewohnt ist, steht ein fertiges CPAN-Modul JSON zur Verfügung, daß das Einbinden denkbar einfach macht. Es funktioniert (unter anderem) mit einer RPC-Schnittstelle á la SOAP. Im Idealfall muss man sich noch nicht einmal mit den JSON-Datenstrukturen beschäftigen, sondern bekommt die Parameter direkt als Funktionsparameter geliefert und gibt Perl-Datenstrukturen zurück. Die nötigen Umwandlungen passieren im Hintergrund.


package MyJSON;
use strict;
sub finduser {
my $server = shift;
my $username = shift;
my $time = shift;
#...
# return a scalar value or a hashref or an arryaref. Z.B.:
# return {'username'=>"Franz Mustermann", 'userid'=>14};
}

# a la XMLRPC::Lite
JSONRPC::Transport::HTTP::CGI->dispatch_to('MyJSON')->handle();


#!/usr/bin/perl

use strict;
use Unicode::String;
print Unicode::String::latin1($ARGV[0])->utf8();

Ausführen mit:
perl iso2uni.pl Ümläüte

Eine Lösung dafür bietet das Perl-Module CPAN::Unwind, das in der Lage ist, ohne die zu installieren die Abhängigkeiten von einem Modul herauszufinden. So können diese gesammelt heruntergeladen und übertragen werden. Das Modul installiert ein shell-Tool namens cpan-unwind.

Mit dem Befehl:
cpan-unwind PDF::API2

Es scheint noch einige Kinderkrankheiten zu geben, so erhält man manche komische Fehlermeldung, grundsätzlich ist das aber schon nützlich.

Bedienung:
m Modulname: Zeige Infos zu einem Modul
install Modulname: Module installieren
force install Modulname: Modulinstall erzwingen

Einstellungen
o conf: Einstellungen anzeigen
o conf urllist unshift “mirror”: Mirror eintragen (hinzufügen)
o conf urllist shift: mirror entfernen

http://pdfapi2.sourceforge.net/twiki/


use Data::Dumper;
$Data::Dumper::Maxdepth = 2;


For this reason i want to write a small howto for the next time

I wanted to get the textual output from the vcard. So I started creating an new Text::vCard, but could not find a method to output the content. After some reading I found out that the only way is to use am addressbook and create a vcard from this one:


my $addressbook = new Text::vCard::Addressbook();
my $vcard = $addressbook->add_vcard();


Next Step is to fill the base-data. Vcard knows base-data and “more complex” data. Note that $self is my user-object which contains the data.


# Basisdaten einfuegen
$vcard->fullname($self->get_fullname());
$vcard->email( $self->get('email') );
$vcard->uid($self->get('user'));
$vcard->title($self->get('title'));


Next Step is an Name-Node. This node belongs to the more complex ones and you can use. I do not know for what more than one of them can be used, but there must be any reason. The Method add_node is used to create a new node of a special type.


# namen setzen
my $name = $vcard->add_node({'node_type'=>'N'});
$name->family( $self->get('name') );
$name->given( $self->get('prename') );


Next i added an address-node. You can add multiple here i think. I did not try, but in other nodes you can do something like that: $add->add_types(’WORK’);


# Adresse einsetzen
my $ad = $vcard->add_node({'node_type'=>'ADR'});
$ad->add_types('work');
$ad->street( $self->get('street') );
$ad->city( $self->get('city') );
$ad->post_code($self->get('zip') );


Finally I added phone numbers. Please note the call add_types(['WORK', 'fax']) to mark that the phone-number is a fax at work.


# Telefonnummern
my $p = $vcard->add_node({'node_type'=>'TEL'});
$p->add_types('WORK');
$p->value($self->get('phone'));

my $mobil = $vcard->add_node({'node_type'=>'TEL'});
$mobil->add_types('cell');
$mobil->value($self->get('mobil'));


Finally you can get the output using the addressbook-object:

my $textonly = $addressbook->export()

If you want to print this to a browser, do not forget to send a proper content-type like text/v-card, so the browser knows what to to with it.