ZKoss Java and the world

Yesterday we have checked in our new Zksample2 application as maven2 projects on sourceforge.net.
It’s shows how you can build a robust and scalable enterprise web application by integrating commonly used frameworks like Hibernate, Spring, Spring-AOP, Spring-Security, JasperReports with the ZK Java web framework.
You can reach the project homepage under the link here .

You will find there 3 eclipse maven subprojects and the folder for the documentation.

1. KeyGenZkoss = one-time-password generator
2. spring-hibernate-backend = backend
3. zkoss = frontend
4. zksample2_doc = documentation

The Documentation you can download seperately as a pdf-file from here .

The documentation is a work in progress so be sure to check sometimes for the newest file.

For checkout and evaluate or work with the application please download and read first the documentation.

Mainly changes to the first sample app are:
- change project structure as maven2 projects
- spring managed frontend
- securing methods with annotations @Secured() with our own implementation
- login statistic
- several integration options of ipToCountry
- one-time-password sources are opened
- Refactoring all Domain/DAO/Service Classes to english names
- many many code changes
- Revised PagedListWrapper
- documentation

We whish all fun with it and hope that it can be usefull for others.

---

Authors: Stephan Gerth & Björn Bruhns

Samples are hostet in the Zksample2 project on

---

PS: Help to prevent the global warming by writing cool software

Artikel: Direct RIA: Future of RIA / Author:  Robbie Cheng /  ZK Framework.

Erschienen auf CodeGuru.com http://www.codeguru.com/java/article.php/c16445__1/

Direkt RIA = Ansatz von Client + Server Verschmelzung

Mehr Auswahl, schwierigere Entscheidung

Obwohl Unternehmen von Rich-Internet-Anwendungen profitieren können, so kann die Einführung neuer Technologien auch Risiken beherbergen. Das erste Problem ist, das richtige Werkzeug für die gewünschte Lösung zu wählen. Hier kann es leicht zu einer falschen Entscheidung kommen aufgrund zu großer Auswahl, unklarer Kriterien, und komplexen Anforderungen.

Produktivität oder Kontrollierbarkeit

RIA (Rich Internet Application) Lösungen können in der Regel in zwei Kategorien eingestuft werden. Client- oder Server-seitig arbeitend.

Client-seitige Frameworks sind wie manuelle Schaltgetriebe im  Auto, sie bieten mehr Kontrolle, erfordern aber auch mehr Aufwand. Im Gegensatz dazu verhalten sich Server-seitige Frameworks wie Automatik- Getriebe, die einfacher zu handhaben sind. Entwickler können durch AJAX-Technologie die Produktivität erhöhen und  transparenter gestalten.

Die zu treffende Auswahl zwischen beiden Lösungsansätzen verursacht weiterhin Kopfschmerzen. Komplette Kontrolle oder Produktivität? Können wir von beiden Ansätzen zur gleichen Zeit profitieren? Der beste Fall wäre, dass unterschiedliche Anforderungen wie ein manuell schaltbares Automatik-Getriebe behandelt werden können.

Direct RIA ermöglicht einen revolutionäre Ansatz von Client + Server Verschmelzung, der die Vorteile von Produktivität und Kontrollierbarkeit bei der Programmierung zur gleichen Zeit nutzt, je nach dem ob vollständige Anpassung oder Reaktionsfähigkeit benötigt wird.

Übersicht über die Architektur von Direct RIA

Direct RIA ist eine Server-seitige Lösung plus optionale Client-seitige Programmierung. Wenn Sie einen Blick auf die folgende Grafik nehmen, können Sie sehen, dass das Server-seitige Programmiermodell  dem Entwickler erlaubt die Web-Anwendung unter Verwendung von reinem Server-seitigen Code zu bauen.

Der Server-seitige Code Generator erzeugt den benötigten HTML- und JavaScript-Code automatisch. Danach  wird der Client-seitige Code Generator mit dem DOM-Baum interagieren, um den Inhalt zu aktualisieren. Darüber hinaus ist die Synchronisation zwischen dem Browser und dem Server durch das  Zusammenspiel  des Client-seitigen und Server-seitigen AJAX Generators automatisiert. Entwickler können sich so auf das Erstellen der Anwendung konzentrieren als auf die komplexen AJAX-Technologien.

Allerdings ist einer der größten Nachteile des reinen Server-seitigen Programmiermodells, dass die Entwickler nicht vollständig die Darstellung der Benutzeroberfläche kontrollieren können. Um dieses Problem zu überwinden, ermöglicht Direct RIA ein zusätzliches Client-seitiges Programmiermodell, das es Entwicklern ermöglicht Client-Code zu schreiben um, wenn nötig, die Benutzeroberfläche direkt zu kontrollieren.

Direkter Oberflächen Zugriff

Da die Anwendung auf dem Server läuft  kann sie auf Widgets direkt zugreifen. Nehmen wir das ZK Framework als ein Beispiel und erstellen ein Java-2D-Objekt auf dem Server, und geben dieses Objekt einfach in das Widget. Die Nutzer werden das Bild auf dem Browser  sehen, sobald sie auf die Schaltfläche klicken.

<image id="image">
<button onClick='draw(10,10,10,10)'/>
<zscript>
void draw( int x1, int y1, int x2, int y2) {
LiveImage li = new LiveImage(400, 300, LiveImage.TYPE_INT_RGB);
Graphics2D g2d = li.createGraphics();
Line2D line = new Line2D.Double(x1, y1, x2, y2); g2d.draw(line);
image.setContent(Images.encode("test.png", li));
}
</zscript>

Mit Direct RIA, müssen sich Entwicklern nicht mehr um Client-seitige Programmierung kümmern. Sie können also sehr schnell ein Projekt beginnen ohne die vielen Client-seitigen Technologien zu erlernen.

- Keine Client-seitige Programmierung.

Direkter Datenzugriff

Darüber hinaus kann die Applikation leicht und direkt auf Server-Ressourcen zugreifen, einschließlich Datenbank- und Web-Services, da beide sowohl das Frontend als auch das Backend auf der Server-Seite laufen. Das folgende Beispiel zeigt ein einfaches Szenario, um Daten aus der Datenbank zu lesen, und zeigt sie dem Anwender mithilfe des ZK Frameworks. Sobald der Benutzer auf die Schaltfläche klickt, erscheint eine Willkommens Nachricht.

Hi. <label id="name"/>

<button>

<attribute name="onClick">

User usr = Database.getUserById(1);

name.setValue(usr.getName());

</attribute>

</button>

Eine der schwierigsten Herausforderungen bei der Erstellung von Web-Anwendungen liegt in im asynchronen Programmiermodell, welches die verschiedenen Schritte enthält, um Daten vom Server zu bekommen und entsprechend den DOM-Baum zu aktualisieren. Mit Direct RIA jedoch können Frontend und Backend nahtlos integriert werden.

- Keine asynchrone Kommunikation mehr.

Direkte Live Daten

Mit Live-Daten können Entwickler die Daten von der View trennen. Entwickler können die Daten durch die Implementierung des ListModel Interfaces anbieten. Das ZK Framework ermöglicht diesen Weg anstatt der direkte Manipulation der Daten.

<zscript>

String[] data = new  String[1000]; for ( int  j=0; j < data.length; ++j) {

data[j] = "option "+j;

}

ListModel strset = new  SimpleListModel(data);

</zscript>

<grid width="100px" height="100px" model="${strset}">

<columns>

<column label="options"/>

</columns>

</grid>

Das Grid sendet die Daten nur dann an den Client, wenn es sichtbar ist. Es spart so eine Menge des Netzwerkverkehrs, wenn die Datenmenge sehr groß ist.

-Kein Problem mehr mit der Skalierbarkeit.

Direkte Klienten Kontrolle

Mit Direct Client Control kann der Entwickler Widgets entweder in Java-Script oder einer Markup-Sprache entwickeln und die Funktionen im Klienten implementieren um so das Verhalten der Antwortzeiten zu verbessern. Im folgenden Beispiel zeigen wir eine einfache Funktion zur Anzeige einer User-Eingabe mittels reiner Client-Programmierung. Diese wird  mit der Markup-Sprache von ZK umgesetzt.

<page id="main">
<textbox id="searchBox"/>
<label id="value">
</page>
<script>
zk.zuml.Parser.createAt( '#main', null, null, function (page) {
page.$f('searchBox').listen({onChanging: function (event) {
page.$f( 'value').setValue(event.data.value);}});
</script>

Entwicklern steht es frei, eine Funktion auf dem Client-Seite anpassen, um ihre unterschiedlichen Anforderungen gerecht zu werden.

- Keine Anpassung Probleme mehr.

Direct RIA ist die Zukunft der RIA

Es ist nie eine leichte Aufgabe eine Enterprise-Anwendung zu erstellen, ganz zu schweigen die Benutzer-Schnittstelle zur selben Zeit zu erzeugen. Darüber hinaus ist es nicht leicht, die richtige Lösung zu wählen bei über 200 Lösungen für die verschiedensten Anforderungen. Direct RIA bietet den Ansatz für eine Client-Server Verschmelzung so dass Entwickler ihre Produktivität steigern können. Mit Hilfe des Direct RIA Programmiermodells kann sowohl auf Frontend und Backend direkt zugreifen werden, außerdem steht es Entwicklern frei, wenn nötig Funktion auf der Client-Seite zu erstellen. Direct RIA weist darauf hin, eine Komplettlösung für Entwickler zu sein, die die  Vorteile der gleichzeitigen Nutzung  von Produktivität und Kontrollierbarkeit zur Verfügung stellt.

Über den Autor

Robbie Cheng ist ein Evangelist des ZK Frameworks. Er ist der Hauptentwickler von ZK Mobile für Android und ZK Forum. Er ist der Co-Autor des Buches “ZK: Ajax ohne Javascript Framework” und hat zahlreiche Artikel im AJAXWorld Mgazine, TheServerSide und Javalobby veröffentlicht. Weiterhin ist Robbie auch bei verschiedenen Veranstaltungen wie, Google Developer Day, Mobile Monday, und OSDC 2009 als Redner aufgetreten.

Übersetzt aus dem englischen von Stephan Gerth.

Today i have checked in a ZKoss sample application in the google subversion repository that uses following frameworks:

Spring

Spring-Security (i have extended the rights management upon a group/group-rights and loaded all from a table, for allow customizing without a new tomcat start while i’m not using therefore the configuration file.)

Hibernate as an ORM.

JasperReports for reporting.

Generic-Hibernate-DAO for creating hql queries from a search-object. Used for all listboxes.

H2 DB v1.1.15 for a easier demo mode, which is started and filled with demo-data by deploying the application on tomcat.

You can checked out both as Eclipse 3.4 projects here:

The Frontend
The Backend

Samples are hostet in the Zksample2 project on

Have fun with it.

Stephan Gerth

Dipl.rer.pol.

---

PS: Help to prevent the global warming by writing cool software

With followed code you can create a zkoss multi line messagebox which works with line feeds ‘\n’.
Only take the zul template and the controller to your project and set the template path in the controller.

Additionally you can set an empty line before and after the message for a nicer looking.

Continue reading ‘HowTo: ZKoss Multiline Messagebox’ »

Preface

The ZKoss paging component by default works with the complete list of loaded records. For working with huge tables we need to modify the paging component so that it shows only exact the count of records that the user can see in the page of the listbox at one time. So by paging we can intercept the paging event and do a special call to the database where we can overhanded the actual/next page and the pagesize (count of pulled records). So we became page for page only subsets of the result.

The interesting part to solve is to work with a database oriented paging mechanism AND accept changings of the order triggered by the listheaders.

For an overview how the pagination can be coded look at the Smalltalk from Marcos de Sousa:

Use Load-On-Demand to Handle Hugh Data. http://docs.zkoss.org/wiki/Use_Load-On-Demand_to_Handle_Huge_Data.

In short: Pagination is a block wise loading of records.

Advantage:

• reduces DB work;
• redudes network traffic between Database and the application server;
• reduces cpu and memory demand
• reduces the response time;
• increase the data throughput

Problem Definition

If we want database paged records from a table and would like to allow changing the sort order of these data by clicking on the listheaders we have to consider three things:

• First we must consequently do the sorting on the database to prevent users confusion if the resultset sorted in the grid.
• Secondly we need the right place in code where we can catch which of the listheaders is clicked for changing the sorting.
• Third we need a mechanism to remember what is the originally query that should now be modified for sorting in an other sort order.

Why we need this?

Let us consider what we want from the database side: First we have a sql statement with a where clause. Second we want to add/manipulate the order by clause. By changing the sort order we need to remember what is in the select clause and in the where clause to add the changed ‘order by’.

Continue reading ‘HowTo: ZKoss Load on Demand with Paging + Sorting’ »