Technology Guidelines"
| Line 13: | Line 13: | ||
==When to use MVC== | ==When to use MVC== | ||
| − | [[ZK Developer's Reference/MVC|MVC]] (Model-View-Control) is an architectural pattern that | + | [[ZK Developer's Reference/MVC|MVC]] (Model-View-Control) is an architectural pattern that isolates the modeling of the domain and the actions on user input are divided into three separate classes: model, view and controller. It is easy to collaborate, develop and maintain. In addition, MVC is praised for its great performance since it is done in compiled Java code. MVC is strongly suggested for development, especially for production systems. |
==When to use zscript== | ==When to use zscript== | ||
Revision as of 03:55, 20 July 2011
ZK provides end-to-end solutions from UI design, development, testing to production. Here is the technology guidelines to help developers to make choices along the way.
If you are new to ZK and prefer to have some prior knowledge of ZK first, you could skip this section and come back later when you understand ZK more.
MVC vs. ZScript
They serve different purposes and could work together. However, some developers got confused about these two technologies.
When to use MVC
MVC (Model-View-Control) is an architectural pattern that isolates the modeling of the domain and the actions on user input are divided into three separate classes: model, view and controller. It is easy to collaborate, develop and maintain. In addition, MVC is praised for its great performance since it is done in compiled Java code. MVC is strongly suggested for development, especially for production systems.
When to use zscript
Zscript allows you to embed Java code in ZUML pages. It speeds up the design cycle, so this can be a good approach for prototyping, POC and testing. Zscript is also good for exploiting ZK features and reporting bugs to ZK. However, like any other interpreters, the performance is not very good. It tends to be error prone, so it is not suggested to use zscript for production systems.
MVC Extractor
ZK Studio provides a tool called MVC Extractor that can convert zscript to MVC automatically. It simplifies to transfer the code from prototyping to production.
Documentation links
| MVC: | |
| ZSCRIPT: |
Data Binding
When to use
Data Binding automates the data-copy plumbing code (CRUD) between UI components and the data source. It is strongly suggested whenever applicable, because it boosts the productivity a lot and the code is easy to read and maintain.
When not to use
Barely. However, it requires more knowledge to learn than EL expressions, so EL expressions is an alternative for people not familiar with ZK, especially in the UI design phase, such as UI designer.
Notice that there is a limitation: data binding won't be applied components that are created, after the page is initialized and rendered at the client[1].
- ↑ This limitation will be resolved in the upcoming Data Binding 2.
Documentation links
ZUML vs. Richlet vs. JSP
When to use ZUML
ZUML is XML-based approach to declare UI. It does not require programming knowledge, and works well with MVC, Data Binding and others. It is strongly suggested unless you have different preferences (such as pure Java and JSP).
However, if most parts of a page are pure HTML (such as header and footer) and UI designer is not familiar with ZUML, you could use JSP to define the page and then include ZUML page(s) for the part that requires ZK components.
Notice that using ZUML does not prevent you from creating components dynamically in Java. In fact, it is a common practice to use ZUML to layout the theme of the Web application, and then use pure Java to manipulate it dynamically.
When to use Richlet
A richlet is a small Java program that composes a user interface in Java for serving user's request. You could use it if you prefer to compose UI in pure Java (like Swing).
When to use JSP
If you'd like to use ZK in legacy JSP pages, you could use one of following approaches:
- Use
<jsp:include>to include a ZUML page. - Use ZK JSP Tags in a JSP page directly.
As described above, if most of a page is pure HTML and UI designer is not familiar with ZUML, you could use JSP to design the page, and then include ZUML pages if necessary.
Notice that ZUML support the use of HTML tags well (without JSP). For more information, please refer to ZK Developer's Reference: HTML Tags.
Documentation links
| ZUML: | |
| Richlet: | |
| JSP: |
Bookmarks vs. Multiple Pages
A traditional page-based Web framework forces developers split an applications into pages. On the other hand, Ajax (ZK) allows developers to group a set of functionality into a single desktop-like page that enables a more friendly user experiences.
Grouping is better to base on the functionality, unless it is a small application. For example, it might not be a good idea to group administration with, say, data entry. Here are some guidelines:
- If a set of functionality is a logical unit to use and/or to develop, you might group it as a single page.
- If SEO (i.e., able to be indexed by search engine) is important, it is better to split into multiple pages (and turn on the crawlable option).
Whether UI shares the same template (such as header and footer) does not matter, since it is easy to make multiple pages to appear similarly (by use inclusion, templating and composite).
When to use bookmarks (in single page)
After grouping a set of functionality into a single page, you could still allow users to use BACK and FORWARD to switch among the states of the single page and even bookmark on a particular state, as if there are multiple pages. It can be done by use of so-called Browser History Management (aka., bookmarks). You might consider it is a technique to simulate multiple pages (for a single page with multiple states).
When to use multiple pages
If a set of functionality is logically independent of another, you could make them as separated pages. To jump from one page to another, you could use the so-called send-redirect technique.
Documentation links
| Bookmarks: | |
| Multiple Pages: |
|
Native Namespace vs. XHTML Components
ZK provides several ways to mix XHTML tags in a ZUML document. Here we discuss native namespace vs. XHTML components. In a ZUML document, they are the same except the XML namespace, so it is easy to switch between them.
When to use native namespace
By use of a XML namespace called the native namespace, you could declare any tags in ZUML as long as it is valid to the client (i.e., any HTML tags for a browser). It is suggested to use this technology if the HTML tags are static, i.e., you won't change the content dynamically with Ajax. The header, sidebar, footer and layout elements are typical examples. It saves the memory at the server.
When to use XHTML components
ZK also provides a set of components to represent each XHTML tag at the server. Unlike native namespace, they are really ZK components.
It is suggested if you want to change their content dynamically, since they behave the same as other ZK components. However, since it is a component, it consumes the server's memory.
Documentation links
- ZK Developer's Reference: HTML Tags
- ZK Developer's Reference: Performance Tips|Native vs. XHTML
- ZK Developer's Reference: Performance Tips: Stubonly
Include, Macro, Composite and Templating
They allow developers to modularize the UI such that it is easier to develop, maintain and reuse.
When to use include
Include allows you to include a ZUML page, a static page, a JSP page or the result of a servlet. It is suggested if you'd like to:
The limitation of Include is that you can not encapsulate its behavior in a Java class (like macro or composite components do).
When to use macro components
Macro components allow developers to define a new component with a ZUML page. It is suggested if you'd like to reuse a ZUML page across different pages, because
- Though optional, you could encapsulate the behavior in a Java class
- It is easier to map a macro component to another URI, if necessary
- The use of a macro component is no different from other components
When to use composite components
Composite component is another way to define a new component[1]. With this approach, you could extend it from any existent component. However, you must implement a Java class to represent the component[2], and then, unlike macro components, handle the component creation from a ZUML page by yourself[3].
It is suggested if you want to inherit the behavior from an existent component, such as Window and Cell, and enhance it to have child components defined in a ZUML document.
- ↑ It is more a particular pattern of extending an existent component than a technology.
- ↑ Here is an example of composite components in ZK Demo
- ↑ It could be done easily with Executions.createComponents(String, Component, Map)
When to use templating
Templating allows developers to define UI fragments, and define how to assemble them into a complete UI at runtime. Its use is very different from other approaches. However, it is suggested if you'd like the overall layout to be decided at runtime based on, say, user's role or preference.
Performance and Security
For production systems, it is strongly recommended to take a look at Performance Tips and Security Tips first.
JSF
When to use
JSF is a page-based framework and too complicated. We strongly recommend to use ZK instead of JSF. ZK can do whatever JSF can, and better. However, if you have to use ZK with legacy JSF, please refer to the Embed ZK Component in Foreign Framework section[1].
- ↑ Notice that ZK JSF Components is no longer supported.
Version History
| Version | Date | Content |
|---|---|---|