java - 如果返回的类型不是已知类型，如何使用 intoGroups() ？

Question

我有一个用例，通过连接两个表 ITEM 来构造结果。和ITEM_DESCRIPTION 。从那里我获取了几列，然后我希望将它们方便地转换为对象列表。就我而言，这些对象实际上是 DTO 对象，但当然它们也可以是业务对象。

这就是我现在正在做的方式:

public Map<Long, List<StoreItemDTO>> getItems(Long storeId) {

    LOGGER.debug("getItems");

    // Get all item_ids for the store

    SelectHavingStep<Record1<Long>> where = this.ctx
        .select(STORE_ITEM.ID)
        .from(STORE_ITEM)
        .where(STORE_ITEM.STORE_ID.eq(storeId))
        // GROUP BY store_item.id
        .groupBy(STORE_ITEM.ID);

    // Get all store_item_details according to the fetched item_ids

    TableLike<?> storeItemDetails = this.ctx
        .select(
                STORE_ITEM_DETAILS.ID,
                STORE_ITEM_DETAILS.STORE_ITEM_ID,
                STORE_ITEM_DETAILS.NAME,
                STORE_ITEM_DETAILS.DESCRIPTION,
                STORE_ITEM_DETAILS.STORE_LANGUAGE_ID
                )
        .from(STORE_ITEM_DETAILS)
        .where(STORE_ITEM_DETAILS.STORE_ITEM_ID.in(where))
        .asTable("storeItemDetails");

    // Join the result and use

    Field<Long> itemIdField = STORE_ITEM.ID.as("item_id");

    Result<?> fetch = this.ctx  
        .select(
                STORE_ITEM.ID.as("item_id"), 
                itemIdField,
                storeItemDetails.field(STORE_ITEM_DETAILS.ID),
                storeItemDetails.field(STORE_ITEM_DETAILS.NAME),
                storeItemDetails.field(STORE_ITEM_DETAILS.DESCRIPTION),
                storeItemDetails.field(STORE_ITEM_DETAILS.STORE_LANGUAGE_ID)                    
                )
        .from(STORE_ITEM)
        .join(storeItemDetails)
        .on(storeItemDetails.field(STORE_ITEM_DETAILS.STORE_ITEM_ID).eq(STORE_ITEM.ID))
        .fetch();

    Map<Long, ?> groups = fetch.intoGroups(STORE_ITEM.ID);

    return null;
} 

如您所见，结果应该是一个项目列表，其中每个项目都有不同语言的项目详细信息:

 StoreItemDTO
 - Long id
   // Maps language-id to item details
 - Map<Long, StoreItemDetails> itemDetails

 StoreItemDetails
 - Long id
 - String name
 - String description

我找不到 intoGroups() 的版本这将返回一个有用的类型。我可以想象有类似 Map<Long, List<Record>> 的东西但我无法做到这一点。

但是，有一个intoGroups(RecordMapper<? super R, K> keyMapper)这可能就是我正在寻找的东西。如果映射器还允许我将结果记录实际转换为自定义对象，如 MyCustomPojo然后我就可以很方便地检索和转换数据。我不知道这是否可能。像这样的东西:

public static class MyCustomPojo {
    public Long itemId; 
    // etc.
}

// ..

Map<Long, List<MyCustomPojo>> result = fetch.intoGroups(STORE_ITEM.ID, new RecordMapper<Record, List<MyCustomPojo>>() {
    @Override
    public List<MyCustomPojo> map(List<Record> record) {
        // 'record' is grouped by STORE_ITEM.ID
        // Now map each 'record' into every item of each group ..
        return resultList;
    }
}); 

但不幸的是编译器只允许

fetch.intoGroups(new RecordMapper<Record, Result<?>>() {
    @Override
    public Result<?> map(Record record) {
        return null;
    }
});

Answer 1

经过一番摆弄编译器后，事实证明这是可以完成的。

我不得不“作弊”一点，将我的结果 map 声明为匿名之外的最终，而我实际上并没有“使用 “keyMapper 参数，因为我只是返回 null。

这是我想到的:

public Map<Long, StoreItemDTO> getItems(Long storeId) {

    // Get all item_ids for the store

    SelectHavingStep<Record1<Long>> where = this.ctx
        .select(STORE_ITEM.ID)
        .from(STORE_ITEM)
        .where(STORE_ITEM.STORE_ID.eq(storeId))
        .groupBy(STORE_ITEM.ID);

    // Get all store_item_details according to the fetched item_ids

    TableLike<?> storeItemDetails = this.ctx
        .select(
                STORE_ITEM_DETAILS.ID,
                STORE_ITEM_DETAILS.STORE_ITEM_ID,
                STORE_ITEM_DETAILS.NAME,
                STORE_ITEM_DETAILS.DESCRIPTION,
                STORE_ITEM_DETAILS.STORE_LANGUAGE_ID
                )
        .from(STORE_ITEM_DETAILS)
        .where(STORE_ITEM_DETAILS.STORE_ITEM_ID.in(where))
        .asTable("storeItemDetails");

    // Join the result and use

    final Field<Long> itemIdField = STORE_ITEM.ID.as("item_id");

    Result<?> fetch = fetch = this.ctx
        .select(
                itemIdField,
                storeItemDetails.field(STORE_ITEM_DETAILS.ID),
                storeItemDetails.field(STORE_ITEM_DETAILS.NAME),
                storeItemDetails.field(STORE_ITEM_DETAILS.DESCRIPTION),
                storeItemDetails.field(STORE_ITEM_DETAILS.STORE_LANGUAGE_ID)
                )
        .from(STORE_ITEM)
        .join(storeItemDetails)
        .on(storeItemDetails.field(STORE_ITEM_DETAILS.STORE_ITEM_ID).eq(STORE_ITEM.ID))
        .fetch();

    final Map<Long, StoreItemDTO> itemIdToItemMap = new HashMap<>();

    fetch.intoGroups(
            record -> {
                Long itemDetailsId = record.getValue(STORE_ITEM_DETAILS.ID);
                // ... sake of compactness

                StoreItemDetailsDTO storeItemDetailsDto = new StoreItemDetailsDTO();
                storeItemDetailsDto.setId(itemDetailsId);
                // ... sake of compactness

                Long itemId = record.getValue(itemIdField);

                StoreItemDTO storeItemDto = new StoreItemDTO();
                storeItemDto.setId(itemId);
                storeItemDto.getItemDetailsTranslations().put(languageId, storeItemDetailsDto);

                StoreItemDTO itemDetailsList = itemIdToItemMap.get(itemId);

                if(itemDetailsList == null) {
                    itemDetailsList = new StoreItemDTO();
                    itemIdToItemMap.put(itemId, itemDetailsList);
                }

                itemDetailsList.getItemDetailsTranslations().put(languageId, storeItemDetailsDto);

                return null;
            });

    return itemIdToItemMap;
}

由于我不确定这是否是最优雅的解决方案，我仍然愿意接受建议，并愿意接受任何可以优雅地缩短此代码的答案 - 如果此时可能的话。 :)