一、概述
公共基础服务(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/resources3.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;
}
}