spring boot+iview 前后端分离架构之组织管理的实现（二十九）

古城微笑少年丶 2021-12-11 13:02 168阅读 0赞

### spring boot 与 iview 前后端分离架构之组织管理的实现（二十九） ###

*  公众号
 *  组织管理
 *   *  前文错误本章修改
     *  相关工具类的实现
     *   *  OrgDto【实体转换类】
         *  OrgMapper【组织实体转换】
         *  OrgCascaderDto【组织下拉的实体类】
         *  OrgInstall【组织组装的工具类】
     *  组织管理的实现
     *   *  UserOrgDao.xml的实现
         *  UserOrgDao的实现
         *  OrgDao.xml的实现
         *  OrgDao的实现
         *  OrgService的实现
         *  OrgController的实现
     *  运行项目

# 公众号 #

![在这里插入图片描述][20191218155125364.jpg]  
大家可以直接微信扫描上面的二维码关注我的公众号，然后回复【bg29】 里面就会给到源代码的下载地址同时会附上相应的视频教程，并定期在我的公众号上给大家推送相应的技术文章，欢迎大家关注我的公众号。

# 组织管理 #

在前面几章我们已经完成了我们整个系统的百分70的功能了，那么到本章我们将完成我们的组织架构此块的功能。

## 前文错误本章修改 ##

由于当时在使用mybatis生成相应的代码的时候OrgDao和OrgDao.xml不小心写成了OrgeDao和OrgeDao.xml，因此本章做一个修改将其修改为OrgDao和OrgDao.xml。

## 相关工具类的实现 ##

在我们开始编写组织管理的时候我们首先需要实现一些相关工具类。

### OrgDto【实体转换类】 ###

package com.github.bg.admin.core.dto;
    
    import java.util.List;
    
    /**
     * @author linzf
     * @since 2019/5/09
     * 类描述：前端展示组织架构的dto实体
     */
    public class OrgDto {
    
        /**
         * 流水ID
         */
        private Integer orgId;
    
        /**
         * 菜单名字
         */
        private String title;
    
        /**
         * 组织编码
         */
        private String orgCode;
    
        /**
         * 父流水ID
         */
        private Integer parentOrgId;
    
        /**
         * 父组织架构名字
         */
        private String parentOrgName;
    
        /**
         * 菜单流水完整路径(1.2.3)
         */
        private String fullPath;
    
        /**
         * 默认子节点都是展开的
         */
        private boolean expand = true;
        /**
         * 默认节点是没有选中的
         */
        private boolean checked = false;
    
        /**
         * 子节点数据
         */
        private List<OrgDto> children;
    
        public String getFullPath() {
            return fullPath;
        }
    
        public void setFullPath(String fullPath) {
            this.fullPath = fullPath;
        }
    
        public Integer getOrgId() {
            return orgId;
        }
    
        public void setOrgId(Integer orgId) {
            this.orgId = orgId;
        }
    
        public String getTitle() {
            return title;
        }
    
        public void setTitle(String title) {
            this.title = title;
        }
    
        public String getOrgCode() {
            return orgCode;
        }
    
        public void setOrgCode(String orgCode) {
            this.orgCode = orgCode;
        }
    
        public Integer getParentOrgId() {
            return parentOrgId;
        }
    
        public void setParentOrgId(Integer parentOrgId) {
            this.parentOrgId = parentOrgId;
        }
    
        public String getParentOrgName() {
            return parentOrgName;
        }
    
        public void setParentOrgName(String parentOrgName) {
            this.parentOrgName = parentOrgName;
        }
    
        public boolean isExpand() {
            return expand;
        }
    
        public void setExpand(boolean expand) {
            this.expand = expand;
        }
    
        public boolean isChecked() {
            return checked;
        }
    
        public void setChecked(boolean checked) {
            this.checked = checked;
        }
    
        public List<OrgDto> getChildren() {
            return children;
        }
    
        public void setChildren(List<OrgDto> children) {
            this.children = children;
        }
    }

### OrgMapper【组织实体转换】 ###

package com.github.bg.admin.core.mapper;
    
    
    import com.github.bg.admin.core.dto.OrgDto;
    import com.github.bg.admin.core.entity.Org;
    import org.mapstruct.Mapper;
    import org.mapstruct.Mapping;
    import org.mapstruct.Mappings;
    
    import java.util.List;
    
    /**
     * @author linzf
     * @since 2019/5/9
     * 类描述： 组织架构快速转换的实现
     */
    @Mapper(componentModel = "spring")
    public interface OrgMapper {
    
        /**
         * 功能描述：实现数据的转换
         *
         * @param entity
         * @return
         */
        @Mappings({
                @Mapping(target = "title", source = "orgName"),
                @Mapping(target = "orgId", source = "orgId")
        })
        OrgDto orgToOrgDto(Org entity);
    
    
        /**
         * 功能描述：实现集合的数据的转换
         *
         * @param orgs
         * @return
         */
        List<OrgDto> orgsToOrgDto(List<Org> orgs);
    
    }

### OrgCascaderDto【组织下拉的实体类】 ###

package com.github.bg.admin.core.dto;
    
    import java.util.List;
    
    /**
     * @author linzf
     * @since 2019/5/13
     * 类描述： 级联下拉的dto
     */
    public class OrgCascaderDto {
    
        /**
         * 流水ID
         */
        private String value;
    
        /**
         * 组织架构名称
         */
        private String label;
    
        /**
         * 子节点数据
         */
        private List<OrgCascaderDto> children;
    
        public String getValue() {
            return value;
        }
    
        public void setValue(String value) {
            this.value = value;
        }
    
        public String getLabel() {
            return label;
        }
    
        public void setLabel(String label) {
            this.label = label;
        }
    
        public List<OrgCascaderDto> getChildren() {
            return children;
        }
    
        public void setChildren(List<OrgCascaderDto> children) {
            this.children = children;
        }
    }

### OrgInstall【组织组装的工具类】 ###

package com.github.bg.admin.core.util;
    
    
    import com.github.bg.admin.core.dto.OrgCascaderDto;
    import com.github.bg.admin.core.dto.OrgDto;
    import com.github.bg.admin.core.entity.Org;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author linzf
     * @since 2019-05-09
     * 类描述：实现组织架构数据的组装
     */
    public class OrgInstall {
    
        /**
         * 功能描述：实现递归组装选中的菜单节点的数据
         *
         * @param orgList 全部菜单节点的集合
         * @param orgMap  当前被选中的数据
         * @return 返回组装好的数据
         */
        public static List<OrgDto> installCheckOrg(List<OrgDto> orgList, Map<String, Object> orgMap) {
            List<OrgDto> trees = new ArrayList<>();
            for (OrgDto orgDto : orgList) {
                if (0 == orgDto.getParentOrgId()) {
                    orgDto.setChildren(getCheckChild(orgDto.getOrgId(), orgList, orgMap));
                    // 用于防止子节点部分选中，而父节点全部选中
                    if (orgDto.getChildren().size() > 0) {
                        for (OrgDto checkDto : orgDto.getChildren()) {
                            if (!checkDto.isChecked()) {
                                orgDto.setChecked(false);
                                break;
                            }
                        }
                    }
                    trees.add(orgDto);
                }
            }
            return trees;
        }
    
        /**
         * 功能描述：实现树形菜单组织架构的数据的组装
         *
         * @param orgList 需要组装的组织架构的数据
         * @return 返回组装好的数据
         */
        public static List<OrgCascaderDto> installOrgCascader(List<Org> orgList) {
            List<OrgCascaderDto> orgCascaderDtos = new ArrayList<>();
            OrgCascaderDto orgCascaderDto = null;
            for (Org org : orgList) {
                orgCascaderDto = new OrgCascaderDto();
                orgCascaderDto.setValue(org.getOrgId().toString());
                orgCascaderDto.setLabel(org.getOrgName());
                if (0 == org.getParentOrgId()) {
                    orgCascaderDto.setChildren(getCascaderChild(org.getOrgId(), orgList));
                    orgCascaderDtos.add(orgCascaderDto);
                }
            }
            return orgCascaderDtos;
        }
    
        /**
         * 功能描述：递归遍历组织架构节点
         *
         * @param id 父节点ID
         * @param orgList 组织架构数据
         * @return 递归组装数据
         */
        private static List<OrgCascaderDto> getCascaderChild(Integer id, List<Org> orgList) {
            List<OrgCascaderDto> childList = new ArrayList<>();
            OrgCascaderDto orgCascaderDto = null;
            for (Org org : orgList) {
                orgCascaderDto = new OrgCascaderDto();
                orgCascaderDto.setValue(org.getOrgId().toString());
                orgCascaderDto.setLabel(org.getOrgName());
                if (org.getParentOrgId().intValue() == id.intValue()) {
                    orgCascaderDto.setChildren(getCascaderChild(org.getOrgId(), orgList));
                    childList.add(orgCascaderDto);
                }
            }
            return childList;
        }
    
        /**
         * 功能描述：实现树形菜单组织架构的数据的组装
         *
         * @param orgDtoList 需要组装的组织架构的数据
         * @return 返回组装好的数据
         */
        public static List<OrgDto> installOrg(List<OrgDto> orgDtoList) {
            List<OrgDto> orgDtos = new ArrayList<>();
            for (OrgDto orgDto : orgDtoList) {
                if (0 == orgDto.getParentOrgId()) {
                    orgDto.setChildren(getChild(orgDto.getOrgId(), orgDtoList));
                    orgDtos.add(orgDto);
                }
            }
            return orgDtos;
        }
    
    
        /**
         * 功能描述：递归遍历菜单节点
         *
         * @param id      父节点ID
         * @param orgDtos 组织架构的集合
         * @param OrgMap  当前被选中的组织架构
         * @return 递归实现组装数据
         */
        private static List<OrgDto> getCheckChild(Integer id, List<OrgDto> orgDtos, Map<String, Object> OrgMap) {
            List<OrgDto> childList = new ArrayList<>();
            for (OrgDto orgDto : orgDtos) {
                if (orgDto.getParentOrgId().intValue() == id.intValue()) {
                    orgDto.setChildren(getCheckChild(orgDto.getOrgId(), orgDtos, OrgMap));
                    if (OrgMap.get(orgDto.getOrgId().toString()) != null) {
                        orgDto.setChecked(true);
                    } else {
                        orgDto.setChecked(false);
                    }
                    if (orgDto.getChildren().size() > 0) {
                        for (OrgDto checkOrg : orgDto.getChildren()) {
                            if (!checkOrg.isChecked()) {
                                orgDto.setChecked(false);
                                break;
                            }
                        }
                    }
                    childList.add(orgDto);
                }
            }
            return childList;
        }
    
        /**
         * 功能描述：递归遍历组织架构节点
         *
         * @param id 父节点ID
         * @param orgDtos 组织架构数据
         * @return 递归组装数据
         */
        private static List<OrgDto> getChild(Integer id, List<OrgDto> orgDtos) {
            List<OrgDto> childList = new ArrayList<>();
            for (OrgDto orgDto : orgDtos) {
                if (orgDto.getParentOrgId().intValue() == id.intValue()) {
                    orgDto.setChildren(getChild(orgDto.getOrgId(), orgDtos));
                    childList.add(orgDto);
                }
            }
            return childList;
        }
    
    }

## 组织管理的实现 ##

由于组织和用户是具有关联关系的，因此我们在删除组织的时候，同时要删除组织和用户之间的关联关系，因此我们需要实现UserOrgDao的以下的方法。

### UserOrgDao.xml的实现 ###

### UserOrgDao的实现 ###

package com.github.bg.admin.core.dao;
    
    import com.github.bg.admin.core.entity.UserOrg;
    import org.apache.ibatis.annotations.Param;
    import tk.mybatis.mapper.common.Mapper;
    
    public interface UserOrgDao extends Mapper<UserOrg> {
    
        /**
         * 功能描述：根据用户ID来删除关联数据
         * @param userId 用户ID
         * @return 返回删除结果
         */
        int deleteUserOrgByUserId(@Param("userId") String userId);
    
        /**
         * 功能描述：根据组织架构ID来统计用户和组织架构的数量
         * @param orgId 组织架构流水ID
         * @return 返回删除结果
         */
        int countUserOrgByOrgId(@Param("orgId") Integer orgId);
    
        /**
         * 功能描述：根据组织架构ID来删除关联关系的数据
         * @param orgId 组织架构流水ID
         * @return 返回删除结果
         */
        int deleteUserOrgByOrgId(@Param("orgId") Integer orgId);
    
    }

### OrgDao.xml的实现 ###

<?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.github.bg.admin.core.dao.OrgDao">
      <resultMap id="BaseResultMap" type="com.github.bg.admin.core.entity.Org">
        <id column="orgId" jdbcType="INTEGER" property="orgId" />
        <result column="orgName" jdbcType="VARCHAR" property="orgName" />
        <result column="orgCode" jdbcType="VARCHAR" property="orgCode" />
        <result column="parentOrgId" jdbcType="INTEGER" property="parentOrgId" />
        <result column="parentOrgName" jdbcType="VARCHAR" property="parentOrgName" />
        <result column="crtDate" jdbcType="TIMESTAMP" property="crtDate" />
        <result column="fullPath" jdbcType="VARCHAR" property="fullPath" />
      </resultMap>
    
      
      <select id="getOrgByUserId" resultMap="BaseResultMap">
        select t.* from t_org t left join  t_user_org tuo on t.orgId = tuo.orgId where tuo.userId = #{userId}
      </select>
    
      
      <update id="updateFullPath">
            update t_org set fullPath = #{fullPath} where  orgId = #{orgId}
        </update>
    
      
      <select id="countOrgChildren" resultType="java.lang.Integer">
            select count(*) from t_org where parentOrgId = #{orgId}
        </select>
    
      
      <select id="checkOrgNameAndCode" resultType="java.lang.Integer">
        select count(*) from t_org where 1=1
        <if test="orgName!=null and orgName !=''">
          and orgName = #{orgName}
        </if>
        <if test="orgCode!=null and orgCode !=''">
          and orgCode = #{orgCode}
        </if>
        <if test="orgId != null and orgId != ''">
          and orgId != #{orgId}
        </if>
      </select>
    
    </mapper>

### OrgDao的实现 ###

package com.github.bg.admin.core.dao;
    
    import com.github.bg.admin.core.entity.Org;
    import org.apache.ibatis.annotations.Param;
    import tk.mybatis.mapper.common.Mapper;
    
    public interface OrgDao extends Mapper<Org> {
    
        /**
         * 功能描述：根据用户ID来获取关联的组织架构的数据
         *
         * @param userId 用户流水ID
         * @return 返回获取的结果
         */
        Org getOrgByUserId(@Param("userId") String userId);
    
        /**
         * 功能描述：判断当前组织架构底下是否还有子节点
         *
         * @param orgId 组织架构ID
         * @return 返回统计结果
         */
        int countOrgChildren(@Param("orgId") Integer orgId);
    
        /**
         * 功能描述：更新节点的路径
         *
         * @param orgId    组织架构ID
         * @param fullPath 组织架构完整路径
         * @return 返回更新结果
         */
        int updateFullPath(@Param("orgId") Integer orgId, @Param("fullPath") String fullPath);
    
        /**
         * 功能描述：验证组织架构名字和编码是否存在
         *
         * @param orgId   组织架构ID
         * @param orgName 组织架构名称
         * @param orgCode 组织架构编码
         * @return 返回验证结果
         */
        int checkOrgNameAndCode(@Param("orgId") Integer orgId, @Param("orgName") String orgName, @Param("orgCode") String orgCode);
    
    }

### OrgService的实现 ###

package com.github.bg.admin.core.service;
    
    
    import com.github.bg.admin.core.constant.SystemStaticConst;
    import com.github.bg.admin.core.dao.OrgDao;
    import com.github.bg.admin.core.dao.UserOrgDao;
    import com.github.bg.admin.core.entity.Org;
    import com.github.bg.admin.core.entity.ReturnInfo;
    import com.github.bg.admin.core.mapper.OrgMapper;
    import com.github.bg.admin.core.util.OrgInstall;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    
    /**
     * @author linzf
     * @since 2019-05-09
     * 类描述：组织架构的service
     */
    @Service
    @Transactional(rollbackFor = {IllegalArgumentException.class})
    public class OrgService {
    
        @Autowired
        private OrgDao orgDao;
        @Autowired
        private UserOrgDao userOrgDao;
        @Autowired
        private OrgMapper orgMapper;
    
        /**
         * 功能描述：获取组织架构信息
         * @param orgId 组织架构流水ID
         * @return 返回获取结果
         */
        public ReturnInfo getOrgByOrgId(Integer orgId) {
            Org org = orgDao.selectByPrimaryKey(orgId);
            if (org == null) {
                return new ReturnInfo(SystemStaticConst.FAIL, "查无此组织架构数据，请重新刷新页面！");
            }
            return new ReturnInfo(SystemStaticConst.SUCCESS, "获取组织架构数据成功", org);
        }
    
        /**
         * 功能描述：删除组织架构
         *
         * @param orgId 组织架构流水ID
         * @return 返回删除结果
         */
        public ReturnInfo deleteOrg(Integer orgId) {
            Org org = orgDao.selectByPrimaryKey(orgId);
            if (org == null) {
                return new ReturnInfo(SystemStaticConst.FAIL, "删除组织架构数据失败，查无此组织架构数据！");
            }
            if (orgDao.countOrgChildren(orgId) > 0) {
                return new ReturnInfo(SystemStaticConst.FAIL, "删除组织架构数据失败，当前组织架构底下还有子组织，请先删除子组织！");
            }
            if (userOrgDao.countUserOrgByOrgId(orgId) > 0) {
                return new ReturnInfo(SystemStaticConst.FAIL, "删除组织架构数据失败，当前组织架构底下还有用户，请先删除该组织架构底下的用户！");
            }
            if (orgDao.deleteByPrimaryKey(orgId) > 0) {
                userOrgDao.deleteUserOrgByOrgId(orgId);
                return new ReturnInfo(SystemStaticConst.SUCCESS, "删除组织架构成功！");
            } else {
                return new ReturnInfo(SystemStaticConst.FAIL, "删除组织架构数据失败，查无此组织架构数据！");
            }
        }
    
        /**
         * 功能描述：更新组织架构的数据
         *
         * @param orgId   组织架构流水ID
         * @param orgName 组织架构名字
         * @param orgCode 组织架构编码
         * @return 返回更新结果
         */
        public ReturnInfo updateOrg(Integer orgId, String orgName, String orgCode) {
            if (orgDao.checkOrgNameAndCode(orgId, orgName, "") > 0) {
                return new ReturnInfo(SystemStaticConst.FAIL, "当前组织架构名称已经存在，请重新修改以后再提交！");
            }
            if (orgDao.checkOrgNameAndCode(orgId, "", orgCode) > 0) {
                return new ReturnInfo(SystemStaticConst.FAIL, "当前组织架构编码已经存在，请重新修改以后再提交！");
            }
            Org org = orgDao.selectByPrimaryKey(orgId);
            if (org == null) {
                return new ReturnInfo(SystemStaticConst.FAIL, "查无此组织架构数据，请重新刷新页面！");
            }
            org.setOrgName(orgName);
            org.setOrgCode(orgCode);
            if (orgDao.updateByPrimaryKey(org) > 0) {
                return new ReturnInfo(SystemStaticConst.SUCCESS, "更新组织架构数据成功");
            } else {
                return new ReturnInfo(SystemStaticConst.FAIL, "更新组织架构失败");
            }
        }
    
        /**
         * 功能描述：增加组织架构
         *
         * @param orgName     组织架构名称
         * @param orgCode     组织架构编码
         * @param parentOrgId 父节点ID
         * @return
         */
        public ReturnInfo addOrg(String orgName, String orgCode, Integer parentOrgId) {
            StringBuilder fullPath = new StringBuilder();
            Org org = new Org();
            if (parentOrgId.intValue() == 0) {
                org.setParentOrgName("");
            } else {
                Org parent = orgDao.selectByPrimaryKey(parentOrgId);
                if (parent == null) {
                    return new ReturnInfo(SystemStaticConst.FAIL, "查无此父组织架构数据，请重新选择父组织架构！");
                }
                org.setParentOrgName(parent.getOrgName());
                fullPath.append(parent.getFullPath());
            }
            org.setOrgName(orgName);
            org.setOrgCode(orgCode);
            org.setCrtDate(new Date());
            org.setParentOrgId(parentOrgId);
            if (orgDao.insert(org) > 0) {
                fullPath.append(".").append(org.getOrgId());
                orgDao.updateFullPath(org.getOrgId(), fullPath.toString());
                return new ReturnInfo(SystemStaticConst.SUCCESS, "增加组织架构成功", org);
            } else {
                return new ReturnInfo(SystemStaticConst.FAIL, "增加组织架构失败");
            }
    
        }
    
        /**
         * 功能描述：验证组织架构名字和编码是否存在
         *
         * @param orgId   组织架构ID
         * @param orgName 组织架构名称
         * @param orgCode 组织架构编码
         * @return 返回验证结果
         */
        public ReturnInfo checkOrgNameAndCode(Integer orgId, String orgName, String orgCode) {
            Map<String, Object> result = new HashMap<>(1);
            try {
                if (orgDao.checkOrgNameAndCode(orgId, orgName, orgCode) > 0) {
                    result.put("success", "unPass");
                } else {
                    result.put("success", "pass");
                }
            } catch (Exception e) {
                return new ReturnInfo(SystemStaticConst.FAIL, "验证请求处理失败，失败原因：" + e.getMessage());
            }
            return new ReturnInfo(SystemStaticConst.SUCCESS, "验证请求处理成功", result);
        }
    
        /**
         * 功能描述：获取组织架构树目录
         *
         * @return 返回获取的结果
         */
        public ReturnInfo getOrgTree() {
            return new ReturnInfo(SystemStaticConst.SUCCESS, "加载组织架构数据成功", OrgInstall.installOrg(orgMapper.orgsToOrgDto(orgDao.selectAll())));
        }
    
        /**
         * 功能描述：获取组织架构的Cascader的数据
         * @return 返回获取结果
         */
        public ReturnInfo getOrgCascader(){
            return new ReturnInfo(SystemStaticConst.SUCCESS, "加载级联菜单的组织架构数据成功", OrgInstall.installOrgCascader(orgDao.selectAll()));
        }
    
    }

### OrgController的实现 ###

package com.github.bg.admin.core.controller;
    
    
    import com.github.bg.admin.core.entity.ReturnInfo;
    import com.github.bg.admin.core.service.OrgService;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author linzf
     * @since 2019-05-09
     * 类描述：组织架构的controller
     */
    @RestController
    @RequestMapping("/org")
    public class OrgController {
    
        @Autowired
        private OrgService orgService;
    
        /**
         * 功能描述：获取组织架构信息
         * @param orgId 组织架构流水ID
         * @return 返回获取结果
         */
        @ApiOperation(value = "获取组织架构信息")
        @PostMapping("getOrgByOrgId")
        public ReturnInfo getOrgByOrgId(@RequestParam(name = "orgId") Integer orgId){
            return orgService.getOrgByOrgId(orgId);
        }
    
        /**
         * 功能描述：删除组织架构
         *
         * @param orgId 组织架构流水ID
         * @return 返回删除结果
         */
        @ApiOperation(value = "删除组织架构")
        @PostMapping("deleteOrg")
        public ReturnInfo deleteOrg(@RequestParam(name = "orgId") Integer orgId) {
            return orgService.deleteOrg(orgId);
        }
    
        /**
         * 功能描述：更新组织架构的数据
         *
         * @param orgId   组织架构流水ID
         * @param orgName 组织架构名字
         * @param orgCode 组织架构编码
         * @return 返回更新结果
         */
        @ApiOperation(value = "更新组织架构的数据")
        @PostMapping("updateOrg")
        public ReturnInfo updateOrg(@RequestParam(name = "orgId") Integer orgId,
                                    @RequestParam(name = "orgName") String orgName,
                                    @RequestParam(name = "orgCode") String orgCode) {
            return orgService.updateOrg(orgId, orgName, orgCode);
        }
    
        /**
         * 功能描述：增加组织架构
         *
         * @param orgName     组织架构名称
         * @param orgCode     组织架构编码
         * @param parentOrgId 父节点ID
         * @return 返回增加组织架构的结果
         */
        @ApiOperation(value = "增加组织架构")
        @PostMapping("addOrg")
        public ReturnInfo addOrg(@RequestParam(name = "orgName") String orgName,
                                 @RequestParam(name = "orgCode") String orgCode,
                                 @RequestParam(name = "parentOrgId") Integer parentOrgId) {
            return orgService.addOrg(orgName, orgCode, parentOrgId);
        }
    
        /**
         * 功能描述：验证组织架构名字和编码是否存在
         *
         * @param orgId   组织架构ID
         * @param orgName 组织架构名称
         * @param orgCode 组织架构编码
         * @return 返回验证结果
         */
        @ApiOperation(value = "验证组织架构名字和编码是否存在")
        @PostMapping("checkOrgNameAndCode")
        public ReturnInfo checkOrgNameAndCode(@RequestParam(name = "orgId", required = false) Integer orgId,
                                              @RequestParam(name = "orgName", required = false) String orgName,
                                              @RequestParam(name = "orgCode", required = false) String orgCode) {
            return orgService.checkOrgNameAndCode(orgId, orgName, orgCode);
        }
    
    
        /**
         * 功能描述：获取组织架构树目录
         *
         * @return 返回获取的结果
         */
        @ApiOperation(value = "获取组织架构树目录")
        @PostMapping("getOrgTree")
        public ReturnInfo getOrgTree() {
            return orgService.getOrgTree();
        }
    
    
        /**
         * 功能描述：获取组织架构的Cascader的数据
         * @return 返回获取结果
         */
        @ApiOperation(value = "获取组织架构的Cascader的数据")
        @PostMapping("getOrgCascader")
        public ReturnInfo getOrgCascader(){
            return orgService.getOrgCascader();
        }
    
    }

## 运行项目 ##

最后我们重新编译我们的项目，记得一定要重新编译，因为我们引入了mapper，不重新编译是会报错的，然后我们使用账号：admin密码：123456登录系统操作我们的用户组织模块，可以正常的对组织进行维护，但是这个时候会产生报错，这是因为用户还没有集成进去的原因，等下一章集成进去就不会有这个问题了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70]  
上一篇文章地址：[spring boot+iview 前后端分离架构之角色管理的实现（二十八）][spring boot_iview]  
下一篇文章地址：[spring boot+iview 前后端分离架构之用户管理的实现（三十）][spring boot_iview 1]

[20191218155125364.jpg]: /images/20211211/2e651ab22a984064bad245c7ac81fbf1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70]: /images/20211211/c5c1659ce0204784ac891040130fad5e.png
[spring boot_iview]: https://blog.csdn.net/linzhefeng89/article/details/95108001
[spring boot_iview 1]: https://blog.csdn.net/linzhefeng89/article/details/95193315