mybatis多层嵌套集合不规则表来源字段会随着主表的id合并覆盖部分的问题

拼搏现实的明天。 2022-12-10 08:39 14阅读 0赞

从resultmap中看出以下sqlt\_product\_category为主表聚合，其前后的表是副表 ，sql，都需要id,

pos\_menu\_version等其他不在有id的集合中（mybaits根据字段的表前缀，结合集合id，以表为单位聚合，不再集合单位中的字段，由于没有id会随着主从表这些有表单位聚合覆盖），此时只能把整个结果集拉平不用集合属性概念，这样就会有很多重复行，此时可用java8的分类，去重实现用java组装嵌套，去重（key-value），再分类（以此key字段分类）,通过分类key获取前面的value再组装见方式2

我们sql中查询的字段是扁平的，用collection+实体的id来组合嵌套关系，一个层次中一个id区分，某一个层次一个id区分不了的字段（  
一对多，应另起集合collection，否则会覆盖只取一条），扁平化的也可用java分类构建层级关系不用collection

<collection>   
        collection里面多条也只会有一条记录聚合  
      嵌套方式：  标签里用了sql，就需要主键映射，主键作为集合查询的条件  
      表连接方式： join 式的sql  
      上两种方式：collection需要id或者能区分行之间不同的列作为属性之一，这个标签根据行的hash判断重复的合并，不同的显示

1，

<select id="getCategoryListAndProductOnline" resultMap="templateCategoryAndProductResultForOnlineALL">  
        SELECT  
    pc.id,  
    pc.data\_version,  
    mvd.pos\_menu\_version,  
    mvd.sequence\_no,  
    cp.template\_id,  
    mvd.channel\_group\_code,  
    mvd.channel\_code,  
    mvd.date\_type,  
    mvd.daypart,  
    cp.dimension\_id,  
    cp.category\_id,  
    mvd.configed\_channel\_code,  
    mvd.configed\_date\_type\_code,  
    mvd.configed\_daypart\_code,  
    pc.\`name\` AS category\_name,  
    cp.product\_code,  
    p.id AS pid,  
    p.\`name\` AS product\_name,  
    cp.sort,  
    pc.selected\_image,  
    pc.unselected\_image,  
    pc.product\_big\_bg\_image,  
    pc.product\_small\_bg\_image,  
    pc.parent\_category\_id,  
    pc.is\_visible,  
    p.sales\_flag,  
    p.\`code\` AS pcode,  
    p.type AS product\_type,  
             tct.sales\_tag\_code,  
            mst.NAME tab\_name,  
            mst.image tab\_image,  
                    le.content as categoryNameEn

FROM  
    v\_menu\_version\_dimension mvd  
    INNER JOIN t\_template\_category\_product cp ON ( cp.data\_version = mvd.data\_version AND cp.template\_id = mvd.template\_id AND cp.dimension\_id = mvd.configed\_dimension\_id )  
    INNER JOIN t\_template\_category c ON (  
        c.data\_version = cp.data\_version  
        AND c.template\_id = cp.template\_id  
        AND c.dimension\_id = cp.dimension\_id  
        AND c.category\_id = cp.category\_id  
    )  
    INNER JOIN t\_product\_category pc ON ( pc.data\_version = cp.data\_version AND pc.category\_id = cp.category\_id )  
    INNER JOIN t\_product p ON ( p.data\_version = cp.data\_version AND p.\`code\` = cp.product\_code )  
     left join t\_template\_category\_tag tct  
        on c.data\_version = tct.data\_version  
        and c.template\_id = tct.template\_id  
        and c.dimension\_id = tct.dimension\_id  
        and c.category\_id = tct.category\_id  
        left join t\_master\_sales\_tag mst  
        on tct.sales\_tag\_code = mst.code  
        and mst.type = 1  
                 LEFT JOIN t\_international\_language le ON le.key\_code = pc.category\_id  
        AND le. LANGUAGE = 'en\_US'  
        AND le.field\_name = 'name'  
        AND le.table\_name = 't\_product\_category'  
         AND le.data\_version = pc.data\_version  
WHERE  
    mvd.pos\_menu\_version =\#\{posMenuVersion\}  
    AND mvd.sequence\_no =\#\{sequenceNo\}  
ORDER BY  
    mvd.channel\_group\_code,  
    mvd.template\_id,  
    mvd.channel\_code,  
    mvd.date\_type,  
    mvd.daypart,  
    c.sort,  
    cp.sort;  
    </select>

2，

//获取去重后的分类

List<CategoryDetailAllVO> demissionCategoryDetailAllDis = demissionCategoryDetailAllVos.stream().filter(distinctByKey(p -> p.getCategoryCode()))  
                                        .collect(Collectors.toList());  
                                if (null != demissionCategoryDetailAllDis && demissionCategoryDetailAllDis.size() > 0) \{  
                                    demissionCategoryDetailAllDis.stream().forEach(categoryDetailDisVo -> \{  
                                        CategoryDetailVO categoryDetailVo = new CategoryDetailVO();  
                                        BeanUtils.copyProperties(categoryDetailDisVo, categoryDetailVo);  
                                        demissionCategoryDetailMap.put(categoryDetailVo.getCategoryCode(), categoryDetailVo);  
                                    \});  
                                \}

//按照分类分组  遍历收集code,标签--操作结果集需一样  
                                Map<String, List<CategoryDetailAllVO>> demissionCategoryDetailAllMap = demissionCategoryDetailAllVos.stream().collect(Collectors.groupingBy(CategoryDetailAllVO::getCategoryCode));  
                                for (Map.Entry<String, List<CategoryDetailAllVO>> categoryDetailAllMap : demissionCategoryDetailAllMap.entrySet()) \{  
                                    String categoryKey = categoryDetailAllMap.getKey();  
                                    //当前分类下的商品  
                                    List<CategoryDetailAllVO> categoryDetailAlls = categoryDetailAllMap.getValue();  
                                    if (null != categoryDetailAlls) \{  
                                        //根据商品code去重

List<CategoryDetailAllVO> categoryProductDetailAllDis = categoryDetailAlls.stream().filter(distinctByKey(p -> p.getProductCode()))  
                                                .collect(Collectors.toList());  
                                        if (null != categoryProductDetailAllDis && categoryProductDetailAllDis.size() > 0) \{  
                                            //收集这分类下的商品  
                                            List<ProductVO> productVos = new ArrayList<>();  
                                            categoryProductDetailAllDis.stream().forEach(categoryProduct -> \{  
                                                ProductVO productVo = new ProductVO();  
                                                BeanUtils.copyProperties(categoryProduct, productVo);  
                                                productVos.add(productVo);  
                                            \});  
                                            //对应的分类  
                                            CategoryDetailVO categoryDetailVo = demissionCategoryDetailMap.get(categoryKey);  
                                            categoryDetailVo.setProductList(productVos);  
                                        \}  
                                        //根据分类标签去重  
                                        List<CategoryDetailAllVO> categorTagDetailAllDis = categoryDetailAlls.stream().filter(distinctByKey(p -> (p.getTagCode() == null ? "" : p.getTagCode())))  
                                                .collect(Collectors.toList());  
//                                    List<CategoryDetailAllVO> categorTagDetailAllDis = categoryDetailAlls.stream().collect(collectingAndThen(  
//                                            toCollection(() -> new TreeSet<>(Comparator.comparing(CategoryDetailAllVO::getTagCode))), ArrayList::new)  
//                                    );  
                                        if (null != categorTagDetailAllDis && categorTagDetailAllDis.size() > 0) \{  
                                            //收集这分类下的标签  
                                            List<TagVO> tagVos = new ArrayList<>();  
                                            categorTagDetailAllDis.stream().forEach(categorTagDetailAll -> \{  
                                                if (!"".equals(categorTagDetailAll.getTagCode())) \{  
                                                    TagVO tagVo = new TagVO();  
                                                    BeanUtils.copyProperties(categorTagDetailAll, tagVo);  
                                                    tagVos.add(tagVo);  
                                                \}

\});  
                                            //对应的分类  
                                            CategoryDetailVO categoryDetailVo = demissionCategoryDetailMap.get(categoryKey);  
                                            categoryDetailVo.setCategoryTagList(tagVos);  
                                        \}

\}  
                                \}