商品业务的实现（两级嵌套）
编辑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);
}
}