一、概述

团队空间是知识库系统中的组织协作功能,通过团队层级结构和成员管理,实现文档的团队化组织和权限隔离。

本文将详细介绍如何在 kb-user-auth 服务中实现完整的团队空间管理功能。

1.1 功能定位

团队空间管理作为组织的核心功能,提供以下能力:

功能模块说明使用场景
团队CRUD创建、更新、删除、查询团队团队基础管理
层级结构支持父团队-子团队的树形组织多级部门架构
成员管理添加、移除团队成员人员调配
分页查询按名称、编码、状态筛选团队团队搜索
团队树按层级展示完整团队结构组织架构图

1.2 数据模型

团队采用层级树形结构设计:

根团队 (parentId = 0)
├── 技术部 (level=1, path=/1)
│   ├── 后端组 (level=2, path=/1/2)
│   │   ├── Java小组 (level=3, path=/1/2/3)
│   │   └── Go小组 (level=3, path=/1/2/4)
│   └── 前端组 (level=2, path=/1/5)
├── 产品部 (level=1, path=/6)
│   ├── 产品设计组 (level=2, path=/6/7)
│   └── 用户研究组 (level=2, path=/6/8)
└── 运营部 (level=1, path=/9)

1.3 技术实现

  • 层级关系存储:通过 parentId、level、path 三个字段实现高效的层级查询
  • 路径前缀查询:使用 path LIKE '/1/%' 快速查询某团队下的所有子团队
  • 成员数量冗余:memberCount 字段避免频繁关联查询
  • 树形构建:递归算法构建完整团队树
  • 批量操作:支持一次添加/移除多个成员

二、数据库设计

2.1 团队表结构

在 kb\_user 数据库中创建团队表 kb_team:

DROP TABLE IF EXISTS `kb_team`;
CREATE TABLE `kb_team` (
  `id` BIGINT NOT NULL COMMENT '团队ID',
  `team_name` VARCHAR(100) NOT NULL COMMENT '团队名称',
  `team_code` VARCHAR(50) DEFAULT NULL COMMENT '团队编码',
  `description` VARCHAR(500) DEFAULT NULL COMMENT '团队描述',
  `leader_id` BIGINT DEFAULT NULL COMMENT '团队负责人ID',
  `parent_id` BIGINT NOT NULL DEFAULT 0 COMMENT '父团队ID',
  `sort` INT NOT NULL DEFAULT 0 COMMENT '排序号',
  `status` TINYINT NOT NULL DEFAULT 1 COMMENT '状态',
  `create_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `create_by` BIGINT DEFAULT NULL COMMENT '创建人',
  `update_by` BIGINT DEFAULT NULL COMMENT '更新人',
  `deleted` TINYINT NOT NULL DEFAULT 0 COMMENT '删除标识',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_team_code` (`team_code`, `deleted`),
  KEY `idx_leader_id` (`leader_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='团队表';

2.2 团队成员表结构

创建团队成员关联表 kb_team_member:

DROP TABLE IF EXISTS `kb_team_member`;
CREATE TABLE `kb_team_member` (
  `id` BIGINT NOT NULL COMMENT '主键ID',
  `team_id` BIGINT NOT NULL COMMENT '团队ID',
  `user_id` BIGINT NOT NULL COMMENT '用户ID',
  `member_role` VARCHAR(20) NOT NULL DEFAULT 'member' COMMENT '成员角色',
  `join_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '加入时间',
  `create_by` BIGINT DEFAULT NULL COMMENT '添加人',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_team_user` (`team_id`, `user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='团队成员表';

2.3 字段说明

kb\_team 表:

字段类型说明必填默认值
idBIGINT团队ID(雪花算法)是-
team\_nameVARCHAR(100)团队名称是-
team\_codeVARCHAR(50)团队编码(唯一)否-
descriptionVARCHAR(500)团队描述否-
leader\_idBIGINT团队负责人ID否-
parent\_idBIGINT父团队ID是0
sortINT排序号是0
statusTINYINT状态(0-禁用,1-启用)是1

kb\_team\_member 表:

字段类型说明必填默认值
idBIGINT主键ID是-
team\_idBIGINT团队ID是-
user\_idBIGINT用户ID是-
member\_roleVARCHAR(20)成员角色是member
join\_timeDATETIME加入时间是NOW()

2.4 索引设计

  • uk_team_code:团队编码唯一索引(联合 deleted 字段,允许已删除的记录编码被复用)
  • idx_leader_id:加速按负责人查询团队
  • uk_team_user:团队成员唯一索引(防止重复添加)

三、实体类设计

3.1 创建 Team 实体类

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/entity/Team.java:

package com.knowledge.base.userauth.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import com.knowledge.base.common.config.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * 团队实体
 *
 * <p>继承自BaseEntity,复用ID、创建时间、更新时间、创建人、更新人、逻辑删除等通用字段</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("kb_team")
@Schema(description = "团队实体")
public class Team extends BaseEntity {

    private static final long serialVersionUID = 1L;

    @Schema(description = "团队名称")
    private String teamName;

    @Schema(description = "团队编码")
    private String teamCode;

    @Schema(description = "团队描述")
    private String description;

    @Schema(description = "父团队ID")
    private Long parentId;

    @Schema(description = "团队层级")
    private Integer level;

    @Schema(description = "团队路径")
    private String path;

    @Schema(description = "成员数量")
    private Integer memberCount;

    @Schema(description = "文档数量")
    private Integer docCount;

    @Schema(description = "团队负责人ID")
    private Long leaderId;

    @Schema(description = "状态:0-禁用,1-正常")
    private Integer status;

    @Schema(description = "排序号")
    private Integer sort;
}

3.2 创建 TeamMember 实体类

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/entity/TeamMember.java:

package com.knowledge.base.userauth.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.io.Serializable;
import java.time.LocalDateTime;

/**
 * 团队成员实体
 *
 * <p>关联kb_team_member表,记录团队与用户的成员关系</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@TableName("kb_team_member")
@Schema(description = "团队成员实体")
public class TeamMember implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(type = IdType.ASSIGN_ID)
    @Schema(description = "主键ID")
    private Long id;

    @Schema(description = "团队ID")
    private Long teamId;

    @Schema(description = "用户ID")
    private Long userId;

    @Schema(description = "成员角色:leader-负责人, member-普通成员")
    private String memberRole;

    @Schema(description = "加入时间")
    private LocalDateTime joinTime;

    @Schema(description = "添加人ID")
    private Long createBy;
}

3.3 设计思路

  1. Team 继承 BaseEntity:复用基础字段(id、创建时间、更新时间、逻辑删除等)
  2. level 和 path 字段:冗余存储层级关系,加速查询

    • level:根团队为 1,每级递增

      • path:如 /1/2/3,用 LIKE '/1/%' 快速查询所有子团队
  3. memberCount:冗余字段,避免频繁 JOIN 查询成员数
  4. TeamMember 不继承 BaseEntity:关联表无需软删除,直接物理删除即可

四、DTO 和 VO 设计

4.1 创建 TeamCreateDTO

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/dto/TeamCreateDTO.java:

package com.knowledge.base.userauth.dto;

import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.Data;

import java.io.Serializable;

/**
 * 团队创建DTO
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Schema(description = "团队创建请求")
public class TeamCreateDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    @Schema(description = "团队名称")
    @NotBlank(message = "团队名称不能为空")
    @Size(max = 100, message = "团队名称长度不能超过100个字符")
    private String teamName;

    @Schema(description = "团队编码")
    @NotBlank(message = "团队编码不能为空")
    @Size(max = 50, message = "团队编码长度不能超过50个字符")
    private String teamCode;

    @Schema(description = "团队描述")
    @Size(max = 500, message = "团队描述长度不能超过500个字符")
    private String description;

    @Schema(description = "父团队ID")
    private Long parentId;

    @Schema(description = "团队负责人ID")
    @NotNull(message = "团队负责人不能为空")
    private Long leaderId;
}

4.2 创建 TeamUpdateDTO

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/dto/TeamUpdateDTO.java:

package com.knowledge.base.userauth.dto;

import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.Data;

import java.io.Serializable;

@Data
@Schema(description = "团队更新请求")
public class TeamUpdateDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    @Schema(description = "团队ID")
    @NotNull(message = "团队ID不能为空")
    private Long id;

    @Schema(description = "团队名称")
    @Size(max = 100, message = "团队名称长度不能超过100个字符")
    private String teamName;

    @Schema(description = "团队编码")
    @Size(max = 50, message = "团队编码长度不能超过50个字符")
    private String teamCode;

    @Schema(description = "团队描述")
    @Size(max = 500, message = "团队描述长度不能超过500个字符")
    private String description;

    @Schema(description = "团队负责人ID")
    private Long leaderId;

    @Schema(description = "状态")
    private Integer status;
}

4.3 创建 TeamQueryDTO

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/dto/TeamQueryDTO.java:

package com.knowledge.base.userauth.dto;

import com.knowledge.base.common.config.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;

@Data
@EqualsAndHashCode(callSuper = true)
@Schema(description = "团队查询请求")
public class TeamQueryDTO extends PageParam {

    @Schema(description = "团队名称(模糊查询)")
    private String teamName;

    @Schema(description = "团队编码")
    private String teamCode;

    @Schema(description = "父团队ID")
    private Long parentId;

    @Schema(description = "状态")
    private Integer status;
}

4.4 创建 TeamVO

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/vo/TeamVO.java:

package com.knowledge.base.userauth.vo;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.List;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "团队信息")
public class TeamVO implements Serializable {

    private static final long serialVersionUID = 1L;

    @Schema(description = "团队ID")
    private Long id;

    @Schema(description = "团队名称")
    private String teamName;

    @Schema(description = "团队编码")
    private String teamCode;

    @Schema(description = "团队描述")
    private String description;

    @Schema(description = "父团队ID")
    private Long parentId;

    @Schema(description = "父团队名称")
    private String parentName;

    @Schema(description = "团队层级")
    private Integer level;

    @Schema(description = "成员数量")
    private Integer memberCount;

    @Schema(description = "文档数量")
    private Integer docCount;

    @Schema(description = "团队负责人ID")
    private Long leaderId;

    @Schema(description = "团队负责人名称")
    private String leaderName;

    @Schema(description = "状态")
    private Integer status;

    @Schema(description = "创建时间")
    private LocalDateTime createdAt;

    @Schema(description = "子团队列表")
    private List<TeamVO> children;
}

4.5 创建 TeamMemberVO

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/vo/TeamMemberVO.java:

package com.knowledge.base.userauth.vo;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.time.LocalDateTime;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "团队成员信息")
public class TeamMemberVO implements Serializable {

    private static final long serialVersionUID = 1L;

    @Schema(description = "用户ID")
    private Long userId;

    @Schema(description = "用户名")
    private String username;

    @Schema(description = "真实姓名")
    private String realName;

    @Schema(description = "用户头像")
    private String avatar;

    @Schema(description = "成员角色:leader-负责人, member-普通成员")
    private String role;

    @Schema(description = "加入时间")
    private LocalDateTime joinedAt;
}

4.6 设计说明

DTO vs VO 的区别:

类型用途特点
DTO接收客户端请求字段精简,用于参数校验
VO返回客户端响应包含业务计算字段(如 parentName、leaderName、children)

转换逻辑:

  • VO 中的 parentName 通过查询父团队实体获取
  • VO 中的 leaderName 通过查询 kb\_user 表获取
  • VO 中的 children 由树形构建算法动态生成

五、数据访问层

5.1 创建 TeamMapper 接口

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/mapper/TeamMapper.java:

package com.knowledge.base.userauth.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.knowledge.base.userauth.entity.Team;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;

@Mapper
public interface TeamMapper extends BaseMapper<Team> {

    List<Team> selectByParentId(@Param("parentId") Long parentId);

    Team selectByTeamCode(@Param("teamCode") String teamCode);

    List<Team> selectByStatus(@Param("status") Integer status);

    List<Team> selectByLevel(@Param("level") Integer level);

    List<Team> selectRootTeams();

    List<Team> selectByLeaderId(@Param("leaderId") Long leaderId);

    List<Team> selectByPathPrefix(@Param("path") String path);

    List<Team> selectTeamTree();

    int updateMemberCount(@Param("teamId") Long teamId, @Param("count") Integer count);

    int incrementMemberCount(@Param("teamId") Long teamId);

    int decrementMemberCount(@Param("teamId") Long teamId);

    int updateDocumentCount(@Param("teamId") Long teamId, @Param("count") Integer count);

    int incrementDocumentCount(@Param("teamId") Long teamId);

    int decrementDocumentCount(@Param("teamId") Long teamId);

    Boolean checkTeamCodeExists(@Param("teamCode") String teamCode, @Param("id") Long id);

    Long countAll();

    Long countEnabled();
}

5.2 创建 TeamMemberMapper 接口

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/mapper/TeamMemberMapper.java:

package com.knowledge.base.userauth.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.knowledge.base.userauth.entity.TeamMember;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;

@Mapper
public interface TeamMemberMapper extends BaseMapper<TeamMember> {

    List<TeamMember> selectByTeamId(@Param("teamId") Long teamId);

    List<TeamMember> selectByUserId(@Param("userId") Long userId);

    int deleteByTeamIdAndUserIds(@Param("teamId") Long teamId, @Param("userIds") List<Long> userIds);

    Long countByTeamId(@Param("teamId") Long teamId);
}

5.3 创建 TeamMapper XML

创建 kb-user-auth/src/main/resources/mapper/TeamMapper.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.knowledge.base.userauth.mapper.TeamMapper">

    <resultMap id="BaseResultMap" type="com.knowledge.base.userauth.entity.Team">
        <id column="id" property="id" />
        <result column="team_name" property="teamName" />
        <result column="team_code" property="teamCode" />
        <result column="description" property="description" />
        <result column="parent_id" property="parentId" />
        <result column="level" property="level" />
        <result column="path" property="path" />
        <result column="member_count" property="memberCount" />
        <result column="doc_count" property="docCount" />
        <result column="leader_id" property="leaderId" />
        <result column="status" property="status" />
        <result column="deleted" property="deleted" />
        <result column="create_time" property="createTime" />
        <result column="update_time" property="updateTime" />
        <result column="create_by" property="createBy" />
        <result column="update_by" property="updateBy" />
    </resultMap>
    <sql id="Base_Column_List">
        id, team_name, team_code, description, parent_id, level, path, member_count,
        doc_count, leader_id, status, deleted, create_time, update_time, create_by, update_by
    </sql>
    <select id="selectByParentId" resultMap="BaseResultMap">
        SELECT <include refid="Base_Column_List" />
        FROM kb_team
        WHERE parent_id = #{parentId} AND deleted = 0
        ORDER BY id ASC
    </select>
    <select id="selectByTeamCode" resultMap="BaseResultMap">
        SELECT <include refid="Base_Column_List" />
        FROM kb_team
        WHERE team_code = #{teamCode} AND deleted = 0
        LIMIT 1
    </select>
    <select id="selectByStatus" resultMap="BaseResultMap">
        SELECT <include refid="Base_Column_List" />
        FROM kb_team
        WHERE status = #{status} AND deleted = 0
        ORDER BY id ASC
    </select>
    <select id="selectByLevel" resultMap="BaseResultMap">
        SELECT <include refid="Base_Column_List" />
        FROM kb_team
        WHERE level = #{level} AND deleted = 0
        ORDER BY id ASC
    </select>
    <select id="selectRootTeams" resultMap="BaseResultMap">
        SELECT <include refid="Base_Column_List" />
        FROM kb_team
        WHERE parent_id = 0 AND deleted = 0
        ORDER BY id ASC
    </select>
    <select id="selectByLeaderId" resultMap="BaseResultMap">
        SELECT <include refid="Base_Column_List" />
        FROM kb_team
        WHERE leader_id = #{leaderId} AND deleted = 0
        ORDER BY id ASC
    </select>
    <select id="selectByPathPrefix" resultMap="BaseResultMap">
        SELECT <include refid="Base_Column_List" />
        FROM kb_team
        WHERE path LIKE CONCAT(#{path}, '%') AND deleted = 0
        ORDER BY level ASC, id ASC
    </select>
    <select id="selectTeamTree" resultMap="BaseResultMap">
        SELECT <include refid="Base_Column_List" />
        FROM kb_team WHERE deleted = 0
        ORDER BY level ASC, id ASC
    </select>
    <update id="updateMemberCount">
        UPDATE kb_team SET member_count = #{count}
        WHERE id = #{teamId} AND deleted = 0
    </update>
    <update id="incrementMemberCount">
        UPDATE kb_team SET member_count = member_count + 1
        WHERE id = #{teamId} AND deleted = 0
    </update>
    <update id="decrementMemberCount">
        UPDATE kb_team SET member_count = GREATEST(member_count - 1, 0)
        WHERE id = #{teamId} AND deleted = 0
    </update>
    <update id="updateDocumentCount">
        UPDATE kb_team SET doc_count = #{count}
        WHERE id = #{teamId} AND deleted = 0
    </update>
    <update id="incrementDocumentCount">
        UPDATE kb_team SET doc_count = doc_count + 1
        WHERE id = #{teamId} AND deleted = 0
    </update>
    <update id="decrementDocumentCount">
        UPDATE kb_team SET doc_count = GREATEST(doc_count - 1, 0)
        WHERE id = #{teamId} AND deleted = 0
    </update>
    <select id="checkTeamCodeExists" resultType="java.lang.Boolean">
        SELECT COUNT(*) > 0 FROM kb_team
        WHERE team_code = #{teamCode} AND deleted = 0
        <if test="id != null">
            AND id != #{id}
        </if>
    </select>
    <select id="countAll" resultType="java.lang.Long">
        SELECT COUNT(*) FROM kb_team WHERE deleted = 0
    </select>
    <select id="countEnabled" resultType="java.lang.Long">
        SELECT COUNT(*) FROM kb_team WHERE status = 1 AND deleted = 0
    </select>
</mapper>

5.4 MyBatis Plus 集成

使用 MyBatis Plus 后,简单的 CRUD 操作无需编写 SQL:

// 自动生成SQL
teamMapper.selectById(id);
teamMapper.selectList(wrapper);
teamMapper.selectPage(page, wrapper);
teamMapper.insert(team);
teamMapper.updateById(team);
teamMapper.deleteById(id);

六、业务逻辑层

6.1 创建 Service 接口

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/service/TeamService.java:

package com.knowledge.base.userauth.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.knowledge.base.common.result.PageResult;
import com.knowledge.base.userauth.dto.TeamCreateDTO;
import com.knowledge.base.userauth.dto.TeamQueryDTO;
import com.knowledge.base.userauth.dto.TeamUpdateDTO;
import com.knowledge.base.userauth.entity.Team;
import com.knowledge.base.userauth.vo.TeamMemberVO;
import com.knowledge.base.userauth.vo.TeamVO;

import java.util.List;

public interface TeamService extends IService<Team> {

    /** 创建团队 */
    Long createTeam(TeamCreateDTO dto);

    /** 更新团队 */
    Boolean updateTeam(TeamUpdateDTO dto);

    /** 删除团队 */
    Boolean deleteTeam(Long teamId);

    /** 获取团队详情 */
    TeamVO getTeamDetail(Long teamId);

    /** 分页查询团队 */
    PageResult<TeamVO> pageTeams(TeamQueryDTO dto);

    /** 获取团队树 */
    List<TeamVO> getTeamTree();

    /** 添加团队成员 */
    Boolean addTeamMembers(Long teamId, List<Long> userIds);

    /** 移除团队成员 */
    Boolean removeTeamMembers(Long teamId, List<Long> userIds);

    /** 获取团队成员 */
    List<TeamMemberVO> getTeamMembers(Long teamId);
}

6.2 创建 Service 实现类

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/service/impl/TeamServiceImpl.java:

package com.knowledge.base.userauth.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.knowledge.base.common.exception.BusinessException;
import com.knowledge.base.common.result.PageResult;
import com.knowledge.base.common.utils.SnowflakeIdGenerator;
import com.knowledge.base.userauth.dto.TeamCreateDTO;
import com.knowledge.base.userauth.dto.TeamQueryDTO;
import com.knowledge.base.userauth.dto.TeamUpdateDTO;
import com.knowledge.base.userauth.entity.Team;
import com.knowledge.base.userauth.entity.TeamMember;
import com.knowledge.base.userauth.mapper.TeamMapper;
import com.knowledge.base.userauth.mapper.TeamMemberMapper;
import com.knowledge.base.userauth.service.TeamService;
import com.knowledge.base.userauth.vo.TeamMemberVO;
import com.knowledge.base.userauth.vo.TeamVO;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Service
public class TeamServiceImpl extends ServiceImpl<TeamMapper, Team> implements TeamService {

    @Resource
    private TeamMapper teamMapper;

    @Resource
    private TeamMemberMapper teamMemberMapper;

    @Resource
    private JdbcTemplate jdbcTemplate;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createTeam(TeamCreateDTO dto) {
        // 检查团队编码是否存在
        LambdaQueryWrapper<Team> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Team::getTeamCode, dto.getTeamCode());
        if (baseMapper.selectCount(queryWrapper) > 0) {
            throw new BusinessException("团队编码已存在");
        }

        // 构建团队实体
        Team team = new Team();
        team.setId(SnowflakeIdGenerator.getInstance().nextId());
        team.setTeamName(dto.getTeamName());
        team.setTeamCode(dto.getTeamCode());
        team.setDescription(dto.getDescription());

        // 处理层级关系
        if (dto.getParentId() != null) {
            Team parentTeam = baseMapper.selectById(dto.getParentId());
            if (parentTeam == null) {
                throw new BusinessException("父团队不存在");
            }
            team.setParentId(dto.getParentId());
            team.setLevel(parentTeam.getLevel() + 1);
            team.setPath(parentTeam.getPath() + "/" + team.getId());
        } else {
            team.setLevel(1);
            team.setPath("/" + team.getId());
        }

        team.setLeaderId(dto.getLeaderId());
        team.setStatus(1);
        team.setMemberCount(0);
        team.setDocCount(0);

        baseMapper.insert(team);
        log.info("创建团队成功,团队ID: {}", team.getId());
        return team.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateTeam(TeamUpdateDTO dto) {
        Team team = baseMapper.selectById(dto.getId());
        if (team == null) {
            throw new BusinessException("团队不存在");
        }

        // 检查团队编码是否被占用
        if (StrUtil.isNotBlank(dto.getTeamCode())
                && !dto.getTeamCode().equals(team.getTeamCode())) {
            LambdaQueryWrapper<Team> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Team::getTeamCode, dto.getTeamCode());
            queryWrapper.ne(Team::getId, dto.getId());
            if (baseMapper.selectCount(queryWrapper) > 0) {
                throw new BusinessException("团队编码已被占用");
            }
        }

        // 部分更新
        Team updateEntity = new Team();
        updateEntity.setId(dto.getId());
        if (StrUtil.isNotBlank(dto.getTeamName())) {
            updateEntity.setTeamName(dto.getTeamName());
        }
        if (StrUtil.isNotBlank(dto.getTeamCode())) {
            updateEntity.setTeamCode(dto.getTeamCode());
        }
        if (StrUtil.isNotBlank(dto.getDescription())) {
            updateEntity.setDescription(dto.getDescription());
        }
        if (dto.getLeaderId() != null) {
            updateEntity.setLeaderId(dto.getLeaderId());
        }
        if (dto.getStatus() != null) {
            updateEntity.setStatus(dto.getStatus());
        }

        int result = baseMapper.updateById(updateEntity);
        log.info("更新团队成功,团队ID: {}", dto.getId());
        return result > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean deleteTeam(Long teamId) {
        // 检查是否有子团队
        LambdaQueryWrapper<Team> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Team::getParentId, teamId);
        long childCount = baseMapper.selectCount(queryWrapper);
        if (childCount > 0) {
            throw new BusinessException("该团队下有子团队,无法删除");
        }

        // 清理团队成员关联
        LambdaQueryWrapper<TeamMember> memberWrapper = new LambdaQueryWrapper<>();
        memberWrapper.eq(TeamMember::getTeamId, teamId);
        teamMemberMapper.delete(memberWrapper);

        // 软删除团队
        int result = baseMapper.deleteById(teamId);
        log.info("删除团队成功,团队ID: {}", teamId);
        return result > 0;
    }

    @Override
    public TeamVO getTeamDetail(Long teamId) {
        Team team = baseMapper.selectById(teamId);
        if (team == null) {
            throw new BusinessException("团队不存在");
        }
        return convertToVO(team);
    }

    @Override
    public PageResult<TeamVO> pageTeams(TeamQueryDTO dto) {
        LambdaQueryWrapper<Team> queryWrapper = new LambdaQueryWrapper<>();

        if (StrUtil.isNotBlank(dto.getTeamName())) {
            queryWrapper.like(Team::getTeamName, dto.getTeamName());
        }
        if (StrUtil.isNotBlank(dto.getTeamCode())) {
            queryWrapper.eq(Team::getTeamCode, dto.getTeamCode());
        }
        if (dto.getStatus() != null) {
            queryWrapper.eq(Team::getStatus, dto.getStatus());
        }

        queryWrapper.orderByAsc(Team::getLevel)
                    .orderByDesc(Team::getCreateTime);

        Page<Team> page = new Page<>(dto.getCurrent(), dto.getSize());
        Page<Team> resultPage = baseMapper.selectPage(page, queryWrapper);

        List<TeamVO> voList = resultPage.getRecords().stream()
                .map(this::convertToVO)
                .collect(Collectors.toList());

        return PageResult.of(
                resultPage.getCurrent(),
                resultPage.getSize(),
                resultPage.getTotal(),
                voList
        );
    }

    @Override
    public List<TeamVO> getTeamTree() {
        LambdaQueryWrapper<Team> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Team::getStatus, 1);
        queryWrapper.orderByAsc(Team::getLevel)
                    .orderByAsc(Team::getCreateTime);

        List<Team> allTeams = baseMapper.selectList(queryWrapper);
        return buildTeamTree(allTeams, null);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean addTeamMembers(Long teamId, List<Long> userIds) {
        if (CollUtil.isEmpty(userIds)) {
            return false;
        }

        Team team = baseMapper.selectById(teamId);
        if (team == null) {
            throw new BusinessException("团队不存在");
        }

        int addedCount = 0;
        for (Long userId : userIds) {
            // 检查是否已是成员
            LambdaQueryWrapper<TeamMember> existWrapper = new LambdaQueryWrapper<>();
            existWrapper.eq(TeamMember::getTeamId, teamId)
                        .eq(TeamMember::getUserId, userId);
            if (teamMemberMapper.selectCount(existWrapper) > 0) {
                continue;
            }

            TeamMember member = new TeamMember();
            member.setId(SnowflakeIdGenerator.getInstance().nextId());
            member.setTeamId(teamId);
            member.setUserId(userId);
            member.setMemberRole("member");
            member.setJoinTime(LocalDateTime.now());
            teamMemberMapper.insert(member);
            addedCount++;
        }

        // 重新计算成员数量
        Long actualCount = teamMemberMapper.countByTeamId(teamId);
        Team updateTeam = new Team();
        updateTeam.setId(teamId);
        updateTeam.setMemberCount(actualCount.intValue());
        baseMapper.updateById(updateTeam);

        log.info("添加团队成员成功,团队ID: {}, 新增: {}, 总数: {}",
                teamId, addedCount, actualCount);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean removeTeamMembers(Long teamId, List<Long> userIds) {
        if (CollUtil.isEmpty(userIds)) {
            return false;
        }

        Team team = baseMapper.selectById(teamId);
        if (team == null) {
            throw new BusinessException("团队不存在");
        }

        // 删除成员关联记录
        teamMemberMapper.deleteByTeamIdAndUserIds(teamId, userIds);

        // 重新计算成员数量
        Long actualCount = teamMemberMapper.countByTeamId(teamId);
        Team updateTeam = new Team();
        updateTeam.setId(teamId);
        updateTeam.setMemberCount(actualCount.intValue());
        baseMapper.updateById(updateTeam);

        log.info("移除团队成员成功,团队ID: {}, 移除: {}, 剩余: {}",
                teamId, userIds.size(), actualCount);
        return true;
    }

    @Override
    public List<TeamMemberVO> getTeamMembers(Long teamId) {
        Team team = baseMapper.selectById(teamId);
        if (team == null) {
            throw new BusinessException("团队不存在");
        }

        List<TeamMember> members = teamMemberMapper.selectByTeamId(teamId);
        if (CollUtil.isEmpty(members)) {
            return new ArrayList<>();
        }

        // 批量查询用户信息
        List<Long> userIds = members.stream()
                .map(TeamMember::getUserId)
                .collect(Collectors.toList());

        String userSql = "SELECT id, username, real_name, avatar FROM kb_user "
                + "WHERE id IN (" + userIds.stream()
                    .map(String::valueOf).collect(Collectors.joining(","))
                + ") AND deleted = 0";
        List<Map<String, Object>> userRows = jdbcTemplate.queryForList(userSql);

        Map<Long, Map<String, Object>> userMap = userRows.stream()
                .collect(Collectors.toMap(
                        row -> ((Number) row.get("id")).longValue(),
                        row -> row
                ));

        return members.stream().map(member -> {
            Map<String, Object> userInfo = userMap.get(member.getUserId());
            String username = userInfo != null
                    ? (String) userInfo.get("username") : "未知用户";
            String realName = userInfo != null
                    ? (String) userInfo.get("real_name") : null;
            String avatar = userInfo != null
                    ? (String) userInfo.get("avatar") : null;

            return TeamMemberVO.builder()
                    .userId(member.getUserId())
                    .username(username)
                    .realName(realName)
                    .avatar(avatar)
                    .role(member.getMemberRole())
                    .joinedAt(member.getJoinTime())
                    .build();
        }).collect(Collectors.toList());
    }

    // ========== 私有辅助方法 ==========

    /**
     * 构建团队树
     */
    private List<TeamVO> buildTeamTree(List<Team> allTeams, Long parentId) {
        List<TeamVO> tree = new ArrayList<>();

        for (Team team : allTeams) {
            if ((parentId == null && team.getParentId() == null)
                    || (parentId != null && parentId.equals(team.getParentId()))) {
                TeamVO vo = convertToVO(team);
                vo.setChildren(buildTeamTree(allTeams, team.getId()));
                tree.add(vo);
            }
        }

        return tree;
    }

    /**
     * 转换为VO
     */
    private TeamVO convertToVO(Team team) {
        TeamVO vo = new TeamVO();
        BeanUtil.copyProperties(team, vo);
        vo.setCreatedAt(team.getCreateTime());

        // 设置父团队名称
        if (team.getParentId() != null) {
            Team parentTeam = baseMapper.selectById(team.getParentId());
            if (parentTeam != null) {
                vo.setParentName(parentTeam.getTeamName());
            }
        }

        // 设置负责人名称(跨表查询kb_user)
        if (team.getLeaderId() != null) {
            try {
                List<Map<String, Object>> rows = jdbcTemplate.queryForList(
                    "SELECT username FROM kb_user WHERE id = ? AND deleted = 0",
                    team.getLeaderId()
                );
                if (CollUtil.isNotEmpty(rows)) {
                    vo.setLeaderName((String) rows.get(0).get("username"));
                }
            } catch (Exception e) {
                log.warn("获取团队负责人信息失败: leaderId={}", team.getLeaderId(), e);
            }
        }

        return vo;
    }
}

6.3 核心算法说明

6.3.1 树形结构构建

private List<TeamVO> buildTeamTree(List<Team> allTeams, Long parentId) {
    List<TeamVO> tree = new ArrayList<>();

    for (Team team : allTeams) {
        if ((parentId == null && team.getParentId() == null)
                || (parentId != null && parentId.equals(team.getParentId()))) {
            TeamVO vo = convertToVO(team);
            vo.setChildren(buildTeamTree(allTeams, team.getId()));
            tree.add(vo);
        }
    }

    return tree;
}

算法特点:

  • 时间复杂度:O(n²),n为节点数量
  • 空间复杂度:O(n),递归栈深度
  • 适用场景:中小型组织架构树(<1000个节点)
  • 支持多根节点(parentId = null 的团队并列展示)

6.3.2 层级路径设计

创建团队时自动计算层级和路径:

if (dto.getParentId() != null) {
    Team parentTeam = baseMapper.selectById(dto.getParentId());
    team.setParentId(dto.getParentId());
    team.setLevel(parentTeam.getLevel() + 1);       // 层级 = 父级 + 1
    team.setPath(parentTeam.getPath() + "/" + team.getId()); // 路径拼接
} else {
    team.setLevel(1);          // 根团队层级为1
    team.setPath("/" + team.getId()); // 根路径
}

路径设计优势:

  • 查询所有子团队:WHERE path LIKE '/1/%'(一次查询)
  • 查询直接子团队:WHERE parent_id = 1
  • 不用递归也能获取完整子树

6.3.3 删除前检查

// 检查是否有子团队
long childCount = baseMapper.selectCount(
    new LambdaQueryWrapper<Team>().eq(Team::getParentId, teamId)
);
if (childCount > 0) {
    throw new BusinessException("该团队下有子团队,无法删除");
}

删除逻辑:

  1. 检查是否有子团队 - 有则拒绝删除
  2. 清理 kb_team_member 中的所有成员关联
  3. 软删除 kb_team 中的团队记录

七、控制器层

7.1 创建 TeamController

创建 kb-user-auth/src/main/java/com/knowledge/base/userauth/controller/TeamController.java:

package com.knowledge.base.userauth.controller;

import com.knowledge.base.common.annotation.OperationLog;
import com.knowledge.base.common.result.PageResult;
import com.knowledge.base.common.result.Result;
import com.knowledge.base.userauth.dto.TeamCreateDTO;
import com.knowledge.base.userauth.dto.TeamQueryDTO;
import com.knowledge.base.userauth.dto.TeamUpdateDTO;
import com.knowledge.base.userauth.service.TeamService;
import com.knowledge.base.userauth.vo.TeamMemberVO;
import com.knowledge.base.userauth.vo.TeamVO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RestController
@RequestMapping("/teams")
@RequiredArgsConstructor
@Tag(name = "团队管理", description = "团队管理相关接口")
public class TeamController {

    private final TeamService teamService;

    @PostMapping
    @Operation(summary = "创建团队", description = "创建新的团队")
    @OperationLog(module = "团队管理", operation = "创建团队", description = "创建新团队")
    public Result<Long> createTeam(@Valid @RequestBody TeamCreateDTO dto) {
        Long teamId = teamService.createTeam(dto);
        return Result.success(teamId);
    }

    @PutMapping
    @Operation(summary = "更新团队", description = "更新团队信息")
    @OperationLog(module = "团队管理", operation = "更新团队", description = "更新团队信息")
    public Result<Boolean> updateTeam(@Valid @RequestBody TeamUpdateDTO dto) {
        Boolean result = teamService.updateTeam(dto);
        return Result.success(result);
    }

    @DeleteMapping("/{teamId}")
    @Operation(summary = "删除团队", description = "删除指定团队")
    @OperationLog(module = "团队管理", operation = "删除团队", description = "删除团队")
    public Result<Boolean> deleteTeam(@PathVariable Long teamId) {
        Boolean result = teamService.deleteTeam(teamId);
        return Result.success(result);
    }

    @GetMapping("/{teamId}")
    @Operation(summary = "获取团队详情", description = "根据ID获取团队详情")
    public Result<TeamVO> getTeamDetail(@PathVariable Long teamId) {
        TeamVO teamVO = teamService.getTeamDetail(teamId);
        return Result.success(teamVO);
    }

    @PostMapping("/page")
    @Operation(summary = "分页查询团队", description = "分页查询团队列表")
    public Result<PageResult<TeamVO>> pageTeams(@RequestBody TeamQueryDTO dto) {
        PageResult<TeamVO> pageResult = teamService.pageTeams(dto);
        return Result.success(pageResult);
    }

    @GetMapping("/tree")
    @Operation(summary = "获取团队树", description = "获取完整的团队树结构")
    public Result<List<TeamVO>> getTeamTree() {
        List<TeamVO> teamTree = teamService.getTeamTree();
        return Result.success(teamTree);
    }

    @PostMapping("/{teamId}/members")
    @Operation(summary = "添加团队成员", description = "批量添加团队成员")
    @OperationLog(module = "团队管理", operation = "添加成员", description = "添加团队成员")
    public Result<Boolean> addTeamMembers(
            @PathVariable Long teamId,
            @RequestBody List<Long> userIds) {
        Boolean result = teamService.addTeamMembers(teamId, userIds);
        return Result.success(result);
    }

    @DeleteMapping("/{teamId}/members")
    @Operation(summary = "移除团队成员", description = "批量移除团队成员")
    @OperationLog(module = "团队管理", operation = "移除成员", description = "移除团队成员")
    public Result<Boolean> removeTeamMembers(
            @PathVariable Long teamId,
            @RequestBody List<Long> userIds) {
        Boolean result = teamService.removeTeamMembers(teamId, userIds);
        return Result.success(result);
    }

    @GetMapping("/{teamId}/members")
    @Operation(summary = "获取团队成员", description = "获取团队成员列表")
    public Result<List<TeamMemberVO>> getTeamMembers(@PathVariable Long teamId) {
        List<TeamMemberVO> members = teamService.getTeamMembers(teamId);
        return Result.success(members);
    }
}

7.2 RESTful API 设计

方法路径说明请求参数
POST/teams创建团队TeamCreateDTO(Body)
PUT/teams更新团队TeamUpdateDTO(Body)
DELETE/teams/{teamId}删除团队teamId(Path)
GET/teams/{teamId}获取团队详情teamId(Path)
POST/teams/page分页查询团队TeamQueryDTO(Body)
GET/teams/tree获取团队树-
POST/teams/{teamId}/members添加成员teamId(Path)+ userIds(Body)
DELETE/teams/{teamId}/members移除成员teamId(Path)+ userIds(Body)
GET/teams/{teamId}/members获取成员列表teamId(Path)

八、前端开发

8.1 定义 TypeScript 类型

在 src/types/index.ts 中添加 Team 和 TeamMember 类型定义:

export interface Team {
  id: string;
  teamName: string;
  name?: string; // 兼容旧字段
  teamCode?: string;
  description?: string;
  leaderId?: number;
  leaderName?: string;
  leader?: User;
  parentId?: number;
  parentName?: string;
  level?: number;
  path?: string;
  memberCount: number;
  docCount?: number;
  status?: number;
  sort?: number;
  createdAt?: string;
  updatedAt?: string;
  createdBy?: string;
  children?: Team[];
}

export interface TeamMember {
  userId: string;
  username: string;
  realName?: string;
  avatar?: string;
  role: string;
  joinedAt: string;
}

8.2 创建 API 服务层

创建 src/services/team.service.ts:

import { http } from './request';
import { Team, TeamMember } from '@/types';

export const teamService = {
  // 分页查询团队
  getTeams: (params?: {
    current?: number;
    size?: number;
    teamName?: string;
    status?: number;
  }) => {
    return http.post<{
      current: number;
      size: number;
      total: number;
      pages: number;
      records: Team[];
    }>('/auth/teams/page', params || {});
  },

  // 获取团队树
  getTeamTree: () => {
    return http.get<Team[]>('/auth/teams/tree');
  },

  // 获取团队详情
  getTeam: (id: string) => {
    return http.get<Team>(`/auth/teams/${id}`);
  },

  // 创建团队
  createTeam: (data: {
    teamName: string;
    teamCode: string;
    description?: string;
    leaderId: string;
    parentId?: string;
  }) => {
    return http.post<number>('/auth/teams', data);
  },

  // 更新团队
  updateTeam: (data: {
    id: string;
    teamName?: string;
    teamCode?: string;
    description?: string;
    leaderId?: string;
    status?: number;
  }) => {
    return http.put<boolean>('/auth/teams', data);
  },

  // 删除团队
  deleteTeam: (id: string) => {
    return http.delete<boolean>(`/auth/teams/${id}`);
  },

  // 添加团队成员(批量)
  addMembers: (teamId: string, userIds: string[]) => {
    return http.post<boolean>(`/auth/teams/${teamId}/members`, userIds);
  },

  // 移除团队成员(批量)
  removeMembers: (teamId: string, userIds: string[]) => {
    return http.delete<boolean>(
      `/auth/teams/${teamId}/members`,
      { data: userIds } as any
    );
  },

  // 获取团队成员列表
  getTeamMembers: (teamId: string) => {
    return http.get<TeamMember[]>(`/auth/teams/${teamId}/members`);
  },
};

export default teamService;

在 src/services/index.ts 中导出:

export { default as teamService } from './team.service';

8.3 创建管理页面

创建 src/pages/admin/TeamsPage.tsx:

实现要点:

  1. 状态管理:使用 React useState 管理团队列表、选中团队、成员列表、分页状态
  2. 分页查询:调用 teamService.getTeams 并维护 pagination 状态
  3. 成员管理:左侧点击团队,右侧展示详情和成员列表
  4. 添加成员:多选下拉框,自动过滤已有成员
  5. 头像展示:使用 <img> 标签,支持真实头像和默认头像回退
  6. Modal 表单:创建/编辑团队使用 Ant Design Modal + Form

关键代码结构:

export const TeamsPage: React.FC = () => {
  const { message } = App.useApp();
  const [teams, setTeams] = useState<Team[]>([]);
  const [selectedTeam, setSelectedTeam] = useState<Team | null>(null);
  const [teamMembers, setTeamMembers] = useState<TeamMember[]>([]);
  const [modalVisible, setModalVisible] = useState(false);
  const [editingTeam, setEditingTeam] = useState<Team | null>(null);
  const [pagination, setPagination] = useState({
    current: 1, size: 10, total: 0
  });

  // 获取团队列表
  const fetchTeams = async (page = 1, pageSize = 10) => {
    const result = await teamService.getTeams({
      current: page, size: pageSize
    });
    setTeams(result.records || []);
    setPagination({
      current: result.current,
      size: result.size,
      total: result.total,
    });
  };

  // 创建团队
  const handleSubmit = async (values: any) => {
    if (editingTeam) {
      await teamService.updateTeam({ id: editingTeam.id, ...values });
    } else {
      await teamService.createTeam(values);
    }
    // 刷新列表
    fetchTeams(pagination.current, pagination.size);
  };

  // 获取团队成员
  const fetchTeamMembers = async (teamId: string) => {
    const members = await teamService.getTeamMembers(teamId);
    setTeamMembers(members || []);
  };

  // ... 渲染左右两栏布局
};

团队负责人头像展示:

import { DEFAULT_AVATAR } from '@/constants/default-avatar';

// 团队负责人
<Space>
  <img
    src={selectedTeam.leader?.avatar || DEFAULT_AVATAR}
    alt={selectedTeam.leaderName || ''}
    style={{ width: '24px', height: '24px',
             borderRadius: '50%', objectFit: 'cover' }}
  />
  <Text>{selectedTeam.leaderName || selectedTeam.leader?.username
         || selectedTeam.leaderId || '未设置'}</Text>
</Space>
// 团队成员列表
<List.Item.Meta
  avatar={
    <img
      src={member.avatar || DEFAULT_AVATAR}
      alt={member.username || ''}
      style={{ width: '32px', height: '32px',
               borderRadius: '50%', objectFit: 'cover' }}
    />
  }
  title={...}
/>

8.4 配置路由

在 src/router/index.tsx 中添加路由:

// 懒加载
const TeamsPage = lazy(() => import('@/pages/admin/TeamsPage'));

// 路由配置(在 ProtectedRoute 中,requireAdmin)
{
  path: 'admin/teams',
  element: (
    <ProtectedRoute requireAdmin>
      <Suspense fallback={<LoadingFallback />}>
        <TeamsPage />
      </Suspense>
    </ProtectedRoute>
  ),
}

测试

按顺序启动下面这些微服务:

kb-gateway

kb-auth

启动前端

cd knowledge-base-frontend

npm run dev

浏览器访问团队空间管理页面:

http://localhost:3002/admin/teams

图片.png

在该页面中可以新增、修改和删除团队空间,也可以添加团队成员。

总结

本文详细介绍了团队空间管理功能的完整实现,涵盖了从数据库设计到前后端开发的全部内容。

已完成功能

功能实现方式说明
团队CRUDService + Controller完整的增删改查
层级结构parentId + level + path三级冗余提升查询效率
成员管理批量添加/删除支持多用户操作
分页查询MyBatis Plus Page支持模糊搜索和多条件筛选
团队树递归构建算法多根节点并列展示
头像展示真实头像 + 默认回退统一的头像显示方案
操作日志@OperationLog 注解记录关键管理操作
权限控制ProtectedRoute仅管理员可访问

通过本文的学习,你应该能够掌握:

  • 层级组织架构的数据设计方法
  • 树形结构构建和路径优化的技巧
  • MyBatis Plus 的 CRUD 和自定义 SQL 使用
  • 前端两栏布局和 Modal 表单的实现模式
  • 批量操作的性能优化方法

祝你开发顺利!

最后修改:2026 年 10 月 24 日
如果觉得我的文章对你有用,请随意赞赏