0

从primefaces我有..

public abstract class LazyDataModel<T> extends DataModel<T> implements SelectableDataModel<T>, Serializable {

- - - - - - 编辑 - - - - - - -

primefaces 的完整课程

/*
 * Copyright 2009-2012 Prime Teknoloji.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.primefaces.model;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import javax.faces.model.DataModel;

/**
 * Custom lazy loading DataModel to deal with huge datasets
 */
public abstract class LazyDataModel<T> extends DataModel<T> implements SelectableDataModel<T>, Serializable {

    private int rowIndex = -1;

    private int rowCount;

    private int pageSize;

    private List<T> data;

    public LazyDataModel() {
        super();
    }

    public boolean isRowAvailable() {
        if(data == null) {
            return false;
        }

        return rowIndex >= 0 && rowIndex < data.size();
    }

    public int getRowCount() {
        return rowCount;
    }

    public T getRowData() {
        return data.get(rowIndex);
    }

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

    public void setRowIndex(int rowIndex) {
        this.rowIndex = rowIndex == -1 ? rowIndex : (rowIndex % pageSize);
    }

    public Object getWrappedData() {
        return data;
    }
    public void setWrappedData(Object list) {
        this.data = (List) list;
    }

    public int getPageSize() {
        return pageSize;
    }
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public void setRowCount(int rowCount) {
        this.rowCount = rowCount;
    }

    public List<T> load(int first, int pageSize, String sortField, SortOrder sortOrder, Map<String,String> filters) {
        throw new UnsupportedOperationException("Lazy loading is not implemented.");
    }

    public List<T> load(int first, int pageSize, List<SortMeta> multiSortMeta, Map<String,String> filters) {
        throw new UnsupportedOperationException("Lazy loading is not implemented.");
    }

    public T getRowData(String rowKey) {
        throw new UnsupportedOperationException("getRowData(String rowKey) must be implemented when basic rowKey algorithm is not used.");
    }

    public Object getRowKey(T object) {
        throw new UnsupportedOperationException("getRowKey(T object) must be implemented when basic rowKey algorithm is not used.");
    }
}

-------------结束编辑---------

我创造了

public class LazyRetiDataModel<T> extends LazyDataModel<Rete> {

    public void setFilters( Map<String, String> filters ) {
        this.qbeFilters = filters;
    }
}

我必须使用惰性模型作为

 private LazyDataModel<Rete> lazyModel;
 lazyModel = new LazyRetiDataModel<>( cfgRetePstnTAB );

在我的代码中，我有

Map<String, String> mappa = ABAcus.createMap( p1,p2, p3, p4, p5);

if (lazyModel != null) {
            ((LazyRetiDataModel) lazyModel).setFilters( mappa );
}

我收到此警告

warning: [unchecked] unchecked call to setFilters(Map<String,String>) as a member of the raw type LazyRetiDataModel
                ((LazyRetiDataModel) lazyModel).setFilters( mappa );

对，因为LazyRetiDataModel<T> extends LazyDataModel<Rete> 我解决了 ((LazyRetiDataModel<?>) lazyModel).setFilters( mappa );

但是?是正确的。？

解决了正确的答案是

Tom Hawtin 提出的建议，Mark Peters 也用他的话改变了我的看法。我定义了

private LazyRetiDataModel lazyModel;

无论如何，Luiggi Mendoza 和 Paul Bellora 给了我一个关于泛型的重要想法，我认为类的正确定义是 

public class LazyRetiDataModel extends LazyDataModel<Rete> {

LazyRetiDataModel 不使用泛型。

4

3 回答 3

1

为什么public class LazyRetiDataModel<T>首先是通用的？它定义了超类的通用参数，如果这是它唯一的方法（setFilters），那么只需删除 . 更新：如果没有使用新定义的通用方法，则应将其删除。正如你所提到的，它覆盖了一些不能使用新的方法（如果我是正确的），所以我仍然认为你可能不需要新的 .

于 2013-06-04T14:45:28.630 回答
0

Tom Hawtin 提出的建议，Mark Peters 也用他的话改变了我的看法。我定义了

私有 LazyRetiDataModel 惰性模型；无论如何，Luiggi Mendoza 和 Paul Bellora 给了我一个关于泛型的重要想法，我认为类的正确定义是

public class LazyRetiDataModel extends LazyDataModel { LazyRetiDataModel 不使用泛型。

java泛型primefaces

于 2013-06-27T15:13:06.110 回答
0

您收到警告是因为您正在转换为 raw type LazyRetiDataModel。我会推荐以下内容：

if (lazyModel != null) {
    ((LazyRetiDataModel<Rete>)lazyModel).setFilters(mappa);
}

通常，这会导致未经检查的强制转换警告，但这实际上是该规则的一个例外，因为编译器已经知道泛型类型是Rete.

请注意，我也同意 Luiggi Mendoza 关于LazyRetiDataModel<T> extends LazyDataModel<Rete>可能是错字的评论 - 你想要LazyRetiDataModel<T> extends LazyDataModel<T>。

于 2013-06-04T14:28:35.727 回答