Sorting sortMode="；“多重”；而懒惰=”；“真的”；在<；p:dataTable>；在分页期间清除多排序元_Sorting_Jsf 2_Primefaces_Datatable_Lazy Loading

Sorting sortMode="；“多重”；而懒惰=”；“真的”；在<；p:dataTable>；在分页期间清除多排序元

sorting jsf-2 primefaces

Sorting sortMode="；“多重”；而懒惰=”；“真的”；在<；p:dataTable>；在分页期间清除多排序元,sorting,jsf-2,primefaces,datatable,lazy-loading,Sorting,Jsf 2,Primefaces,Datatable,Lazy Loading,我刚刚在showcase代码中为“”启用了多重排序 datatableLazy.xhtml <html lang="en" xmlns="http://www.w3.org/1999/xhtml" xmlns:f="http://java.sun.com/jsf/core" xmlns:h="http://java.sun.com/jsf/html" xmlns:p="http://primefaces.org/ui" xmlns:ui="http://java.sun.com/jsf/f

我刚刚在showcase代码中为“”启用了多重排序

datatableLazy.xhtml

<html lang="en" xmlns="http://www.w3.org/1999/xhtml"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:p="http://primefaces.org/ui"
xmlns:ui="http://java.sun.com/jsf/facelets">
<h:head>
<title>CarDataTable</title>
</h:head>
<h:body>
<h:form id="form">
    <p:dataTable var="car" value="#{tableBean.lazyModel}" paginator="true"
        rows="10"
        paginatorTemplate="{RowsPerPageDropdown} {FirstPageLink} {PreviousPageLink} {CurrentPageReport} {NextPageLink} {LastPageLink}"
        rowsPerPageTemplate="5,10,15" id="carTable" lazy="true"
        sortMode="multiple">

        <p:ajax event="rowSelect" listener="#{tableBean.onRowSelect}"
            update=":form:display" oncomplete="carDialog.show()" />

        <p:column headerText="Model" sortBy="#{car.model}"
            filterBy="#{car.model}">
            <h:outputText value="#{car.model}" />
        </p:column>

        <p:column headerText="Year" sortBy="#{car.year}"
            filterBy="#{car.year}">
            <h:outputText value="#{car.year}" />
        </p:column>

        <p:column headerText="Manufacturer" sortBy="#{car.manufacturer}"
            filterBy="#{car.manufacturer}">
            <h:outputText value="#{car.manufacturer}" />
        </p:column>

        <p:column headerText="Color" sortBy="#{car.color}"
            filterBy="#{car.color}">
            <h:outputText value="#{car.color}" />
        </p:column>
    </p:dataTable>
</h:form>
</h:body>
</html>

LazyCarDataModel.java

package com.solartis.primefaces.sample;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import javax.faces.bean.ManagedBean;

import org.primefaces.model.LazyDataModel;

@ManagedBean
public class TableBean {

private LazyDataModel<Car> lazyModel;

private Car selectedCar;

private List<Car> cars = new ArrayList<Car>();

private final static String[] colors;

private final static String[] manufacturers;

static {
    colors = new String[10];
    colors[0] = "Black";
    colors[1] = "White";
    colors[2] = "Green";
    colors[3] = "Red";
    colors[4] = "Blue";
    colors[5] = "Orange";
    colors[6] = "Silver";
    colors[7] = "Yellow";
    colors[8] = "Brown";
    colors[9] = "Maroon";

    manufacturers = new String[10];
    manufacturers[0] = "Mercedes";
    manufacturers[1] = "BMW";
    manufacturers[2] = "Volvo";
    manufacturers[3] = "Audi";
    manufacturers[4] = "Renault";
    manufacturers[5] = "Opel";
    manufacturers[6] = "Volkswagen";
    manufacturers[7] = "Chrysler";
    manufacturers[8] = "Ferrari";
    manufacturers[9] = "Ford";
}

public TableBean() {
    populateRandomCars(cars, 50);
    lazyModel = new LazyCarDataModel(cars);
}

public Car getSelectedCar() {
    return selectedCar;
}

public void setSelectedCar(Car selectedCar) {
    this.selectedCar = selectedCar;
}

public LazyDataModel<Car> getLazyModel() {
    return lazyModel;
}

private void populateRandomCars(List<Car> list, int size) {
    for (int i = 0; i < size; i++) {
        list.add(new Car(getRandomModel(), getRandomYear(),
                getRandomManufacturer(), getRandomColor()));
    }
}

private String getRandomColor() {
    return colors[(int) (Math.random() * 10)];
}

private String getRandomManufacturer() {
    return manufacturers[(int) (Math.random() * 10)];
}

private int getRandomYear() {
    return (int) (Math.random() * 50 + 1960);
}

private String getRandomModel() {
    return UUID.randomUUID().toString().substring(0, 8);
}
}

package com.solartis.primefaces.sample;

import java.util.ArrayList;

/**
 * Dummy implementation of LazyDataModel that uses a list to mimic a real 
   datasource like a database.
 */
public class LazyCarDataModel extends LazyDataModel<Car> {

private List<Car> datasource;

public LazyCarDataModel(List<Car> datasource) {
    this.datasource = datasource;
}

@Override
public Car getRowData(String rowKey) {
    for(Car car : datasource) {
        if(car.getModel().equals(rowKey))
            return car;
    }

    return null;
}

@Override
public void setRowIndex(int rowIndex) {

    if (rowIndex == -1 || getPageSize() == 0) {
        super.setRowIndex(-1);
    } else
        super.setRowIndex(rowIndex % getPageSize());
}

@Override
public Object getRowKey(Car car) {
    return car.getModel();
}

@Override
public List<Car> load(int first, int pageSize, 
                      List<SortMeta> multiSortMeta,Map<String, String> filters) {

    System.out.println("\nTHE INPUT PARAMETER VALUE OF LOAD METHOD :   
    \t"+"first=" + first + ", pagesize=" + pageSize + ", multiSortMeta=" + 
    multiSortMeta + " filter:" + filters);

    System.out.println("\nTHE MULTISORTMETA CONTENT  : \t");

    if (multiSortMeta != null) {
        for (SortMeta sortMeta : multiSortMeta) {
            System.out.println("SORTFIELD:" +sortMeta.getSortField());
            System.out.println("SORTORDER:" +sortMeta.getSortOrder());
                    System.out.println("SORTFUNCTION:"
                                                         +sortMeta.getSortFunction());
            System.out.println("COLUMN:" +sortMeta.getColumn());
            System.out.println("CLASS:" +sortMeta.getClass());
        }
    }

    List<Car> data = new ArrayList<Car>();

    //filter
    for(Car car : datasource) {
        boolean match = true;

        for(Iterator<String> it = filters.keySet().iterator(); it.hasNext();) {
            try {
                String filterProperty = it.next();
                String filterValue = filters.get(filterProperty);
                String fieldValue =  String.valueOf(car.getClass().
                                getField(filterProperty).get(car));

                if(filterValue == null || fieldValue.startsWith(filterValue)) {
                    match = true;
                }
                else {
                    match = false;
                    break;
                }
            } catch(Exception e) {
                match = false;
            } 
        }

        if(match) {
            data.add(car);
        }
    }


    //rowCount
    int dataSize = data.size();
    this.setRowCount(dataSize);

    //paginate
    if(dataSize > pageSize) {
        try {
            return data.subList(first, first + pageSize);
        }
        catch(IndexOutOfBoundsException e) {
            return data.subList(first, first + (dataSize % pageSize));
        }
    }
    else {
        return data;
    }
}
}

package com.solartis.primefaces.sample；
导入java.util.ArrayList；
/**
*LazyDataModel的虚拟实现，它使用一个列表来模拟真实的
像数据库一样的数据源。
*/
公共类LazyCardDataModel扩展了LazyDataModel{
私有列表数据源；
公共LazyCarDataModel（列表数据源）{
this.datasource=数据源；
}
@凌驾
公共汽车getRowData（字符串rowKey）{
for（汽车：数据源）{
if（car.getModel（）.equals（rowKey））
返回车；
}
返回null；
}
@凌驾
公共void setRowIndex（int-rowIndex）{
如果（rowIndex=-1 | | getPageSize（）==0）{
super.setRowIndex（-1）；
}否则
super.setRowIndex（rowIndex%getPageSize（））；
}
@凌驾
公共对象getRowKey（汽车）{
return car.getModel（）；
}
@凌驾
公共列表加载（int-first，int-pageSize，
列表多端口（元数据、映射过滤器）{
System.out.println（“\n加载方法的输入参数值：
\t“+”first=“+first+”，pagesize=“+pagesize+”，multiSortMeta=“+
multiSortMeta+“过滤器：”+过滤器）；
System.out.println（“\n多端口元数据内容：\t”）；
如果（multiSortMeta！=null）{
for（SortMeta SortMeta:MultiportMeta）{
System.out.println（“SORTFIELD:+sortMeta.getSortField（））；
System.out.println（“SORTORDER:+sortMeta.getSortOrder（））；
System.out.println（“排序函数：”
+getSortFunction（））；
System.out.println（“COLUMN:+sortMeta.getColumn（））；
System.out.println（“类：+sortMeta.getClass（））；
}
}
列表数据=新的ArrayList（）；
//滤器
for（汽车：数据源）{
布尔匹配=真；
for（Iterator it=filters.keySet（）.Iterator（）；it.hasNext（）；）{
试一试{
String filterProperty=it.next（）；
字符串filterValue=filters.get（filterProperty）；
String fieldValue=String.valueOf（car.getClass（）。
getField（filterProperty）.get（car））；
if（filterValue==null | | fieldValue.startsWith（filterValue））{
匹配=真；
}
否则{
匹配=假；
打破
}
}捕获（例外e）{
匹配=假；
} 
}
如果（匹配）{
数据。添加（car）；
}
}
//行数
int dataSize=data.size（）；
此.setRowCount（数据大小）；
//分页
如果（数据大小>页面大小）{
试一试{
返回数据。子列表（第一，第一+页面大小）；
}
catch（IndexOutOfBoundsException e）{
返回数据。子列表（第一，第一+（数据大小%pageSize））；
}
}
否则{
返回数据；
}
}
}

除了使用多列排序进行分页外，它工作得很好，与使用

String sortField的load（）
方法不同，使用List
的load（）方法不会为我提供当前已排序的列详细信息，这些列详细信息会传递到另一页，SortOrder SortOrder
，它提供了这些排序详细信息
例如：
单击“制造商”中的排序箭头，然后按住Ctrl键并单击“年份”的排序箭头

您将获得load（）
方法的排序列详细信息（我已经在load方法中打印了输入参数值）

现在，进行分页。这里的load（）
方法无法给出排序列的详细信息

不仅对于分页，如果在单击排序列后输入列筛选器值，也存在相同的问题

我如何解决这个问题？我临时解决了这个问题。。。
有一个sessionscoped托管bean，用于存储排序列的详细信息，以便在分页期间进入load（）中，
比如：-
@ManagedBean
@会议范围
公共类StoreSortColumnDetail实现可序列化{
/**保存多排序值**/
私有列表mMultiSortMeta；
公共列表getMultiSortMeta（）{
返回mMultiSortMeta；
}
public void setmultiportmeta（列出multiportmeta）{
mMultiSortMeta=multiSortMeta；
}
public void clearMultiSortMeta（）{
如果（this.mMultiSortMeta！=null）
这个.mMultiSortMeta.clear（）；
}
}

并在load（）中使用它，如下所示：
@Override
public List<Car> load(int first, int pageSize, 
                  List<SortMeta> multiSortMeta,Map<String, String> filters) {

/** Instance to the SessionScoped scoped StoreSortColumnDetail managed bean*/
@ManagedProperty(value="#{StoreSortColumnDetail }")
private StoreSortColumnDetail storeSortColumnDetail ;

public void setStoreSortColumnDetail (StoreSortColumnDetail sortColumnDetail ) {
    this.storeSortColumnDetail = sortColumnDetail ;
}

/** to hold the handled sort column detail**/
List<SortMeta> handledMultiSortMeta = new ArrayList<SortMeta>();

/*Here starts the multisortmeta handling process*/
   /** check for List<SortMeta> for null**/
if(multiSortMeta != null ) {

    /** updates StoreSortColumnDetail's List<SortMeta> with Load()'s List<SortMeta>**/
    storeSortColumnDetail.setMultiSortMeta(multiSortMeta);
    handledMultiSortMeta  = multiSortMeta;
} 
/** check for List<SortMeta> for notnull **/
else if (multiSortMeta == null) {

    /**assigns Load()'s List<SortMeta> with StoreSortColumnDetail's List<SortMeta>**/
    handledMultiSortMeta  = storeSortColumnDetail.getMultiSortMeta();
} 


   /*Now u have handled multisortmeta from load()...
     and u can process now from handledMultiSortMeta*/
}

@覆盖
公共列表加载（int-first，int-pageSize，
列表多端口（元数据、映射过滤器）{
/**SessionScoped作用域StoreSortColumnDetail托管bean的实例*/
@ManagedProperty（value=“#{StoreSortColumnDetail}”）
私有存储或列详细信息存储或列详细信息；
public void setStoreSortColumnDetail（存储区sortColumnDetail sortColumnDetail）{
this.storeSortColumnDetail=sortColumnDetail；
}
/**保存已处理的排序列详细信息的步骤**/
List handledMultiSortMeta=new ArrayList（）；
/*这里开始多端口元处理过程*/
/**检查列表是否为空**/
如果（multiSortMeta！=null）{
/**使用Load（）的列表更新StoreSortColumnDetail的列表**/
storeSortColumnDetail.setMultiSortMeta（multiSortMeta）；
handledMultiSortMeta=multiSortMeta；
} 
/**检查notnull的列表**/
else if（multiSortMeta==null）{
/**使用StoreSortColumnDetail的列表分配Load（）的列表**/
handledMultiSortMeta=storeSortColumnDetail.getMultiSortMeta（）；
} 
/*现在您已经从load（）处理了MultiportMeta。。。
您现在可以从HandledMultiportMeta进行处理*/
}

我希望你知道我是如何处理的，如果不是亲密的话。。。
但这是一种临时方法，需要通过primefaces方法处理…
@Override
public List<Car> load(int first, int pageSize, 
                  List<SortMeta> multiSortMeta,Map<String, String> filters) {

/** Instance to the SessionScoped scoped StoreSortColumnDetail managed bean*/
@ManagedProperty(value="#{StoreSortColumnDetail }")
private StoreSortColumnDetail storeSortColumnDetail ;

public void setStoreSortColumnDetail (StoreSortColumnDetail sortColumnDetail ) {
    this.storeSortColumnDetail = sortColumnDetail ;
}

/** to hold the handled sort column detail**/
List<SortMeta> handledMultiSortMeta = new ArrayList<SortMeta>();

/*Here starts the multisortmeta handling process*/
   /** check for List<SortMeta> for null**/
if(multiSortMeta != null ) {

    /** updates StoreSortColumnDetail's List<SortMeta> with Load()'s List<SortMeta>**/
    storeSortColumnDetail.setMultiSortMeta(multiSortMeta);
    handledMultiSortMeta  = multiSortMeta;
} 
/** check for List<SortMeta> for notnull **/
else if (multiSortMeta == null) {

    /**assigns Load()'s List<SortMeta> with StoreSortColumnDetail's List<SortMeta>**/
    handledMultiSortMeta  = storeSortColumnDetail.getMultiSortMeta();
} 


   /*Now u have handled multisortmeta from load()...
     and u can process now from handledMultiSortMeta*/
}


UIColumn sortColumn = sortMeta.getSortColumn()
if(sortColumn.isDynamic())
  ((DynamicColumn)sortColumn).applyStatelessModel();
//for single mode sorting
ValueExpression sortByVal = activeTable.getValueExpression("sortBy");
//multiColumn sorting 
ValueExpression sortByVal = sortColumn.getValueExpression("sortBy");
int caseSensitive = activeTable.isCaseSensitiveSort();
SortOrder order = sortMeta.getSortOrder();
MethodExpression exp = sortColumn.getSortFunction();
//pass required properties to constructor
//single mode sort
Collections.sort(filteredItems, new BeanPropertyComparator(......))
//for multi column sort use ChainedBeanPropertyComparator and add every new comparator to it than
Collections.sort(filteredItems, chainedComparator);