ExtendedDataTable in RichFaces 4: DataModel handli

Question

I have another question, somewhat related to the one I posted in January. I have a list, which is rich:extendedDataTable component, and it gets updated on the fly, as the user types his search criteria in a separate text box (i.e. the user types in the first 4 characters and as he keeps typing, the results list changes). And in the end it works fine, when I use RichFaces 3, but as I upgraded to RichFaces 4, I've got all sorts of compilation problems. The following classes are no longer accessible and there no suitable replacement for these, it seems:

org.richfaces.model.DataProvider
org.richfaces.model.ExtendedTableDataModel
org.richfaces.model.selection.Selection
org.richfaces.model.selection.SimpleSelection

Here is what it was before:

This is the input text that should trigger the search logic:

<h:inputText id="firmname" value="#{ExtendedTableBean.searchValue}">
   <a4j:support ajaxSingle="true" eventsQueue="firmListUpdate"  
                reRender="resultsTable" 
                actionListener="#{ExtendedTableBean.searchForResults}" event="onkeyup" />
</h:inputText>

Action listener is what should update the list. Here is the extendedDataTable, right below the inputText:

<rich:extendedDataTable tableState="#{ExtendedTableBean.tableState}" var="item"
                       id="resultsTable" value="#{ExtendedTableBean.dataModel}">

        ... <%-- I'm listing columns here --%>

</rich:extendedDataTable>

And here's the back-end code, where I use my data model handling:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.beans;

import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.ConcurrentModificationException;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import org.richfaces.model.DataProvider;
import org.richfaces.model.ExtendedTableDataModel;

public class ExtendedTableBean {      
    private String sortMode="single";
    private ExtendedTableDataModel<ResultObject> dataModel;
    //ResultObject is a simple pojo and getResultsPerValue is a method that 
    //read the data from the properties file, assigns it to this pojo, and
    //adds a pojo to the list 

    private Object tableState;
    private List<ResultObject> results = new CopyOnWriteArrayList<ResultObject>();
    private List<ResultObject> selectedResults = 
                                      new CopyOnWriteArrayList<ResultObject>();

    private String searchValue;

    /**
     * This is the action listener that the user triggers, by typing the search value
     */
    public void searchForResults(ActionEvent e) {
       synchronized(results) {
           results.clear();
       }        

       //I don't think it's necessary to clear results list all the time, but here
       //I also make sure that we start searching if the value is at least 4 
       //characters long
       if (this.searchValue.length() > 3) {
           results.clear();
           updateTableList();
       } else {
           results.clear();
       }

       dataModel = null; // to force the dataModel to be updated.
    }

    public List<ResultObject> getResultsPerValue(String searchValue) {
        List<ResultObject> resultsList = new CopyOnWriteArrayList<ResultObject>();

        //Logic for reading data from the properties file, populating ResultObject
        //and adding it to the list

        return resultsList;
    }

    /**
     * This method updates a firm list, based on a search value
     */
    public void updateTableList() {
        try {              
            List<ResultObject> searchedResults = getResultsPerValue(searchValue);

            //Once the results have been retrieved from the properties, empty 
            //current firm list and replace it with what was found.

            synchronized(firms) {
                firms.clear();
                firms.addAll(searchedFirms);
            }
        } catch(Throwable xcpt) {
            //Exception handling
        }
    }

    /**
     * This is a recursive method, that's used to constantly keep updating the 
     * table list.
     */
    public synchronized ExtendedTableDataModel<ResultObject> getDataModel() {
        try {
            if (dataModel == null) {
                dataModel = new ExtendedTableDataModel<ResultObject>(
                               new DataProvider<ResultObject>() {
                                   public ResultObject getItemByKey(Object key) {
                                       try {
                                           for(ResultObject c : results) {
                                               if (key.equals(getKey(c))){
                                                   return c;
                                               }
                                           }
                                       } catch (Exception ex) {
                                           //Exception handling
                                       }
                                       return null;
                                   }

                                   public List<ResultObject> getItemsByRange(
                                                 int firstRow, int endRow) {
                                       return Collections.unmodifiableList(results.subList(firstRow, endRow));
                                   }

                                   public Object getKey(ResultObject item) {
                                       return item.getResultName();
                                   }

                                   public int getRowCount() {
                                       return results.size();
                                   }
                              });
            }
        } catch (Exception ex) {
            //Exception handling    
        }

        return dataModel;
    }

    //Getters and setters 

}

Now that the classes ExtendedTableDataModel and DataProvider are no longer available, what should I be using instead? RichFaces forum claims there's really nothing and developers are pretty much on their own there (meaning they have to do their own implementation). Does anyone have any other idea or suggestion?

Thanks again for all your help and again, sorry for a lengthy question.

Answer 1

You could convert your data model to extend the abstract org.ajax4jsf.model.ExtendedDataModel instead which actually is a more robust and performant datamodel for use with <rich:extendedDataTable/>. A rough translation of your existing model to the new one below (I've decided to use your existing ExtendedDataModel<ResultObject> as the underlying data source instead of the results list to demonstrate the translation):

   public class MyDataModel<ResultObject> extends ExtendedDataModel<ResultObject>{

    String currentKey; //current row in the model
    Map<String, ResultObject> cachedResults = new HashMap<String, ResultObject>(); // a local cache of search/pagination results
    List<String> cachedRowKeys; // a local cache of key values for cached items
    int rowCount;
    ExtendedTableDataModel<ResultObject> dataModel; // the underlying data source. can be anything


    public void setRowKey(Object item){
     this.currentKey = (ResultObject)item.getResultName();   
    }

    public void walk(FacesContext context, DataVisitor visitor, Range range, Object argument) throws IOException {
    int firstRow = ((SequenceRange)range).getFirstRow();
    int numberOfRows = ((SequenceRange)range).getRows();
    cachedRowkeys = new ArrayList<String>();
    for (ResultObject result : dataModel.getItemsByRange(firstRow,numberOfRows)) {
       cachedRowKeys.add(result.getResultName());
       cachedResults.put(result.getResultName(), result); //populate cache. This is strongly advised as you'll see later.
       visitor.process(context, result.getResultName(), argument);
      }
    }

   }


 public Object getRowData() {
   if (currentKey==null) {
       return null;
   } else {
       ResultObject selectedRowObject = cachedResults.get(currentKey); // return result from internal cache without making the trip to the database or other underlying datasource
       if (selectedRowObject==null) {  //if the desired row is not within the range of the cache

           selectedRowObject = dataModel.getItemByKey(currentKey);
           cachedResults.put(currentKey, selectedRowObject);
           return selectedRowObject;
       } else {
           return selectedRowObject;
       }
   }

 public int getRowCount(){
 if(rowCount == 0){
    rowCount = dataModel.getRowCount(); //cache row count
    return  rowCount;
  }
  return rowCount

 }

Those are the 3 most important methods in that class. There are a bunch of other methods, basically carry over from legacy versions that you don't need to worry yourself about. If you're saving JSF state to client, you might be interested in the org.ajax4jsf.model.SerializableDataModel for serialization purposes. See an example for that here. It's an old blog but the logic is still applicable.

Unrelated to this, your current implementation of getRowData will perform poorly in production grade app. Having to iterate thru every element to return a result? Try a better search algorithm.