Techniques for Passing Row IDs to Command Links in JSF 2 DataTables

In JavaServer Faces (JSF) 2 applications, developers often use components like <p:dataTable> to display tabular data and <p:commandLink> to enable user actions on individual rows. A frequent challenge is passing the row-specific identifier to the action method triggered by the command link, especially when using iteration constructs such as dataTable or ui:repeat. This article delves into the root cause of this issue and presents several effective solutions.

Direct Parameter Passing

One straightforward approach is to pass the row ID directly as a parameter to the action method. This method requires Servlet 3.0 or EL 2.2 support. For example, in the JSF markup, you can use:

<p:commandLink action="#{bean.insert(item.id)}" value="insert" />

In the backing bean, the method signature would be:

public void insert(Long id) {
    // implementation here
}

This ensures that the item.id is evaluated at render time and passed to the method. To maintain data consistency across requests, it is advisable to scope the bean as @ViewScoped.

Using f:param for Request Parameters

Another common method is to employ the <f:param> tag, which adds a request parameter to the command link. This approach works well with request-scoped beans and does not rely on the preservation of the data model. The JSF code snippet might look like:

<p:commandLink action="#{bean.insert}" value="insert">
    <f:param name="id" value="#{item.id}" />
</p:commandLink>

In the bean, the ID can be injected using @ManagedProperty(value="#{param.id}") or handled via <f:viewParam> for better control over conversion and validation.

Leveraging f:setPropertyActionListener

The <f:setPropertyActionListener> tag provides a clean way to set a property in the backing bean directly. This is particularly useful when the bean has a broader scope, such as view or session scope. Example usage:

<p:commandLink action="#{bean.insert}" value="insert">
    <f:setPropertyActionListener target="#{bean.id}" value="#{item.id}" />
</p:commandLink>

In the bean, a setter for the id property is required, and the data model should be preserved across the request.

DataModel Approach

Binding the dataTable value to a DataModel<E> offers an alternative where the row data can be accessed without explicit parameter passing. This method is suitable for view-scoped beans and uses the DataModel#getRowData() method. Example:

<h:dataTable value="#{bean.model}" var="item">

In the bean, implement a lazy-initialized DataModel:

private transient DataModel<Item> model;

public DataModel<Item> getModel() {
    if (model == null) {
        model = new ListDataModel<>(items);
    }
    return model;
}

The action method can then retrieve the current row using model.getRowData().

Programmatic Evaluation

For advanced scenarios, the Application#evaluateExpressionGet() method allows programmatic evaluation of the current row in the iteration context. This is less common but can be useful in certain edge cases. Example:

public void insert() {
    FacesContext context = FacesContext.getCurrentInstance();
    Item item = context.getApplication().evaluateExpressionGet(context, "#{item}", Item.class);
    Long id = item.getId();
    // proceed with action
}

In conclusion, the choice of method depends on the specific requirements of the application, such as servlet container support, bean scope, and data model preservation. For most modern applications with Servlet 3.0 support, direct parameter passing is recommended for its simplicity and efficiency. Alternatively, using <f:param> provides a flexible solution that works across different scopes and does not require data model retention.