Von Java Swing über JavaFX nach RISC-HTML

Transkript

1 Von Java Swing über JavaFX nach RISC-HTML Björn Müller, CaptainCasa Wir eine Community europäischer Software- Hersteller von Geschäftsanwendungen waren lange Zeit ganz gut mit Java Swing gefahren. Aber der Druck zu einer Modernisierung wurde zunehmend stärker. Ein Umstieg in Richtung JavaFX war zwar technologisch interessant, doch so recht brachte uns dieser auch nicht weiter Dann kam uns eine Idee, die für uns zum Game Changer wurde und uns den Weg in den Browser bahnte: RISC-HTML. Unser Swing-Client ist im Jahr 2007 entstanden. Eine Zeit, in der die einen uns rieten, ActionScript mit dem Macromedia/Adobe Player zu verwenden. Die anderen rieten uns, auf HTML-Frameworks zu setzen. Wir entschieden uns für Swing und dies aus guten Gründen. Swing war (und ist es auch noch ) rock-solid, performant und die Existenz langfristig gesichert. Geschäftsanwendungen haben in ihren Kernteilen sehr lange Lebenszyklen von teilweise weit mehr als Jahren und werden in der Regel von Teams überschaubarer Größe entwickelt und gewartet. Die Lust und Zeit, die Dialoge solcher Anwendungen alle paar Jahre mit anderen Technologien neu zu entwickeln, ist begrenzt. Dies gilt genauso für die Lust und Zeit, sich mit Problemen wie Browser- Kompatibilität herumzuschlagen. Deswegen liegt der größte Fokus neben der Verkaufbarkeit und Attraktivität der Anwendung auf einer langfristigen Stabilität (siehe Abbildung 1). So ganz direkt wurde Swing nicht auf die Anwendungsentwicklung losgelassen: Unser Swing-Frontend lief im Client des Benutzers und bekam vom Server das Layout als XML-Beschreibung der Dialoge zugesendet. Diese Dialogbeschreibungen wurden also vom Swing-Client ausgerendert. Eingaben des Benutzers wurden zu passenden Zeitpunkten an den Server übermittelt und dort in die Java-Anwendung eingearbeitet, worauf der Server dann ein Dialogupdate zum Client zurücksendete. Der Swing-Client war somit Java aktuell 05/17 37

2 Abbildung 1: Eine Anwendung, drei Clients: Swing (2007), FX (2012) und RISC-HTML (2016) kein konkret implementierter Anwendungsdialog, sondern eine generische Rendering Engine (siehe Abbildung 2). Modernisierungsdruck Natürlich gingen drei Entwicklungen nicht an uns vorüber: Zum einen war da die zunehmende Qualität der Browser und die zunehmende Steigerung der Performance von JavaScript. Zum anderen gab es zunehmende generelle Zweifel an Java im Frontend vor allem getrieben durch Sicherheitsprobleme der Java VM. Hinzu kam das Erscheinen von JavaFX als Ablösung von Java Swing das spätestens mit JavaFX 2.0 eine gewisse Ernsthaftigkeit zeigte. Alle drei Entwicklungen nagten an der Attraktivität unserer Swing-Client- Lösung und damit an der Attraktivität der Anwendungslösungen unserer Community-Mitglieder. JavaFX 2.0 im Jahr 2011 starteten wir also die Reimplementierung unseres Clients. Beim Umstieg kam uns natürlich unsere entkoppelte Client-Struktur zu Hilfe letztlich mussten wir ja nur den generischen Rendering-Client in JavaFX reimplementieren. JavaFX hat uns dabei von Release 2.0 an technologisch gut gefallen. Wir haben schnell einen Weg gefunden, um effektiv damit zu entwickeln, und blieben innerhalb dieses Wegs auch von Stabilitätsproblemen verschont. Noch konkreter: Wir fanden JavaFX klasse. Umstieg auf JavaFX Unsere Versuche, mithilfe existierender Web-Frameworks unseren generischen Client in HTML/JavaScript zu reimplementieren, scheiterten regelmäßig. Gründe waren die üblichen Verdächtigen: mangelnde Browser-Kompatibilität, mangelnde Performance bei großen Szenarien und mangelnde Layout-Fähigkeiten. Es zeigte sich, dass die Frameworks für überschaubare Szenarien funktionierten, ab einer gewissen Komplexität jedoch immer an ihre Grenzen stießen. Für uns war somit die Richtung gegeben: Wir blieben Client-seitig auf dem Java-Zug und setzen darauf, dass das Thema Java im Client über JavaFX wieder salonfähig wird. Mit dem Erscheinen von Abbildung 2: Abgekoppelter Client 38

3 Einige Probleme, die wir im Swing-Client funktional hatten, wurden in JavaFX solide gelöst: das freiere Styling der Komponenten, die bessere Integrierbarkeit von HTML-Inhalten und auch im Bereich von Geschäftsanwendungen nicht ganz unwichtig die Möglichkeit, professionell anmutende Animationen zu verwenden. Natürlich gab es auch technologische Herausforderungen: Ein Hauptkampfgebiet war dabei eine gewisse Trägheit des Clients beim Aufbau großer Dialoge, etwa mit einer hohen Anzahl von Textfeldern. Summa summarum waren wir aber technologisch zufrieden und konnten nach einem Jahr einen Client zur Verfügung stellen, der eine weitgehend kompatible Alternative zu unserem Swing-Client darstellte und dazu optisch noch eine Ecke attraktiver war. Nun standen wir da, mit einem frisch aufpolierten Client in moderner JavaFX-Technologie und mussten feststellen, dass JavaFX bei Weitem nicht in dem Maße abhob, wie wir es erwartet oder vielmehr gehofft hatten. Im Gegenteil: JavaFX wurde (und wird weiterhin) gerade aus dem Java-Lager heraus äußerst kritisch beurteilt und hat nie ein gewisses Hype-Potenzial erreicht. Das bedeutete für die Software-Hersteller unserer Community: Die Ressentiments gegenüber Java im Frontend blieben unvermindert groß und wurden teilweise durch Zweifel an der Zukunftsfähigkeit von JavaFX noch verstärkt. Der Druck in Richtung HTML-Client stieg, aber unsere technologischen Bedenken, mit bestehenden HTML- Frameworks langfristig unsere Probleme zu lösen, blieben bestehen. RISC-HTML: Eine etwas andere Nutzung von HTML und JavaScript Genau in dieser Phase entwickelten wir eine Idee, die als Laborversuch startete und binnen kurzer Zeit zum Selbstläufer wurde. Die Idee bekam den Namen RISC-HTML, in Anlehnung an den Paradigmenwechsel, der in den 1990er-Jahren durch die Entwicklung von RISC-Prozessoren im Bereich der Hardware vollzogen wurde. RISC steht bei uns für Reduced Instruction Set Client. Die Idee lautet: Zum flexiblen Erstellen von Oberflächen-Komponenten benötigt man eigentlich nur ganz wenige optische Grundelemente, die ein Browser zur Verfügung stellen muss. Die beiden wichtigsten Grundelemente sind dabei Rechtecke, die gestylt werden können, und Texteingabe-Felder. Diese Grundelemente müssen nun so zusammengesetzt werden, dass aus ihnen vollständige, funktionale Komponenten werden, also Buttons, Combo-Boxen, Grids, Dialoge etc. Für das Zusammensetzen wird allein die absolute Positionierung per x,y,width,height,(z) -Koordinate verwendet. Beispiel: Ein Button ist nichts anderes als eine Schachtelung von Rechtecken. Gleiches gilt für die Combo-Box; sie ist eine Zusammenschachtelung von Rechtecken um ein Textfeld und beinhaltet zusätzlich ein Dialog-Rechteck, das sich per z-koordinate in den Vordergrund drängt (siehe Abbildung 3). Das Zusammensetzen der Grundelemente geschieht über JavaScript. Es werden also Komponentenklassen programmiert, die zur Laufzeit die Grundelemente im DOM-Tree anlegen und arrangieren sowie Events verarbeiten. Jede Klasse hat ein standardisiertes Set an Methoden und muss beispielsweise nach außen berichten, was ihre minimale beziehungsweise präferierte Größe ist. Jede Komponente ist für die Ausrichtung ihrer beinhalteten Grund- Abbildung 3: Alles baut sich aus Rechtecken zusammen elemente zuständig; im Falle eines Buttons ist die Logik hierfür überschaubar, bei komplexen Layout-Komponenten, etwa mit einer Mischung aus prozentualen und festen Größenangaben, ist die Logik entsprechend komplexer. Im RISC-HTML-Ansatz werden also alle Komponenten auf Basis minimaler Grundelemente zusammengesetzt. Ganz konkret im Browser sind dies zwei Elemente: das DIV- und das INPUT-beziehungsweise TEXTAREA-Element. Das CSS-Styling sorgt dafür, dass die zusammengesetzten Elemente am Ende auch wie die betreffende Komponente aussehen. Das Verfahren kann man recht gut veranschaulichen, wenn man sich den DOM-Tree eines konkret mit RISC-HTML aufgebauten Dialogs im Entwicklermodus des Browsers anschaut. Man sieht vor allem eines: eine tiefe Schachtelung von absolut positionierten DIV- Elementen (siehe Abbildung 4). Die Vorteile des RISC-HTML Warum wurde der RISC-HTML-Ansatz vor dem Hintergrund einer Vielzahl existierender Web-Ansätze überhaupt erfunden? Der erste Hauptgrund war die Schaffung einer langfristig stabilen Grundlage für die Erstellung von Komponenten mit hoher Komplexität einerseits und mit technisch garantierter Browser-Kompatibilität andererseits. Vom Browser selbst werden nur einfachste Elemente erwartet ( DIV, INPUT / TEXTAREA ), diese kommen zudem nur auf einfachste Art und Weise zum Einsatz (absolute Positionierung). Damit ergibt sich eine dramatische Reduktion der Abhängigkeiten und damit der Kompatibilitätsprobleme. Der zweite Hauptgrund war die Schaffung einer Grundlage, auf deren Basis beliebige Layout- und Gestaltungs-Strategien entwickelt werden können. Als Beispiel sei hier genannt, dass gängige HTML- Frameworks immer Probleme im Bereich des flexiblen vertikalen Ausrichtens haben: Ein Dialog hat einen festen Header-Bereich, einen scrollbaren Innenbereich und einen festen Footer-Bereich für gängiges HTML ist so eine Konstruktion immer noch eine Herausforderung. Wir alle kennen die HTML-Seiten, auf denen man immer ganz nach unten zu den Verarbeitungsbuttons scrollen muss. Eigene Layouting-Verfahren sind im Browser nur über den Umweg des nachträglichen Ausmessens von Inhalten zu realisieren; der Browser rendert also erst aus; danach weiß man, wie man das Layout anpassen muss. Das Layout richtet sich dann vor dem Auge des Benutzers aus. Was uns in der Praxis von Anfang an mehr als überraschte, das war die Performance, mit der über den RISC-HTML-Ansatz erstellte Dialoge aufgebaut und verarbeitet wurden. Ehrlich gesagt hatten wir Java aktuell 05/17 39

4 Abbildung 4: Schachtelung von einfachsten Grundelementen, absolut positionierten DIVs hier massive Probleme erwartet, da bei RISC-HTML doch ein erheblicher Teil von Rendering-Logik, die klassisch im nativen Bereich des Browsers abläuft, nun auf einer JavaScript-Ebene abläuft. Aber im Gegenteil: Auch wenn die Anzahl der zusammengesteckten Grundelemente durchaus hoch ist und die aufgebauten DOM- Element-Bäume deswegen groß sind, kommen die Browser damit hervorragend zurecht. Der Browser wird ja auch nur noch zum Zeichnen absolut positionierter Rechteck-Bereiche verwendet. Er rechnet nicht mehr selbst aus, wo welches Element nun genau hinkommt, sondern führt nur noch das aus, was ihm die entsprechende JavaScript-basierte Layout-Komponente vorgibt. JavaScript ist mittlerweile einfach schnell geworden und auf einem Level, der es erlaubt, auch Algorithmen einer gewissen Komplexität darin abzubilden. Eine Anwendung mit RISC-HTML bauen RISC-HTML ist zunächst also eine JavaScript-Bibliothek, in der über JavaScript-Klassen Komponenten (Button, Feld, Grid, Dialoge etc.) instanziiert und zusammengesetzt werden können. Komponenten haben ganz klassische Properties und Events. Jede Komponente zerlegt sich dabei in andere Komponenten oder auf unterster Ebene rendert sich in entsprechende Grundelemente aus (Rechtecke, Texteingabe-Felder). Wie nun konkret eine Anwendung an diese Library anschließt, das ist prinzipiell frei gestaltbar. Freunde einer direkten, Client-seitigen JavaScript-Anwendungsverarbeitung können nun direkt Single-Page-Applications bauen. Innerhalb unserer CaptainCasa-Community ist der Ansatz natürlich ein anderer: Hier wurde der generische Rendering-Client, der nichts anderes macht, als vom Server kommende Dialogbeschreibungen auszurendern, auf Basis der RISC-HTML-Library reimplementiert. Vom Server kommende Layoutbeschreibungen werden also in entsprechende RISC-HTML-Komponenten umgesetzt. Abbildung 5: Hello world -Anwendung <t:rowbodypane> <t:label text="your Name" width="100" /> <t:field text="#{demohelloworld.name" width="200" /> <t:coldistance width="100" /> <t:button actionlistener="#{demohelloworld.on- Hello" text="hello" /> <t:rowdistance height="20" /> <t:label text="result" width="100" /> <t:field enabled="false" text="#{demohelloworld. output" width="100%" /> </t:rowbodypane> Listing 1 CaptainCasa Enteprise Client Wie hat man sich das aus Sicht der Anwendungsentwicklung vorzustellen? Dazu das berühmte Hello-World-Beispiel (siehe Abbildung 5). Im einfachsten Falle definiert die Anwendung entweder direkt oder per Wysiwyg-Layout-Editor einen konkreten Dialog als XML- Definition (siehe Listing 1). 40

5 package demo; import javax.faces.event.actionevent; public class DemoHelloWorld { String m_name; String m_output; Listing 2 public void setname(string value){ m_name = value; public String getname() { return m_name; public String getoutput() { return m_output; public void onhello(actionevent ae) { if (m_name == null) m_output = "No name set."; else m_output = "Hello World, "+m_name+"!"; In der XML-Definition sind die Auswahl und das Arrangement der Komponenten definiert. Attribute der Komponenten werden entweder direkt gesetzt oder sie werden per Expression an eine Java-Bean ( Managed Bean ) gebunden. Diese Java-Bean wird nun implementiert (siehe Listing 2). Das war s. Die Laufzeitumgebung, auf Server-Seite übrigens JSF-basiert, übernimmt nun den Rest: Der generische Client fordert das Layout an, der Server liest das XML-Layout, baut den Kontakt zur Managed Bean auf und sendet das gefüllte XML-Layout zum Client, der dieses dann optisch für den Benutzer ausrendert. Der Benutzer sieht den Dialog und tätigt Eingaben. Beim Drücken des Buttons werden Eingaben und Events per Request zum Server geschickt, der sie dann der Managed Bean weitergibt. Änderungen in der Bean werden dann wieder zurück zum Client übertragen. Die Kommunikation zwischen Client und Server-Verarbeitung verläuft dabei inhaltlich immer so, dass nur Änderungen übertragen werden; dies gilt speziell für die Übermittlung der Layouts. RISC-HTML ist doch gar kein richtiges HTML Wie sieht der DOM-Element-Baum eines mit RISC-HTML erstellten Dialogs aus? Es gibt praktisch nur noch DIV und ein paar INPUT beziehungsweise TEXTAREA, kein TABLE, TR, BUTTON, SPAN, UL oder LI. Für diejenigen, die aus dem klassischen HTML-Umfeld kommen, ist das zunächst einmal gegen die Lehre: Die Semantik eines Dialogs lässt sich nicht mehr durch direktes Anschauen auf das gerenderte HTML erkennen. Wir können dem entgegenhalten, dass das gängige Praxis ist. Jede Control-Bibliothek gibt sich nicht mit den doch recht einfach gestrickten HTML-Elementen zufrieden, sondern baut kräftig eigene, höherwertige Komponenten (etwa eine Kalender-Komponente), die sich dann wieder in echte HTML-Elemente zerlegt. Zugegeben, CaptainCasa treibt das etwas mehr auf die Spitze, aber das Prinzip ist das gleiche. Für bestimmte Bereiche, in denen die Semantik von Komponenten hervorstechen muss, gibt es als Folge dieser Entwicklung entsprechende Möglichkeiten, die Semantik explizit zu definieren. Der wichtigste Bereich ist Accessibility. Dort werden im RISC-Client beispielsweise die semantischen Informationen über die ARIA-Schnittstelle übergeben. RISC-HTML wurde erfunden, um durchaus komplexe Sachbearbeiter-Dialoge von Geschäftsanwendungen effektiv und langfristig stabil abbilden zu können. Es ist dort geeignet, wo Oberflächen programmiert werden. Dies sind typischerweise Dialoge mit einem gewissen Umfang und einer gewissen Komplexität. Bei der grafischen Ausgestaltung der Dialoge geht es mehr darum, ein konsistentes Look & Feel über die vielen Dialoge einer Anwendung effizient zu gestalten, und nicht darum, jeden einzelnen Dialog individuell zu designen. Der RISC-HTML-Ansatz ist naturgemäß nicht dort zu Hause, wo Oberflächen über HTML-Design beziehungsweise HTML-Templating entstehen. Hier steht ja gerade das klassische HTML und damit das explizite Designen mit HTML-Mitteln im Vordergrund. Fazit Wir kamen von Swing, standen etwas ratlos mit einer JavaFX- Umsetzung herum und landeten über die Entwicklung einer neuen Methode, RISC-HTML, im Browser. Dort fühlen wir uns nun angekommen. Der RISC-HTML-Ansatz bietet uns im Browser eine Architektur-bedingte Stabilität und Flexibilität, auf deren Basis wir die langfristig orientierten Geschäftsanwendungen der Community-Mitglieder mit gutem Gewissen aufsetzen. Ein Austausch der UI-Technologie war in unserem Framework vergleichsweise einfach, weil von Anfang an die Client-Verarbeitung in Form einer generischen Rendering-Engine komplett von der Anwendungsverarbeitung getrennt war. Für die Anwendungsentwicklungen bedeutete dies, dass sie von dem Wechsel der Client-Technologie weitestgehend unberührt waren. Und zu guter Letzt: Der CaptainCasa-Enterprise-Client so heißt das Client-Framework unserer Community kann kostenfrei (dies gilt sowohl für die Entwicklung als auch für die Nutzung) von der Seite http: / bezogen werden. Dort finden sich auch weitergehende Informationen und Online-Demos. Björn Müller bjoern.mueller@captaincasa.com Björn Müller arbeitete zunächst zehn Jahre in der Anwendungsentwicklung, Basisentwicklung und Architekturentwicklung für SAP erfolgte die Gründung der Casabac Technologies GmbH als Pionier im Bereich von Rich Internet Applications auf Basis von Client-Scripting (AJAX) gründete er die CaptainCasa Community, eine Verbindung mittelständischer, deutschsprachiger Softwarehäuser mit dem Fokus auf Rich Client Frameworks für umfangreiche, langlebige Anwendungssysteme. Java aktuell 05/17 41