springboot多级分类源码

 
 
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.tree.Tree;
import cn.hutool.core.lang.tree.TreeNodeConfig;
import cn.hutool.core.lang.tree.TreeUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 
import org.springframework.beans.BeanUtils;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
 
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
 
/**
 *
 */
@Service
public class OaClassificationServiceImpl extends ServiceImpl<OaClassificationMapper, OaClassification>
        implements OaClassificationService {
    String slash = "/";
    String comma = ",";
    @Resource
    private OaClassificationMapper classificationMapper;
 
 
    @Override
    public Long createClassification(ClassificationCreateReqVO reqVO) {
        // 校验正确性
        Long parentId = reqVO.getParentId();
        checkCreateOrUpdate(null, parentId, reqVO.getName());
        // 插入分类
        OaClassification classifiction = new OaClassification();
        BeanUtils.copyProperties(reqVO, classifiction);
        setLevelDept(parentId, classifiction);
        classificationMapper.insert(classifiction);
        Long id = classifiction.getId();
        if (Objects.equals(classifiction.getParentId(), 0L)) {
            OaClassification update = new OaClassification();
            update.setId(id);
            update.setDethId(String.valueOf(id));
            classificationMapper.updateById(update);
        } else {
            OaClassification parentClass = classificationMapper.selectById(classifiction.getParentId());
            OaClassification update = new OaClassification();
            update.setId(id);
            update.setDethId(parentClass.getDethId().concat(slash).concat(String.valueOf(id)));
            classificationMapper.updateById(update);
        }
        return id;
    }
 
 
    @Override
    public void updateClassification(ClassificationUpdateReqVO reqVO) {
        Long id = reqVO.getId();
        Long parentId = reqVO.getParentId();
        // 校验正确性
        checkCreateOrUpdate(id, parentId, reqVO.getName());
        // 更新分类
        OaClassification updateObj = new OaClassification();
        BeanUtils.copyProperties(reqVO, updateObj);
        setLevelDept(parentId, updateObj);
        classificationMapper.updateById(updateObj);
        if (!Objects.equals(parentId, 0L)) {
            OaClassification parentClass = classificationMapper.selectById(parentId);
            OaClassification update = new OaClassification();
            update.setId(id);
            update.setDethId(parentClass.getDethId().concat(slash).concat(String.valueOf(id)));
            classificationMapper.updateById(update);
        }
        //修改是修改子分类名称
        reName(updateObj.getId());
    }
 
    /**
     * @param parentId      父级ID
     * @param classifiction
     */
    private void setLevelDept(Long parentId, OaClassification classifiction) {
        //如果不是一级分类插入层级、纵深
        if (parentId == null || Objects.equals(parentId, 0L)) {
            //设置层级
 
            classifiction.setParentId(0L);
            classifiction.setDethName(classifiction.getName());
            return;
        } else {
            OaClassification dbOaClassification = classificationMapper.selectById(parentId);
 
            //设置纵深
            String deth = dbOaClassification.getDeth();
            if (StrUtil.isEmpty(deth)) {
                classifiction.setDeth(String.valueOf(parentId));
            } else {
                classifiction.setDeth(deth.concat(comma).concat(String.valueOf(parentId)));
            }
            classifiction.setDethName(dbOaClassification.getDethName().concat("/").concat(classifiction.getName()));
        }
    }
 
    @Async
    public void reName(Long id) {
        List<OaClassification> classificationDOs = classificationMapper.selectByParentId(id);
        if (classificationDOs == null) {
            return;
        }
        //遍历子类
        classificationDOs.forEach((tem) -> {
            Long parentId = tem.getParentId();
            OaClassification dbOaClassification = classificationMapper.selectById(parentId);
            //设置层级
 
            //设置纵深
            String deth = dbOaClassification.getDeth();
            if (StrUtil.isEmpty(deth)) {
                tem.setDeth(String.valueOf(parentId));
            } else {
                tem.setDeth(deth.concat(comma).concat(String.valueOf(parentId)));
            }
            tem.setDethName(dbOaClassification.getDethName().concat(slash).concat(tem.getName()));
            tem.setDethId(dbOaClassification.getDethId().concat(slash).concat(tem.getId().toString()));
            classificationMapper.updateById(tem);
            reName(tem.getId());
        });
    }
 
    @Override
    public void deleteClassification(Long id) {
        // 校验是否存在
        checkClassificationExists(id);
        // 校验是否有子分类
        List<OaClassification> oaClassifications = classificationMapper.selectByParentId(id);
        if (!CollUtil.isEmpty(oaClassifications)) {
            throw new ServiceException("存在子分类，无法删除");
        }
 
        classificationMapper.deleteById(id);
    }
 
    @Override
    public List<OaClassification> getSimpleClassifications(ClassificationListReqVO reqVO) {
        return classificationMapper.selectPageList(reqVO);
    }
 
    @Override
    public List<Tree<Integer>> getSimpleClassificationsChildren() {
        // 获得项目分类列表，只要开启状态的
        ClassificationListReqVO reqVO = new ClassificationListReqVO();
        reqVO.setStatus(CommonStatusEnum.ENABLE.getStatus());
        List<OaClassification> list = getSimpleClassifications(reqVO);
 
        //配置
        TreeNodeConfig treeNodeConfig = new TreeNodeConfig();
        // 自定义属性名 都要默认值的
        // 排序字段，这个字段不能是null，不然会报错，默认最好是数字
        treeNodeConfig.setWeightKey("sort");
        treeNodeConfig.setIdKey("id");
        // 父级id字段
        treeNodeConfig.setParentIdKey("parentId");
        // 最大递归深度
        //treeNodeConfig.setDeep(3);
        //转换器
        List<Tree<Integer>> trees = TreeUtil.build(list, 0, treeNodeConfig, ((object, treeNode) -> {
            treeNode.setId(object.getId().intValue());//id
            treeNode.setParentId(object.getParentId().intValue());//父id
            treeNode.putExtra("name", object.getName());
        }));
        return trees;
    }
 
    @Override
    public void getClassiByParentId(List<OaClassification> list, Long id) {
        if (id == null) {
            return;
        }
        List<OaClassification> classificationDOs = classificationMapper.selectByParentId(id);
        if (CollUtil.isEmpty(classificationDOs)) {
            return;
        }
        list.addAll(classificationDOs);
        // 递归，简单粗暴
        classificationDOs.forEach((tem) -> {
            this.getClassiByParentId(list, tem.getId());
        });
 
        return;
    }
 
 
    private void checkCreateOrUpdate(Long id, Long parentId, String name) {
        // 校验自己存在
        checkClassificationExists(id);
        // 校验父分类的有效性
        checkParentClassificationEnable(id, parentId);
        // 校验分类名的唯一性
        checkClassificationNameUnique(id, parentId, name);
    }
 
    private void checkParentClassificationEnable(Long id, Long parentId) {
        if (parentId == null || Objects.equals(parentId, 0L)) {
            return;
        }
        // 不能设置自己为父分类
        if (parentId.equals(id)) {
            throw new ServiceException("不能设置自己为父分类");
        }
        // 父不存在
        OaClassification classifiction = classificationMapper.selectById(parentId);
        if (classifiction == null) {
            throw new ServiceException("父级分类不存在");
        }
        // 父分类被禁用
        if (!CommonStatusEnum.ENABLE.getStatus().equals(classifiction.getStatus())) {
            throw new ServiceException("分类不处于开启状态，不允许选择");
        }
        // 父分类不能是原来的子分类
        List<OaClassification> children = new ArrayList<>();
        this.getClassiByParentId(children, id);
        if (children.stream().anyMatch(classifiction1 -> classifiction1.getId().equals(parentId))) {
            throw new ServiceException("不能设置自己的子分类为父分类");
        }
    }
 
    private void checkClassificationExists(Long id) {
        if (id == null) {
            return;
        }
        OaClassification classifiction = classificationMapper.selectById(id);
        if (classifiction == null) {
            throw new ServiceException("分类不存在");
        }
    }
 
 
    private void checkClassificationNameUnique(Long id, Long parentId, String name) {
        OaClassification menu = classificationMapper.selectByParentIdAndName(parentId, name);
        if (menu == null) {
            return;
        }
        // 如果 id 为空，说明不用比较是否为相同 id 的
        if (id == null) {
            throw new ServiceException("已经存在该名字的分类");
        }
        if (!menu.getId().equals(id)) {
            throw new ServiceException("已经存在该名字的分类");
        }
    }
 
 
    @Override
    public OaClassification getClassification(Long id) {
        return classificationMapper.selectById(id);
    }
 
 
}
 
 
 
 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xxxx.mapper.OaClassificationMapper">
 
    <resultMap id="BaseResultMap" type="com.xxxx.domain.OaClassification">
        <id property="id" column="id" jdbcType="BIGINT"/>
        <result property="name" column="name" jdbcType="VARCHAR"/>
        <result property="parentId" column="parent_id" jdbcType="BIGINT"/>
        <result property="sort" column="sort" jdbcType="INTEGER"/>
        <result property="status" column="status" jdbcType="TINYINT"/>
        <result property="deth" column="deth" jdbcType="VARCHAR"/>
        <result property="dethName" column="deth_name" jdbcType="VARCHAR"/>
        <result property="dethId" column="deth_id" jdbcType="VARCHAR"/>
        <result property="createBy" column="create_by" jdbcType="VARCHAR"/>
        <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
        <result property="updateBy" column="update_by" jdbcType="VARCHAR"/>
        <result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
    </resultMap>
 
    <sql id="Base_Column_List">
        id
        ,name,parent_id,
        sort,status,deth,
        deth_name,deth_id,create_by,
        create_time,update_by,update_time
    </sql>
    <select id="selectPageList" resultType="com.xxxx.domain.OaClassification">
        select * from oa_classification
        <where>
            <if test="reqVO.id != null ">
                id= #{reqVO.name}
            </if>
            <if test="reqVO.name != null and reqVO.name != ''">
                and name like (concat('%', #{reqVO.name}, '%'))
            </if>
            <if test="reqVO.status != null ">
               and status= #{reqVO.status}
            </if>
        </where>
        order by sort desc,id desc
    </select>
    <select id="selectByParentIdAndName" resultType="com.xxxx.domain.OaClassification">
        select * from oa_classification
        <where>
            <if test="parentId != null ">
                parent_id= #{parentId}
            </if>
            <if test="name != null and name != ''">
                and name =#{name}
            </if>
        </where>
    </select>
    <select id="selectByParentId" resultType="com.xxxx.domain.OaClassification">
        select * from oa_classification
        <where>
            <if test="parentId != null ">
                parent_id= #{parentId}
            </if>
        </where>
    </select>
 
 
</mapper>