RichFaces ExtendedTableDataModel: les colonnes de tri récupèrent toutes les lignes

Question

Nous utilisons le ExtendedTableDataModel pour la pagination. Ceci est fait pour récupérer un ensemble de résultats avec Hibernate et charger l'ensemble suivant quand une autre page est demandée.

Tout fonctionne correctement, mais si nous trions les colonnes en utilisant rich: column sortBy dans le fichier riche: dataTable, alors RichFaces essaie de charger toutes les lignes. Nous pouvons le voir en déboguant le getItemsByRange que nous avons créé pour notre DataProvider personnalisé. Après avoir cliqué sur trier une fois, RichFaces continuera d'extraire toutes les lignes de la base de données. Ce n'est bien sûr pas ce que nous voulons. Nous voulions utiliser cette solution pour minimiser le trafic de données et les temps de chargement.

Nous utilisons Richfaces 3.3.2. Y at-il quelqu'un avec une solution possible ou une solution de contournement?

Answer 1

Nous avons eu le même problème, et voici notre solution. Je ne suis pas tout à fait sûr que tout le code que je suis coller est pertinent, mais il devrait être

public class PagingExtendedTableDataModel<T> extends ExtendedDataModel implements 
     Serializable, Modifiable { 

    private DataProvider dataProvider; 
    private Object rowKey; 
    private List wrappedKeys; 
    private Map wrappedData; 
    private Integer rowCount; 
    private Integer rowIndex; 
    private List<FilterField> filterFields; 
    private List<SortField2> sortFields; 

    public PagingExtendedTableDataModel(DataProvider<T> dataProvider) { 
     wrappedKeys = null; 
     wrappedData = new HashMap(); 
     rowCount = null; 
     rowIndex = Integer.valueOf(-1); 
     rowKey = null; 

     this.dataProvider = dataProvider; 
    } 

    public Object getRowKey() { 
     return rowKey; 
    } 

    public void setRowKey(Object key) { 
     rowKey = key; 
    } 

    @SuppressWarnings("unchecked") 
    public void walk(FacesContext context, DataVisitor visitor, Range range, 
      Object argument) throws IOException { 

     int rowC = getRowCount(); 
     int firstRow = ((SequenceRange) range).getFirstRow(); 
     int numberOfRows = ((SequenceRange) range).getRows(); 
     if (numberOfRows <= 0) { 
      numberOfRows = rowC; 
     } 

     if (wrappedKeys != null) { 
      Object key; 
      for (Iterator it = wrappedKeys.iterator(); it.hasNext(); 
       visitor.process(context, key, argument)) { 

       key = it.next(); 
       setRowKey(key); 
      } 

     } else { 
      wrappedKeys = new ArrayList(); 
      int endRow = firstRow + numberOfRows; 
      if (endRow > rowC) { 
       endRow = rowC; 
      } 

      if (dataProvider instanceof Sortable2) { 
       ((Sortable2) dataProvider).setSortFields(sortFields); 
      } 

      if (dataProvider instanceof Filterable) { 
       ((Filterable) dataProvider).setFilterFields(filterFields); 
      } 

      Object key; 
      for (Iterator it = loadData(firstRow, endRow).iterator(); it.hasNext(); 
       visitor.process(context, key, argument)) { 

       Object item = it.next(); 
       key = getKey(item); 
       wrappedKeys.add(key); 
       wrappedData.put(key, item); 
      } 

     } 
    } 

    protected List loadData(int startRow, int endRow) { 
     if (startRow < 0) { 
      startRow = 0; 
      throw new IllegalArgumentException((new StringBuilder()).append(
        "Illegal start index value: ").append(startRow).toString()); 
     } 
     int rowCount = getRowCount(); 
     if (endRow > rowCount) { 
      endRow = rowCount; 
      throw new IllegalArgumentException((new StringBuilder()).append(
        "Illegal end index value: ").append(endRow).toString()); 
     } 

     return dataProvider.getItemsByRange(startRow, endRow); 
    } 

    public int getRowCount() { 
     if (rowCount == null) { 
      rowCount = new Integer(dataProvider.getRowCount()); 
     } else { 
      return rowCount.intValue(); 
     } 

     return rowCount.intValue(); 
    } 

    public Object getRowData() { 
     if (rowKey == null) { 
      return null; 
     } 

     return getObjectByKey(rowKey); 
    } 

    @SuppressWarnings("unchecked") 
    public Object getKey(Object o) { 
     return dataProvider.getKey(o); 
    } 

    @SuppressWarnings("unchecked") 
    public Object getObjectByKey(Object key) { 
     Object t = wrappedData.get(key); 
     if (t == null) { 
      t = dataProvider.getItemByKey(key); 
      wrappedData.put(key, t); 
     } 
     return t; 
    } 

    public int getRowIndex() { 
     return rowIndex.intValue(); 
    } 

    public void setRowIndex(int rowIndex) { 
     this.rowIndex = Integer.valueOf(rowIndex); 
    } 

    public Object getWrappedData() { 
     throw new UnsupportedOperationException(); 
    } 

    public void setWrappedData(Object data) { 
     throw new UnsupportedOperationException(); 
    } 

    public boolean isRowAvailable() { 
     return getRowData() != null; 
    } 

    public void reset() { 
     wrappedKeys = null; 
     wrappedData.clear(); 
     rowCount = null; 
     rowIndex = Integer.valueOf(-1); 
     rowKey = null; 
    } 

    public DataProvider getDataProvider() { 
     return dataProvider; 
    } 

    public void setDataProvider(DataProvider dataProvider) { 
     this.dataProvider = dataProvider; 
    } 

    @Override 
    public void modify(List<FilterField> filterFields, List<SortField2> sortFields) { 
     this.filterFields = filterFields; 
     this.sortFields = sortFields; 

     reset(); 
    } 
} 

Et vous avez aussi besoin d'une coutume DataProvider

public class PagingDataProvider implements DataProvider<BeanDisplay>, 
     Sortable2, Filterable 

Dans la méthode getItemsByRange le chargement de votre requête seulement un nombre limité d'enregistrements. Toutes les autres méthodes devraient être simples à mettre en œuvre (je ne suis pas coller notre code, car il est plein code tout à fait spécifique, qui ne concerne pas)

Et vous construisez votre modèle de données comme suit:

new PagingExtendedTableDataModel<BeanDisplay>(new PagingDataProvider());