实例化java收集器<；行，列表>；从vertx重新激活调用准备好的语句

我正在尝试使用读取数据库并获取对象列表。我准备了以下方法

public <T> Future<List<T>> queryForList(String query, Tuple parameters,
                                        Collector<Row, ?, List<T>> collector) {
    Promise<List<T>> promise = Promise.promise();
    this.pgPool.preparedQuery(query, parameters, collector, ar -> {
        if (ar.succeeded()) {
            SqlResult<List<T>> result = (SqlResult<List<T>>) ar.result();
            if (result.rowCount() == 0) {
                promise.complete(Collections.emptyList());
                    return;
                }
                promise.complete((List<T>)result.value());
            } else {
                log.warn("Query execution failed. sql: {}, message: {}", 
                          query, ar.cause().getMessage());
                promise.fail(convertPgException(ar.cause()));
            }
        });
        return promise.future();
    }

public Future queryForList（字符串查询、元组参数、，
收集器（收集器）{
允诺，允诺；
this.pgPool.preparedQuery（查询、参数、收集器、ar->{
如果（ar.successed（））{
SqlResult=（SqlResult）ar.result（）；
如果（result.rowCount（）==0）{
promise.complete（Collections.emptyList（））；
返回；
}
promise.complete（（列表）result.value（））；
}否则{
warn（“查询执行失败。sql:{}，消息：{}”，
查询，ar.cause（）.getMessage（））；
承诺失败（convertPgException（ar.cause（））；
}
});
回报承诺。未来（）；
}

但是我很难为这个方法创建测试。我需要定义一个收集器传递给下面的测试用例，因为在下面的测试行中安装收集器有困难

@Test                                                                                                                 
public void returnsAsListUsingCollectors(TestContext ctx) {                                                                                                                                                                                 
    Collector<Row, ?, List<Temp>> collector = Collector.of(
        DataCollector::list,
        DataCollector::accept,
        DataCollector::combine,
        DataMapper::apply,
        DataCollector::charactoristics);

    this.subject.queryForList("select id,data from test_table where id in ($1, $2)",
                             Tuple.of(1, 2), collector)       
                             .setHandler(ctx.asyncAssertSuccess(res -> { 
                                 //verification of elements                                                               
                             }));                                                                                                      

}                                                                                                                     

@测试
public void returnsListUsingCollector（TestContext ctx）{
收集器收集器=Collector.of(
DataCollector:：list，
DataCollector:：接受，
DataCollector:：combine，
DataMapper:：apply，
DataCollector:：Characteristics）；
this.subject.queryForList（“选择id，来自test_表的数据，其中id位于（$1，$2）”，
（1，2，收集器）的元组
.setHandler（ctx.asyncAssertSuccess（res->{
//要素核查
}));                                                                                                      
}                                                                                                                     

以下方法用于数据收集和数据映射。我得到“无法解析应用”编译错误

class DataMapper implements Function {                          

    @Override                                                   
    public Object apply(Object o) {                             
        String data = ((Row)o).getString("data");               
        String extra = ((Row)o).getString("extra");             
        return new Temp(extra, data);                           
    }                                                           
}                                                               

class Temp {                                                    
    String extra;                                             
    String data;                                              

    public Temp(String extra, String data){                     
          this.data = data;                                     
          this.extra = extra;                                   
    }                                                         
}                                                               

class DataCollector {                                           

    private List<Temp> tempList = new ArrayList<>();                                                                     

    public void accept(Temp o) {                                
        tempList.add(o);                                        
    }                                                           

    DataCollector combine(DataCollector collector){             
        this.tempList.addAll(collector.list());                 
        return this;                                            
    }                                                           

    public List<Temp> list(){                                   
        return this.tempList;                                   
    }                                                           

    public Set<Collector.Characteristics> charactoristics(){    
        return Collections.emptySet();                          
    }                                                           
}                                                               

类数据映射器实现函数{
@凌驾
公共对象应用（对象o）{
字符串数据=（（行）o）.getString（“数据”）；
字符串额外=（（行）o）.getString（“额外”）；
返回新的温度（额外、数据）；
}                                                           
}                                                               
类临时{
额外的字符串；
字符串数据；
公共临时（字符串额外，字符串数据）{
这个数据=数据；
这个.额外的=额外的；
}                                                         
}                                                               
类数据收集器{
private List templast=new ArrayList（）；
公共无效接受（临时o）{
圣殿骑士。添加（o）；
}                                                           
DataCollector组合（DataCollector收集器）{
this.templast.addAll（collector.list（））；
归还这个；
}                                                           
公共列表（）{
把这个还给圣堂武士；
}                                                           
公共集特征（）
返回集合；
}                                                           
}                                                               

让我们从这里慢慢开始。首先，生成原始类始终是一个糟糕的想法，如果您知道您正在从

行

转换为

临时

，请将其指定为：

static class DataMapper implements Function<Row, Temp> {

    @Override
    public Temp apply(Row o) {
        String data = o.getString("data");
        String extra = o.getString("extra");
        return new Temp(extra, data);
    }
}

然后，养成将构造函数中设置的字段声明为

final

的好习惯：

static class Temp {

    private final String extra;
    private final String data;

    public Temp(String extra, String data) {
        this.data = data;
        this.extra = extra;
    }
}

您面临的主要问题是定义这个定制收集器，而您的工作过于复杂。如果要使用

Collector:：of

，则必须查看其

行的定义？列表

。这基本上是说：我将把一些

行

s（一次打开）作为输入，并将它们转换为

列表

。这就是你所关心的。因此，您的收集器可以定义为：

 Collector<Row, ?, List<Temp>> collector =
        Collector.of(ArrayList::new,
                     (list, element) -> list.add(DataMapper.apply(element)),
                     (left, right) -> {
                         left.addAll(right);
                         return left;
                     },
                     Characteristics.IDENTITY_FINISH
 );

收集器=
Collector.of（ArrayList:：new，
（list，element）->list.add（DataMapper.apply（element）），
（左，右）->{
左。addAll（右）；
左转；
},
特性.标识
);

让我们从这里慢慢开始。首先，生成原始类始终是一个糟糕的想法，如果您知道您正在从

行

转换为

临时

，请将其指定为：

static class DataMapper implements Function<Row, Temp> {

    @Override
    public Temp apply(Row o) {
        String data = o.getString("data");
        String extra = o.getString("extra");
        return new Temp(extra, data);
    }
}

然后，养成良好习惯，将在构造中设置的字段声明为

final