一、概述
团队空间是知识库系统中的组织协作功能,通过团队层级结构和成员管理,实现文档的团队化组织和权限隔离。
本文将详细介绍如何在 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 表:
| 字段 | 类型 | 说明 | 必填 | 默认值 |
|---|---|---|---|---|
| id | BIGINT | 团队ID(雪花算法) | 是 | - |
| team\_name | VARCHAR(100) | 团队名称 | 是 | - |
| team\_code | VARCHAR(50) | 团队编码(唯一) | 否 | - |
| description | VARCHAR(500) | 团队描述 | 否 | - |
| leader\_id | BIGINT | 团队负责人ID | 否 | - |
| parent\_id | BIGINT | 父团队ID | 是 | 0 |
| sort | INT | 排序号 | 是 | 0 |
| status | TINYINT | 状态(0-禁用,1-启用) | 是 | 1 |
kb\_team\_member 表:
| 字段 | 类型 | 说明 | 必填 | 默认值 |
|---|---|---|---|---|
| id | BIGINT | 主键ID | 是 | - |
| team\_id | BIGINT | 团队ID | 是 | - |
| user\_id | BIGINT | 用户ID | 是 | - |
| member\_role | VARCHAR(20) | 成员角色 | 是 | member |
| join\_time | DATETIME | 加入时间 | 是 | 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 设计思路
- Team 继承 BaseEntity:复用基础字段(id、创建时间、更新时间、逻辑删除等)
level 和 path 字段:冗余存储层级关系,加速查询
level:根团队为 1,每级递增path:如/1/2/3,用LIKE '/1/%'快速查询所有子团队
- memberCount:冗余字段,避免频繁 JOIN 查询成员数
- 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("该团队下有子团队,无法删除");
}删除逻辑:
- 检查是否有子团队 - 有则拒绝删除
- 清理
kb_team_member中的所有成员关联 - 软删除
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:
实现要点:
- 状态管理:使用 React useState 管理团队列表、选中团队、成员列表、分页状态
- 分页查询:调用
teamService.getTeams并维护 pagination 状态 - 成员管理:左侧点击团队,右侧展示详情和成员列表
- 添加成员:多选下拉框,自动过滤已有成员
- 头像展示:使用
<img>标签,支持真实头像和默认头像回退 - 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

在该页面中可以新增、修改和删除团队空间,也可以添加团队成员。
总结
本文详细介绍了团队空间管理功能的完整实现,涵盖了从数据库设计到前后端开发的全部内容。
已完成功能
| 功能 | 实现方式 | 说明 |
|---|---|---|
| 团队CRUD | Service + Controller | 完整的增删改查 |
| 层级结构 | parentId + level + path | 三级冗余提升查询效率 |
| 成员管理 | 批量添加/删除 | 支持多用户操作 |
| 分页查询 | MyBatis Plus Page | 支持模糊搜索和多条件筛选 |
| 团队树 | 递归构建算法 | 多根节点并列展示 |
| 头像展示 | 真实头像 + 默认回退 | 统一的头像显示方案 |
| 操作日志 | @OperationLog 注解 | 记录关键管理操作 |
| 权限控制 | ProtectedRoute | 仅管理员可访问 |
通过本文的学习,你应该能够掌握:
- 层级组织架构的数据设计方法
- 树形结构构建和路径优化的技巧
- MyBatis Plus 的 CRUD 和自定义 SQL 使用
- 前端两栏布局和 Modal 表单的实现模式
- 批量操作的性能优化方法
祝你开发顺利!