ZK Framework

ZK is a Java framework designed for building enterprise web and mobile applications. It is particularly suited for:

• Backend-heavy Java projects: Ideal when the development team has minimal frontend (JavaScript/HTML) expertise.
• Enterprise applications: When long-term stability is a requirement.
• Data-intensive UIs: For applications requiring complex user interactions and heavy data handling.
• Rapid Prototyping: For quickly building internal tools.

ZUML is a declarative language used to design rich user interfaces. It is a variant of XUL that inherits XML features.

Key Features

• Separation of Concerns: ZUML separates the UI definition from the runtime logic.
• Declarative UI: Designing interfaces is as simple as authoring HTML-like markup.
• Data Automation: ZUML supports automating CRUD operations between UI components and data sources using annotations, data binding, and the MVVM (Model-View-ViewModel) pattern.

ZK uses a server-centric approach to Ajax, often described as "Ajax without JavaScript."

Core Mechanism

• Component Surrogates: Every UI element rendered in the browser is represented on the server as a Plain Old Java Object (POJO) component.
• Event Marshalling: User events triggered in the browser are encapsulated and marshalled to event listeners running on the server.
• Transparent Updates: When you modify a POJO component on the server, the changes are automatically reflected on the client via a client/update engine (acting as 'pitcher and catcher') without requiring the developer to write manual Ajax or JavaScript code.
• Java Integration: Because logic executes on the server, you can directly leverage Java EE, Spring, and existing backend services.

A ZK Composer is stored as an attribute on the component object it is applied to. Its lifecycle is tied to that component:

When using Spring beans as ZK Composers, you must use scope="prototype".

ZK Composers are inherently component-scoped; they live and die with the ZK component they are attached to. If you use the default Spring Singleton scope, the same Composer instance will be shared across all users, all desktops, and all components. This leads to severe data races and security leaks where one user's state is visible to another.

Recommendation Summary:

• FQCN (apply="com.example.MyComposer"): Safe. Use when no Spring DI is needed.
• Spring Prototype (apply="${myComposer}" with scope="prototype"): Safe. Use when Spring DI is required.
• Spring Singleton (apply="${myComposer}" with default scope): NEVER USE.

You can delegate a ZK Composer's instantiation to the Spring container by using the DelegatingVariableResolver. This allows Spring to manage the Composer's dependencies via Dependency Injection (DI).

To implement this, first declare the DelegatingVariableResolver in your ZUL file, then use an EL expression in the apply attribute of a component to reference your Spring bean name.

<?xml version="1.0"?>
<zk>
    <?variable-resolver class="org.zkoss.zkplus.spring.DelegatingVariableResolver"?>
    <div apply="${myComposer}">
        <!-- Component content -->
    </div>
</zk>

To begin using ZK, you can follow these official resources:

• Tutorial: Get ZK up and running with MVC
• Essentials: ZK Essentials Overview
• API Reference: Javadoc API
• Download: Download ZK CE (Community Edition)

To get type safety and autocompletion for the ZK Framework in a TypeScript project, install the zk-types package as a development dependency and configure your tsconfig.json to include it in the types array.

1. Install dependencies: npm i -D typescript zk-types
2. Initialize TypeScript (if not already done): npx tsc --init
3. Update tsconfig.json to include zk-types in compilerOptions.types.

When packaging your Web application, you must decide how to distribute the ZK libraries based on your server configuration:

1. Embedded Libraries: If you want to include all ZK libraries directly within your Web application (e.g., inside your .war file), copy war.libs.all to war.libs.
2. Shared Server Libraries: If you have already installed the ZK libraries into the shared directory of your Web server, use the minimal set by copying war.libs.minimal to war.libs.

# To embed ZK libraries into your Web application:
cp war.libs.all war.libs

# To use ZK libraries installed in the Web server's shared directory:
cp war.libs.minimal war.libs

To ensure version consistency across all ZK modules, add the zk-bom to your pom.xml within the <dependencyManagement> section. This allows you to omit version numbers when declaring individual ZK dependencies, as the BOM will provide the correct versions automatically. Replace x.y.z with the specific version of the BOM you wish to use.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.zkoss.zk</groupId>
            <artifactId>zk-bom</artifactId>
            <version>x.y.z</version><!-- replace with the actual version -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>   
    </dependencies>
</dependencyManagement>