查询分类业务

商品业务的实现（两级嵌套）

编辑ItemCatController

 /*商品分类修改

    请求路径: /itemCat/updateItemCat
    请求类型: put
    请求参数: 表单数据 ItemCat对象
    返回值: SysResult对象
    */
    @PutMapping("/updateItemCat")
    public SysResult updateItemCat(@RequestBody ItemCat itemCat){
        itemCatService.updateItemCat(itemCat);
        return SysResult.success();
    }

编辑ItemCatService

void updateStatus(ItemCat itemCat);

编辑ItemCatServiceImpl

public List<ItemCat> findItemCatList(Integer level) {
    //查询所有的parent_id为0的
    QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
    //查询所有的parent_id为0的 就是一级标题
    queryWrapper.eq("parent_id", 0);
    List<ItemCat> oenList = itemCatMapper.selectList(queryWrapper);
    //清空所有条件
    long start = System.currentTimeMillis();
    //遍历一级
    for (ItemCat onenItemCat : oenList) {
        queryWrapper.clear();
        queryWrapper.eq("parent_id", onenItemCat.getId());
        List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);

        for (ItemCat twoItemCat : twoList) {
            queryWrapper.clear();
            queryWrapper.eq("parent_id", twoItemCat.getId());
            List<ItemCat> threeList = itemCatMapper.selectList(queryWrapper);

            twoItemCat.setChildren(threeList);
        }

        onenItemCat.setChildren(twoList);
    }
    long end = System.currentTimeMillis();
    System.out.println("耗时："+(end - start));

    return oenList;
}

问题：

出现两层嵌套循环，完成需要多次查询数据库。

优化策略：

数据库只查询一次，就可以获取商品分类三级嵌套结构。

程序设计:
1.数据结构 Map<父级ID,子级列表> 列表信息中不包含嵌套关系
例如: Map<0,一级列表信息> 一级列表不包含二级/三级
Map<一级ID,二级列表信息> 只有2级列表 不包含3级
Map<二级ID,三级列表信息> 只有3级列表信息.
2.根据数据结构动态根据level查询子级.

Map集合知识

方法摘要：

方法摘要
void	clear()           从此映射中移除所有映射关系（可选操作）。
boolean	containsKey(Object key)           如果此映射包含指定键的映射关系，则返回 true。
boolean	containsValue(Object value)           如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>>	entrySet()           返回此映射中包含的映射关系的 Set 视图。
boolean	equals(Object o)           比较指定的对象与此映射是否相等。
V	get(Object key)           返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int	hashCode()           返回此映射的哈希码值。
boolean	isEmpty()           如果此映射未包含键-值映射关系，则返回 true。
Set<K>	keySet()           返回此映射中包含的键的 Set 视图。
V	put(K key, V value)           将指定的值与此映射中的指定键关联（可选操作）。
void	putAll(Map<? extends K,? extends V> m)           从指定映射中将所有映射关系复制到此映射中（可选操作）。
V	remove(Object key)           如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
int	size()           返回此映射中的键-值映射关系数。
Collection<V>	values()           返回此映射中包含的值的 Collection 视图。

Map—无序(不是collection的子接口)

 Map<K,V>,类型参数 : K - 表示此映射所维护的键 V – 表示此映射所维护的对应的值

Map中存放的数据是无序的数据

 Key值不可以重复,否则会覆盖.

Map的两种迭代方式:

方式一: 遍历map中的数据,但是map本身没有迭代器,所以需要转换成set集合.

Set<Key> :把map集合中的所有Key存到set集合中--keySet()

Set<Integer> keySet = m.keySet();

Iterator<Integer> it = keySet.iterator();

用Set 的迭代器进行迭代,通过遍历得到的key值使用—m.get(key);

获取对应的value;

方式二:遍历map中的数据,将map集合中的key和value作为一个Entry整体放入set-----m.entrySet();

 Set<Map.Entry<Integer, String>> e = m.entrySet();

 Iterator<Map.Entry<Integer, String>> e2 = e.iterator();

HashMap:        Map.Entry<Key,Value>

1.会拿到当前entry中的key作运算,得出当这个entry应该放在entry[]的哪个位置

 2.如果两个entry的key值经过运算余数相等表示这两个entry的数组下标一致就是hash冲突

 3. 当计算的位置,有数据时,会发生hash冲突/hash碰撞,解决的办法就是采用链表的结构,

Hashmap底层是数组Entry[]

数组+链表(链表长度<6时会再转回链表)

数组加红黑树(链表长度>8)

算法:hash(key)%n , n就是数组的长度,其实也就是集合的容量

当计算的位置没有数据的时候,会直接存放数据

当计算的位置,有数据时,会发生hash冲突/hash碰撞,解决的办法就是采用链表的结构

影响hashmap的查询效率

初始容量:约等于2倍的方式来扩容—初始容量16

加载因子:存到什么程度就扩容---0.75f

尽量避免rehashmap

优化：

编辑编辑ItemCatServiceImpl

     * 1.数据结构:  Map<K,V>  key=parentId   value="List<ItemCat>"
     * 2.封装Map的数据类型
     * 3.如果level=1 只获取一级.
     * 4.如果level=2 获取一级,一级嵌套二级
     * 5.如果level=3 获取一级,一级嵌套二级,二级嵌套三级.
 

 @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long startTime = System.currentTimeMillis();
        //1.封装Map集合
        Map<Integer,List<ItemCat>> map = getMap();

        //2.判断level的值
        if(level == 1){
        //查询key值等于0时，所映射的value
            return map.get(0);
        }

        if(level == 2){

            return getTwoList(map);
        }

        //如果level不是1-2级则一定是三级
        List<ItemCat> list = getThreeList(map);
        long endTime = System.currentTimeMillis();
        System.out.println("耗时:"+(endTime - startTime)+"毫秒");
        return list;
    }

getMap()

1.查询所有的商品分类列表，查询一次数据库

2.循环遍历所有的数据，按照parentId,list<ItemCat>方式封装数据。

 private Map<Integer, List<ItemCat>> getMap() {
        Map<Integer,List<ItemCat>> map = new HashMap<>();
        List<ItemCat> list = itemCatMapper.selectList(null);
        for(ItemCat itemCat : list){
            //获取parentId
            int parentId = itemCat.getParentId();
            if(map.containsKey(parentId)){
                //key存在
                //List<ItemCat> list1 = map.get(parentId);
                //list1.add(itemCat);
                map.get(parentId).add(itemCat);
            }else{
                //key不存在
                List<ItemCat> childrenList = new ArrayList<>();
                childrenList.add(itemCat);
                //将第一个元素封装到map中
                map.put(parentId,childrenList);
            }
        }
        return map;
    }

                                                        摘自（闪耀的太阳）

getTwoList()

1.先获取一级列表

2.遍历一级列表得到属性的id就是二级列表的oarentid

3.用map.get(parentId)得到二级列表

4.将二级列表封装到一级对象中

5.返回一级列表

 private List<ItemCat> getTwoList(Map<Integer, List<ItemCat>> map) {
        //1.先获取一级列表
        List<ItemCat> oneList = map.get(0);
        //2.根据一级查询二级
        for(ItemCat oneItemCat :oneList){
            //查询二级,所以parentId是一级的Id
            int parentId = oneItemCat.getId();
            List<ItemCat> twoList = map.get(parentId);
            //封装数据
            oneItemCat.setChildren(twoList);
        }
        return oneList;
    }

getThreeList()

二级相当于一个桥梁，如果这个二级没有，跳过本次循环接着查询

    private List<ItemCat> getThreeList(Map<Integer, List<ItemCat>> map) {
        //获取一级和二级
        List<ItemCat> oneList = getTwoList(map);
        //封装三级
        for(ItemCat oneItemCat : oneList){
            //获取二级集合
            List<ItemCat> twoList = oneItemCat.getChildren();
            if(twoList == null || twoList.size() == 0){
                System.out.println("执行跳过循环操作");
                //由于业务数据不合理,跳过本次循环,执行下一次
                continue;
            }
            for (ItemCat twoItemCat : twoList){
                //查询三级列表,需要parentId=二级Id
                int parentId = twoItemCat.getId();
                List<ItemCat> threeList = map.get(parentId);
                twoItemCat.setChildren(threeList);
            }
        }
        return oneList;
    }

删除多级列表

规则：

1.如果删除的商品分类是三级,则可以直接删除.
2.如果删除的商品分类是二级,则先删除三级,在删除二级.
3.如果删除的商品分类是一级,则先删除三级/二级/一级
注意事务的控制.

编辑ItemCatController

 /**
     * 业务需求: 实现商品分类删除
     * URL: /itemCat/deleteItemCat?id=xx&level=2
     * 参数: id/level
     * 返回值: SysResult对象
     */
    @DeleteMapping("/deleteItemCat")
    public SysResult deleteItemCats(ItemCat itemCat){

        itemCatService.deleteItemCats(itemCat);
        return SysResult.success();
    }

编辑ItemCatService

/**
     * 需求: 删除商品分类信息
     * 条件: 如果有子级,应该先删除子级.
     * Sql:
     *  DELETE FROM item_cat WHERE (parent_id IN (?,?) OR parent_id = ? OR id = ?)
     * @param itemCat
     */
    @Override
    @Transactional
    public void deleteItemCats(ItemCat itemCat) {
        int level = itemCat.getLevel();
        if(level == 3){
            //表示需要删除的数据是三级菜单,可以直接删除
            itemCatMapper.deleteById(itemCat.getId());
        }

        if(level == 2){
            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id",itemCat.getId())
                        .or()
                        .eq("id",itemCat.getId());
            itemCatMapper.delete(queryWrapper);
        }

        if(level == 1){
            //1.必须获取二级ID
            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id",itemCat.getId());
            //2获取结果的第一列字段(主键)  二级Id
            List twoIdsList = itemCatMapper.selectObjs(queryWrapper);

            //3.删除三级的数据
            queryWrapper.clear();
            //删除parent_id中包含二级Id的数据,实则删除的是三级数据
            queryWrapper.in(twoIdsList.size()>0,"parent_id",twoIdsList)
                        .or()
                        //删除parent_id 等于一级ID的,实则删除的是二级数据
                        .eq("parent_id",itemCat.getId())
                        .or()
                        //删除id=一级Id  则删除一级数据.
                        .eq("id",itemCat.getId() );
            itemCatMapper.delete(queryWrapper);
        }
    }