Lazy Loading DataTable con IceFaces

IceFaces fornisce ai programmatori numerosi componenti per facilitare lo sviluppo di applicazioni web. Tra questi, uno dei piu' utili e' sicuramente la ice:dataTable. Questo componente, unito all'ice:dataPaginator permette infatti di paginare l'intero data set di una tabella, mostrando solamente N righe per pagina. La debolezza principale di questo componente risiede nella difficolta' di gestire data set di grandi dimensioni: per funzionare il componente ice:dataTable si aspetta infatti di ricevere una lista contenente tutte le righe che andra' via via a mostrare. Finche' siamo nell'ordine di qualche centinaia di record, non c'e' nessun problema a fornire al componente l'intera lista di risultati; se questi iniziano ad essere migliaia, tenere in memoria una tale quantita' di oggetti puo' essere un problema. La soluzione consiste nel gestire la lista dei risultati in modo lazy: sara' la lista stessa a recuperare i record da mostrare nella pagina corrente solo quando ce ne sara' un effettivo bisogno. Oltre a questo, sara' inoltre necessario gestire il paginatore in modo che mostri comunque l'insieme di tutte le pagine corrispondente al numero totale di risultati. Il paginatore calcola infatti il totale delle pagine invocando il metodo size() della lista fornita alla tabella. Vediamo ora tre implementazioni possibili per applicare il lazy loading alla lista. Saranno inizializzate nel backing bean e invocate nel template .jsf in questo modo:


....


...

h2. 1. LazyLoadingList Questa lista mantiene in memoria una lista di oggetti corrispondente alla prima pagina. Quando l'utente navighera' nelle pagine successive, queste verranno di volta in volta recuperate dal metodo get() e salvate in una diversa lista. Da notare che il costruttore della lista accetta in entrata il parametro totalResultsNumber, cioe' il numero totale dei risultati da mostrare in tabella. Questo parametro sara' dunque il risultato di una count query.

package com.devinterface.lazyloading;

import java.util.AbstractList;
import java.util.List;

/**
 * This list loads and stores only the first page and the current page.
 * If pageSize is equals to totalResultsNumber, the dataTable will be non paginated: the first query will retrieve all the dataset.
 *
 * @param 
 */
public class LazyLoadingList extends AbstractList
{
  private IDataProvider dataProvider;

  private List firtsPageData;
  private List currentPageData;

  private int currentPage = -1;
  private int totalResultsNumber;
  private int pageSize;

  /**
   * @param dataProvider, the object that will perform the query
   * @param pageSize, the number of rows to be showed in a table page
   * @param totalResultsNumber, the total number of rows as result of the database count query. 
   */
  public LazyLoadingList(IDataProvider dataProvider, int pageSize, int totalResultsNumber)
  {
    this.dataProvider = dataProvider;
    this.totalResultsNumber = totalResultsNumber;
    this.pageSize = pageSize;
  }

  @Override
  public T get(int i)
  {
    if (i < pageSize)
    {
      if (firtsPageData == null)
        firtsPageData = dataProvider.getBufferedData(i, pageSize);
      return firtsPageData.get(i);
    }
    int page = i / pageSize;

    if (page != currentPage)
    {
      currentPage = page;
      currentPageData = dataProvider.getBufferedData(i, pageSize);
    }

    return currentPageData.get(i % pageSize);
  }

  @Override
  public int size()
  {
    return totalResultsNumber;
  }

  public void setTotalResultsNumber(int totalResultsNumber)
  {
    this.totalResultsNumber = totalResultsNumber;
  }

  @Override
  public void clear()
  {
    firtsPageData.clear();
    currentPageData.clear();
  }

}
h2. 2. LazyLoadingMapList Questa lista mantiene in memoria i record che man mano recupera dal database in una HashMap. Da notare che la mappa non viene mai svuotata, quindi nel caso peggiore in cui l'utente scorre una ad una tutte le pagine la mappa conterra' tutti gli elementi del dataset.

package com.devinterface.lazyloading;

import java.util.AbstractList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * This list stores all records in a map with key = "table row index" and value = "T"
 * If pageSize is equals to totalResultsNumber, the dataTable will be non paginated: the first query will retrieve all the dataset.
 * Note that if a user moves from first to last page, one page at time, all record will be in memory.
 *
 * @param 
 */
public class LazyLoadingMapList extends AbstractList
{
  private IDataProvider dataProvider;

  private int totalResultsNumber;
  private int pageSize;

  /** cache of loadedData items */
  private Map loadedData;

  /**
   * @param dataProvider, the object that will perform the query
   * @param pageSize, the number of rows to be considered as "a page"
   * @param totalResultsNumber, the total number of rows as result of the database count query. 
   */
  public LazyLoadingMapList(IDataProvider dataProvider, int pageSize, int totalResultsNumber)
  {
    this.dataProvider = dataProvider;
    this.totalResultsNumber = totalResultsNumber;
    this.pageSize = pageSize;
    loadedData = new HashMap();
  }

  @Override
  public T get(int i)
  {
    if (!loadedData.containsKey(i))
    {
      int pageIndex = i / pageSize;
      List results = dataProvider.getBufferedData(i, pageSize);
      for (int j = 0; j < results.size(); j++)
      {
        loadedData.put(Integer.valueOf(pageIndex * pageSize + j), (T) results.get(j));
      }
    }
    return loadedData.get(i);

  }

  @Override
  public int size()
  {
    return totalResultsNumber;
  }

  public void setTotalResultsNumber(int totalResultsNumber)
  {
    this.totalResultsNumber = totalResultsNumber;
  }

  @Override
  public void clear()
  {
    loadedData.clear();
  }

}
h2. 3. LazyLoadingBufferedMapList Questa lista rappresenta un'evoluzione della precedente, mantenendo in memoria solo gli elementi corrispondenti alla pagina corrente, alla precedente e alla successiva.

package com.devinterface.lazyloading;

import java.util.AbstractList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * This list stores records in a map with key = "table row index" and value = "element"
 * It keeps a buffer of 3 pages: the first time it will load pages 1,2,3. 
 * When user moves to page 4, all stored data will be cleared and will be retrieved page 3,4,5.
 * Basically, this list will store current page, previous page and next page. 
 * If bufferSize is equals to totalResultsNumber, the dataTable will be non paginated: the first query will retrieve all the dataset.
 *
 * @param 
 */
public class LazyLoadingBufferedMapList extends AbstractList
{
  private IDataProvider dataAdapter;

  private int totalResultsNumber;
  private int pageSize = 10;
  private int bufferSize = 30;

  /** cache of loadedData items */
  private Map loadedData;

  /**
   * 
   * @param dataAdapter, the object that will perform the query
   * @param pageSize, the number of rows to be considered as "a page"
   * @param totalResultsNumber, the total number of rows as result of the database query. 
   */
  public LazyLoadingBufferedMapList(IDataProvider dataAdapter, int pageSize, int totalResultsNumber)
  {
    this.dataAdapter = dataAdapter;
    this.totalResultsNumber = totalResultsNumber;
    this.pageSize = pageSize;
    this.bufferSize = pageSize * 3;
    loadedData = new HashMap();
  }

  @Override
  public T get(int i)
  {
    if (!loadedData.containsKey(i))
    {
      clearMap();

      int startRow = getStartRow(i);

      int numElementToFind = bufferSize;
      if ((startRow + numElementToFind) > totalResultsNumber)
        numElementToFind = totalResultsNumber - startRow;

      List results = dataAdapter.getBufferedData(startRow, numElementToFind);
      for (int j = 0; j < results.size(); j++)
        loadedData.put((startRow + j), (T) results.get(j));
    }
    return loadedData.get(i);

  }

  /**
   * clears the map except the first element that MUST be kept
   */
  private void clearMap()
  {
    T firstElement = loadedData.get(0);
    loadedData.clear();
    loadedData.put(0, firstElement);
  }

  /**
   * Calculates the index of the previous page's first element
   * @param i, the current row index
   * @return the index of the previous page's first element
   */
  private int getStartRow(int i)
  {
    int currentPage = (i / pageSize) + 1;

    int firstIndexOfCurrentPage = pageSize * (currentPage - 1);

    int firstIndexOfPreviusPage = firstIndexOfCurrentPage - (bufferSize / 3);

    if (firstIndexOfPreviusPage < 0)
      firstIndexOfPreviusPage = 0;

    return firstIndexOfPreviusPage;
  }

  @Override
  public int size()
  {
    return totalResultsNumber;
  }

  public void setNumResults(int numResults)
  {
    this.totalResultsNumber = numResults;
  }

  @Override
  public void clear()
  {
    loadedData.clear();
  }
}
h2. Conclusioni Tutte le implementazioni danno la possibilita' di recuperare record in modo lazy. Sicuramente la seconda rappresenta la soluzione potenzialmente piu' debole in quanto nel caso peggiore manterra' in memoria tutto il dataset. Sicuramente la terza implementazione rappresenta la soluzione migliore sotto tutti i punti di vista. Permette infatti di avere in memoria solo un numero limitato di record e di soddisfare potenzialmente eventuali "avanti e indietro" dell'utente. I sorgenti nel mio repository su GitHub, "LazyLoadingDataTable":http://github.com/xponrails/LazyLoadingDataTable