Get ZK Up and Running with MVC"

From Documentation
Line 76: Line 76:
  
  
After associating the controller to the <zul?>, the controller can listen events sent from UI and retrieve components. Thus we can use above <2 abilities ?> to implement application's function. Let's start from the search function: a user enters a keyword, clicks the "Search" button to trigger the search. <So, we should write codes to response clicking "Search" button.>
+
After associating the controller with the ''window'', the controller can listen events sent from UI and retrieve components which allows us to implement application's function. Let's start from the search function: a user enters a keyword, clicks the "Search" button to trigger the search.  
  
 
Steps to implement a function:
 
Steps to implement a function:
Line 84: Line 84:
 
== Listening to User Action ==
 
== Listening to User Action ==
  
When we associate a controller to a component, every event triggered by this component (and its child components) is sent to the controller. If there is a method which we assigned to listen to the triggered event, it will be invoked.
+
When we associate a controller with a component, every event triggered by this component (and its child components) is sent to the controller. If there is a method which we assigned to listen to the triggered event, it will be invoked.
 
As a user clicks "Search" button to trigger the search function, we have to listener to "Search" button's "onClick" event.
 
As a user clicks "Search" button to trigger the search function, we have to listener to "Search" button's "onClick" event.
 
We declare a method, <tt> search()</tt>, and specify it to be invoked when <"Search button" is clicked with the following annotation>:
 
We declare a method, <tt> search()</tt>, and specify it to be invoked when <"Search button" is clicked with the following annotation>:
Line 90: Line 90:
 
<tt> @Listen("[EVENT_NAME] = #[COMPONENT_ID]").</tt>
 
<tt> @Listen("[EVENT_NAME] = #[COMPONENT_ID]").</tt>
  
<Such method is called an event listener method. {we also called this a Command method in SmallTalks and Developer Reference}>
+
Such method serves as an event listener method.
  
 
The final code looks like:  
 
The final code looks like:  
Line 122: Line 122:
  
  
Then ZK will "wire" a corresponding ZK component object to the variable you declared. After this has been done, you can then control and manipulate UI by accessing those annotated member variables.
+
Then ZK will "wire" a corresponding ZK component object to the variable we declared. After this has been done, we can then control and manipulate UI by accessing those annotated member variables.
  
 
<source lang="java" high="3,4,5,6">
 
<source lang="java" high="3,4,5,6">
Line 140: Line 140:
  
 
The search method performs a simple logic: call car service class to search with keyword and set result list to ''listbox''.
 
The search method performs a simple logic: call car service class to search with keyword and set result list to ''listbox''.
For a variable which references to a component, we can get component's attribute such as user's input with getter (<tt>getValue()</tt>) or change a component's status like making a ''label'' invisible with setter (<tt>setVisible(false)</tt>) to achieve some dynamic UI effect. Hence, we can easily get what keyword a user inputs by <tt> keywordBox.getValue() </tt> and change data item of ''listbox'' by <tt> carListbox.setModel() </tt>. The model of a component is the data the component holds and you can change the model to change the data rendering on the screen.
+
For a variable which references to a component, we can get component's attribute such as user's input with getter (<tt>getValue()</tt>) or change a component's status like making a ''label'' invisible with setter (<tt>setVisible(false)</tt>) to achieve some dynamic UI effect. Hence, we can easily get what keyword a user inputs by <tt> keywordBox.getValue() </tt> and change data item of ''listbox'' by <tt> carListbox.setModel() </tt>. The model of a component is the data the component holds and we can change the model to change the data rendering on the screen.
  
 
<source lang="java" high="8">
 
<source lang="java" high="8">
Line 159: Line 159:
  
  
We have successfully made clicking "Search" button <to invoke its corresponding event listener>, but we'll still find that content of ''listbox'' doesn't show search result correctly. That is because we <haven't specified> how to render data model on a ''listbox''. Now, we will use a special tag, <tt> <template> </tt><ref>[[ZK Developer's Reference/MVC/View/Template]]</ref>, to control the rendering of each item. ZK will render template tag's content <iteratively> for each object in the <data model>.
+
We have successfully made clicking "Search" button <to invoke its corresponding event listener>, but we would still find that content of ''listbox'' doesn't show the search result correctly. That is because we haven't specified how to render data model on a ''listbox''. Now, we will use a special tag, <tt> <template> </tt><ref>[[ZK Developer's Reference/MVC/View/Template]]</ref>, to control the rendering of each item. ZK will render template tag's content iteratively for each object in the data model.
  
 
Steps to use <tt> <template> </tt>:
 
Steps to use <tt> <template> </tt>:
# Use '''<tt><template></tt>''' to enclose components that you want to create repeatedly.
+
# Use '''<tt><template></tt>''' to enclose components that we want to create iteratively.
 
# Set template's "name" attribute to "model". <ref> [[ZK Developer's Reference/MVC/View/Template/Listbox Template]]</ref>
 
# Set template's "name" attribute to "model". <ref> [[ZK Developer's Reference/MVC/View/Template/Listbox Template]]</ref>
 
# Use implicit variable, '''each''', to assign domain object's properties to component's attributes.
 
# Use implicit variable, '''each''', to assign domain object's properties to component's attributes.
Line 185: Line 185:
 
</source>
 
</source>
 
* Line 7: The template tag should be put inside the ''listbox'' .  
 
* Line 7: The template tag should be put inside the ''listbox'' .  
* Line 8: The <listitem> in previous chapter's zul is for static data, you should replace it with current code.
+
* Line 8: The <listitem> in previous chapter's zul is for static data, we should replace it with current code.
* Line 9: The "each" is a variable that references to a domain object in the model list which is <tt> Car</tt> in our example application. You can use it to access domain object's property with EL, e.g. ${each.name}.
+
* Line 9: The "each" is a variable that references to a domain object in the model list which is <tt> Car</tt> in our example application. We can use it to access domain object's property with EL, e.g. ${each.name}.
  
 
== Implement View Details Function ==
 
== Implement View Details Function ==

Revision as of 08:47, 14 August 2012

WarningTriangle-32x32.png This page is under construction, so we cannot guarantee the accuracy of the content!

Introduction

This tutorial is intended for software developers who have experience in writing Java programs. We will guide you through how to build a modern web application with ZK. The target application we are going to build is a simple car catalog application. You will also learn basic concepts of ZK during this tutorial.

You can take look at the [http:// target application's live demo] and download the complete source code with an Eclipse project zip file under Import and Run Example Application section.



Tutorial Objective

Our target application is a simple car catalog application. This application has two functions:

  1. Search cars.
    Enter a keyword in the input field, click Search and search results will be displayed in the car list below.
  2. View details.
    Click an item from the car list, the area below the car list will show the selected car's details including model, price, description, and preview.


Tutorial-searchexample.png


Start from Example Project

You can get the source code of this article and import it to your IDE without starting from scratch. Please follow the README to run the project.

If you want to start a new project, please refer to ZK Installation Guide/Quick Start.

Declaring Domain Class

The following is the domain object that represents a car.

public class Car {
	private Integer id;
	private String model;
	private String make;
	private String preview;
	private String description;
	private Integer price;
	//omit getter and setter for brevity
}

We then define a service class to perform the business logic (search cars) shown below:

public interface CarService {

	/**
	 * Retrieve all cars in the catalog.
	 * @return all cars
	 */
	public List<Car> findAll();
	
	/**
	 * search cars according to keyword in  model and make.
	 * @param keyword for search
	 * @return list of car that matches the keyword
	 */
	public List<Car> search(String keyword);
}

In this example, we have defined a class, CarServeImpl, that implements the above interface. For simplicity, it uses a static list object as the data model. You can rewrite it so that it connects to a database in a real application. Its implementation details are not in the scope of this article, please refer to source code repository.

Building User Interface

UI is a good start to building an application as it helps you define the scope of your application. ZK provides hundreds of readily made UI components, so developers can rapidly build their desired user interface by combining and mix-matching these components without having to create a page from scratch.

In ZK, you can use ZK User Interface Markup Language (ZUML), an XML-formatted language, to describe UI. By ZK's convention, the files to describe the user interface with ZUML uses .zul as the name suffix. In zul files, one component is represented as an XML element (tag) and you can configure each component's style, behavior, and function by setting XML element's attributes. (check ZK Component Reference for details)

In this example application, first of all, we want to use a Window with the specified title and normal border as our application's frame.


As Window is the outermost component, it is called the root component. Window is a commonly used container because it makes your web application look like a desktop application. Besides, it can also enclose other components. All other components inside Window are called its child components and should be put in <window>'s body.

Extracted from search.zul

1 	<window title="Search" border="normal" width="600px">
2 		<!-- put child components inside a tag's body -->
3 	</window>
  • Line 1: Specifying title bar text with title and make <window> display a normal border with border . For width attribute, use CSS like syntax such as 800px or 60%.


Our example application's user interface is divided into 3 areas within the <window> (from top to bottom):

  1. search function
  2. car list
  3. car details.
Tutorial-ui-3areas.png


Search Area

ZK components are like building blocks, you can combine and mix-match existing components to construct your desired UI. To allow users to search, we need a text to prompt users for input, a place to enter keywords, and a button for triggering the search. We can use the following ZK components to fulfill this requirement:

Extracted from search.zul

1 Keyword:
2 <textbox id="keywordBox" />
3 <button id="searchButton" label="Search" iconSclass="z-icon-search" style="margin: 0 0 5px 5px"/>
  • Line 1~2: Specifying the id attribute for some components allows you to control them by referencing their id.
  • Line 3: You can use built-in Font Awesome icon at iconSclass. Please refer to LabelImageElement#IconSclass for details.

Car List Area

ZK provides several components to display a collection of data such as listbox, grid, and tree. In this example, we use a listbox to display a list of cars with 3 columns: Model, Make, and Price. Here we use listcell with static label to demonstrate structure of a listitem. Later, we'll talk about how to create listitem dynamically with a collection of data.

Extracted from search.zul

 1 <listbox id="carListbox" emptyMessage="No car found in the result" rows="5">
 2     <listhead>
 3         <listheader label="Model" />
 4         <listheader label="Make" />
 5         <listheader label="Price" width="20%"/>
 6     </listhead>
 7     <listitem>
 8         <listcell label="car model"></listcell>
 9         <listcell label="make"></listcell>
10         <listcell>$<label value="price" /></listcell>
11     </listitem>
12 </listbox>
  • Line 1: rows determines the max visible row. emptyMessage is used to show a message when listbox contains no items.
  • Line 2: The listbox is a container component, and you can add listhead to define a column.
  • Line 7: The listitem is used to display data, and the number of listcell in one listitem usually equals to the number of listheader.

Car Details Area

hlayout and vlayout are layout components which arrange their child components in horizontal and vertical order.

Extracted from search.zul

1 	<hlayout style="margin-top:20px" width="100%">
2 		<image id="previewImage" width="250px" />
3 		<vlayout hflex="1">
4 			<label id="modelLabel" />
5 			<label id="makeLabel" />
6 			<label id="priceLabel" />
7 			<label id="descriptionLabel" />
8 		</vlayout>
9 	</hlayout>
  • Line 1: the style attribute allows you to customize component's style with CSS syntax.

Handling UI Logic

The next step after building the UI is to make it respond to users. The approach we introduce here is to control UI component directly by yourself. This approach can be classified to Model-View-Controller (MVC) design pattern. [1] This pattern divides an application into three parts.

The Model consists of application data and business rules. CarService and other classes used by it represent this part in our example application.

The View means user interface. The zul page which contains ZK components represents this part. A user's interaction with components triggers events to be sent to controllers.

The Controller plays the role of a coordinator between View and Model. It receives events from View to update Model and retrieve data to change View's presentation.


Tutorial-mvc.png
  1. When a user interacts with a component (e.g. click a button) on a ZUL, the user's action triggers an event.
  2. This event is sent to the controller and invokes corresponding event listener method.
  3. The event listener method usually executes business logic or accesses data, then manipulate ZK components.
  4. A change in component's states in an event listener is reflected in its corresponding UI.


Declaring UI Controllers

In ZK, the controller is responsible for controlling ZK components and listening to events triggered by user interaction.

We have to implement a controller class for the UI component which we wish to reference and control. We can simply extend org.zkoss.zk.SelectorComposer :

package tutorial;

// omit import for brevity

public class SearchController extends SelectorComposer<Component> {

}


After a controller is created, we associate it with its corresponding UI component. Associating a controller to a component is just specifying full-qualified class name in target component's apply attribute. The following code shows how to associate a controller with a window.

Extracted from searchMvc.zul

	<window title="Search" width="600px" border="normal"
	apply="tutorial.SearchController">
	<!-- omit other components for brevity -->
	</window>

See the complete zul in References.[2]


After associating the controller with the window, the controller can listen events sent from UI and retrieve components which allows us to implement application's function. Let's start from the search function: a user enters a keyword, clicks the "Search" button to trigger the search.

Steps to implement a function:

  1. Declare a method which listens to a component's event
  2. Control UI components to implement presentation and business logic in the listener method

Listening to User Action

When we associate a controller with a component, every event triggered by this component (and its child components) is sent to the controller. If there is a method which we assigned to listen to the triggered event, it will be invoked. As a user clicks "Search" button to trigger the search function, we have to listener to "Search" button's "onClick" event. We declare a method, search(), and specify it to be invoked when <"Search button" is clicked with the following annotation>:

@Listen("[EVENT_NAME] = #[COMPONENT_ID]").

Such method serves as an event listener method.

The final code looks like:

public class SearchController extends SelectorComposer<Component> {

	@Listen("onClick = #searchButton")
	public void search(){

	}
}
  • Line 3: "searchButton" is the button component's id, and you can find it in previous zul. There are other syntax which can be specified in @Listen's parameter [3] to describe a component.
  • Line 4: It must be a public method.

Controlling the UI Components

After establishing the relationship between an event and an event listener method, we can start to implement method's logic with components. But firstly we should retrieve the UI component's object by annotating @Wire on controller's member variables.

Steps to retrieve components:

  1. Declare a variable with target component type (e.g. Listbox, Label...)
  2. Name the variable as component's ID. [4]
  3. Annotate the variable with @Wire.


Then ZK will "wire" a corresponding ZK component object to the variable we declared. After this has been done, we can then control and manipulate UI by accessing those annotated member variables.

public class SearchController extends SelectorComposer<Component> {

	@Wire
	private Textbox keywordBox;
	@Wire
	private Listbox carListbox;

	//other codes...
}
  • Line 5-6: In searchMvc.zul, there is a listbox whose id is carListbox. ZK will make the variable carListbox reference to the listbox object after components are created.


The search method performs a simple logic: call car service class to search with keyword and set result list to listbox. For a variable which references to a component, we can get component's attribute such as user's input with getter (getValue()) or change a component's status like making a label invisible with setter (setVisible(false)) to achieve some dynamic UI effect. Hence, we can easily get what keyword a user inputs by keywordBox.getValue() and change data item of listbox by carListbox.setModel() . The model of a component is the data the component holds and we can change the model to change the data rendering on the screen.

public class SearchController extends SelectorComposer<Component> {
	//omit codes to get components

	@Listen("onClick = #searchButton")
	public void search(){
		String keyword = keywordBox.getValue();
		List<Car> result = carService.search(keyword);
		carListbox.setModel(new ListModelList<Car>(result));
	}
}
  • Line 8: Notice that setModel() only accepts a ListModel object, so we can use org.zkoss.zul.ListModelList to wrap search result list. There are other ListModel objects for different collection types, please refer to References section. [5]

Displaying a Data Collection

We have successfully made clicking "Search" button <to invoke its corresponding event listener>, but we would still find that content of listbox doesn't show the search result correctly. That is because we haven't specified how to render data model on a listbox. Now, we will use a special tag, <template> [6], to control the rendering of each item. ZK will render template tag's content iteratively for each object in the data model.

Steps to use <template> :

  1. Use <template> to enclose components that we want to create iteratively.
  2. Set template's "name" attribute to "model". [7]
  3. Use implicit variable, each, to assign domain object's properties to component's attributes.

Extracted from searchMvc.zul

		<listbox id="carListbox" height="160px" emptyMessage="No car found in the result">
			<listhead>
				<listheader label="Name" />
				<listheader label="Company" />
				<listheader label="Price" width="20%"/>
			</listhead>
			<template name="model">
				<listitem>
					<listcell label="${each.name}"></listcell>
					<listcell label="${each.company}"></listcell>
					<listcell>$<label value="${each.price}" /></listcell>
				</listitem>
			</template>
		</listbox>
  • Line 7: The template tag should be put inside the listbox .
  • Line 8: The <listitem> in previous chapter's zul is for static data, we should replace it with current code.
  • Line 9: The "each" is a variable that references to a domain object in the model list which is Car in our example application. We can use it to access domain object's property with EL, e.g. ${each.name}.

Implement View Details Function

Previous sections describe the basic steps to implement a function with ZK. Let's recap them by implementing "view details" function. We declare a method to listen to "onSelect" event of listbox with @Listen, then use @Wire to get components including previewImage, nameLabel, priceLabel, and descriptionLabel and <assign value to them with setter>.

public class SearchController extends SelectorComposer<Component> {

	@Wire
	private Listbox carListbox;
	@Wire
	private Label nameLabel;
	@Wire
	private Label companyLabel;
	@Wire
	private Label priceLabel;
	@Wire
	private Label descriptionLabel;
	@Wire
	private Image previewImage;

	@Listen("onSelect = #carListbox")
	public void showDetail(){
		Car selected = carListbox.getSelectedItem().getValue();
		previewImage.setSrc(selected.getPreview());
		nameLabel.setValue(selected.getName());
		companyLabel.setValue(selected.getCompany());
		priceLabel.setValue(selected.getPrice().toString());
		descriptionLabel.setValue(selected.getDescription());
	}
	//omit other codes for brevity
}


For complete source code, please refer to References section [8]

References