Question

目前，我正在编写一个程序，其中有以下语句。

List<BaseballStatistic> q = BaseballStatistic.FIND.where().eq("teamID", "CHN").query();

在这里，它抱怨

未经检查的分配：从“ java.util.List”到“ java.util.List”。原因：'BaseballStatistic.FIND.where（）。eq（“ teamID”，“ CHN”）'具有原始类型，因此查询结果会被删除更多...

我有一个看起来像这样的界面

public interface Query<T> {
  ...
  List<T> execute();
}

然后是实现此接口的抽象类

public abstract class AbstractQuery<T> implements Query<T> {
  Statement _statement = null;
  String _tableName;
  List<Clause> _clauses;
  Class<T> _type;

AbstractQuery(Class<T> type) {
  _type = type;
  _clauses = new ArrayList<>();
  _tableName = type.getAnnotation(Table.class).name();
}

...
public abstract List<T> execute();
}

最后是一个具体的实现：

public class SimpleQuery<T> extends AbstractQuery<T> {

public SimpleQuery(Class<T> type) {
  super(type);
}

其中包含以下.query函数，如下所示：

@Override
public List<T> execute() {
try {
  JSONObject jsonObject = Peanut.getClient().listStatistics(buildQuery());

  if (jsonObject == null || !jsonObject.has("results")) {
    return Collections.emptyList();
  }

  JSONArray columnNames = jsonObject.getJSONArray("columns");

  Map<String, Integer> columnNameMap = new HashMap<>();
  for (int i = 0; i < columnNames.length(); i++) {
    columnNameMap.put((String) columnNames.get(i), i);
  }

  JSONArray results = jsonObject.getJSONArray("results");

  List<T> ts = new ArrayList<>();
  for (int i = 0; i < results.length(); i++) {
    JSONArray result = results.getJSONArray(i);
    T t = _type.newInstance();
    for (Field field : ObjectUtils.getFieldsUpTo(t.getClass(), PinotModel.class)) {
      if (field.getAnnotation(Column.class) == null) {
        continue;
      }

      Object obj = ObjectUtils.getDefaultValue(field.getType());
      String columnName = field.getAnnotation(Column.class).name();

      if (columnNameMap.containsKey(columnName)) {
        int idx = columnNameMap.get(columnName);
        field.setAccessible(true);
        field.set(t, ObjectUtils.convertObject(obj, result.get(idx)));
      }
    }
    ts.add(t);
  }
  return ts;
} catch (Exception e) {
  // TODO: Throw Peanut specific error.
  Peanut.LOG.error(e);
  return Collections.emptyList();
}
}

似乎在这里，在编译时，返回的列表丢失了导致警告的类型。如果我将原始变量声明更改为List，则警告将消失，这很有意义。

反正还是存在一个更大的基本问题？

编辑：

调用执行的查询功能在这里

 public List<T> query() {
   return _query.execute();
 }

SimpleQuery与BaseballStatistic.Find之间的关系如下。

@Table(name = "baseballStats")
public class BaseballStatistic extends PinotModel {

  public static final Find FIND = new Find<BaseballStatistic (BaseballStatistic.class) { };
...

和PinotModel看起来像

public class PinotModel {
  public static class Find<T> {
    private final Class<T> type;

  protected Find(Class<T> type) {
    this.type = type;
  }

  public Query select(String... s) {
    return new SimpleQuery<T>(type).select(s);
  }

  public Clause where() {
    return new SimpleQuery<T>(type).where();
  }

  public Clause limit(Integer n) {
    return new SimpleQuery<T>(type).limit(n);
  }

  public Clause top(Integer n) {
    return new SimpleQuery<T>(type).top(n);
  }

  public Clause orderBy(String columnName, Order o) {
    return new SimpleQuery<T>(type).orderBy(columnName, o);
  }

  public String tableName() {
    return new SimpleQuery<T>(type).getTableName();
  }
 }
}

Answer 1

有2个地方缺少通用类型参数。

BaseballStatistic.FIND：

public static final Find<BaseballStatistic> FIND = new Find<BaseballStatistic> (BaseballStatistic.class) { };
PinotModel.select：

public Query<T> select(String... s) { return new SimpleQuery<T>(type).select(s); }

您还缺少PinotModel.where()上的类型参数。 Clause还需要一个类型参数，包括AbstractQuery._clauses字段上的

。

Java类型擦除，带有未检查分配的通用列表

1 个答案: