Jsf 2 在Primefaces 4&；中面临关键性能问题；5.

我正在从事一个处理大量数据集的项目。我使用的是PrimeFaces4和5、spring和hibernate。我必须显示一个非常庞大的数据集，例如最少3000行，100列，具有排序、筛选、行扩展等各种功能。我的问题是，我的应用程序需要8到10分钟来显示整个页面，以及其他功能（排序、筛选）也需要很多时间。我的客户一点也不高兴。不过，我可以使用分页来实现这一点，但我的客户机也不需要分页。因此，我决定使用livescroll，但不幸的是，我没能在有lazyload或没有lazyload的情况下实现livescroll，因为PF中有关于livescroll的bug。我之前也发布过这个问题，但没有找到解决方案

这个性能问题对我来说非常关键。要显示3000行100列，加载的页面大小约为10MB。 我已经计算了JSF的各个生命周期所消耗的时间，使用阶段侦听器我发现它的浏览器正在花时间解析JSF提供的响应。要完成所有阶段，我的申请只花了25秒。 至少我想提高我的项目的性能。请分享任何有助于克服这个问题的想法、建议和任何东西

注意：getter和setter中没有数据库操作，也没有复杂的业务逻辑

更新： 这是我的没有lazyload的数据表：

<p:dataTable 
                style="width:100%"
                id="cdTable"
                selection="#{controller.selectedArray}"
                resizableColumns="true" 
                draggableColumns="true" 
                var="cd"
                value="#{controller.cdDataModel}"
                editable="true" 
                editMode="cell"
                selectionMode="multiple"
                rowSelectMode="add"
                scrollable="true"
                scrollHeight="650"
                rowKey="#{cd.id}"
                rowIndexVar="rowIndex"
                styleClass="screenScrollStyle"
                liveScroll="true"
                scrollRows="50"
                filterEvent="enter"
                widgetVar="dt4"
                >

在这里，除了过滤，一切都正常。一旦我过滤，第一页就会显示出来，但无法在datatable上进行排序或动态滚动。请注意，我已在Primefaces5中测试了这一点

2次进近

具有相同数据表的lazyload 1） 当我添加rows=“100”livescroll时，会出现行编辑、行扩展问题，但过滤和排序工作正常。 2） 当我删除行时livescroll可以进行行编辑、行扩展等操作，但筛选和排序不起作用

我的懒散模式如下所示

public class MyDataModel extends LazyDataModel<YData> 
         {

    @Override
    public List<YData> load(int first, int pageSize,
            List<SortMeta> multiSortMeta, Map<String, Object> filters) {
        System.out.println("multisort wala load");
        return super.load(first, pageSize, multiSortMeta, filters);
    }



    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private List<YData> datasource;

    public YieldRecBondDataModel() {
    }

    public YieldRecBondDataModel(List<YData> datasource) {
         this.datasource = datasource;
    }




    @Override
    public YData getRowData(String rowKey) {
        // In a real app, a more efficient way like a query by rowKey should be
        // implemented to deal with huge data

    //  List<YData> yList = (List<YData>) getWrappedData();

        for (YData y : datasource) 
        {
            System.out.println("datasource :"+datasource.size());
            if(y.getId()!=null)
            {
            if (y.getId()==(new Long(rowKey)))
            {
                return y;
            }
            }
        }

        return null;
    }

    @Override
    public Object getRowKey(YData y) {
        return y.getId();
    }






      @Override
        public void setRowIndex(int rowIndex) {
            /*
             * The following is in ancestor (LazyDataModel):
             * this.rowIndex = rowIndex == -1 ? rowIndex : (rowIndex % pageSize);
             */
            if (rowIndex == -1 || getPageSize() == 0) {
                super.setRowIndex(-1);
            }
            else
                super.setRowIndex(rowIndex % getPageSize());
        }



      @Override
        public List<YData> load(int first, int pageSize, String sortField, SortOrder sortOrder, Map<String,Object> filters) {
            List<YData> data = new ArrayList<YData>();
            System.out.println("sort order : "+sortOrder);
            //filter
            for(YData yInfo : datasource) {
                boolean match = true;

                for(Iterator<String> it = filters.keySet().iterator(); it.hasNext();) {
                    try {
                        String filterProperty = it.next();
                        String filterValue = String.valueOf(filters.get(filterProperty));
                        Field yField = yInfo.getClass().getDeclaredField(filterProperty);
                        yField.setAccessible(true);
                        String fieldValue = String.valueOf(yField.get(yInfo));
                        if(filterValue == null || fieldValue.startsWith(filterValue)) {
                            match = true;
                        }
                        else {
                            match = false;
                            break;
                        }
                    } catch(Exception e) {
                        e.printStackTrace();
                        match = false;
                    }
                }

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

            //sort
            if(sortField != null) {
                Collections.sort(data, new LazySorter(sortField, sortOrder));
            }

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

            //paginate
            if(dataSize > pageSize) {
                try {

                    List<YData> subList = data.subList(first, first + pageSize);
                    return subList;
                }
                catch(IndexOutOfBoundsException e) {
                    return data.subList(first, first + (dataSize % pageSize));
                }
            }
            else
                return data;
        }

    @Override
    public int getRowCount() {
        // TODO Auto-generated method stub
        return super.getRowCount();
    }

    }

公共类MyDataModel扩展了LazyDataModel
{
@凌驾
公共列表加载（int-first，int-pageSize，
列表多端口（元数据、映射过滤器）{
System.out.println（“多端口wala加载”）；
返回super.load（第一，pageSize，multiportmeta，filters）；
}
/**
* 
*/
私有静态最终长serialVersionUID=1L；
私有列表数据源；
公共YieldRecBondDataModel（）{
}
公共YieldRecBondDataModel（列表数据源）{
this.datasource=数据源；
}
@凌驾
公共YData getRowData（字符串rowKey）{
//在真正的应用程序中，一种更有效的方法（如按rowKey查询）应该是
//实现了对海量数据的处理
//List yList=（List）getWrappedData（）；
用于（YData y:数据源）
{
System.out.println（“datasource:+datasource.size（））；
如果（y.getId（）！=null）
{
如果（y.getId（）==（新长（行键）））
{
返回y；
}
}
}
返回null；
}
@凌驾
公共对象getRowKey（YData y）{
返回y.getId（）；
}
@凌驾
公共void setRowIndex（int-rowIndex）{
/*
*在祖先（LazyDataModel）中有以下内容：
*this.rowIndex=rowIndex=-1？rowIndex：（rowIndex%pageSize）；
*/
如果（rowIndex=-1 | | getPageSize（）==0）{
super.setRowIndex（-1）；
}
其他的
super.setRowIndex（rowIndex%getPageSize（））；
}
@凌驾
公共列表加载（int-first、int-pageSize、字符串排序字段、排序器排序器、映射过滤器）{
列表数据=新的ArrayList（）；
System.out.println（“排序顺序：“+sortOrder”）；
//滤器
for（YData yInfo:数据源）{
布尔匹配=真；
for（Iterator it=filters.keySet（）.Iterator（）；it.hasNext（）；）{
试一试{
String filterProperty=it.next（）；
String filterValue=String.valueOf（filters.get（filterProperty））；
字段yField=yInfo.getClass（）.getDeclaredField（filterProperty）；
yField.setAccessible（true）；
String fieldValue=String.valueOf（yField.get（yInfo））；
if（filterValue==null | | fieldValue.startsWith（filterValue））{
匹配=真；
}
否则{
匹配=假；
打破
}
}捕获（例外e）{
e、 printStackTrace（）；
匹配=假；
}
}
如果（匹配）{
添加数据（yInfo）；
}
}
//分类
if（sortField！=null）{
分类（数据，新懒散分类机（sortField，sortOrder））；
}
int dataSize=data.size（）；
此.setRowCount（数据大小）；
//分页
如果（数据大小>页面大小）{
试一试{
列表子列表=数据。子列表（第一，第一+页面大小）；
返回子列表；
}
catch（IndexOutOfBoundsException e）{
返回数据。子列表（第一，第一+（数据大小%pageSize））；
}
}
其他的
返回数据；
}
@凌驾
public int getRowCount（）{
//TODO自动生成的方法存根
return super.getRowCo
 public class ElementiLazyDataModel extends LazyDataModel<T> implements Serializable {

        private Service<T> abstractFacade;


        public ElementiLazyDataModel(Service<T> abstractFacade) {
            this.abstractFacade = abstractFacade;

        }

        public Service<T> getAbstractFacade() {
            return abstractFacade;
        }

        public void setAbstractFacade(Service<T> abstractFacade) {
            this.abstractFacade = abstractFacade;
        }

        @Override
        public List<T> load(int first, int pageSize, String sortField, SortOrder sortOrder, Map<String, Object> filters) {
            PaginatedResult<T> pr = abstractFacade.findRange(new int[]{first, first + pageSize}, sortField, sortOrder, filters);

            setRowCount(new Long(pr.getTotalItems()).intValue());

            return pr.getItems();
        }

    }

@Override
    public PaginatedResult<T> findRange(int[] range, String sortField, SortOrder sortOrder, Map<String, Object> filters) {

        final Query query = getEntityManager().createQuery("select x from " + entityClass.getSimpleName() + " x")
                .setFirstResult(range[0]).setMaxResults(range[1] - range[0] + 1);

        // Add filter sort etc.

        final Query queryCount = getEntityManager().createQuery("select count(x) from " + entityClass.getSimpleName() + " x");
        // Add filter sort etc.

        Long rowCount = (Long) queryCount.getSingleResult();

        List<T> resultList = query.getResultList();

        return new PaginatedResult<T>(resultList, rowCount);
    }

public class PaginatedResult<T> implements Serializable {

    private List<T> items;
    private long totalItems;

    public PaginatedResult() {
    }

    public PaginatedResult(List<T> items, long totalItems) {
        this.items = items;
        this.totalItems = totalItems;
    }

    public List<T> getItems() {
        return items;
    }

    public void setItems(List<T> items) {
        this.items = items;
    }

    public long getTotalItems() {
        return totalItems;
    }

    public void setTotalItems(long totalItems) {
        this.totalItems = totalItems;
    }
}

String query = "select e from Entity e where lower(e.f1) like lower('" + filters.get(key) + "'%) and..., etc. for the other fields

query.append("order by ").append(sortField).append(" ").append(SortOrder.ASCENDING.name() ? "" : sortOrder.substring(0, 4)),..., etc. for the other columns.

Long totalCount = (Long) entityManager.createQuery("select count(*) from Entity e where lower(e.f1) like lower('filterKey1%') and lower(e.f2) like lower('filterKey2%') ...").getSingleResult();