JSConf.eu - Roundup Tag 2

Nach einer richtig guten Party ging es am zweiten Tag mit der JSConf.eu direkt weiter.

Tomasz Janzcuk von Microsoft zeigte, wie sich leichtgewichtige Node-Anwendungen (Singe-Page-Anwendungen, die auf node.js aufbauen) kostengünstig skalieren lassen. Es lassen sich nicht nur einzelne Node-Instanzen pro virtualisierter Maschine, sondern auch innerhalb einer virtualisierten Maschine verschiedene Node-Prozesse starten. Statt einzelner Node-Prozesse lassen sich zudem auch leichtgewichtige Threads verwenden. Dies ist aber nicht effektiv genug. Erst mit dem Verwenden von isolierten Kontexten innerhalb einzelner Threads lassen sich die Betriebskosten einer leichtgewichtigen Node-Anwendung signifikant drücken.

Andrea Giammarchi von Nokia berichtete von Problemen, die beim Entwickeln von HTML5-Apps auf neuen Endgeräten (Mobile und Tablet) auftreten. HTML5 ist kein fester Standard und die Implementierungen in verschiedenen (mobilen) Browsern sind noch sehr unterschiedlich. Er konnte Lösungen und Workarounds für gängige Probleme aufzeigen. Dieser Talk schien direkt aus der Praxis zu kommen und Giammarchi Tipps erscheinen sehr wertvoll.

Jed Schmidt rockte den Saal mit seinem Vortrag über 140byt.es.

Jakub Siemiątkowski implementierte Voxels in JavaScript. Wenn eine 3D-Welt nicht aus Polygonen sondern aus Würfeln zusammengesetzt wird, dann nennt man diese Würfel Voxel bzw. die Welt Voxelspace. Voxel sind sehr speicher- und rechenzeitintensiv. Trotzdem konnte er eine - wenn auch langsame und nicht besonders stabile - Implementierung live demonstrieren.

Lea Verou hielt einen sehr umfangreichen Talk über Polyfills. Polyfills sind Softwarekomponenten, die fehlende Implementierungen von spezifizierten Features in Webbrowsern durch JavaScript nachimplementieren. Wenn ein Browser das spezifizierte Feature selbst implementiert, dann werden die Polyfills nicht verwendet sondern die native Implementierung des Browser führt das Feature selbst aus. Polyfills sind also Softwarekomponenten, die nur so lange leben sollten, bis die jeweiligen Features von allen Zielbrowsern unterstützt wird.

James Coglan verwendete Websockets, um nahezu alle Laptops im Raum fernzusteuern, um darauf Musik wiederzugeben.

David Coallier demonstrierte node-php. Mit node-php lassen sich PHP-Anwendungen in Node ausführen. Durch node-php sind Node und PHP nicht länger Konkurrenzplattformen sondern lassen sich gemeinsam in einer Webanwendung nutzen.

Tom Robinson, einer der Autoren des Cappuccino Webframeworks, hielt einen Talk über Compiler und Interpreter. Er führte anschaulich und durch Beispiele in die Welt von Compilern ein, die selbst in JavaScript implementiert sind oder JavaScript als Zielsprache erzeugen. Jeder Entwickler sollte selbst in der Lage sein, einen eigenen Compiler für eine eigene (domänenspezifische) Sprache zu schreiben, denn dies ist nicht so schwer, wie es auf den ersten Blick erscheint.

Douglas Campos präsentierte dyn.js. Dyn.js ist eine JavaScript-Implementierung auf der Java Virtual Machine. Anders als Rhino, das noch auf Java 1.2 aufbaut, verwendet dyn.js „Invoke Dynamic“, ein neues Feature der JVM seit Java 7. Durch „Invoke Dynamic“ kann JavaScript für die JVM sehr viel einfacher und evtl. sogar performanter implementiert werden als dies noch Rhino tut.

Michael Aufreiter hielt einen sehr interessanten Talk über data.js. Data.js ist eine JavaScript-Biblothek zum Bauen von datengetriebenen Webapplikation. Es bietet Features zur Defintion, Manipluation und Persistierungen von Graphen in Node und / oder im Webbrowser. Data.js ist die technische Basis von substance.io, einem webbasierten Dokumentenmanagementsystem.

Erik Corry führte in den neuen Garbage Collector von Googles V8 ein. Zudem konnte er Tipps zeigen, um Memory-Leaks zu vermeiden.

Michal Budzyinski hielt einen unterhaltsamen Talk über anaglyphe 3D-Darstellung (jene bunten Bilder, die über zweifarbige Brillen erst dreidimensional wahrgenommen werden). Er konnte in einer Live-Coding-Session eine Demo entwickeln, in dem Side-By-Side-Bilder der NASA anaglyph im Browser dargestellt werden. Dazu verwendete er das Canvas-Element und JavaScript.

Beendet wurde die Konferenz durch zwei sehr emotionsgeladene Talks. James Whelton stellte das Projekt „Coder Dojo“ vor, in dem Kinder unterrichtet werden. Ein T-Shirt, das von Brendan Eich getragen wurde, wurde zugunsten dieses Projekts für 1.500 € an die Veranstalter versteigert. Chris Williams hielt schließlich das Schluss-Plädoyer, in dem er alle Anwesenden zu einer positiveren Einstellung im Umgang miteinander aufforderte.

Die Konferenz war sehr gelungen - ein Lob an die Veranstalter!

JSConf.eu - Roundup Tag 1

Ich bin auf der JSConf.eu 2011. Hier meine Eindrücke vom ersten Tag.

Der Veranstaltungsort - die Alte Münze Berlin - ist eine alte Geldfabrik in Berlin Mitte. Hier wurden 1935 bis 2006 Münzen geprägt. Seit der Schließung kann man die alten Münze als Veranstaltungsort mieten. Und die Alte Münze Berlin eignet sich hervorragend für eine Konferenz - etwas heruntergekommen aber mit dem gewissen etwas an Industrieromantik.

Nach dem Eröffnungssong von Bella Morningstar berichtete Dean McNamee von Plask. Laut der Konferenzbeschreibung ist Plask „is a multimedia programming environment. It brings together many of the recent advances in web-related technologies, graphics rendering, and languages, and brings them away from the web.“ Zwar hatte der Talk einige recht anschauliche Beispiele zur Verwendung von Plask, aber so richtig konnte ich die Essenz nicht fassen. Mir ist unklar, was Plask im Wesentlichen von anderen Exerimentier-Umgebungen wie Processing / Processing.js unterscheidet. Plask ist wie Processing auf Speed!

Peter van der Zee plädierte für mehr Tools. Im Bezug auf Entwicklerwerkzeuge befindet sich JavaScript - trotz Firebug, Web-Inspector und Chrome-Debugger - noch im Mittelalter. Als Beispiel für ein gelungenes Entwicklungswerkzeug präsentierte Van der Zee Zeon.js. Zeon.js is ist ein Tool, das im Browser läuft. In einer Text-Area lässt sich mit Zeon.js JavaScript bearbeiten. Zeon.js findet dabei Probleme. Anders als bekannte Tools wie JSLint ist Zeon.js jedoch interaktiv. Es ist eine wirkliche Hilfe und kein Hindernis beim Entwickeln. Zeon.js benutzt einen selbst geschriebenen Parser und statische Analsyse, um Probleme zu finden. Van der Zee führte Tiefer in dieses Thema ein und ermutigte die anwesenden Entwickler, ähnliche Werkzeuge zu schreiben, um die Arbeit mit JavaScript zu vereinfachen.

Aaron Quint ist der Autor von sammy.js. In seinem Talk rantete über Front-End-Frameworks. Frameworks sind keine Religion. Frameworks sollen Probleme lösen. Statt Hypes zu folgen sollten sich Entwickler wieder mehr ihren eigentlichen Aufgaben widmen und weniger fanatisch im Hinblick auf Technologien und Frameworks eingestellt sein.

Marijn Haverbeke, der Autor des Buchs „Eloquent JavaScript“ und des Minifizierers uglify.js, beschäftigte sich in letzter Zeit vermehrt mit Front-End-Performance, dem DOM und hardwarebeschleunigtem Rendering. In seinem Talk präsentierte er seine Erkenntnisse. Diese waren zwar teilweise nicht neu, trotzdem konnte man den Talk aber als gelungen bezeichnen.

Paul Bakaus, der Autor von jQuery-UI, ist inzwischen CTO bei der Social-Game-Schmiede Zynga. Er zeigte, welche Probleme es auch heute noch gibt, wenn man Spiele im Browser entwickeln möchte. Er plädierte dafür, alte Browser (< IE 9) nicht länger zu unterstützen. Zum Lösen des Problems des Scrollens und des Verschiebens des Viewports vor allem auf mobilen Endgeräten präsentierte er „Scroller“ und „Viewporter“. Diese stehen ab heute als OpenSource auf Github zur Verfügung.

Jan Kleinert und Paul Kinlan präsentierten Web-Intents. Web-Intents übertragen das Konzept der Intents auf Android-Smartphones („An intent is an abstract description of an operation to be performed…“) auf den Webbrowser. Statt eine Vielzahl von Diensten für Image Hosting, Social Bookmarking usw. zu integrieren (und den Benutzer damit zu verwirren), spezifiziert eine Anwendung lediglich einen Intent (wie „Sharing“ oder „Image Editing“). Der Webbrowser schlägt dann dem Nutzer Dienste vor, die genau dieses Feature bieten und bei denen er bereits registriert ist. Web-Intents könnten die Art, wie Webanwendungen Dienste dritter Webanwendungen integrieren, grundlegend verändern, sofern sich Web-Intents durchsetzen können.

Tobias Schneider, Nikolai Onken und Stephan Seidt präsentierten die „Arduino Extravaganza“. Dies ist ein Trinkspiel. Im Webbrowser müssen zwei Kontrahenten ein Problem in JavaScript lösen. Eine von einem Arduino-Board gesteuerte Zapfanlage mixt für den Verlierer ein hochalkoholisches Getränk. Die Farbe des Getränks wird vom Gewinner als Hexcode festgelegt - die Anlage kümmert sich vollautomatisch um die richtige Mischung.

Philip Tellis zeigte, wie sich Netzwerke mit JavaScript im Browser messen lassen. Dabei ging er ins Detail. Gegen Ende des Talks konnte er zeigen, wie sich ein Netzwerkscanner im Browser schreiben lässt, der automatisiert Cross-Site-Request-Forgery-Attacken durchführen kann. Dies war einer der interessantesten Talks bisher.

Jakob Mattson hielt ein Plädoyer für eine neue dynamische Sprache, die JavaScript ablösen sollte. JavaScript selbst sei zu statisch und zu wenig formbar, um den Ansprüchen an eine moderne, dynamische Sprache gerecht zu werden. Auch Sprachen wie CoffeeScript, die JavaScript erzeugen, sind laut Mattson kein Ausweg.

Alon Zakai zeige Emscripten. Emscripten ermöglicht es, C/C++-Code im Browser laufen zu lassen. Dazu nutzt Emscripten die LLVM (Low Level Virtual Machine). Ähnlich wie ein Java-Compiler Bytecode erzeugt, erzeugt LLVM-GCC (ein GCC-Compiler, der die LLVM unterstützt) Bitcode. Diesen Bitcode, der sehr viel einfacher als C/C++-Code ist, kann Emscripten zu JavaScript kompilieren. Standardbibliotheken bringt Emscripten gleich mit. So lassen sich C/C++-Bibliotheken direkt im Browser nutzen. Selbst komplexe Anwendungen wie das Computerspiel Quake laufen so im Browser. Dieser Talk war mehr als beeindruckend.

Als Überraschungsgast trat Bendan Eich, der Schöpfer von JavaScript, auf. Er zeigte, welche Features voraussichtlich in ES6 (ECMAScript 6th Edition) enthalten sein werden. Außerdem konnte er RiverTrail präsentieren. RiverTrail implementiert parallelisierbare Arrays in JavaScript. In einem grafischen Demo mit Web-CL zeigte er, dass eine parallelisierte Implementierung des Demos zehn mal so schnell lief wie eine sequentielle Implementierung.
Sein Talk entsprach im Wesentlichen dem Talk, den er auf der Capitol.js gehalten hatte. Er lässt sich auf seiner Website komplett einsehen.

WPO - DOM und CSS

In den letzen Monaten wanderte der Fokus in der Web Performance Optimierung von der Zeit, die zum Laden einer Seite benötigt wurde, zunehmend auf die Geschwindigkeit, in der das Rendering einer Seite und die anschließende Manipulation der Seite durchgeführt werden kann.

Der letzte Blog-Beitrag konzentrierte sich auf JavaScript, wohingegen sich dieser Blog-Beitrag mit dem DOM und CSS beschäftigt.

DOM

Die Verschachtelung des DOMs sollte nicht zu tief werden, genauer: Eine Schachtelungstiefe von mehr als 15 sollte unbedingt vermieden werden.

Elemente sollten über CSS gestylt werden. Direkt in Elementen sollten Style-Attribute nur in Ausnahmefällen (z.B. zur individuellen Platzierung) verwendet werden.

Leere DOM-Nodes sollten vermieden werden. Dies gilt auch für Spacer- oder Clear-DIVs.

Auch auf sonstige überflüssige Elemente (z.B. Grafiken für gerundete Ecken) sollte nach Möglichkeit (d.h. wenn dies der Style-Guide erlaubt) verzichtet werden.

Die Komplexität des DOMs lässt sich mit dem Bookmarklet DOM-Monster von Thomas Fuchs auch auf fremden Seiten überprüfen.

Benutze Hardware-Beschleunigung

Moderne Browser (IE9, Mozilla und Webkit) bieten hardwarebeschleunigtes Rendering. Dieses macht sich allerdings erst bei der Berechnung von Animationen (Ein- und Ausblenden von Dialogen, Bewegen von Infoboxen über den Bildschirm) wirklich bemerkbar.

Hardwarebeschleunigung steht allerdings (wenn man von Canvas und WebGL absieht) nur CSS, nicht aber JavaScript zur Verfügung. Darum sollten Animationen stets per CSS mit Transitions erfolgen. JavaScript sollte nur als Fallback eingesetzt werden.

#transition_animated { -moz-transition: all 5s ease-out; -o-transition: all 5s ease-out; -webkit-transition: all 5s ease-out; transition: all 5s ease-out; }

Nutze CSS-Features durchgänging

Effekte wie Schatten oder gerundete Ecken können und sollten mit CSS realisiert werden. Für Browser, die dies nicht unterstützen, wird dann auf eine Darstellung ohne diese Effekte zurückgegriffen. Einige CSS-Features kann man in alten IE-Versionen durch CSS3-Pie nachrüsten. Allerdings wirkt sich CSS3-PIE negativ auf die Laufzeit aus.

CSS-Selektoren

Ein Browser wertet CSS-Selektoren von rechts nach links aus. Eine Auswertung von rechts nach links ist nämlich technisch einfacher und performanter zu implementieren, da mit diesem Ansatz lediglich Listen gefiltert (reduziert) werden müssen. D.h., zunächst werden im Dokument alle Elemente ermittelt, die im rechten Teil des CSS-Selektors stehen, dann wird durch die Liste der gefundenen Elemente iteriert. Auf jedes vorher ermittelte Element wird dann der nächste Selektor ausgewertet. Die Liste wird um diesen Selektor reduziert.

Hierzu ein Negativbeispiel aus einem Stylesheet, das so wirklich existierte:

div#page_navigation #navbar_01 ul.navbar_02 li.act_childs a

• a – Es werden alle Links einer Seite in einer Liste gesammelt. Diese kann sehr lang werden, denn die Seite kann sehr viele Links enthalten.
• li.act_childs – Es werden von allen Elementen in der Liste die Parent-Nodes ermittelt, um zu prüfen, ob diese ein Listen-Element mit der Klasse act_childs enthalten. Die Liste wird anhand dieses Kriterium reduziert.
• ul.navbar_02 – Es werden von allen Elementen in der Liste die Parent-Nodes ermittelt, um zu prüfen, ob diese eine ungeordnete Liste mit der Klasse navbar_02 enhalten. Die Liste wird anhand dieses Kriterium reduziert.
• #navbar_01 – Es werden von allen Elementen in der Liste die Parent-Nodes ermittelt, um zu prüfen, ob ein Element die ID navbar_01 hat. Eine ID muss auf einer HTML-Seite eindeutig sein. Die Liste wird anhand dieses Kriterium reduziert.
• div#page_navigation – Obwohl im vorherigen Selektor bereits eine eindeutige ID angegeben wurde, werden von allen Elementen in der Liste die Parent-Nodes ermittelt, um zu prüfen, ob diese ein DIV mit der ID page_navigation enhalten. Ein ID-Selektor ist bereits eindeutig. Eine zusätzliche Überprüfung, ob dies ein DIV ist, ist überflüssig. Die Liste wird durch dieses Kriterium nicht wirklich reduziert, denn der vorhergehende ID-Selektor war bereits eindeutig.

Daher gelten einige Regeln für effektive CSS-Selektoren:

Verwende effektive Selektoren

IDs sind die effektivsten Selektoren, gefolgt von Klassen-, Tags- und Universal-Selektoren.

#main_navigation /* ID */
.main_navigation /* Class */
ul li a /* Tag */
li a [title='Zurück zur Startseite'] /* Universal */

Man sollte stets den schnellsten geeigneten Selektor möglichst weit rechts verwenden und den HTML-Code entsprechend gestalten. Selektoren auf Tags und Universal-Selektoren sollten komplett vermieden werden.

Ebenso sollten Descendant-Selektoren vermieden werden, die am langsamsten sind (siehe oben!). Oft lassen sich Descendant-Selektoren durch Child-Selektoren beschleunigen. Child-Selektoren sind zwar auch nicht schnell, aber doch schneller als Descendant-Selektoren, da von einem Element nicht potentiell alle Vorfahren, sondern lediglich das Elternelement ermittelt werden muss.

ul.navbar_02 li.act_childs /* bad */
ul.navbar_02 > li.act_childs /* still bad but better */

Überqualifiziere Selektoren nicht

IDs sind bereits eindeutig. Auch Klassen sollten nur für einen Tag definiert sein. Daher sind überqualifizierte Selektoren wie div#main_navigation oder li .act_childs überflüssig. Es genügt, die Elemente über den sehr schnellen ID-Selektor oder den Class-Selektor zu filtern.

Halte die Selektor-Kette kurz

Je länger die Selektor-Kette, desto mehr Operationen muss der Browser durchführen, um ein Element zu finden. Daher sollte die Kette der Selektoren kurz gehalten werden; überflüssige sollten ganz vermieden werden. Wenn sich eine Selektor-Kette nicht vermeiden lässt, dann sollte sie möglichst früh fehlschlagen, damit Elemente nicht überflüssig oft evaluiert werden müssen, bevor sie herausgefiltert werden.

Benutze Kaskadierung

Oft lässt sich eine lange Selektor-Kette durch Kaskadierung vermeiden. CSS kaskadiert Style-Informationen hin zu den Sub-Elementen. Daher lässt sich ein Style oft schon an einem Vater-Element notieren, damit er im Kinder-Element angewendet wird.

Lange Selektoren trifft man oft an: #navbar_01 ul.navbar_02 li a { font: „Arial“}

Dieser lange Selektor könnte durch die Verwendung eines kurzen Selektors minimiert werden.

#navbar_01 { font: „Arial“}

Dieser Blog-Beitrag sollte gezeigt haben, dass nicht nur dynamische Inhalte und Download-Größen sondern auch Struktur und Styling mitverantwortlich für die Performance einer Website sein können.

Dies ist ein Cross-Post vom Holisticon-Blog.

WPO - JavaScript und das DOM

Web Performance Optimierung konzentrierte sich in den letzten Jahren vor allem auf die Optimierung der Ladezeit einer Seite. Dazu haben sich Best Practices durchgesetzt, die bereits in einem Artikel in diesem Blog beschrieben wurden.

In jüngster Zeit wandert der Fokus jedoch immer mehr auf die Optimierung einer geladenen Seite, also auf die Zeit, die ein Browser für das Rendering und die Manipulation des DOMs benötigt.

In diesem Blog-Beitrag werden ich mich auf JavaScript konzentrieren.

Document.write

Die Verwendung von document.write ist generell – auch für JavaScripte von Dritten – untersagt. Es sind stattdessen DOM-Operationen (auch innerHtml) zu verwenden. Dies dient nicht nur der der Performance, sondern auch der Robustheit.

Inline-JavaScript

Inline-JavaScript sollte vermieden werden. Wenn dies nicht geht, sollten sie sich am Ende der Seite befinden. Das gilt auch für Event-Listener, die direkt in HTML-Elemente geschrieben werden. Diese sollten eigentlich erst nach dem Laden der Seite gebunden werden. Es sollten zudem so wenige JavaScript-Blöcke wie möglich verwendet werden, da jeder Block zu einer kurzen Verzögerung im Rendering führt.

JavaScript-Blöcke

Jeder JavaScript-Block wird isoliert abgearbeitet. Wenn in einem solchen ein Fehler auftritt, beeinflusst dies andere JavaScript-Blöcke nicht. Daher sollten Scripte, die mit Scripten von Dritten (Tracking, Targeting etc.) interagieren, in einem eigenen Block laufen. Dies widerspricht zwar der Anforderung, möglichst wenige Inline-JavaScripte einzubinden, sorgt aber für Robustheit der Seite. Um Performance-Einbußen zu minimieren, sollten diese Blöcke ausschließlich am Seitenende eingesetzt werden.

Selektoren

Selektoren, die z.B. in jQuery verwendet werden, sollten möglichst performant sein.

Nach Möglichkeit sollten nur Selektoren verwendet werden, die moderne Browser nativ implementieren können. Ob ein Selektor in der nativen Implementierung eines Browser funktioniert, kann man über die Funktion document.querySelectorAll in der Firebug-, Safari-, Internet Explorer- oder Chrome-Konsole testen (z.B. document.querySelectorAll(“.container .p–heading-1″)).

Zum Beispiel implementieren nicht alle Browser die Funktion document.getElementsByClassName. Ein Class-Selektor müsste also von einer Library wie jQuery implementiert werden. Wenn man einen Class-Selektor verwendet, dann muss jQuery alle Elemente der Seite (oder des Bereichs) über einen *-Selektor in eine Liste sammeln und jedes Element prüfen, ob seine Klasse der Klasse des Selektors entspricht. Dies kann auf einer Seite mit sehr vielen Elementen lange dauern. Statt Class-Selektoren sollte man also möglichst ID-Selektoren verwenden. Wenn ein ID-Selektor nicht möglich ist, kann man Events auch per Event Delegation (siehe unten!) an ein Vorfahren-Element binden, dass sich per ID referenzieren lässt.

Minimiere DOM-Manipulationen

JavaScript-Engines werden immer schneller. Dies gilt aber nicht unbedingt für den Zugriff auf das DOM. Manipulationen hieran sind teuer, weswegen sie minimiert werden sollten. Auf DOM-Manipulationen in Schleifen sollte nach Möglichkeit völlig verzichtet werden.

Cache DOM-Nodes und Attribute

Das Ermitteln von DOM-Elementen und -Attributen kostet Zeit. Daher sollten Elemente und Attribute einmalig ermittelt und dann in Variablen gecacht werden. Wenn sich das DOM verändert, so verändert sich auch automatisch das DOM-Element, das bereits ermittelt wurde – es besteht keine Notwendigkeit, erneut das Element im DOM zu suchen und auszuwerten. Module, die Objekte kapseln, können auch zur Zwischenspeicherung der DOM-Elemente genutzt werden.

Minimiere Redraws und Reflows

Jede Änderung im DOM führt zu einer Neuberechnung und einem Rendering der Seite. Dieser Redraw findet immer nach Events bzw. nach dem Beenden von JavaScript-Callbacks, die durch diese Events ausgelöst wurden, statt.

Änderungen sollten kumulativ erfolgen. Statt aus dem DOM zu lesen, in das DOM zu schreiben, erneut aus dem DOM zu lesen und wieder in das DOM zu schreiben, sollten Lese- und Schreiboperationen gebündelt erfolgen, so dass diese Operationen in einem einzigen Redraw bzw. Reflow erfolgen.

Das Document-Ready-Event

Im Document-Ready-Event sollte so wenig wie möglich getan werden. Lediglich Event-Listener dürfen an Elemente gebunden werden. Diese Elemente sollten nach Möglichkeit per ID referenziert werden. Wenn dies nicht möglich ist, bietet sich Event Delegation (siehe unten!) an.

Gänzlich verzichtet werden sollte auf DOM-Manipulationen, die schon beim Laden der Seite stattfinden (wie das Erzeugen von DIVs auf Reserve oder das Setzen von Attributen aufgrund von CSS-Klassen). Das DOM sollte bereits auf dem Server statt erst im Browser manipuliert werden.

Lazy Initialisation

Berechnungen und Bindings beim Document-Ready-Event sollten minimiert werden (siehe oben!), sondern erst durchgeführt werden, wenn sie benötigt werden (z.B. nach einen Klick-Event). Natürlich ist im Einzelfall abzuwägen, ob Lazy Initialisation einen Vorteil bietet. Eine Lazy Initialisation bei einem MouseOver-Event könnte als störend (verzögert) empfunden werden, während sie nach einem Klick-Event vom User nicht bemerkt wird.

Event Delegation

Es kann nach dem Laden der Seite lange dauern, bis alle Event Handler an DOM-Elemente gebunden sind. Um diese Zeit zu minimieren, bietet sich Event Delegation an, die der der Lazy Initalisation ähnelt. Man registriert ein Event (z.B. ein Klick-Event) an einem umschließenden Bereich, der sich z.B. über eine ID referenzieren lässt. Die Auflösung auf das einzelne geklickte Element findet dann erst nach dem Klick-Event statt. Die Zeit, die beim Laden der Seite eingespart wird, tritt dann also bei jedem einzelnen Event auf. Daher ist im Einzelfall abzuwägen, ob Event Delegation einen Vorteil bietet. Eine Event Delegation bei einem MouseOver-Event könnte als störend empfunden werden, während eine Event Delegation nach einem Klick-Event vom User nicht bemerkt wird.

Dies ist ein Cross-Post vom Holisticon-Blog und von Ajaxer.

JSON-P mit Spring und CXF

Viele Webapplikationen laden Daten per JavaScript im JSON-Format von einem Server in den Browser, um sie dort darzustellen oder zu verarbeiten. Ein solcher Beispieldatensatz im JSON-Format könnte wie folgt aussehen:

{
  “cities”: [”Hamburg”, “New-York”, “Tokio”]
}

Ein Webbrowser lässt allerdings nicht zu, dass ein Script Daten von einer anderen Domain lädt als der, von der die Seite, in die das Script eingebettet wurde, geladen wurde. JavaScript hat also keinen Zugriff auf Daten, die von einer anderen Domain kommen. Diese Einschränkung ist ein Security-Feature des Browsers und als Same Origin Policy bekannt.

Oft ist es aber nötig, Daten von einer fremden Domain oder einer eigenen Subdomain zu ermitteln. Die saubere technische Lösung für dieses Problem ist Cross Origin Resource Sharing. Beim Cross Origin Resource Sharing werden Berechtigungen über HTTP-Header gesteuert. Leider funktioniert Cross Origin Resource Sharing nicht mit Legacy-Browsern, die noch häufig anzutreffen sind.

Ein Workaround, der in jedem Browser funktioniert, ist JSON-P: JSON with Padding. Ein Script darf selbst zwar keine Daten von einer fremden Domain anfordern, aber es darf einen Script-Tag generieren, der ein weiteres JavaScript von dieser fremden Domain lädt und direkt ausführt. Diesem nachgeladenen JavaScript übergibt man als GET-Parameter den Namen einer Callback-Funktion, die von dem nachgeladenen JavaScript ausgeführt werden sollte. Per Konvention trägt dieser GET-Parameter den Namen „_jsonp“.

script src="”http://my.otherdomain.de/rest-ws/myservice/mydata?_jsonp=jsonpCallback“" type="”text/javascript”"

Das so eingebundene Script muss dynamisch auf dem Server in einer Weise erzeugt werden, dass es die übergebene Callback-Funktion aufruft, sobald es vom Browser geladen wurde. Der Callback-Funktion werden in der Regel die Daten übergeben, die man ansonsten direkt als JSON-Objekt angefragt hätte:

jsonpCallback (
 
  {
 
    “cities”: [”Hamburg”, “New-York”, “Tokio”]
 
  }
 
);

Die Callback-Funktion wird von dem Script, das eigentlich die Daten anfordern wollte, bereitgestellt. So werden Daten von einer fremden Domain per JSON-P geladen. Front-End-Libraries wie jQuery stellen eine automatisch generierte Callback-Funktion bereit. Daher muss sich der Entwickler nicht um das Schreiben dieser Callback-Funktion kümmern.

return $.ajax({
 
type: “GET”,
 
url: “http://my.otherdomain.de/rest-ws/myservice/” + data,
 
error: errorcallback,
 
success: callback,
 
dataType: “jsonp”,
 
jsonp: “_jsonp”,
 
jsonpCallback: “ jsonpCallback “
 
});

Auf Client-Seite stellt JSON-P also kein Problem dar und wird von gängigen JavaScript-Bibliotheken unterstützt.

Auf dem Java Enterprise-Server wird für RESTful Services oft eine JAX-RS-Implementierung benutzt. Eine gängige JAX-RS-Implementierung ist Apache CXF. Allerdings stellt CXF im Moment noch kein JSON-P zur Verfügung (JIRA 3005). Daher muss man sich einen eigenen JSON-P-Provider schreiben. Dies ist glücklicherweise sehr einfach, denn man kann alle Funktionalitäten vom Default-JSONProvider erben:

@Produces("application/json")
 
public class JSONPProvider extends JSONProvider {
 
  @Override
 
  public void writeTo(
 
    Object obj, Class cls,
 
    Type genericType, Annotation[] anns,
 
    MediaType m, MultivaluedMap headers,
 
    OutputStream os
 
  ) throws IOException {
 
    final String prefix = request.getParameter("_jsonp"); // fix for demo
 
    final boolean hasPrefix = !StringUtils.isEmpty(prefix);
 
    if(hasPrefix) {
 
      // … check for injection first
 
      os.write(prefix); // simplified
 
      os.write('(');
 
      super.writeTo(obj, cls, genericType, anns, m, headers, os);
 
      os.write(')');
 
    } else {
 
      super.writeTo(obj, cls, genericType, anns, m, headers, os);
 
    }
 
  }
 
}

Dieser eigene JSON-P-Provider macht nichts, außer die vom JSON-Provider erzeugten JSON-Daten mit dem Aufruf einer Callback-Funktion zu umschließen, falls ein Request-Paramter „_jsonp“ übergeben wurde. Das abgedrucke Listing ist simplifiziert. Selbstverständlich muss man den Eingabeparameter „prefix“ prüfen, um eine Code-Injection auszuschließen.

Dieser selbst geschriebene JSON-P-Provider kann im Spring-Framework nun als JSON-P-Provider-Bean definiert werden. Letztere kann in einem JAX-RS-Server genutzt werden.

So lassen sich RESTful Services, die bisher nur JSON sprechen konnten, durch Konfiguration des JSON-P-Providers so erweitern, dass sie auch optional JSON-P sprechen können.

Dies ist ein Cross-Post vom Holisticon-Blog und von Ajaxer.

Türstehen für Bohnen – Bean Validation mit domänenspezifischen Typen in der Praxis

Simon Zambrovski und Oliver Ochs, JavaMagazin Ausgabe 4.2011


Nachdem vor Kurzem Simon Zambrovski und Oliver Ochs bereits einen IT-Talk zum Thema Bean Validation gehalten haben, ist nun auch ein JavaMagazin-Artikel zum gleichen Thema erschienen.

In einer Java-Enterprise-Anwendung werden Daten erfasst und verarbeitet. Diese Daten müssen validiert werden. Die Validierungslogik ist meist eng an die Daten, die validiert werden, gekoppelt. Darum werden durch JSR-303 Bean Validation die Validierungsregeln direkt an die Daten annotiert. Der JSR-303 ist ein Teil der Java EE 6. Das heißt, man kann Bean Validation in Java EE 6 sowohl mit JSF als auch mit JPA einsetzen. Doch auch außerhalb der Java EE 6-Welt lässt sich Bean Validation z.B. mit Spring 3 verwenden.

Der Artikel bietet einem praxisnahen Überblick über den Einsatz von JSR-303 mit all diesen Frameworks. Zudem wird die Verwendung von domänenspezifischen Typen tiefer gehend erläutert.

Man findet den Artikel in der Rubrik "Enterprise".

Mehr Informationen findet man im Holisticon-Blog.