谷粒商城—商品服务—三级分类（增删改查）（45～58）

一：实现目标：

                1）三级分类：

                2）表结构：

                3）

一.编写出 查出所有分类，以及子分类。以 树形结构 组装起来 的接口：

                1）创建用于 数据传输 的 VO 类（CategoryVo）：

@Data
public class CategoryVo {
    private static final long serialVersionUID = 1L;

    /**
     * 分类id
     */
    private Long catId;
......
    /**
     * 保存此菜单 所有子分类
     *
     * @JsonInclude(value = JsonInclude.Include.NON_EMPTY) 字段不为空时候才返回
     */
    @JsonInclude(value = JsonInclude.Include.NON_EMPTY)
    private List<CategoryVo> categoryChildrenVoList;

                2）Controller：

    /**
     * 查出所有分类，以及子分类，以 树形结构 组装起来
     */
    @RequestMapping("/listWithTree")
    public R listWithTree(@RequestParam Map<String, Object> params) {
        List<CategoryEntity> listWithTree = categoryService.listWithTree();
        return R.ok().put("data", listWithTree);
    }

                3）service：（1个实现类，一个查找子类方法）

    @Override
    public List<CategoryVo> listWithTree() {
        //1.查出所有分类
        List<CategoryEntity> list = categoryDao.selectList(null);
        List<CategoryVo> categoryVoList = list.stream().map(categoryEntity -> {
            CategoryVo categoryVo = new CategoryVo();
            BeanUtils.copyProperties(categoryEntity, categoryVo);
            return categoryVo;
        }).collect(Collectors.toList());

        //2.组装成父子的树形解构
        //2.1 查出所有的一级分类
        //2.2 查出子分类
        List<CategoryVo> collect = categoryVoList.stream()
                .filter(categoryVo -> {
                    return categoryVo.getCatLevel() == 1;
                }).map(categoryVo -> {
                    List<CategoryVo> childrensByCaregory = getChildrensByCaregory(categoryVo, categoryVoList);
                    categoryVo.setCategoryChildrenVoList(childrensByCaregory);
                    return categoryVo;
                }).sorted((o1, o2) -> {
                    return (o1.getSort() == null ? 0 : o1.getSort()) - (o2.getSort() == null ? 0 : o2.getSort());
                }).collect(Collectors.toList());

        return collect;
    }

    private List<CategoryVo> getChildrensByCaregory(CategoryVo baseCategoryVo, List<CategoryVo> allList) {

        List<CategoryVo> collect = allList.stream()
                .filter(categoryVo -> {
                    return categoryVo.getParentCid().equals(baseCategoryVo.getCatId());
                }).map(categoryVo -> {
                    //使用方法的 递归，找当前商品的子菜单
                    categoryVo.setCategoryChildrenVoList(getChildrensByCaregory(categoryVo, allList));
                    return categoryVo;
                }).sorted((CategoryVo o1, CategoryVo o2) -> {
                    return (o1.getSort() == null ? 0 : o1.getSort()) - (o2.getSort() == null ? 0 : o2.getSort());
                }).collect(Collectors.toList());

        return collect;

    }

                4）测试：（http://127.0.0.1:88/api/product/category/listWithTree）

 

二.设置 路由规则：

                1）修改网关项目的 yml：设置跨域：访问（http://127.0.0.1:9527/api/product/category/listWithTree）

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 114.215.173.88:8848

    gateway:
      routes:
        - id: product_route
          uri: lb://gulimail-product
          predicates:
            - Path=/api/product/**
          filters:
            - RewritePath=/api/(?<segment>/?.*), /$\{segment}

        - id: admin_route
          uri: lb://renren-fast
          predicates:
            - Path=/api/**
          filters:
            - RewritePath=/api/(?<segment>/?.*), /renren-fast/$\{segment}

 

 四.批量删除商品（逻辑删除）：

                1）设置删除为 逻辑删除：
                             a：在 Entity 类，标识 有效/无效 字段，加上注解：@TableLogic：

    /**
     * 是否显示[0-不显示，1显示]
     * 
     *     @TableLogic ： 标识 逻辑删除
     */
    @TableLogic
    private Integer showStatus;

                             b：在 yml 文件中，规定 。0：逻辑删除 / 1：逻辑不删除 

mybatis-plus:
  mapper-locations: classpath*:mapper/**/*.xml
  #主键自增
  global-config:
    db-config:
      id-type: auto
      logic-delete-value: 0
      logic-not-delete-value: 1

                2）发送请求：（ http://127.0.0.1:88/api/product/category/delete）

                 3）Controller：

    /**
     * 删除
     */
    @RequestMapping(value = "/delete",method = RequestMethod.POST)
    public R delete(@RequestBody Long[] catIds) {

        //检查当前的菜单，是否被被的地方引用
        categoryService.removeMenuByIds(Arrays.asList(catIds));

        return R.ok();
    }

                4）Service：

    @Override
    public void removeMenuByIds(List<Long> asList) {
        //TODO: 1.检查当前删除的菜单，是否被别的地方引用
        baseMapper.deleteBatchIds(asList);
    }

                5）Dao：

    /**
     * 删除（根据ID 批量删除）
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

                6）产生的 SQL：

UPDATE pms_category 
SET show_status = 0 
WHERE
	cat_id IN ( 1, 2, 3 ) 
	AND show_status =1