Apache Wicket Documentation

In Wicket, a Model is a facade (implementing the org.apache.wicket.model.IModel interface) that decouples components from the underlying data management or persistence strategy.

Key Characteristics

• Decoupling: Components interact with the model rather than the concrete data object, allowing the data to be managed or persisted independently.
• Indirection: Models provide a layer of indirection that allows data to be accessed only when needed (e.g., during the rendering phase).
• Lifecycle: Wicket triggers onModelChanged() after a model is modified and onModelChanging() just before a change occurs.
• Sharing: A single model instance can be shared among multiple components, but a component can have at most one related model.

Core API

The IModel interface relies on two primary methods for data access:

• getObject(): Retrieves the data object.
• setObject(T object): Sets the data object.

Note that org.apache.wicket.model.Model is a basic implementation of IModel that can wrap any java.io.Serializable object, as models are typically stored in the web session.

When using StatelessLink on a stateless page, Wicket generates a new instance of the page every time the link is clicked. Consequently, any state stored in instance variables of the page will be lost between clicks.

Warning: Do not rely on instance variables inside the onClick() method of a StatelessLink, as they will reset to their default values upon every interaction. Instead, retrieve necessary data from PageParameters or other stateless mechanisms.

public class StatelessPage extends WebPage {
    private int index = 0; // This state will be lost on every click

    public StatelessPage(PageParameters parameters) {
        super(parameters);
    }

    @Override
    protected void onInitialize() {
        super.onInitialize();
        setStatelessHint(true);

        add(new StatelessLink("statelessLink") {
            @Override
            public void onClick() {
                // This will always print the initial value (e.g., 0)
                // because a new page instance is created for the request.
                System.out.println(index++);
            }
        });
    }
}

Wicket uses a typed session model rather than a generic map structure (like the standard Servlet session). To maintain a clean and efficient application, follow these state management principles:

1. Use the Wicket Session for Global Data: Store information that is required across nearly every page, such as authentication status, user information, or authorization logic (e.g., determining if a user has permission to edit a specific resource).
2. Avoid Session Bloat for Flow-Specific Data: Do not store data related to specific forms or multi-step flows in the session if that data only spans a few pages.
3. Pass Data via Constructors: For data that moves through a sequence of pages, pass the data (or its IModel) directly through the page constructors.
4. Leverage Automatic Cleanup: Because Wicket pages are user-specific instances, storing models in page fields ensures that data is automatically cleaned up when the user completes or exits the page flow. This prevents the need for manual session cleanup and acts as an 'automatic garbage collector' for your application state.

public class MyPage extends WebPage {
    IModel<MyData> myDataModel;

    public MyPage(IModel<MyData> myDataModel) {
        this.myDataModel = myDataModel;
        Link<Void> next = new Link<Void>("next") {
             public void onClick() {
                  // do something
                  setResponsePage(new NextPage(myDataModel));
             }
        };
        add(next);
    }
}