1
2
3
4
5
6
7
8
9
10
11
12
@Configuration
public class CorsConfig implements WebMvcConfigurer {

   @Override
   public void addCorsMappings(CorsRegistry registry) {
       registry.addMapping("/**")
           .allowedOrigins("*")
           .allowCredentials(true)
           .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
           .maxAge(3600);
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        IPage<CategoryEntity> page = this.page(
                new Query<CategoryEntity>().getPage(params),
                new QueryWrapper<CategoryEntity>()
        );
        return new PageUtils(page);
    }

    @Override
    public List<CategoryEntity> ListTree() {
        // 先取出所有数据,再组装成map: id -> 分类对象
        LinkedList<CategoryEntity> categoryList = new LinkedList<>(baseMapper.selectList(null));
        Map<Long, CategoryEntity> map = categoryList.stream().collect(Collectors.toMap(CategoryEntity::getId, e -> e));
        ListTree(map, 1);
        List<CategoryEntity> list = map.values().stream()
                .filter(e -> e.getCatLevel().equals(1)).collect(Collectors.toList());
        return list;
    }

    /**
     * 按深度层级遍历, 组装子分类到父分类的childCategories属性中
     *
     * @param map      所有分类信息map: id -- 分类对象
     * @param catLevel 初始分类等级, 值为1时, 组装全部分类层级
     */
    private void ListTree(Map<Long, CategoryEntity> map, Integer catLevel) {
        List<CategoryEntity> levelCategories = map.values().stream()
                .filter(e -> e.getCatLevel().equals(catLevel))
                // 根据排序字段排序
                .sorted(Comparator.comparingInt(CategoryEntity::getSort))
                .collect(Collectors.toList());
        if (!CollectionUtils.isEmpty(levelCategories)) {
            // 分类深度递归遍历, 1->2->3
            for (CategoryEntity levelCategory : levelCategories) {
                // 如果有父分类,则加入到父分类中
                CategoryEntity parent = map.get(levelCategory.getParentId());
                if (parent != null) {
                    if (parent.getChildCategories() == null) {
                        parent.setChildCategories(new ArrayList<>());
                    }
                    parent.getChildCategories().add(levelCategory);
                }
            }
            ListTree(map, catLevel + 1);
        }
    } 

1
2
3
4
@TableName(value = "commodity_category",excludeProperty = {"childCategories"})
或者
@TableField(exist = false)
private List<CategoryEntity> childCategories;

1
2
3
4
5
/**
* 0 不显示，1 显示
*/
@TableLogic(value = "1", delval = "0")
private Integer isShow;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;
import org.springframework.web.cors.reactive.CorsWebFilter;
@Configuration
public class GatewayCorsConfiguration {
    @Bean
    public CorsWebFilter corsWebFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        // 配置跨域请求头
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.setAllowCredentials(true);
        source.registerCorsConfiguration("/**",corsConfiguration);
        return new CorsWebFilter(source);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
@Data
@TableName("commodity_brand")
public class BrandEntity implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * id
     */
    @TableId
    private Long id;
    /**
     * 品牌名
     */
    @NotBlank(message = "品牌名称必须填写")
    private String name;
    /**
     * logo
     */
    @NotBlank(message = "logo不能为空")
    @URL(message = "logo不是一个合法的URL")
    private String logo;
    /**
     * 说明
     */
    private String description;
    /**
     * 显示
     */
    @TableField("isShow")
    @NotNull(message = "显示状态不能为空")
    private Integer isShow;
    /**
     * 检索首字母
     */
    @NotBlank(message = "检索首字母不能为空")
    @Pattern(regexp = "^[a-zA-Z]$", message = "检索首字母必须a-z或者A-Z并且长度为1")
    private String firstLetter;
    /**
     * 排序
     */
    @NotNull(message = "排序值不能为空")
    @Range(min = 0, message = "排序值必须是大于等于0的整数")
    private Integer sort;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@RequestMapping("/save")
public R save(@Validated @RequestBody BrandEntity brand, BindingResult result) {
    if (result.hasFieldErrors()) {
        // 创建一个map, 用于收集校验错误, 返回给前端
        Map<String, String> map = new HashMap<>();
        result.getFieldErrors().forEach((item -> {
            String field = item.getField();
            String errorMessage = item.getDefaultMessage();
            map.put(field, errorMessage);
        }));
        return R.error(400, "品牌表单数据校验错误").put("data", map);
    } else {
        brandService.save(brand);
        return R.ok();
    }
}

1
2
3
4
5
6
7
8
9
10
/**
* 保存
* 交给全局异常处理数据校验
*/
@RequestMapping("/save")
// @RequiresPermissions("commodity:brand:save")
public R save(@Validated @RequestBody BrandEntity brand) {
  brandService.save(brand);
  return R.ok();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Slf4j
// 表示只处理controller包下抛出的异常
@ControllerAdvice(basePackages = {"org.xxx.jjmallv2.commodity.controller"})
@ResponseBody
public class MallExceptionControllerAdvice {
    // 捕获异常,并获取错误消息
    // 注意只有MethodArgumentNotValidException异常类可以获取 BindResult中的错误信息
    @ExceptionHandler({MethodArgumentNotValidException.class})
    public R handleValidException(MethodArgumentNotValidException e) {
        BindingResult result = e.getBindingResult();
        Map<String, String> errorMap = new HashMap<>();
        result.getFieldErrors().forEach(item -> {
            errorMap.put(item.getField(), item.getDefaultMessage());
        });
        log.error("数据校验出现异常{} 异常类型是{}", e.getMessage(), e.getClass());
        return R.error(400, "方法参数异常").put("data", errorMap);
    }
}

1
2
3
4
5
6
7
8
// 说明: 如欧冠按照业务逻辑, 需要精确匹配异常/错误, 可以再写具体细化的处理方法

// 处理没有精确匹配的异常/错误, 相当于兜底措施
// 返回一个统一信息, 方便前端展示一个友好信息
@ExceptionHandler({Throwable.class})
public R handlerOthersException(Throwable throwable) {
    return R.error(40000, "系统未知错误");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
@Getter
public enum MallCodeEnum {
    UNKNOWN_EXCEPTION(40000, "系统未知异常"),
    INVALID_EXCEPTION(40001, "参数校验异常");

    private int code;
    private String msg;

    MallCodeEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}

1
2
3
4
@ExceptionHandler({Throwable.class})
public R handlerOthersException(Throwable throwable) {
    return R.error(MallCodeEnum.UNKNOWN_EXCEPTION.getCode(), MallCodeEnum.UNKNOWN_EXCEPTION.getMsg());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@Data
@TableName("commodity_brand")
public class BrandEntity implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * id
     */
    @TableId
    @NotNull(message = "修改时要求id不能为空", groups = {UpdateGroup.class})
    @Null(message = "新增时id必须为空", groups = {SaveGroup.class})
    private Long id;
    /**
     * 品牌名
     * 注解@NotBlank在两个组SaveGroup和SaveGroup都生效
     */
    @NotBlank(message = "品牌名称必须填写", groups = {SaveGroup.class, UpdateGroup.class})
    private String name;
    /**
     * logo
     */
    @NotBlank(message = "logo不能为空", groups = {SaveGroup.class})
    @URL(message = "logo不是一个合法的URL", groups = {SaveGroup.class, UpdateGroup.class})
    private String logo;
    /**
     * 说明
     */
    private String description;
    /**
     * 显示
     */
    @TableField("isShow")
    @NotNull(message = "显示状态不能为空", groups = {SaveGroup.class, UpdateGroup.class})
    private Integer isShow;
    /**
     * 检索首字母
     */
    @NotBlank(message = "检索首字母不能为空", groups = {SaveGroup.class})
    @Pattern(regexp = "^[a-zA-Z]$", message = "检索首字母必须a-z或者A-Z并且长度为1", groups = {SaveGroup.class, UpdateGroup.class})
    private String firstLetter;
    /**
     * 排序
     */
    @NotNull(message = "排序值不能为空", groups = {SaveGroup.class})
    @Range(min = 0, message = "排序值必须是大于等于0的整数", groups = {SaveGroup.class, UpdateGroup.class})
    private Integer sort;
}

1
2
3
4
5
6
7
8
9
10
/**
 * 保存
 * 交给全局异常处理数据校验
 * 注解: @Validated({SaveGroup.class} 表示进行参数校验时使用SaveGroup规则
 */
@RequestMapping("/save")
public R save(@Validated({SaveGroup.class}) @RequestBody BrandEntity brand) {
    brandService.save(brand);
    return R.ok();
}

1
2
public interface SaveGroup {}
public interface UpdateGroup {}

1
2
3
4
5
1. 如果我们的 Controller 指定的分组校验,比如:
public R update(@Validated({UpdateGroup.class}) @RequestBody BrandEntity brand){}
2. 但是我们的 Entity 没有指定的使用哪个分组校验, 则该校验注解就失效了, 比如:
@NotBlank(message = "品牌名不能为空") private String name;
那么@NotBlank 注解 在添加和修改时，都是无效的.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 自定义注解参考的 @NotNull源码
 *
 * @Constraint(validatedBy = {?}) ?可以指定该注意注解和哪个校验器关联
 * String message() default "{?}"; 指定校验时, 返回的信息,放在resources/ValidationMessages.properties中
 */
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = {EnumConstraintValidator.class})
public @interface EnumValidate {
    String message() default "{org.xxx.jjmallv2.common.valid.EnumConstraintValidator.message}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    int[] values() default {};
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// EnumConstraintValidator是真正的校验器, 实现校验的逻辑
// 需要实现接口ConstraintValidator
// ConstraintValidator<EnumValidate,Integer> 表示是针对注解EnumValidate传来的Integer值校验
public class EnumConstraintValidator implements ConstraintValidator<EnumValidate, Integer> {
    private Set<Integer> set = new HashSet<>();

    @Override
    public boolean isValid(Integer integer, ConstraintValidatorContext constraintValidatorContext) {
        return set.contains(integer);
    }

    @Override
    public void initialize(EnumValidate anno) {
        // @EnumValidate(values = {0, 1},...)
        int[] values = anno.values();
        for (int value : values) {
            set.add(value);
        }
        System.out.println("自定义注解EnumValidate的values值: " + Arrays.toString(values));
    }
}

1
2
3
4
5
6
7
8
/**
 * 显示状态
 */
@TableField("isShow")
@NotNull(message = "显示状态不能为空", groups = {SaveGroup.class, UpdateGroup.class})
// @Pattern(regexp = "^(0|1)$", message = "显示状态只能是1或0") 正则对整数不起作用
@EnumValidate(values = {0, 1}, message = "显示状态只能是1或0", groups = {SaveGroup.class, UpdateGroup.class})
private Integer isShow;

1
@Validated({UpdateGroup.class}) @RequestBody BrandEntity brand

1
2
3
4
5
6
7
8
9
/**
* 修改
* 注解: 修改状态, 只校验id和isShow的值
*/
@RequestMapping("/update/isShow")
public R updateIsShow(@Validated({UpdateIsShowGroup.class}) @RequestBody BrandEntity brand) {
    brandService.updateById(brand);
    return R.ok();
}

1
2
3
4
5
6
7
8
9
10
/**
 * 根据categoryId 查询
 */
@RequestMapping("/list/{categoryId}")
// @RequiresPermissions("commodity:attrgroup:list")
public R listByCategoryId(@RequestParam Map<String, Object> params,
                          @PathVariable(name = "categoryId", required = false) Long categoryId) {
    PageUtils page = attrgroupService.queryPage(params, categoryId);
    return R.ok().put("page", page);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public PageUtils queryPage(Map<String, Object> params, Long categoryId) {
    // 封装查询条件
    QueryWrapper<AttrgroupEntity> queryWrapper = new QueryWrapper<>();
    // 获取前端传入的前端检索关键字 "key", 
    // 查(id=key or name like %key%) and category_id = categoryId
    String key = (String) params.get("key");
    if (StringUtils.hasText(key)) {
        queryWrapper.and(qw -> qw.eq("id", key).or().like("name", key));
    }
    // 处理categoryId查询条件
    // 设置业务规则: categoryId ==0, 表示查询条件不携带categoryId
    if (categoryId != 0) {
        queryWrapper.eq("category_id", categoryId);
    }
    IPage<AttrgroupEntity> page = this.page(
            new Query<AttrgroupEntity>().getPage(params),
            queryWrapper);
    return new PageUtils(page);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Configuration
public class MybatisPlusConfig {
    /**
     * 添加分页插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 分页拦截器
        PaginationInnerInterceptor pi = new PaginationInnerInterceptor(DbType.MYSQL);
        // 处理页数溢出,默认设置为第一页
        pi.setOverflow(true);
        pi.setMaxLimit(100L);

        interceptor.addInnerInterceptor(pi); // 如果配置多个插件, 切记分页最后添加
        // 如果有多数据源可以不配具体类型, 否则都建议配上具体的 DbType
        return interceptor;
    }
}

1
2
3
4
5
 /**
     * 还要初始化级联选择器的值, 需要一个分类层级id的数组
     */
    @TableField(exist = false)
    private Long[] categoryIds;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
     * 根据子id 查询所有父id
     * 例如: 传入三级id 202, 返回 [1,22,202]
     *
     * @return 分类id数组
     */
@Override
public Long[] getIdsByChildId(Long childId) {
  List<CategoryEntity> list = baseMapper.selectList(null);
  CategoryEntity childCategory = list.stream()
    .filter(category -> category.getId().equals(childId))
    .findFirst().orElse(null);
  List<Long> idList = new ArrayList<>();
  getIdsByChildId(list, childCategory, idList);
  return idList.toArray(new Long[0]);
}
// 递归方法
private void getIdsByChildId(List<CategoryEntity> list, CategoryEntity child, List<Long> idList) {
  if (child == null) {
    return;
  }
  idList.add(0, child.getId());
  // 父分类: 层级+1 且chid.parentId= parent.Id
  CategoryEntity parent = list.stream().filter(category ->
                                               category.getCatLevel().equals(child.getCatLevel() - 1)
                                               && category.getId().equals(child.getParentId())
                                              ).findFirst().orElse(null);
  // 递归
  getIdsByChildId(list, parent, idList);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Override
@Transactional
public boolean saveAttrAndRelation(AttrEntity attr) {
    Assert.notNull(attr, "属性对象不能为空");
    Assert.notNull(attr.getAttrGroupId(), "分组id不能为空");
    Assert.notNull(attr.getAttrType(), "属性类型不能为空");
    // 校验attrGroup是否存在
    AttrgroupEntity attrgroupEntity = attrgroupService.queryById(attr.getAttrGroupId());
    // Assert.notNull(attrgroupEntity, "属性组不存在 attrGroupId=" + attr.getAttrGroupId());
    // 保存基本属性 attrType=1
    if (attr.getAttrType().equals(1) && attrgroupEntity != null) {
        // 保存属性
        this.save(attr);
        // 保存属性和属性组关联
        AttrAttrgroupRelationEntity attrAttrgroupRelationEntity = new AttrAttrgroupRelationEntity();
        attrAttrgroupRelationEntity.setAttrGroupId(attrgroupEntity.getId());
        attrAttrgroupRelationEntity.setAttrId(attr.getId());
        // 设置默认排序为0
        attrAttrgroupRelationEntity.setAttrSort(0L);
        attrAttrgroupRelationService.save(attrAttrgroupRelationEntity);
    }
    return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@Override
@Transactional(rollbackFor = Exception.class)
public boolean updateAttrAndRelationById(AttrEntity attr) {
    Assert.notNull(attr, "属性对象不能为空");
    Assert.notNull(attr.getId(), "属性id不能为空");
    Long attrGroupId = attr.getAttrGroupId();
    if (attrGroupId != null) {
        // 校验attrGroup是否存在
        AttrgroupEntity attrgroupEntity = attrgroupService.queryById(attr.getAttrGroupId());
        Assert.notNull(attrgroupEntity, "属性组不存在 attrGroupId=" + attr.getAttrGroupId());
        // 先删除旧的关联
        attrAttrgroupRelationService.
                remove(new LambdaQueryWrapper<AttrAttrgroupRelationEntity>()
                        .eq(AttrAttrgroupRelationEntity::getAttrId, attr.getId()));
        // 保存属性和属性组关联
        AttrAttrgroupRelationEntity attrAttrgroupRelationEntity = new AttrAttrgroupRelationEntity();
        attrAttrgroupRelationEntity.setAttrGroupId(attrgroupEntity.getId());
        attrAttrgroupRelationEntity.setAttrId(attr.getId());
        // 设置默认排序为0
        attrAttrgroupRelationEntity.setAttrSort(0L);
        attrAttrgroupRelationService.save(attrAttrgroupRelationEntity);
    }
    // 保存属性
    this.updateById(attr);
    return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * 设置业务规则: categoryId ==0, 表示查询条件不携带categoryId
 * 基本属性的分页检索
 * http://localhost:5050/api/commodity/attr/listByCategoryId/301?page=1&limit=10&key=test&categoryId=301
 * @param params     params
 * @param categoryId categoryId
 * @return page
 */
@Override
public PageUtils queryPageByCategoryId(Map<String, Object> params, Long categoryId) {
    LambdaQueryWrapper<AttrEntity> lw = new LambdaQueryWrapper<>();
    // key是搜索关键字, 可以为id或者name
    String key = (String) params.get("key");
    // categoryId ==0, 表示查询条件不携带categoryId
    // select * from commodity_attr where (category_id = ? AND (id = ? OR attr_name LIKE ?)) LIMIT ?
    lw.eq(categoryId != null && !categoryId.equals(0L), AttrEntity::getCategoryId, categoryId)
            .and(StringUtils.hasText(key),
                    item -> item.eq(AttrEntity::getId, key).or().like(AttrEntity::getAttrName, key));
    IPage<AttrEntity> page = this.page(
            new Query<AttrEntity>().getPage(params),
            lw);
    return new PageUtils(page);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 /**
     * 构造二级分类, 三级分类
     * Map<String,List<Catalog2Vo>>
     * map: catalog1Id --> List<Catalog2Vo>
     */
    @Override
    public Map<String, List<Catalog2Vo>> getCatalog2Map() {
        List<CategoryEntity> treeList = ListTree();
        Map<String, List<Catalog2Vo>> map = treeList.stream()
                .collect(Collectors.toMap(category -> category.getId().toString(), item1 -> {
                    System.out.println(item1.getId() + "#" + item1.getName());
                    List<CategoryEntity> child2Categories = item1.getChildCategories();
                    if (!CollectionUtils.isEmpty(child2Categories)) {
                        List<Catalog2Vo> catalog2VoList = child2Categories.stream().map(item2 -> {
                            System.out.println("\t"+item2.getId() + "##" + item2.getName());
                            Catalog2Vo catalog2Vo = new Catalog2Vo();
                            catalog2Vo.setCatalog1Id(item1.getId().toString());
                            catalog2Vo.setName(item2.getName());
                            catalog2Vo.setId(item2.getId().toString());
                            List<CategoryEntity> child3Categories = item2.getChildCategories();
                            if (!CollectionUtils.isEmpty(child3Categories)) {
                                List<Catalog2Vo.Catalog3Vo> catalog3VoList = child3Categories.stream().map(item3 -> {
                                    System.out.println("\t\t"+item3.getId() + "###" + item3.getName());
                                    Catalog2Vo.Catalog3Vo catalog3Vo = new Catalog2Vo.Catalog3Vo();
                                    catalog3Vo.setCatalog2Id(item2.getId().toString());
                                    catalog3Vo.setName(item3.getName());
                                    catalog3Vo.setId(item3.getId().toString());
                                    return catalog3Vo;
                                }).collect(Collectors.toList());
                                catalog2Vo.setCatalog3VoList(catalog3VoList);
                            }
                            return catalog2Vo;
                        }).collect(Collectors.toList());
                        return catalog2VoList;
                    }
                    return new ArrayList<>();
                }));
        return map;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    /**
     * 搜索数据: 条件+分页查询
     * url: http://localhost:9090/list.html?catalog3Id=717&limit=4&page=4
     * limit 每页容量
     * page 第几页
     */
    @RequestMapping("/list.html")
    @SuppressWarnings("unchecked")
    public String searchList(@RequestParam Map<String, Object> params, Model model) {
        PageUtils pageUtils = skuInfoService.queryWebPage(params);
        SearchResultVo searchResultVo = new SearchResultVo();
        searchResultVo.setSkuList((List<SkuInfoEntity>) pageUtils.getList());
        searchResultVo.setTotal(pageUtils.getTotalCount());
        searchResultVo.setTotalPages(pageUtils.getTotalPage());
        searchResultVo.setPageNum(pageUtils.getCurrPage());
        // 构造分页导航条[1,2,3,4,5,..,]
        searchResultVo.setPageNavs(IntStream.range(1, pageUtils.getTotalPage() + 1).boxed().collect(Collectors.toList()));
        model.addAttribute("skuPage", searchResultVo);
        log.info("searchResultVo=\n{}", searchResultVo);
        return "list";
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// http://localhost:9090/list.html?keyword=显卡&catalog3Id=301&brandId=1
    // 增加 spu状态判断
    @Override
    public SearchResultVo queryWebPage(Map<String, Object> params) {
        String keyword = (String) params.get("keyword");
        String categoryId = (String) params.get("catalog3Id");
        String brandId = (String) params.get("brandId");

        // 只展示发布状态为上架的商品
        List<Long> statusUpIds = new LambdaQueryChainWrapper<>(spuInfoDao)
                .eq(SpuInfoEntity::getPublishStatus, 1)
                .list().stream()
                .map(SpuInfoEntity::getId)
                .collect(Collectors.toList());
        //  如果没有上架的商品,直接返回了
        if (CollectionUtils.isEmpty(statusUpIds)) {
            // 返回一个空数据
            SearchResultVo searchResultVo = new SearchResultVo();
            searchResultVo.setSkuList(new ArrayList<>());
            searchResultVo.setTotal(0L);
            searchResultVo.setTotalPages(0L);
            searchResultVo.setPageNum(1L);
            searchResultVo.setPageNavs(new ArrayList<>());
            return searchResultVo;
        }

        LambdaQueryWrapper<SkuInfoEntity> lw = new LambdaQueryWrapper<>();
        lw.eq(StringUtils.hasText(categoryId) && !categoryId.equals("0"), SkuInfoEntity::getCatalogId, categoryId)
                .eq(StringUtils.hasText(brandId) && !brandId.equals("0"), SkuInfoEntity::getBrandId, brandId)
                .and(StringUtils.hasText(keyword), item -> item.eq(SkuInfoEntity::getSkuId, keyword).or().like(SkuInfoEntity::getSkuName, keyword))
                .in(!CollectionUtils.isEmpty(statusUpIds), SkuInfoEntity::getSpuId, statusUpIds);


        IPage<SkuInfoEntity> page = this.page(
                new Query<SkuInfoEntity>().getPage(params),
                lw
        );
        SearchResultVo searchResultVo = new SearchResultVo();
        searchResultVo.setSkuList(page.getRecords());
        searchResultVo.setTotal(page.getTotal());
        searchResultVo.setTotalPages(page.getPages());
        searchResultVo.setPageNum(page.getCurrent());
        // 构造分页导航条[1,2,3,4,5,..,]
        searchResultVo.setPageNavs(LongStream.range(1L, page.getPages() + 1).boxed().collect(Collectors.toList()));
        return searchResultVo;
    }