一、概述

公共基础服务(kb-foundation)是知识库系统的核心支撑模块,提供系统级的公共服务功能,包括数据字典管理、系统配置管理、通知管理、操作日志记录等功能。

本文将详细介绍如何从零开始搭建公共基础服务模块。

1.1 服务定位

公共基础服务作为系统的基础设施层,为其他业务模块提供:

功能模块说明使用场景
字典管理管理系统中的字典数据下拉选项、数据枚举等
系统配置管理系统运行参数AI配置、存储配置、通知配置等
通知管理统一的消息通知服务系统消息、评论通知、@提醒等
操作日志记录用户操作行为审计追踪、安全监控

1.2 技术架构

kb-foundation
├── 数据持久层:MyBatis Plus + MySQL
├── 缓存层:Redis(字典缓存、配置缓存)
├── 消息队列:RabbitMQ(异步通知)
├── 实时通信:WebSocket + STOMP(通知推送)
├── API文档:Knife4j
└── 基础设施:Spring Boot 3.2

二、环境准备

2.1 中间件安装

公共基础服务需要以下中间件支持:

# Redis安装(Mac)
brew install redis
brew services start redis

# RabbitMQ安装(Mac)
brew install rabbitmq
brew services start rabbitmq

# 验证服务状态
redis-cli ping    # 应返回 PONG
rabbitmq-server  # 启动RabbitMQ服务

也可以直接连接我在京东云服务器上搭建好的中间件。

2.2 数据库准备

创建kb\_foundation数据库:

mysql -u root -p -e "CREATE DATABASE kb_foundation DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"

三、创建模块骨架

3.1 创建Maven模块

在项目根目录下创建kb-foundation子模块:

mkdir -p kb-foundation/src/main/java/com/knowledge/base/foundation
mkdir -p kb-foundation/src/main/resources

3.2 配置pom.xml

创建 kb-foundation/pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.knowledge.base</groupId>
        <artifactId>knowledge-base-backend</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <artifactId>kb-foundation</artifactId>
    <packaging>jar</packaging>
    <name>Knowledge Base Foundation Service</name>
    <description>基础服务(系统配置、通知、操作日志、字典管理)</description>
    <dependencies>
        <!-- 公共模块 -->
        <dependency>
            <groupId>com.knowledge.base</groupId>
            <artifactId>kb-common</artifactId>
        </dependency>
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Spring Boot Validation -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <!-- WebSocket -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- Druid数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-3-starter</artifactId>
        </dependency>
        <!-- MyBatis Plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
        </dependency>
        <!-- Redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- Spring Cache -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <!-- RabbitMQ -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!-- Hutool -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
        </dependency>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- Knife4j -->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
        </dependency>
        <!-- Test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

四、数据库设计

4.1 字典类型表 (kb\_dict)

CREATE TABLE `kb_dict` (
    `id` BIGINT NOT NULL COMMENT '字典ID',
    `dict_code` VARCHAR(100) NOT NULL COMMENT '字典编码',
    `dict_name` VARCHAR(100) NOT NULL COMMENT '字典名称',
    `dict_type` VARCHAR(50) NOT NULL COMMENT '字典类型',
    `description` VARCHAR(500) COMMENT '描述',
    `sort` INT DEFAULT 0 COMMENT '排序',
    `status` TINYINT DEFAULT 1 COMMENT '状态:0-禁用,1-正常',
    `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `update_time` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    `create_by` BIGINT COMMENT '创建人ID',
    `update_by` BIGINT COMMENT '更新人ID',
    `deleted` TINYINT DEFAULT 0 COMMENT '删除标记:0-未删除,1-已删除',
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_dict_code` (`dict_code`),
    KEY `idx_dict_type` (`dict_type`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='字典类型表';

4.2 字典数据表 (kb\_dict\_data)

CREATE TABLE `kb_dict_data` (
    `id` BIGINT NOT NULL COMMENT '数据ID',
    `dict_id` BIGINT NOT NULL COMMENT '字典ID',
    `dict_code` VARCHAR(100) NOT NULL COMMENT '字典编码',
    `dict_label` VARCHAR(100) NOT NULL COMMENT '字典标签',
    `dict_value` VARCHAR(100) NOT NULL COMMENT '字典值',
    `dict_sort` INT DEFAULT 0 COMMENT '排序',
    `css_class` VARCHAR(100) COMMENT '样式类名',
    `list_class` VARCHAR(100) COMMENT '列表样式',
    `is_default` TINYINT DEFAULT 0 COMMENT '是否默认:0-否,1-是',
    `status` TINYINT DEFAULT 1 COMMENT '状态:0-禁用,1-正常',
    `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    PRIMARY KEY (`id`),
    KEY `idx_dict_id` (`dict_id`),
    KEY `idx_dict_code` (`dict_code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='字典数据表';

4.3 系统配置表 (kb\_system\_config)

CREATE TABLE `kb_system_config` (
    `id` BIGINT NOT NULL COMMENT '配置ID',
    `config_key` VARCHAR(100) NOT NULL COMMENT '配置键',
    `config_value` TEXT COMMENT '配置值',
    `config_type` VARCHAR(20) NOT NULL COMMENT '配置类型:string/number/boolean/json',
    `category` VARCHAR(50) NOT NULL COMMENT '配置分类:AI/STORAGE/NOTIFICATION/SECURITY等',
    `description` VARCHAR(500) COMMENT '配置描述',
    `is_public` TINYINT DEFAULT 0 COMMENT '是否公开:0-私有,1-公开',
    `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `update_time` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    `create_by` BIGINT COMMENT '创建人ID',
    `update_by` BIGINT COMMENT '更新人ID',
    `deleted` TINYINT DEFAULT 0 COMMENT '删除标记:0-未删除,1-已删除',
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_config_key` (`config_key`),
    KEY `idx_category` (`category`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='系统配置表';

4.4 系统通知表 (kb\_notification)

CREATE TABLE `kb_notification` (
    `id` BIGINT NOT NULL COMMENT '通知ID',
    `user_id` BIGINT NOT NULL COMMENT '接收用户ID',
    `user_name` VARCHAR(50) COMMENT '用户姓名(冗余字段)',
    `notification_type` VARCHAR(20) NOT NULL COMMENT '通知类型:system/comment/mention/review/like',
    `title` VARCHAR(200) NOT NULL COMMENT '通知标题',
    `content` TEXT COMMENT '通知内容',
    `link` VARCHAR(500) COMMENT '跳转链接',
    `related_type` VARCHAR(50) COMMENT '关联类型',
    `related_id` BIGINT COMMENT '关联ID',
    `is_read` TINYINT DEFAULT 0 COMMENT '是否已读:0-未读,1-已读',
    `read_time` DATETIME COMMENT '阅读时间',
    `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    PRIMARY KEY (`id`),
    KEY `idx_user_id` (`user_id`),
    KEY `idx_is_read` (`is_read`),
    KEY `idx_create_time` (`create_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='系统通知表';

4.5 操作日志表 (kb\_operation\_log)

CREATE TABLE `kb_operation_log` (
    `id` BIGINT NOT NULL COMMENT '日志ID',
    `module` VARCHAR(50) COMMENT '模块名称',
    `operation_type` VARCHAR(20) COMMENT '操作类型:LOGIN/CREATE/UPDATE/DELETE等',
    `operation_desc` VARCHAR(500) COMMENT '操作描述',
    `request_method` VARCHAR(10) COMMENT '请求方法:GET/POST/PUT/DELETE',
    `request_url` VARCHAR(500) COMMENT '请求URL',
    `request_params` TEXT COMMENT '请求参数(JSON)',
    `response_result` TEXT COMMENT '响应结果(JSON)',
    `user_id` BIGINT COMMENT '操作用户ID',
    `username` VARCHAR(50) COMMENT '操作用户名',
    `ip_address` VARCHAR(50) COMMENT 'IP地址',
    `location` VARCHAR(200) COMMENT '地理位置',
    `user_agent` VARCHAR(500) COMMENT '用户代理',
    `execute_time` INT COMMENT '执行时长(毫秒)',
    `status` TINYINT COMMENT '状态:0-失败,1-成功',
    `error_msg` TEXT COMMENT '错误信息',
    `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '操作时间',
    PRIMARY KEY (`id`),
    KEY `idx_user_id` (`user_id`),
    KEY `idx_create_time` (`create_time`),
    KEY `idx_operation_type` (`operation_type`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='操作日志表';

五、应用启动配置

5.1 创建启动类

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/FoundationApplication.java:

package com.knowledge.base.foundation;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * kb-foundation基础服务启动类
 *
 * @author 苏三
 * @since 1.0.0
 */
@EnableAsync
@EnableCaching
@EnableTransactionManagement
@SpringBootApplication
@ComponentScan(basePackages = {"com.knowledge.base.foundation", "com.knowledge.base.common"})
public class FoundationApplication {

    public static void main(String[] args) {
        SpringApplication.run(FoundationApplication.class, args);
        System.out.println("""

                ========================================
                   基础服务启动成功!
                   服务名称: kb-foundation
                   服务端口: 8089
                   API文档: http://localhost:8089/api/foundation/doc.html
                   Druid监控: http://localhost:8089/api/foundation/druid/
                ========================================
                """);
    }
}

5.2 配置application.yml

创建 kb-foundation/src/main/resources/application.yml:

server:
  port: 8089
  servlet:
    context-path: /api/foundation

spring:
  application:
    name: kb-foundation

  # 数据源配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/kb_foundation?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
    username: root
    password: 123456
    druid:
      initial-size: 5
      min-idle: 5
      max-active: 20
      max-wait: 60000
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: SELECT 1
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      filters: stat,wall
      connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      web-stat-filter:
        enabled: true
        url-pattern: /*
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        reset-enable: false
        login-username: admin
        login-password: admin

  # Redis配置
  redis:
    host: localhost
    port: 6379
    password:
    database: 9
    timeout: 10000ms
    lettuce:
      pool:
        max-active: 8
        max-wait: -1ms
        max-idle: 8
        min-idle: 0

  # RabbitMQ配置
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    listener:
      simple:
        acknowledge-mode: manual
        prefetch: 1

  # Jackson配置
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
    default-property-inclusion: non_null

  # Cache配置
  cache:
    type: redis
    redis:
      time-to-live: 600000

# MyBatis Plus配置
mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml
  type-aliases-package: com.knowledge.base.foundation.entity
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: false
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl
  global-config:
    db-config:
      id-type: input
      logic-delete-field: deleted
      logic-delete-value: 1
      logic-not-delete-value: 0

# 日志配置
logging:
  level:
    root: INFO
    com.knowledge.base: DEBUG
    com.baomidou.mybatisplus: DEBUG
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n"

# Swagger配置
knife4j:
  enable: true
  setting:
    language: zh_cn
  production: false

# WebSocket配置
websocket:
  enabled: true
  path: /ws/notification
  allowed-origins: "*"

# 通知配置
notification:
  retention-days: 90
  batch-size: 100

六、基础设施配置

6.1 Redis缓存配置

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/config/RedisCacheConfig.java:

package com.knowledge.base.foundation.config;

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * Redis缓存配置
 *
 * @author 苏三
 * @since 1.0.0
 */
@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {

    /**
     * 缓存管理器
     */
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        // 配置序列化
        RedisSerializationContext.SerializationPair<Object> jsonSerializer =
                RedisSerializationContext.SerializationPair.fromSerializer(
                        new GenericJackson2JsonRedisSerializer());

        // 配置缓存策略
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(jsonSerializer)
                .entryTtl(Duration.ofMinutes(10)) // 默认10分钟过期
                .disableCachingNullValues();

        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(defaultCacheConfig)
                .transactionAware()
                .build();
    }
}

6.2 RabbitMQ消息配置

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/config/RabbitMQConfig.java:

package com.knowledge.base.foundation.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * RabbitMQ消息队列配置
 *
 * @author 苏三
 * @since 1.0.0
 */
@Configuration
public class RabbitMQConfig {

    // 通知交换机
    public static final String NOTIFICATION_EXCHANGE = "kb.notification.exchange";

    // 通知队列
    public static final String NOTIFICATION_QUEUE = "kb.notification.queue";
    public static final String NOTIFICATION_ROUTING_KEY = "notification.#";

    // 系统配置更新交换机
    public static final String CONFIG_EXCHANGE = "kb.config.exchange";

    // 系统配置更新队列
    public static final String CONFIG_QUEUE = "kb.config.queue";
    public static final String CONFIG_ROUTING_KEY = "config.update";

    /**
     * 通知交换机(主题模式)
     */
    @Bean
    public TopicExchange notificationExchange() {
        return new TopicExchange(NOTIFICATION_EXCHANGE, true, false);
    }

    /**
     * 通知队列
     */
    @Bean
    public Queue notificationQueue() {
        return QueueBuilder.durable(NOTIFICATION_QUEUE).build();
    }

    /**
     * 通知队列绑定
     */
    @Bean
    public Binding notificationBinding() {
        return BindingBuilder.bind(notificationQueue())
                .to(notificationExchange())
                .with(NOTIFICATION_ROUTING_KEY);
    }

    /**
     * 系统配置更新交换机(直连模式)
     */
    @Bean
    public DirectExchange configExchange() {
        return new DirectExchange(CONFIG_EXCHANGE, true, false);
    }

    /**
     * 系统配置更新队列
     */
    @Bean
    public Queue configQueue() {
        return QueueBuilder.durable(CONFIG_QUEUE).build();
    }

    /**
     * 系统配置队列绑定
     */
    @Bean
    public Binding configBinding() {
        return BindingBuilder.bind(configQueue())
                .to(configExchange())
                .with(CONFIG_ROUTING_KEY);
    }

    /**
     * RabbitMQ模板(配置消息转换器)
     */
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(new org.springframework.amqp.support.converter.Jackson2JsonMessageConverter());
        return rabbitTemplate;
    }
}

6.3 WebSocket实时通信配置

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/config/WebSocketConfig.java:

package com.knowledge.base.foundation.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

/**
 * WebSocket配置
 *
 * @author 苏三
 * @since 1.0.0
 */
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    /**
     * 配置消息代理
     */
    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        // 启用简单消息代理,用于向客户端推送消息
        registry.enableSimpleBroker("/topic", "/queue");
        // 设置客户端发送消息的前缀
        registry.setApplicationDestinationPrefixes("/app");
    }

    /**
     * 配置STOMP端点
     */
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // 注册WebSocket端点,允许跨域
        registry.addEndpoint("/ws/notification")
                .setAllowedOriginPatterns("*")
                .withSockJS(); // 启用SockJS支持
    }
}

6.4 Knife4j API文档配置

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/config/Knife4jConfig.java:

package com.knowledge.base.foundation.config;

import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Contact;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Knife4j配置类
 *
 * @author 苏三
 * @since 1.0.0
 */
@Configuration
public class Knife4jConfig {

    /**
     * 配置OpenAPI
     *
     * @return OpenAPI
     */
    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
            .info(new Info()
                .title("知识库系统 - 公共基础服务API文档")
                .version("1.0.0")
                .description("提供数据字典、系统配置、通知管理、操作日志等功能")
                .contact(new Contact()
                    .name("苏三")
                    .email("support@knowledge-base.com"))
                .license(new License()
                    .name("Apache 2.0")
                    .url("https://www.apache.org/licenses/LICENSE-2.0.html")));
    }
}

七、Common模块基础类

在开始实体类设计之前,先介绍common模块中的基础类,这些类将被所有模块使用。

7.1 基础实体类BaseEntity

创建 kb-common/src/main/java/com/knowledge/base/common/config/BaseEntity.java:

package com.knowledge.base.common.config;

import com.baomidou.mybatisplus.annotation.*;
import com.knowledge.base.common.utils.SnowflakeIdGenerator;
import lombok.Data;

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

/**
 * 基础实体类
 *
 * <p>按照阿里巴巴Java开发规范设计,所有实体类应继承此类</p>
 * <p>包含通用字段:ID、创建时间、更新时间、逻辑删除标记</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
public abstract class BaseEntity implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键ID(雪花算法生成)
     */
    @TableId(type = IdType.INPUT)
    private Long id;

    /**
     * 创建时间
     */
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;

    /**
     * 创建人ID
     */
    @TableField(fill = FieldFill.INSERT)
    private Long createBy;

    /**
     * 更新人ID
     */
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Long updateBy;

    /**
     * 逻辑删除标记(0-未删除,1-已删除)
     */
    @TableLogic
    private Integer deleted;

    /**
     * 乐观锁版本号
     */
    @Version
    private Integer version;

    /**
     * 插入前自动填充ID
     */
    public void preInsert() {
        if (this.id == null) {
            this.id = SnowflakeIdGenerator.getInstance().nextId();
        }
    }
}

设计要点:

  • 使用@TableId(type = IdType.INPUT)配置手动输入ID(由雪花算法生成)
  • 使用@TableField(fill = FieldFill.INSERT)自动填充创建时间和创建人
  • 使用@TableField(fill = FieldFill.INSERT_UPDATE)自动填充更新时间和更新人
  • 使用@TableLogic配置逻辑删除
  • 使用@Version配置乐观锁
  • 提供preInsert()方法在插入前自动生成ID

7.2 分页参数类PageParam

创建 kb-common/src/main/java/com/knowledge/base/common/result/PageParam.java:

package com.knowledge.base.common.result;

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

import java.io.Serializable;

/**
 * 分页查询参数基类
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Schema(description = "分页查询参数")
public class PageParam implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 当前页码
     */
    @Schema(description = "当前页码", example = "1")
    private Long current = 1L;

    /**
     * 每页大小
     */
    @Schema(description = "每页大小", example = "10")
    private Long size = 10L;

    /**
     * 排序字段
     */
    @Schema(description = "排序字段")
    private String sortField;

    /**
     * 排序方式(asc/desc)
     */
    @Schema(description = "排序方式", example = "desc")
    private String sortOrder;

    /**
     * 获取偏移量
     */
    public long getOffset() {
        return (current - 1) * size;
    }
}

设计要点:

  • 提供统一的分页参数基类
  • 默认当前页为1,每页大小为10
  • 支持排序字段和排序方式
  • 提供getOffset()方法计算偏移量

7.3 分页结果类PageResult

创建 kb-common/src/main/java/com/knowledge/base/common/result/PageResult.java:

package com.knowledge.base.common.result;

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.util.Collections;
import java.util.List;

/**
 * 分页结果封装类
 *
 * @param <T> 数据类型
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "分页结果")
public class PageResult<T> implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 当前页码
     */
    @Schema(description = "当前页码")
    private Long current;

    /**
     * 每页大小
     */
    @Schema(description = "每页大小")
    private Long size;

    /**
     * 总记录数
     */
    @Schema(description = "总记录数")
    private Long total;

    /**
     * 总页数
     */
    @Schema(description = "总页数")
    private Long pages;

    /**
     * 数据列表
     */
    @Schema(description = "数据列表")
    private List<T> records;

    /**
     * 构建分页结果
     */
    public static <T> PageResult<T> of(Long current, Long size, Long total, List<T> records) {
        PageResult<T> pageResult = new PageResult<>();
        pageResult.setCurrent(current);
        pageResult.setSize(size);
        pageResult.setTotal(total);
        pageResult.setRecords(records);
        pageResult.setPages((total + size - 1) / size);
        return pageResult;
    }

    /**
     * 空分页结果
     */
    @SuppressWarnings("unchecked")
    public static <T> PageResult<T> empty() {
        return PageResult.<T>builder()
                .current(1L)
                .size(10L)
                .total(0L)
                .records(Collections.emptyList())
                .build();
    }

    /**
     * 判断是否有数据
     */
    public boolean hasData() {
        return records != null && !records.isEmpty();
    }
}

设计要点:

  • 使用@Builder模式支持灵活构建
  • 包含完整的分页信息(当前页、每页大小、总记录数、总页数、数据列表)
  • 提供of()静态方法快速构建分页结果
  • 提供empty()方法返回空分页结果
  • 提供hasData()方法判断是否有数据

7.4 统一响应结果类Result

创建 kb-common/src/main/java/com/knowledge/base/common/result/Result.java:

package com.knowledge.base.common.result;

import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;

import java.io.Serializable;

/**
 * 统一响应结果封装类
 *
 * <p>按照阿里巴巴Java开发规范设计,所有接口返回统一格式的响应结果</p>
 *
 * @param <T> 数据类型
 * @author 苏三
 * @since 1.0.0
 */
@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Result<T> implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 响应码
     */
    private Integer code;

    /**
     * 响应消息
     */
    private String message;

    /**
     * 响应数据
     */
    private T data;

    /**
     * 时间戳
     */
    private Long timestamp;

    /**
     * 私有构造方法
     */
    private Result() {
        this.timestamp = System.currentTimeMillis();
    }

    /**
     * 私有构造方法
     *
     * @param code    响应码
     * @param message 响应消息
     * @param data    响应数据
     */
    private Result(Integer code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
        this.timestamp = System.currentTimeMillis();
    }

    /**
     * 成功返回(无数据)
     *
     * @param <T> 数据类型
     * @return 统一响应结果
     */
    public static <T> Result<T> success() {
        return new Result<>(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMessage(), null);
    }

    /**
     * 成功返回(有数据)
     *
     * @param data 数据
     * @param <T>  数据类型
     * @return 统一响应结果
     */
    public static <T> Result<T> success(T data) {
        return new Result<>(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMessage(), data);
    }

    /**
     * 成功返回(自定义消息)
     *
     * @param message 消息
     * @param <T>     数据类型
     * @return 统一响应结果
     */
    public static <T> Result<T> success(String message) {
        return new Result<>(ResultCode.SUCCESS.getCode(), message, null);
    }

    /**
     * 成功返回(自定义消息和数据)
     *
     * @param message 消息
     * @param data    数据
     * @param <T>     数据类型
     * @return 统一响应结果
     */
    public static <T> Result<T> success(String message, T data) {
        return new Result<>(ResultCode.SUCCESS.getCode(), message, data);
    }

    /**
     * 失败返回(默认错误)
     *
     * @param <T> 数据类型
     * @return 统一响应结果
     */
    public static <T> Result<T> error() {
        return new Result<>(ResultCode.ERROR.getCode(), ResultCode.ERROR.getMessage(), null);
    }

    /**
     * 失败返回(自定义消息)
     *
     * @param message 错误消息
     * @param <T>     数据类型
     * @return 统一响应结果
     */
    public static <T> Result<T> error(String message) {
        return new Result<>(ResultCode.ERROR.getCode(), message, null);
    }

    /**
     * 失败返回(自定义错误码和消息)
     *
     * @param code    错误码
     * @param message 错误消息
     * @param <T>     数据类型
     * @return 统一响应结果
     */
    public static <T> Result<T> error(Integer code, String message) {
        return new Result<>(code, message, null);
    }

    /**
     * 失败返回(使用结果码枚举)
     *
     * @param resultCode 结果码枚举
     * @param <T>        数据类型
     * @return 统一响应结果
     */
    public static <T> Result<T> error(ResultCode resultCode) {
        return new Result<>(resultCode.getCode(), resultCode.getMessage(), null);
    }

    /**
     * 根据条件返回成功或失败
     *
     * @param flag 条件标识
     * @param <T>  数据类型
     * @return 统一响应结果
     */
    public static <T> Result<T> status(boolean flag) {
        return flag ? success() : error();
    }
}

设计要点:

  • 使用@JsonInclude(JsonInclude.Include.NON_NULL)忽略null字段
  • 包含响应码、响应消息、响应数据、时间戳
  • 提供多个重载的success()和error()方法
  • 自动添加时间戳

7.5 响应码枚举ResultCode

创建 kb-common/src/main/java/com/knowledge/base/common/result/ResultCode.java:

package com.knowledge.base.common.result;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * 响应码枚举类
 *
 * <p>按照阿里巴巴Java开发规范设计,统一管理系统响应码</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Getter
@AllArgsConstructor
public enum ResultCode {

    /**
     * 成功
     */
    SUCCESS(200, "操作成功"),

    /**
     * 失败
     */
    ERROR(500, "操作失败"),

    /**
     * 参数错误
     */
    PARAM_ERROR(400, "参数错误"),

    /**
     * 参数缺失
     */
    PARAM_MISSING(400, "参数缺失"),

    /**
     * 参数无效
     */
    PARAM_INVALID(400, "参数无效"),

    /**
     * 未授权
     */
    UNAUTHORIZED(401, "未授权,请先登录"),

    /**
     * 禁止访问
     */
    FORBIDDEN(403, "禁止访问"),

    /**
     * 资源不存在
     */
    NOT_FOUND(404, "资源不存在"),

    /**
     * 请求方法不支持
     */
    METHOD_NOT_ALLOWED(405, "请求方法不支持"),

    /**
     * 请求超时
     */
    REQUEST_TIMEOUT(408, "请求超时"),

    /**
     * 系统内部错误
     */
    INTERNAL_SERVER_ERROR(500, "系统内部错误"),

    /**
     * 服务不可用
     */
    SERVICE_UNAVAILABLE(503, "服务不可用"),

    /**
     * 用户名或密码错误
     */
    USERNAME_OR_PASSWORD_ERROR(10001, "用户名或密码错误"),

    /**
     * 用户不存在
     */
    USER_NOT_EXIST(10002, "用户不存在"),

    /**
     * 用户已存在
     */
    USER_ALREADY_EXIST(10003, "用户已存在"),

    /**
     * 用户已被禁用
     */
    USER_DISABLED(10004, "用户已被禁用"),

    /**
     * Token无效
     */
    TOKEN_INVALID(10005, "Token无效"),

    /**
     * Token已过期
     */
    TOKEN_EXPIRED(10006, "Token已过期"),

    /**
     * 无权限访问
     */
    ACCESS_DENIED(10007, "无权限访问"),

    /**
     * 文档不存在
     */
    DOCUMENT_NOT_EXIST(20001, "文档不存在"),

    /**
     * 文档已存在
     */
    DOCUMENT_ALREADY_EXIST(20002, "文档已存在"),

    /**
     * 文档分类不存在
     */
    CATEGORY_NOT_EXIST(20003, "文档分类不存在"),

    /**
     * 文件上传失败
     */
    FILE_UPLOAD_FAILED(20004, "文件上传失败"),

    /**
     * 文件类型不支持
     */
    FILE_TYPE_NOT_SUPPORTED(20005, "文件类型不支持"),

    /**
     * 文件大小超限
     */
    FILE_SIZE_EXCEEDED(20006, "文件大小超限");

    /**
     * 响应码
     */
    private final Integer code;

    /**
     * 响应消息
     */
    private final String message;
}

设计要点:

  • 使用@Getter和@AllArgsConstructor简化代码
  • 包含HTTP标准响应码
  • 包含业务自定义响应码(10xxx-用户相关,20xxx-文档相关)
  • 响应码分类管理,便于扩展

7.6 使用示例

实体类继承BaseEntity:

@Data
@EqualsAndHashCode(callSuper = true)
@TableName("kb_dict")
public class Dict extends BaseEntity {
    private String dictCode;
    private String dictName;
    // 其他字段...
}

查询DTO继承PageParam:

@Data
@EqualsAndHashCode(callSuper = true)
public class SystemConfigQueryDTO extends PageParam {
    private String configKey;
    private String category;
    // 其他查询条件...
}

Controller返回Result:

@GetMapping("/{id}")
public Result<Dict> getDictById(@PathVariable Long id) {
    Dict dict = dictService.getById(id);
    return Result.success(dict);
}

Service返回PageResult:

public PageResult<Dict> pageDicts(PageParam pageParam) {
    IPage<Dict> page = dictMapper.selectPage(
        new Page<>(pageParam.getCurrent(), pageParam.getSize()), null
    );
    return PageResult.of(
        page.getCurrent(),
        page.getSize(),
        page.getTotal(),
        page.getRecords()
    );
}

八、实体类设计

7.1 字典类型实体

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/entity/Dict.java:

package com.knowledge.base.foundation.entity;

import com.baomidou.mybatisplus.annotation.TableField;
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;

import java.time.LocalDateTime;

/**
 * 字典类型实体类
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("kb_dict")
@Schema(description = "字典类型实体")
public class Dict extends BaseEntity {

    @Schema(description = "字典编码")
    @TableField("dict_code")
    private String dictCode;

    @Schema(description = "字典名称")
    @TableField("dict_name")
    private String dictName;

    @Schema(description = "字典类型")
    @TableField("dict_type")
    private String dictType;

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

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

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

    @Schema(description = "创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @Schema(description = "更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;
}

7.2 字典数据实体

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/entity/DictData.java:

package com.knowledge.base.foundation.entity;

import com.baomidou.mybatisplus.annotation.TableField;
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;

import java.time.LocalDateTime;

/**
 * 字典数据实体类
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("kb_dict_data")
@Schema(description = "字典数据实体")
public class DictData extends BaseEntity {

    @Schema(description = "字典ID")
    @TableField("dict_id")
    private Long dictId;

    @Schema(description = "字典编码(冗余)")
    @TableField("dict_code")
    private String dictCode;

    @Schema(description = "字典标签")
    @TableField("dict_label")
    private String dictLabel;

    @Schema(description = "字典值")
    @TableField("dict_value")
    private String dictValue;

    @Schema(description = "排序")
    @TableField("dict_sort")
    private Integer dictSort;

    @Schema(description = "样式类名")
    @TableField("css_class")
    private String cssClass;

    @Schema(description = "列表样式")
    @TableField("list_class")
    private String listClass;

    @Schema(description = "是否默认:0-否,1-是")
    @TableField("is_default")
    private Integer isDefault;

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

    @Schema(description = "创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;
}

7.3 系统配置实体

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/entity/SystemConfig.java:

package com.knowledge.base.foundation.entity;

import com.baomidou.mybatisplus.annotation.TableField;
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;

import java.time.LocalDateTime;

/**
 * 系统配置实体类
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("kb_system_config")
@Schema(description = "系统配置实体")
public class SystemConfig extends BaseEntity {

    @Schema(description = "配置键")
    @TableField("config_key")
    private String configKey;

    @Schema(description = "配置值")
    @TableField("config_value")
    private String configValue;

    @Schema(description = "配置类型:string/number/boolean/json")
    @TableField("config_type")
    private String configType;

    @Schema(description = "配置分类:AI/STORAGE/NOTIFICATION/SECURITY等")
    @TableField("category")
    private String category;

    @Schema(description = "配置描述")
    @TableField("description")
    private String description;

    @Schema(description = "是否公开:0-私有,1-公开")
    @TableField("is_public")
    private Integer isPublic;

    @Schema(description = "创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;

    @Schema(description = "更新时间")
    @TableField("update_time")
    private LocalDateTime updateTime;
}

7.4 系统通知实体

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/entity/Notification.java:

package com.knowledge.base.foundation.entity;

import com.baomidou.mybatisplus.annotation.TableField;
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;

import java.time.LocalDateTime;

/**
 * 系统通知实体类
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("kb_notification")
@Schema(description = "系统通知实体")
public class Notification extends BaseEntity {

    @Schema(description = "接收用户ID")
    @TableField("user_id")
    private Long userId;

    @Schema(description = "用户姓名(冗余字段)")
    @TableField("user_name")
    private String userName;

    @Schema(description = "通知类型:system/comment/mention/review/like")
    @TableField("notification_type")
    private String notificationType;

    @Schema(description = "通知标题")
    @TableField("title")
    private String title;

    @Schema(description = "通知内容")
    @TableField("content")
    private String content;

    @Schema(description = "跳转链接")
    @TableField("link")
    private String link;

    @Schema(description = "关联类型")
    @TableField("related_type")
    private String relatedType;

    @Schema(description = "关联ID")
    @TableField("related_id")
    private Long relatedId;

    @Schema(description = "是否已读:0-未读,1-已读")
    @TableField("is_read")
    private Integer isRead;

    @Schema(description = "阅读时间")
    @TableField("read_time")
    private LocalDateTime readTime;

    @Schema(description = "创建时间")
    @TableField("create_time")
    private LocalDateTime createTime;
}

7.5 操作日志实体

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/entity/OperationLog.java:

package com.knowledge.base.foundation.entity;

import com.baomidou.mybatisplus.annotation.TableField;
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;

import java.time.LocalDateTime;

/**
 * 操作日志实体类
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("kb_operation_log")
@Schema(description = "操作日志实体")
public class OperationLog extends BaseEntity {

    @Schema(description = "模块名称")
    @TableField("module")
    private String module;

    @Schema(description = "操作类型:LOGIN/CREATE/UPDATE/DELETE等")
    @TableField("operation_type")
    private String operationType;

    @Schema(description = "操作描述")
    @TableField("operation_desc")
    private String operationDesc;

    @Schema(description = "请求方法:GET/POST/PUT/DELETE")
    @TableField("request_method")
    private String requestMethod;

    @Schema(description = "请求URL")
    @TableField("request_url")
    private String requestUrl;

    @Schema(description = "请求参数(JSON)")
    @TableField("request_params")
    private String requestParams;

    @Schema(description = "响应结果(JSON)")
    @TableField("response_result")
    private String responseResult;

    @Schema(description = "操作用户ID")
    @TableField("user_id")
    private Long userId;

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

    @Schema(description = "IP地址")
    @TableField("ip_address")
    private String ipAddress;

    @Schema(description = "地理位置")
    @TableField("location")
    private String location;

    @Schema(description = "用户代理")
    @TableField("user_agent")
    private String userAgent;

    @Schema(description = "执行时长(毫秒)")
    @TableField("execute_time")
    private Integer executeTime;

    @Schema(description = "状态:0-失败,1-成功")
    @TableField("status")
    private Integer status;

    @Schema(description = "错误信息")
    @TableField("error_msg")
    private String errorMsg;

    @Schema(description = "操作时间")
    @TableField("create_time")
    private LocalDateTime createTime;
}

7.6 DTO和VO设计

创建DTO和VO类用于数据传输和展示。

7.6.1 字典DTO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/dto/DictDTO.java:

package com.knowledge.base.foundation.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
 *
 * <p>按照阿里巴巴Java开发规范设计,用于接收字典类型创建/更新请求参数</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Schema(description = "字典类型请求参数")
public class DictDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 字典ID
     */
    @Schema(description = "字典ID", example = "1234567890123456789")
    private Long id;

    /**
     * 字典编码
     */
    @Schema(description = "字典编码", required = true, example = "sys_user_gender")
    @NotBlank(message = "字典编码不能为空")
    @Size(max = 100, message = "字典编码长度不能超过100个字符")
    private String dictCode;

    /**
     * 字典名称
     */
    @Schema(description = "字典名称", required = true, example = "用户性别")
    @NotBlank(message = "字典名称不能为空")
    @Size(max = 100, message = "字典名称长度不能超过100个字符")
    private String dictName;

    /**
     * 字典类型
     */
    @Schema(description = "字典类型", required = true, example = "system")
    @NotBlank(message = "字典类型不能为空")
    @Size(max = 50, message = "字典类型长度不能超过50个字符")
    private String dictType;

    /**
     * 描述
     */
    @Schema(description = "描述", example = "用户性别字典")
    @Size(max = 500, message = "描述长度不能超过500个字符")
    private String description;

    /**
     * 排序
     */
    @Schema(description = "排序", example = "0")
    @NotNull(message = "排序不能为空")
    private Integer sort;

    /**
     * 状态:0-禁用,1-正常
     */
    @Schema(description = "状态", example = "1")
    @NotNull(message = "状态不能为空")
    private Integer status;
}

7.6.2 字典数据DTO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/dto/DictDataDTO.java:

package com.knowledge.base.foundation.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
 *
 * <p>按照阿里巴巴Java开发规范设计,用于接收字典数据创建/更新请求参数</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Schema(description = "字典数据请求参数")
public class DictDataDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 字典数据ID
     */
    @Schema(description = "字典数据ID", example = "1234567890123456789")
    private Long id;

    /**
     * 字典ID
     */
    @Schema(description = "字典ID", required = true, example = "1234567890123456789")
    @NotNull(message = "字典ID不能为空")
    private Long dictId;

    /**
     * 字典编码(冗余)
     */
    @Schema(description = "字典编码", example = "sys_user_gender")
    @Size(max = 100, message = "字典编码长度不能超过100个字符")
    private String dictCode;

    /**
     * 字典标签
     */
    @Schema(description = "字典标签", required = true, example = "男")
    @NotBlank(message = "字典标签不能为空")
    @Size(max = 100, message = "字典标签长度不能超过100个字符")
    private String dictLabel;

    /**
     * 字典值
     */
    @Schema(description = "字典值", required = true, example = "1")
    @NotBlank(message = "字典值不能为空")
    @Size(max = 100, message = "字典值长度不能超过100个字符")
    private String dictValue;

    /**
     * 排序
     */
    @Schema(description = "排序", example = "0")
    @NotNull(message = "排序不能为空")
    private Integer dictSort;

    /**
     * 样式类名
     */
    @Schema(description = "样式类名", example = "default")
    @Size(max = 100, message = "样式类名长度不能超过100个字符")
    private String cssClass;

    /**
     * 列表样式
     */
    @Schema(description = "列表样式", example = "primary")
    @Size(max = 100, message = "列表样式长度不能超过100个字符")
    private String listClass;

    /**
     * 是否默认:0-否,1-是
     */
    @Schema(description = "是否默认", example = "0")
    @NotNull(message = "是否默认不能为空")
    private Integer isDefault;

    /**
     * 状态:0-禁用,1-正常
     */
    @Schema(description = "状态", example = "1")
    @NotNull(message = "状态不能为空")
    private Integer status;
}

7.6.3 系统配置DTO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/dto/SystemConfigDTO.java:

package com.knowledge.base.foundation.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
 *
 * <p>按照阿里巴巴Java开发规范设计,用于接收系统配置创建/更新请求参数</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Schema(description = "系统配置请求参数")
public class SystemConfigDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 配置ID
     */
    @Schema(description = "配置ID", example = "1234567890123456789")
    private Long id;

    /**
     * 配置键
     */
    @Schema(description = "配置键", required = true, example = "ai.model.name")
    @NotBlank(message = "配置键不能为空")
    @Size(max = 100, message = "配置键长度不能超过100个字符")
    private String configKey;

    /**
     * 配置值
     */
    @Schema(description = "配置值", required = true, example = "gpt-4")
    @NotBlank(message = "配置值不能为空")
    @Size(max = 1000, message = "配置值长度不能超过1000个字符")
    private String configValue;

    /**
     * 配置类型:string/number/boolean/json
     */
    @Schema(description = "配置类型", required = true, example = "string")
    @NotBlank(message = "配置类型不能为空")
    @Size(max = 20, message = "配置类型长度不能超过20个字符")
    private String configType;

    /**
     * 配置分类:AI/STORAGE/NOTIFICATION/SECURITY等
     */
    @Schema(description = "配置分类", required = true, example = "AI")
    @NotBlank(message = "配置分类不能为空")
    @Size(max = 50, message = "配置分类长度不能超过50个字符")
    private String category;

    /**
     * 配置描述
     */
    @Schema(description = "配置描述", example = "AI模型名称配置")
    @Size(max = 500, message = "配置描述长度不能超过500个字符")
    private String description;

    /**
     * 是否公开:0-私有,1-公开
     */
    @Schema(description = "是否公开", example = "0")
    @NotNull(message = "是否公开不能为空")
    private Integer isPublic;
}

7.6.4 系统配置查询DTO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/dto/SystemConfigQueryDTO.java:

package com.knowledge.base.foundation.dto;

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

import java.io.Serializable;

/**
 * 系统配置查询DTO
 *
 * <p>按照阿里巴巴Java开发规范设计,用于系统配置查询条件</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@EqualsAndHashCode(callSuper = true)
@Schema(description = "系统配置查询参数")
public class SystemConfigQueryDTO extends PageParam implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 配置键
     */
    @Schema(description = "配置键", example = "ai.model.name")
    private String configKey;

    /**
     * 配置分类:AI/STORAGE/NOTIFICATION/SECURITY等
     */
    @Schema(description = "配置分类", example = "AI")
    private String category;

    /**
     * 配置类型:string/number/boolean/json
     */
    @Schema(description = "配置类型", example = "string")
    private String configType;

    /**
     * 是否公开:0-私有,1-公开
     */
    @Schema(description = "是否公开", example = "0")
    private Integer isPublic;

    /**
     * 关键词搜索(配置键或描述)
     */
    @Schema(description = "关键词", example = "AI")
    private String keyword;
}

7.6.5 通知DTO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/dto/NotificationDTO.java:

package com.knowledge.base.foundation.dto;

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

import java.io.Serializable;

/**
 * 通知DTO
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Schema(description = "通知DTO")
public class NotificationDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    @Schema(description = "通知ID")
    private Long id;

    @NotNull(message = "接收用户ID不能为空")
    @Schema(description = "接收用户ID")
    private Long userId;

    @Schema(description = "用户姓名(冗余字段)")
    private String userName;

    @NotBlank(message = "通知类型不能为空")
    @Schema(description = "通知类型:system/comment/mention/review/like")
    private String notificationType;

    @NotBlank(message = "通知标题不能为空")
    @Schema(description = "通知标题")
    private String title;

    @NotBlank(message = "通知内容不能为空")
    @Schema(description = "通知内容")
    private String content;

    @Schema(description = "跳转链接")
    private String link;

    @Schema(description = "关联类型")
    private String relatedType;

    @Schema(description = "关联ID")
    private Long relatedId;

    @Schema(description = "是否已读:0-未读,1-已读")
    private Integer isRead;
}

7.6.6 通知查询DTO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/dto/NotificationQueryDTO.java:

package com.knowledge.base.foundation.dto;

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

/**
 * 通知查询DTO
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@EqualsAndHashCode(callSuper = true)
@Schema(description = "通知查询DTO")
public class NotificationQueryDTO extends PageParam {

    private static final long serialVersionUID = 1L;

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

    @Schema(description = "通知类型")
    private String notificationType;

    @Schema(description = "是否已读:0-未读,1-已读")
    private Integer isRead;

    @Schema(description = "开始时间")
    private String startTime;

    @Schema(description = "结束时间")
    private String endTime;
}

7.6.7 操作日志DTO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/dto/OperationLogDTO.java:

package com.knowledge.base.foundation.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
 *
 * <p>按照阿里巴巴Java开发规范设计,用于接收操作日志创建请求参数</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Schema(description = "操作日志请求参数")
public class OperationLogDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 日志ID
     */
    @Schema(description = "日志ID", example = "1234567890123456789")
    private Long id;

    /**
     * 模块名称
     */
    @Schema(description = "模块名称", required = true, example = "用户管理")
    @NotBlank(message = "模块名称不能为空")
    @Size(max = 50, message = "模块名称长度不能超过50个字符")
    private String module;

    /**
     * 操作类型:LOGIN/CREATE/UPDATE/DELETE等
     */
    @Schema(description = "操作类型", required = true, example = "CREATE")
    @NotBlank(message = "操作类型不能为空")
    @Size(max = 20, message = "操作类型长度不能超过20个字符")
    private String operationType;

    /**
     * 操作描述
     */
    @Schema(description = "操作描述", required = true, example = "创建用户")
    @NotBlank(message = "操作描述不能为空")
    @Size(max = 500, message = "操作描述长度不能超过500个字符")
    private String operationDesc;

    /**
     * 请求方法:GET/POST/PUT/DELETE
     */
    @Schema(description = "请求方法", example = "POST")
    @Size(max = 10, message = "请求方法长度不能超过10个字符")
    private String requestMethod;

    /**
     * 请求URL
     */
    @Schema(description = "请求URL", example = "/api/users")
    @Size(max = 500, message = "请求URL长度不能超过500个字符")
    private String requestUrl;

    /**
     * 请求参数(JSON)
     */
    @Schema(description = "请求参数", example = "{\"username\":\"zhangsan\"}")
    private String requestParams;

    /**
     * 响应结果(JSON)
     */
    @Schema(description = "响应结果", example = "{\"code\":200,\"message\":\"success\"}")
    private String responseResult;

    /**
     * 操作用户ID
     */
    @Schema(description = "操作用户ID", example = "1234567890123456789")
    private Long userId;

    /**
     * 操作用户名
     */
    @Schema(description = "操作用户名", example = "admin")
    @Size(max = 50, message = "操作用户名长度不能超过50个字符")
    private String username;

    /**
     * IP地址
     */
    @Schema(description = "IP地址", example = "192.168.1.1")
    @Size(max = 50, message = "IP地址长度不能超过50个字符")
    private String ipAddress;

    /**
     * 地理位置
     */
    @Schema(description = "地理位置", example = "北京市")
    @Size(max = 100, message = "地理位置长度不能超过100个字符")
    private String location;

    /**
     * 用户代理
     */
    @Schema(description = "用户代理", example = "Mozilla/5.0...")
    @Size(max = 500, message = "用户代理长度不能超过500个字符")
    private String userAgent;

    /**
     * 执行时长(毫秒)
     */
    @Schema(description = "执行时长(毫秒)", example = "100")
    private Integer executeTime;

    /**
     * 状态:0-失败,1-成功
     */
    @Schema(description = "状态", example = "1")
    @NotNull(message = "状态不能为空")
    private Integer status;

    /**
     * 错误信息
     */
    @Schema(description = "错误信息", example = "操作失败")
    @Size(max = 2000, message = "错误信息长度不能超过2000个字符")
    private String errorMsg;
}

7.6.8 操作日志查询DTO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/dto/OperationLogQueryDTO.java:

package com.knowledge.base.foundation.dto;

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

import java.io.Serializable;

/**
 * 操作日志查询DTO
 *
 * <p>按照阿里巴巴Java开发规范设计,用于操作日志查询条件</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@EqualsAndHashCode(callSuper = true)
@Schema(description = "操作日志查询参数")
public class OperationLogQueryDTO extends PageParam implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 模块名称
     */
    @Schema(description = "模块名称", example = "用户管理")
    private String module;

    /**
     * 操作类型:LOGIN/CREATE/UPDATE/DELETE等
     */
    @Schema(description = "操作类型", example = "CREATE")
    private String operationType;

    /**
     * 操作用户ID
     */
    @Schema(description = "操作用户ID", example = "1234567890123456789")
    private Long userId;

    /**
     * 操作用户名
     */
    @Schema(description = "操作用户名", example = "admin")
    private String username;

    /**
     * 状态:0-失败,1-成功
     */
    @Schema(description = "状态", example = "1")
    private Integer status;

    /**
     * 开始时间
     */
    @Schema(description = "开始时间", example = "2024-01-01 00:00:00")
    private String startTime;

    /**
     * 结束时间
     */
    @Schema(description = "结束时间", example = "2024-12-31 23:59:59")
    private String endTime;

    /**
     * 关键词搜索(操作描述或请求URL)
     */
    @Schema(description = "关键词", example = "创建")
    private String keyword;
}

7.6.9 字典VO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/vo/DictVO.java:

package com.knowledge.base.foundation.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;

/**
 * 字典VO
 *
 * <p>按照阿里巴巴Java开发规范设计,用于返回字典类型信息</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "字典类型响应")
public class DictVO implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 字典ID
     */
    @Schema(description = "字典ID")
    private Long id;

    /**
     * 字典编码
     */
    @Schema(description = "字典编码")
    private String dictCode;

    /**
     * 字典名称
     */
    @Schema(description = "字典名称")
    private String dictName;

    /**
     * 字典类型
     */
    @Schema(description = "字典类型")
    private String dictType;

    /**
     * 描述
     */
    @Schema(description = "描述")
    private String description;

    /**
     * 排序
     */
    @Schema(description = "排序")
    private Integer sort;

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

    /**
     * 创建时间
     */
    @Schema(description = "创建时间")
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    @Schema(description = "更新时间")
    private LocalDateTime updateTime;
}

7.6.10 字典数据VO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/vo/DictDataVO.java:

package com.knowledge.base.foundation.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;

/**
 * 字典数据VO
 *
 * <p>按照阿里巴巴Java开发规范设计,用于返回字典数据信息</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "字典数据响应")
public class DictDataVO implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 字典数据ID
     */
    @Schema(description = "字典数据ID")
    private Long id;

    /**
     * 字典ID
     */
    @Schema(description = "字典ID")
    private Long dictId;

    /**
     * 字典编码(冗余)
     */
    @Schema(description = "字典编码")
    private String dictCode;

    /**
     * 字典标签
     */
    @Schema(description = "字典标签")
    private String dictLabel;

    /**
     * 字典值
     */
    @Schema(description = "字典值")
    private String dictValue;

    /**
     * 排序
     */
    @Schema(description = "排序")
    private Integer dictSort;

    /**
     * 样式类名
     */
    @Schema(description = "样式类名")
    private String cssClass;

    /**
     * 列表样式
     */
    @Schema(description = "列表样式")
    private String listClass;

    /**
     * 是否默认:0-否,1-是
     */
    @Schema(description = "是否默认")
    private Integer isDefault;

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

    /**
     * 创建时间
     */
    @Schema(description = "创建时间")
    private LocalDateTime createTime;
}

7.6.11 系统配置VO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/vo/SystemConfigVO.java:

package com.knowledge.base.foundation.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;

/**
 * 系统配置VO
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "系统配置VO")
public class SystemConfigVO implements Serializable {

    private static final long serialVersionUID = 1L;

    @Schema(description = "配置ID")
    private Long id;

    @Schema(description = "配置键")
    private String configKey;

    @Schema(description = "配置值")
    private String configValue;

    @Schema(description = "配置类型")
    private String configType;

    @Schema(description = "配置分类")
    private String category;

    @Schema(description = "配置描述")
    private String description;

    @Schema(description = "是否公开")
    private Integer isPublic;

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

    @Schema(description = "更新时间")
    private LocalDateTime updateTime;
}

7.6.12 通知VO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/vo/NotificationVO.java:

package com.knowledge.base.foundation.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;

/**
 * 通知VO
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "通知VO")
public class NotificationVO implements Serializable {

    private static final long serialVersionUID = 1L;

    @Schema(description = "通知ID")
    private Long id;

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

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

    @Schema(description = "通知类型")
    private String notificationType;

    @Schema(description = "通知标题")
    private String title;

    @Schema(description = "通知内容")
    private String content;

    @Schema(description = "跳转链接")
    private String link;

    @Schema(description = "关联类型")
    private String relatedType;

    @Schema(description = "关联ID")
    private Long relatedId;

    @Schema(description = "是否已读")
    private Integer isRead;

    @Schema(description = "阅读时间")
    private LocalDateTime readTime;

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

7.6.13 操作日志VO

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/vo/OperationLogVO.java:

package com.knowledge.base.foundation.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;

/**
 * 操作日志VO
 *
 * <p>按照阿里巴巴Java开发规范设计,用于返回操作日志信息</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "操作日志响应")
public class OperationLogVO implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 日志ID
     */
    @Schema(description = "日志ID")
    private Long id;

    /**
     * 模块名称
     */
    @Schema(description = "模块名称")
    private String module;

    /**
     * 操作类型:LOGIN/CREATE/UPDATE/DELETE等
     */
    @Schema(description = "操作类型")
    private String operationType;

    /**
     * 操作描述
     */
    @Schema(description = "操作描述")
    private String operationDesc;

    /**
     * 请求方法:GET/POST/PUT/DELETE
     */
    @Schema(description = "请求方法")
    private String requestMethod;

    /**
     * 请求URL
     */
    @Schema(description = "请求URL")
    private String requestUrl;

    /**
     * 请求参数(JSON)
     */
    @Schema(description = "请求参数")
    private String requestParams;

    /**
     * 响应结果(JSON)
     */
    @Schema(description = "响应结果")
    private String responseResult;

    /**
     * 操作用户ID
     */
    @Schema(description = "操作用户ID")
    private Long userId;

    /**
     * 操作用户名
     */
    @Schema(description = "操作用户名")
    private String username;

    /**
     * IP地址
     */
    @Schema(description = "IP地址")
    private String ipAddress;

    /**
     * 地理位置
     */
    @Schema(description = "地理位置")
    private String location;

    /**
     * 用户代理
     */
    @Schema(description = "用户代理")
    private String userAgent;

    /**
     * 执行时长(毫秒)
     */
    @Schema(description = "执行时长(毫秒)")
    private Integer executeTime;

    /**
     * 状态:0-失败,1-成功
     */
    @Schema(description = "状态")
    private Integer status;

    /**
     * 错误信息
     */
    @Schema(description = "错误信息")
    private String errorMsg;

    /**
     * 操作时间
     */
    @Schema(description = "操作时间")
    private LocalDateTime createTime;
}

九、数据访问层

8.1 字典Mapper

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/mapper/DictMapper.java:

package com.knowledge.base.foundation.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.knowledge.base.foundation.entity.Dict;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * 字典类型Mapper接口
 *
 * @author 苏三
 * @since 1.0.0
 */
@Mapper
public interface DictMapper extends BaseMapper<Dict> {

    @Select("SELECT * FROM kb_dict WHERE dict_code = #{dictCode}")
    Dict selectByDictCode(@Param("dictCode") String dictCode);

    @Select("SELECT * FROM kb_dict WHERE dict_type = #{dictType} AND status = 1 ORDER BY sort")
    List<Dict> selectByDictType(@Param("dictType") String dictType);
}

8.2 字典数据Mapper

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/mapper/DictDataMapper.java:

package com.knowledge.base.foundation.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.knowledge.base.foundation.entity.DictData;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * 字典数据Mapper接口
 *
 * @author 苏三
 * @since 1.0.0
 */
@Mapper
public interface DictDataMapper extends BaseMapper<DictData> {

    @Select("SELECT * FROM kb_dict_data WHERE dict_code = #{dictCode} AND status = 1 ORDER BY dict_sort")
    List<DictData> selectByDictCode(@Param("dictCode") String dictCode);

    @Select("SELECT * FROM kb_dict_data WHERE dict_id = #{dictId} AND status = 1 ORDER BY dict_sort")
    List<DictData> selectByDictId(@Param("dictId") Long dictId);
}

8.3 系统配置Mapper

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/mapper/SystemConfigMapper.java:

package com.knowledge.base.foundation.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.knowledge.base.foundation.entity.SystemConfig;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * 系统配置Mapper接口
 *
 * @author 苏三
 * @since 1.0.0
 */
@Mapper
public interface SystemConfigMapper extends BaseMapper<SystemConfig> {

    @Select("SELECT * FROM kb_system_config WHERE config_key = #{configKey} AND deleted = 0")
    SystemConfig selectByConfigKey(@Param("configKey") String configKey);

    @Select("SELECT * FROM kb_system_config WHERE category = #{category} AND deleted = 0 ORDER BY id")
    List<SystemConfig> selectByCategory(@Param("category") String category);
}

8.4 通知Mapper

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/mapper/NotificationMapper.java:

package com.knowledge.base.foundation.mapper;

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

/**
 * 通知Mapper接口
 *
 * @author 苏三
 * @since 1.0.0
 */
@Mapper
public interface NotificationMapper extends BaseMapper<Notification> {

    /**
     * 统计用户未读通知数量
     *
     * @param userId 用户ID
     * @return 未读数量
     */
    Long countUnreadByUserId(@Param("userId") Long userId);
}

8.5 操作日志Mapper

创建 kb-foundation/src/main/java/com/knowledge/base/foundation/mapper/OperationLogMapper.java:

package com.knowledge.base.foundation.mapper;

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

/**
 * 操作日志Mapper接口
 *
 * @author 苏三
 * @since 1.0.0
 */
@Mapper
public interface OperationLogMapper extends BaseMapper<OperationLog> {

    /**
     * 删除指定日期前的日志
     *
     * @param date 日期字符串
     * @return 删除数量
     */
    int deleteBeforeDate(@Param("date") String date);
}

十、业务逻辑层

9.1 字典服务

创建接口 kb-foundation/src/main/java/com/knowledge/base/foundation/service/DictService.java:

package com.knowledge.base.foundation.service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.knowledge.base.foundation.dto.DictDTO;
import com.knowledge.base.foundation.entity.Dict;
import com.knowledge.base.foundation.entity.DictData;
import com.knowledge.base.foundation.vo.DictDataVO;
import com.knowledge.base.foundation.vo.DictVO;

import java.util.List;

/**
 * 字典服务接口
 *
 * @author 苏三
 * @since 1.0.0
 */
public interface DictService {

    /**
     * 分页查询字典类型列表
     *
     * @param current 当前页
     * @param size    每页大小
     * @param keyword 搜索关键词
     * @return 字典分页信息
     */
    IPage<Dict> pageDicts(Long current, Long size, String keyword);

    /**
     * 根据字典编码查询字典详情
     *
     * @param code 字典编码
     * @return 字典详情
     */
    Dict getDictByCode(String code);

    /**
     * 创建字典
     *
     * @param dict 字典信息
     * @return 是否成功
     */
    Boolean createDict(Dict dict);

    /**
     * 更新字典
     *
     * @param code 字典编码
     * @param dict 字典信息
     * @return 是否成功
     */
    Boolean updateDict(String code, Dict dict);

    /**
     * 删除字典
     *
     * @param code 字典编码
     * @return 是否成功
     */
    Boolean deleteDict(String code);

    /**
     * 获取字典数据列表
     *
     * @param code 字典编码
     * @return 字典数据列表
     */
    List<DictData> getDictData(String code);

    /**
     * 添加字典数据
     *
     * @param code     字典编码
     * @param dictData 字典数据
     * @return 是否成功
     */
    Boolean addDictData(String code, DictData dictData);

    /**
     * 更新字典数据
     *
     * @param code     字典编码
     * @param dictData 字典数据
     * @return 是否成功
     */
    Boolean updateDictData(String code, DictData dictData);

    /**
     * 删除字典数据
     *
     * @param code 字典编码
     * @param id   数据ID
     * @return 是否成功
     */
    Boolean deleteDictData(String code, Long id);
}

创建实现类 kb-foundation/src/main/java/com/knowledge/base/foundation/service/impl/DictServiceImpl.java:

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

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
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.utils.SnowflakeIdGenerator;
import com.knowledge.base.foundation.entity.Dict;
import com.knowledge.base.foundation.entity.DictData;
import com.knowledge.base.foundation.mapper.DictDataMapper;
import com.knowledge.base.foundation.mapper.DictMapper;
import com.knowledge.base.foundation.service.DictService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

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

/**
 * 字典服务实现类
 *
 * @author 苏三
 * @since 1.0.0
 */
@Slf4j
@Service
public class DictServiceImpl extends ServiceImpl<DictMapper, Dict> implements DictService {

    @Resource
    private DictMapper dictMapper;

    @Resource
    private DictDataMapper dictDataMapper;

    @Override
    public IPage<Dict> pageDicts(Long current, Long size, String keyword) {
        log.info("分页查询字典:current={}, size={}, keyword={}", current, size, keyword);

        LambdaQueryWrapper<Dict> wrapper = new LambdaQueryWrapper<>();

        if (StringUtils.hasText(keyword)) {
            wrapper.like(Dict::getDictCode, keyword)
                    .or()
                    .like(Dict::getDictName, keyword);
        }

        wrapper.orderByAsc(Dict::getSort);

        Page<Dict> page = new Page<>(current, size);
        return dictMapper.selectPage(page, wrapper);
    }

    @Override
    public Dict getDictByCode(String code) {
        log.info("根据编码获取字典:code={}", code);

        if (!StringUtils.hasText(code)) {
            throw new BusinessException("字典编码不能为空");
        }

        return dictMapper.selectByDictCode(code);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean createDict(Dict dict) {
        log.info("创建字典:code={}, name={}", dict.getDictCode(), dict.getDictName());

        if (!StringUtils.hasText(dict.getDictCode())) {
            throw new BusinessException("字典编码不能为空");
        }
        if (!StringUtils.hasText(dict.getDictName())) {
            throw new BusinessException("字典名称不能为空");
        }

        Dict existDict = dictMapper.selectByDictCode(dict.getDictCode());
        if (existDict != null) {
            throw new BusinessException("字典编码已存在");
        }

        dict.setId(SnowflakeIdGenerator.getInstance().nextId());
        dict.setCreateTime(LocalDateTime.now());
        dict.setUpdateTime(LocalDateTime.now());

        int count = dictMapper.insert(dict);
        return count > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateDict(String code, Dict dict) {
        log.info("更新字典:code={}", code);

        Dict existDict = dictMapper.selectByDictCode(code);
        if (existDict == null) {
            throw new BusinessException("字典不存在");
        }

        existDict.setDictName(dict.getDictName());
        existDict.setDescription(dict.getDescription());
        existDict.setSort(dict.getSort());
        existDict.setStatus(dict.getStatus());
        existDict.setUpdateTime(LocalDateTime.now());

        int count = dictMapper.updateById(existDict);
        return count > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean deleteDict(String code) {
        log.info("删除字典:code={}", code);

        Dict existDict = dictMapper.selectByDictCode(code);
        if (existDict == null) {
            throw new BusinessException("字典不存在");
        }

        // 删除字典数据
        LambdaQueryWrapper<DictData> dataWrapper = new LambdaQueryWrapper<>();
        dataWrapper.eq(DictData::getDictId, existDict.getId());
        dictDataMapper.delete(dataWrapper);

        // 删除字典类型
        int count = dictMapper.deleteById(existDict.getId());
        return count > 0;
    }

    @Override
    public List<DictData> getDictData(String code) {
        log.info("获取字典数据:code={}", code);

        if (!StringUtils.hasText(code)) {
            throw new BusinessException("字典编码不能为空");
        }

        return dictDataMapper.selectByDictCode(code);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean addDictData(String code, DictData dictData) {
        log.info("添加字典数据:code={}, label={}", code, dictData.getDictLabel());

        Dict dict = dictMapper.selectByDictCode(code);
        if (dict == null) {
            throw new BusinessException("字典不存在");
        }

        dictData.setId(SnowflakeIdGenerator.getInstance().nextId());
        dictData.setDictId(dict.getId());
        dictData.setCreateTime(LocalDateTime.now());

        int count = dictDataMapper.insert(dictData);
        return count > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateDictData(String code, DictData dictData) {
        log.info("更新字典数据:code={}, id={}", code, dictData.getId());

        int count = dictDataMapper.updateById(dictData);
        return count > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean deleteDictData(String code, Long id) {
        log.info("删除字典数据:code={}, id={}", code, id);

        int count = dictDataMapper.deleteById(id);
        return count > 0;
    }
}
最后修改:2026 年 10 月 24 日
如果觉得我的文章对你有用,请随意赞赏