【后端结合】新程序猿笔记Day15(商品分类实现)（京淘项目）_商品分类实现后端

1. 商品分类实现

1.1 优化商品分类列表

1.1.1 优化策略

数据结构: Map<parentId, 当前父级下的子级>
例子:
Map<0, 所有的一级菜单>
Map<一级ID, 当前一级下的二级菜单>
Map<二级ID, 当前二级下的三级菜单>

设计的优势:
如果将数据保存到Map集合中,则可以有效的降低数据库的访问的次数. 提高查询效率.

 1.1.2 封装Map集合

/**
     * 思路:
     *      1.判断map集合中是否存在key
     *      2.如果key 不存在 准备一个新list集合,将自己作为第一个元素添加
     *      3.如果key 存 在  获取list集合,将自己追加.
     * @return
     */
    public Map<Integer,List<ItemCat>> getMap(){
        Map<Integer,List<ItemCat>> map = new HashMap<>();
        //1.查询数据库的所有的记录
        List<ItemCat> list = itemCatMapper.selectList(null);
        for(ItemCat itemCat : list){
            int key = itemCat.getParentId();
            if(map.containsKey(key)){ //true 有数据
                map.get(key).add(itemCat);
            }else{  //false 没有数据
                List<ItemCat> childrenList = new ArrayList<>();
                childrenList.add(itemCat);
                map.put(key,childrenList);
            }
        }
        return map;
    }

通过图:理解Map集合的作用

1.1.3 商品分类列表实现完整代码 

package com.jt.service;
 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.ItemCatMapper;
import com.jt.pojo.ItemCat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
@Service
public class ItemCatServiceImpl implements ItemCatService{
 
    @Autowired
    private ItemCatMapper itemCatMapper;
 
    /**
     * 思路:
     *      1.判断map集合中是否存在key
     *      2.如果key 不存在 准备一个新list集合,将自己作为第一个元素添加
     *      3.如果key 存 在  获取list集合,将自己追加.
     * @return
     */
    public Map<Integer,List<ItemCat>> getMap(){
        Map<Integer,List<ItemCat>> map = new HashMap<>();
        //1.查询数据库的所有的记录
        List<ItemCat> list = itemCatMapper.selectList(null);
        for(ItemCat itemCat : list){
            int key = itemCat.getParentId();
            if(map.containsKey(key)){ //true 有数据 将自己追加
                map.get(key).add(itemCat);
            }else{  //false 没有数据  准备新集合,添加数据
                List<ItemCat> childrenList = new ArrayList<>();
                childrenList.add(itemCat);
                map.put(key,childrenList);
            }
        }
        return map;
    }
 
    //level 1/2/3
    @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long startTime = System.currentTimeMillis();
        //1.获取数据信息
        Map<Integer,List<ItemCat>> map = getMap();
        if(level == 1){ //只获取一级菜单数据
            return map.get(0);
        }
 
        if(level == 2){ //获取1-2级数据
            return getTwoList(map);
        }
 
        List<ItemCat> list = getThreeList(map);
        long endTime = System.currentTimeMillis();
        System.out.println("业务执行耗时:"+(endTime - startTime)+"毫秒");
        //获取1-2-3级数据
        return list;
    }
 
    private List<ItemCat> getThreeList(Map<Integer, List<ItemCat>> map) {
        //1.获取一级和二级数据
        List<ItemCat> oneList = getTwoList(map);
        for (ItemCat oneItemCat : oneList){
            List<ItemCat> twoList = oneItemCat.getChildren();
            if(twoList == null){
                //说明 该一级下没有二级数据.所以跳过本次循环进入下一次
                continue;
            }
            for(ItemCat twoItemCat : twoList){
                //查询三级数据,使用二级的Id
                int key = twoItemCat.getId();
                List<ItemCat> threeList = map.get(key);
                twoItemCat.setChildren(threeList);
            }
        }
        return oneList;
    }
 
    //获取1-2
    private List<ItemCat> getTwoList(Map<Integer, List<ItemCat>> map) {
        //获取一级数据
        List<ItemCat> oneList = map.get(0);
        for(ItemCat oneItemCat : oneList){
            //根据一级ID查询二级集合
            int key = oneItemCat.getId();
            List<ItemCat> twoList = map.get(key);
            //将二级数据封装到一级中
            oneItemCat.setChildren(twoList);
        }
        return oneList;
    }
 
 
    /**
     * 只查询一级菜单  parent_id=0 或者 level=1
     * 查询二级菜单信息 parent_id = 一级ID
     * 查询三级菜单信息 parent_id = 二级ID
     * 思考: 如何优化代码   要求查询时间最好 控制在20ms+-
     * @param level
     * @return
     */
   /* @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long startTime = System.currentTimeMillis();
        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id",0);
        List<ItemCat> oneList = itemCatMapper.selectList(queryWrapper);
        for (ItemCat oneItemCat : oneList){
            //获取一级对象的ID
            int oneId = oneItemCat.getId();
            //清空多余的条件
            queryWrapper.clear();
            //查询二级数据
            queryWrapper.eq("parent_id",oneId);
            List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);
            //获取3级菜单信息
            for(ItemCat twoItemCat : twoList){
                int twoId = twoItemCat.getId();
                queryWrapper.clear();
                queryWrapper.eq("parent_id",twoId);
                List<ItemCat> threeList = itemCatMapper.selectList(queryWrapper);
                //将三级数据封装到二级对象中
                twoItemCat.setChildren(threeList);
            }
            //将二级封装到一级对象中
            oneItemCat.setChildren(twoList);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("业务调用耗时:"+(endTime - startTime)+"毫秒");
        return oneList;
    }*/
}
 

1.2 商品分类新增

1.2.1 业务接口说明

• 请求路径: /itemCat/saveItemCat
• 请求类型: post
• 请求参数: 表单数据

• 返回值: SysResult对象

1.2.2 前端页面URL请求 

1.页面请求

2.页面传递的JSON串 

1.2.3 编辑ItemCatController 

 /**
     * 业务需求:
     *   实现商品分类新增操作
     *   url地址: /itemCat/saveItemCat
     *   参数:    JSON串
     *   提交方式: post
     *   返回值:  SysResult对象
     */
    @PostMapping("/saveItemCat")
    public SysResult saveItemCat(@RequestBody ItemCat itemCat){
 
        itemCatService.saveItemCat(itemCat);
        return SysResult.success();
    }

1.2.4 编辑ItemCatService

/**
     * 有些数据应该提前填充 status/创建时间/修改时间
     * @param itemCat
     */
    @Override
    @Transactional  //事务注解
    public void saveItemCat(ItemCat itemCat) {
        itemCat.setStatus(true)
                .setCreated(new Date())
                .setUpdated(itemCat.getCreated());
        itemCatMapper.insert(itemCat);
    }

1.3 数据自动填充 

1.3.1 官网介绍

1.3.2 编辑自动填充项 

1.3.3 配置自动填充功能 

说明: 在com.jt.config 中编辑配置类

//将该类交给Spring容器管理
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
 
    @Override
    public void insertFill(MetaObject metaObject) {
        Date date = new Date();
        this.setFieldValByName("created",date,metaObject);
        this.setFieldValByName("updated",date,metaObject);
    }
 
    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updated",new Date(),metaObject);
    }
}

1.4 商品分类删除

1.4.1 业务说明

当用户删除商品分类的时候,应该将它的子级数据全部删除.

• 请求路径: /itemCat/deleteItemCat
• 请求类型: delete
• 业务描述: 当删除节点为父级时,应该删除自身和所有的子节点
• 请求参数:

• 返回值结果 SysResult对象

 1.4.2 编辑ItemCatController

/**
     * 业务说明: 删除商品分类数据
     * URL地址: /itemCat/deleteItemCat
     * 参数:    id/level
     * 返回值:  SysResult对象
     */
    @DeleteMapping("/deleteItemCat")
    public SysResult deleteItemCat(ItemCat itemCat){
 
        itemCatService.deleteItemCat(itemCat);
        return SysResult.success();
    }

1.4.3 编辑ItemCatService 

 /**
     * 删除的思路:
     *      1.判断是否为3级  如果是直接删除
     *      2.判断是否为2级  如果是2级,先删除三级,再删除2级
     *      3.如果是1级,先查询2级,再删除3级/2级/1级
     * @param itemCat
     */
    @Override
    @Transactional
    public void deleteItemCat(ItemCat itemCat) {
        if(itemCat.getLevel() == 3){
            itemCatMapper.deleteById(itemCat.getId());
            return ;
        }
 
        if(itemCat.getLevel() == 2){
            int twoId = itemCat.getId();
            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id",twoId);
            //删除的是三级数据
            itemCatMapper.delete(queryWrapper);
            itemCatMapper.deleteById(twoId);
            return ;
        }
 
        //执行到这里 只剩下一级菜单
        //1.应该先查询二级id
        int oneId = itemCat.getId();
        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id",oneId);
        List twoIdList = itemCatMapper.selectObjs(queryWrapper);
        if(twoIdList.size() == 0){
            //如果没有二级数据,则直接删除一级信息
            itemCatMapper.deleteById(oneId);
        }else{
            //表示有二级,可以删除三级
            //思考: 如何快速删除 三级/二级/一级??
            //Sql: delete from item_cat where parent_id in (xx,xx,xx)
            //     or id in (xxx,xxx,xx,oneId)
            queryWrapper.clear();
            queryWrapper.in("parent_id",twoIdList)
                        .or()
                        .in("id",twoIdList)
                        .or()
                        .eq("id",oneId);
            itemCatMapper.delete(queryWrapper);
        }
    }