Question

从表面我有......

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

------------ EDIT -------------

来自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不使用泛型。

Answer 1

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

Answer 2

您正在收到警告，因为您正在转换为原始类型LazyRetiDataModel。我建议改为：

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

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

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

Answer 3

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

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

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

java generics primefaces

正确使用泛型

3 个答案: