新增模块

dev_1.0.0^2
liu 8 months ago
parent f6f9668e41
commit dc808e5ea2

@ -45,12 +45,6 @@
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.supervision</groupId>
<artifactId>know_sub_rag</artifactId>
<version>1.0.0</version>
</dependency>
</dependencies>

@ -12,13 +12,6 @@ server:
# 是否分配的直接内存
direct-buffers: true
spring:
elasticsearch:
uris: http://192.168.10.137:9200
ai:
vectorstore:
elasticsearch:
index-name: 11
main:
allow-bean-definition-overriding: true
servlet:
@ -82,11 +75,4 @@ knife4j:
user:
# 默认密码
default:
password: 123456
#spring:
# elasticsearch:
# uris: http://192.168.10.137:9200
embedding:
url: http://192.168.10.137:8711/embeddings/
password: 123456

@ -0,0 +1,155 @@
<?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.supervision</groupId>
<artifactId>know_sub</artifactId>
<version>1.0.0</version>
</parent>
<artifactId>know_sub_etl</artifactId>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-tika-document-reader</artifactId>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.13</version>
</dependency>
<!-- 引入ollama的依赖.版本号来自于 dependencyManagement中 spring-ai-bom中的版本号.-->
<dependency>
<groupId>io.springboot.ai</groupId>
<artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-elasticsearch-store</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.supervision</groupId>
<artifactId>know_sub_common</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.supervision</groupId>
<artifactId>know_sub_model</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
<repositories>
<repository>
<id>central</id>
<name>aliyun central repo</name>
<url>https://maven.aliyun.com/nexus/content/repositories/central/</url>
<layout>default</layout>
<releases>
<enabled>true</enabled>
<updatePolicy>daily</updatePolicy>
</releases>
<snapshots>
<enabled>false</enabled>
<updatePolicy>never</updatePolicy>
</snapshots>
</repository>
<repository>
<id>spring-snapshots</id>
<name>Spring Snapshots</name>
<url>https://repo.spring.io/snapshot</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>3.3.0</version>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.11.0</version>
<configuration>
<parameters>true</parameters>
</configuration>
</plugin>
</plugins>
</build>
</project>

@ -0,0 +1,18 @@
package som.supervision.knowsub;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication
@EnableScheduling
@MapperScan(basePackages = {"com.supervision.**.mapper"})
@EnableConfigurationProperties
public class KnowSubEtlApplication {
public static void main(String[] args) {
SpringApplication.run(KnowSubEtlApplication.class, args);
}
}

@ -0,0 +1,78 @@
#服务器端口
server:
port: 9201
servlet:
context-path: /know-sub
undertow:
# HTTP post内容的最大大小。当值为-1时默认值为大小是无限的
max-http-post-size: -1
# 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
# 每块buffer的空间大小,越小的空间被利用越充分
buffer-size: 512
# 是否分配的直接内存
direct-buffers: true
spring:
main:
allow-bean-definition-overriding: true
servlet:
multipart:
max-file-size: 100MB
max-request-size: 100MB
## 数据源配置
datasource:
type: com.alibaba.druid.pool.DruidDataSource
druid:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://192.168.10.138:3306/know_sub?useUnicode=true&characterEncoding=utf-8&useSSL=true&nullCatalogMeansCurrent=true&serverTimezone=GMT%2B8
username: root
password: '123456'
initial-size: 5 # 初始化大小
min-idle: 10 # 最小连接数
max-active: 20 # 最大连接数
max-wait: 60000 # 获取连接时的最大等待时间
min-evictable-idle-time-millis: 300000 # 一个连接在池中最小生存的时间,单位是毫秒
time-between-eviction-runs-millis: 60000 # 多久才进行一次检测需要关闭的空闲连接,单位是毫秒
filters: stat,wall # 配置扩展插件stat-监控统计log4j-日志wall-防火墙防止SQL注入去掉后监控界面的sql无法统计
validation-query: SELECT 1 # 检测连接是否有效的 SQL语句为空时以下三个配置均无效
test-on-borrow: true # 申请连接时执行validationQuery检测连接是否有效默认true开启后会降低性能
test-on-return: true # 归还连接时执行validationQuery检测连接是否有效默认false开启后会降低性能
test-while-idle: true # 申请连接时如果空闲时间大于timeBetweenEvictionRunsMillis执行validationQuery检测连接是否有效默认false建议开启不影响性能
stat-view-servlet:
enabled: true # 是否开启 StatViewServlet
loginUsername: admin
loginPassword: 123456
filter:
stat:
enabled: true # 是否开启 FilterStat默认true
log-slow-sql: true # 是否开启 慢SQL 记录默认false
slow-sql-millis: 5000 # 慢 SQL 的标准,默认 3000单位毫秒
merge-sql: false # 合并多个连接池的监控数据默认false
mybatis-plus:
mapper-locations: classpath*:mapper/**/*.xml
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# springdoc-openapi项目配置
springdoc:
# 默认是false需要设置为true 解决GET请求时,用自定义对象接受现实错误的问题
default-flat-param-object: true
swagger-ui:
path: /swagger-ui.html
tags-sorter: alpha
operations-sorter: alpha
api-docs:
path: /v3/api-docs
group-configs:
- group: 'default'
paths-to-match: '/**'
packages-to-scan: com.supervision
# knife4j的增强配置不需要增强可以不配
knife4j:
enable: true
setting:
language: zh_cn
user:
# 默认密码
default:
password: 123456

@ -0,0 +1,92 @@
#服务器端口
server:
port: 9201
servlet:
context-path: /know-sub
undertow:
# HTTP post内容的最大大小。当值为-1时默认值为大小是无限的
max-http-post-size: -1
# 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
# 每块buffer的空间大小,越小的空间被利用越充分
buffer-size: 512
# 是否分配的直接内存
direct-buffers: true
spring:
elasticsearch:
uris: http://192.168.10.137:9200
ai:
vectorstore:
elasticsearch:
index-name: 11
main:
allow-bean-definition-overriding: true
servlet:
multipart:
max-file-size: 100MB
max-request-size: 100MB
## 数据源配置
datasource:
type: com.alibaba.druid.pool.DruidDataSource
druid:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://192.168.10.137:3306/know_sub?useUnicode=true&characterEncoding=utf-8&useSSL=true&nullCatalogMeansCurrent=true&serverTimezone=GMT%2B8
username: root
password: '123456'
initial-size: 5 # 初始化大小
min-idle: 10 # 最小连接数
max-active: 20 # 最大连接数
max-wait: 60000 # 获取连接时的最大等待时间
min-evictable-idle-time-millis: 300000 # 一个连接在池中最小生存的时间,单位是毫秒
time-between-eviction-runs-millis: 60000 # 多久才进行一次检测需要关闭的空闲连接,单位是毫秒
filters: stat,wall # 配置扩展插件stat-监控统计log4j-日志wall-防火墙防止SQL注入去掉后监控界面的sql无法统计
validation-query: SELECT 1 # 检测连接是否有效的 SQL语句为空时以下三个配置均无效
test-on-borrow: true # 申请连接时执行validationQuery检测连接是否有效默认true开启后会降低性能
test-on-return: true # 归还连接时执行validationQuery检测连接是否有效默认false开启后会降低性能
test-while-idle: true # 申请连接时如果空闲时间大于timeBetweenEvictionRunsMillis执行validationQuery检测连接是否有效默认false建议开启不影响性能
stat-view-servlet:
enabled: true # 是否开启 StatViewServlet
loginUsername: admin
loginPassword: 123456
filter:
stat:
enabled: true # 是否开启 FilterStat默认true
log-slow-sql: true # 是否开启 慢SQL 记录默认false
slow-sql-millis: 5000 # 慢 SQL 的标准,默认 3000单位毫秒
merge-sql: false # 合并多个连接池的监控数据默认false
mybatis-plus:
mapper-locations: classpath*:mapper/**/*.xml
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# springdoc-openapi项目配置
springdoc:
# 默认是false需要设置为true 解决GET请求时,用自定义对象接受现实错误的问题
default-flat-param-object: true
swagger-ui:
path: /swagger-ui.html
tags-sorter: alpha
operations-sorter: alpha
api-docs:
path: /v3/api-docs
group-configs:
- group: 'default'
paths-to-match: '/**'
packages-to-scan: com.supervision
# knife4j的增强配置不需要增强可以不配
knife4j:
enable: true
setting:
language: zh_cn
user:
# 默认密码
default:
password: 123456
#spring:
# elasticsearch:
# uris: http://192.168.10.137:9200
embedding:
url: http://192.168.10.137:8711/embeddings/

@ -0,0 +1,20 @@
package com.supervision.knowsub;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.scheduling.annotation.EnableScheduling;
import javax.swing.*;
@SpringBootApplication
@EnableScheduling
@MapperScan(basePackages = {"com.supervision.**.mapper"})
@EnableConfigurationProperties
public class KnowSubRagApplication {
public static void main(String[] args) {
SpringApplication.run(KnowSubRagApplication.class, args);
}
}

@ -18,16 +18,16 @@ public class EsTestController {
private ElasticsearchVectorStore elasticsearchVectorStore;
@GetMapping("add")
public void add(){
public void add() {
Document document = new Document("测试测试");
elasticsearchVectorStore.add(List.of(document));
}
@GetMapping("search")
public void search(){
List<Document> result = elasticsearchVectorStore.similaritySearch("");
public void search(String question) {
List<Document> result = elasticsearchVectorStore.similaritySearch(question);
for (Document document : result) {
System.out.println(JSONUtil.toJsonStr(document));
System.out.println(document.getContent());
}
}
}

@ -1,11 +1,9 @@
package com.supervision.knowsub.controller;
import com.supervision.knowsub.etl.reader.TikaReader;
import com.supervision.knowsub.dto.HtmlContext;
import com.supervision.knowsub.etl.EtlProcessor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
@ -15,10 +13,15 @@ import java.io.IOException;
public class EtlController {
@Autowired
private TikaReader tikaReader;
private EtlProcessor etlProcessor;
@PostMapping("testLoadText")
public void testLoadText(@RequestParam(name = "file") MultipartFile file) throws IOException {
tikaReader.loadAndSplitThenSaveVectorStore(file.getInputStream());
@PostMapping("testLoadFile")
public void testLoadFile(@RequestParam(name = "file") MultipartFile file) throws IOException {
etlProcessor.loadFile(file.getInputStream());
}
@PostMapping("testLoadHtml")
public void testLoadHtml(@RequestBody HtmlContext htmlContext){
etlProcessor.loadHtml(htmlContext);
}
}

@ -0,0 +1,27 @@
package com.supervision.knowsub.controller;
import com.supervision.knowsub.service.RagService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@Tag(name = "RAG问答")
@RestController
@RequestMapping("rag")
@RequiredArgsConstructor
public class RagController {
private final RagService ragService;
@Operation(summary = "问答")
@GetMapping("question")
public String ask(String question) {
return ragService.ask(question);
}
}

@ -0,0 +1,9 @@
package com.supervision.knowsub.dto;
import lombok.Data;
@Data
public class HtmlContext {
private String htmlContext;
}

@ -1,5 +1,6 @@
package com.supervision.knowsub.etl.reader;
package com.supervision.knowsub.etl;
import com.supervision.knowsub.dto.HtmlContext;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.document.Document;
@ -8,6 +9,7 @@ import org.springframework.ai.transformer.splitter.TokenTextSplitter;
import org.springframework.ai.vectorstore.ElasticsearchVectorStore;
import org.springframework.core.io.InputStreamResource;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestBody;
import java.io.InputStream;
import java.util.List;
@ -15,7 +17,7 @@ import java.util.List;
@Slf4j
@Component
@RequiredArgsConstructor
public class TikaReader {
public class EtlProcessor {
private final ElasticsearchVectorStore elasticsearchVectorStore;
@ -24,7 +26,7 @@ public class TikaReader {
*
* @param inputStream
*/
public void loadAndSplitThenSaveVectorStore(InputStream inputStream) {
public void loadFile(InputStream inputStream) {
// 首先使用tika进行文件切分操作
log.info("首先进行内容切分");
TikaDocumentReader tikaDocumentReader = new TikaDocumentReader(new InputStreamResource(inputStream));
@ -39,4 +41,8 @@ public class TikaReader {
log.info("保存完成");
}
public void loadHtml(HtmlContext htmlContext) {
// 使用Html工具进行读取
}
}

@ -0,0 +1,6 @@
package com.supervision.knowsub.service;
public interface RagService {
String ask(String question);
}

@ -0,0 +1,70 @@
package com.supervision.knowsub.service.impl;
import com.supervision.knowsub.service.RagService;
import com.supervision.knowsub.util.SpringBeanUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.SystemPromptTemplate;
import org.springframework.ai.document.Document;
import org.springframework.ai.ollama.OllamaChatClient;
import org.springframework.ai.vectorstore.ElasticsearchVectorStore;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Slf4j
@Service
@RequiredArgsConstructor
public class RagServiceImpl implements RagService {
private final ElasticsearchVectorStore elasticsearchVectorStore;
private static final OllamaChatClient chatClient = SpringBeanUtil.getBean(OllamaChatClient.class);
private static final String springDemoSystemPrompt = """
使
:
<context>{context}</context>
""";
private static final String systemPrompt = """
使"我不知道"
!"感谢你的提问".
::
:
<context>{context}</context>
Question: {input}
""";
@Override
public String ask(String question) {
log.info("检索相关文档");
List<Document> similarDocuments = elasticsearchVectorStore.similaritySearch(question);
log.info("找到:{}条相关文档", similarDocuments.size());
// 构建系统消息
String relevantDocument = similarDocuments.stream().map(Document::getContent).collect(Collectors.joining("\n"));
SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate(springDemoSystemPrompt);
Message systemMessage = systemPromptTemplate.createMessage(Map.of("context", relevantDocument));
// 构建用户消息
UserMessage userMessage = new UserMessage(question);
Prompt prompt = new Prompt(List.of(systemMessage, userMessage));
log.info("Asking AI model to reply to question.");
ChatResponse chatResponse = chatClient.call(prompt);
log.info("AI responded.");
return chatResponse.getResult().getOutput().getContent();
}
}

@ -0,0 +1,106 @@
package com.supervision.knowsub.util;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.ollama.OllamaChatClient;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.*;
@Slf4j
public class AiChatUtil {
private static final ExecutorService chatExecutor = ThreadUtil.newFixedExecutor(5, 5, "chat", new ThreadPoolExecutor.CallerRunsPolicy());
private static final OllamaChatClient chatClient = SpringBeanUtil.getBean(OllamaChatClient.class);
/**
*
*
* @param chat
* @return jsonObject
*/
public static Optional<JSONObject> chat(String chat) {
Prompt prompt = new Prompt(List.of(new UserMessage(chat)));
Future<String> submit = chatExecutor.submit(new ChatTask(chatClient, prompt));
try {
return Optional.of(JSONUtil.parseObj(submit.get()));
} catch (ExecutionException | InterruptedException e) {
log.error("调用大模型生成失败");
}
return Optional.empty();
}
/**
* ,
*
* @param messageList
* @return jsonObject
*/
public static Optional<JSONObject> chat(List<Message> messageList) {
Prompt prompt = new Prompt(messageList);
Future<String> submit = chatExecutor.submit(new ChatTask(chatClient, prompt));
try {
return Optional.of(JSONUtil.parseObj(submit.get()));
} catch (ExecutionException | InterruptedException e) {
log.error("调用大模型生成失败");
}
return Optional.empty();
}
/**
*
*
* @param messageList
* @param clazz
* @param <T>
* @return ,
*/
public static <T> Optional<T> chat(List<Message> messageList, Class<T> clazz) {
Prompt prompt = new Prompt(messageList);
Future<String> submit = chatExecutor.submit(new ChatTask(chatClient, prompt));
try {
String s = submit.get();
return Optional.ofNullable(JSONUtil.toBean(s, clazz));
} catch (ExecutionException | InterruptedException e) {
log.error("调用大模型生成失败", e);
}
return Optional.empty();
}
/**
*
*
* @param chat
* @param clazz
* @param <T>
* @return ,
*/
public static <T> Optional<T> chat(String chat, Class<T> clazz) {
Prompt prompt = new Prompt(List.of(new UserMessage(chat)));
Future<String> submit = chatExecutor.submit(new ChatTask(chatClient, prompt));
try {
String s = submit.get();
return Optional.ofNullable(JSONUtil.toBean(s, clazz));
} catch (ExecutionException | InterruptedException e) {
log.error("调用大模型生成失败");
}
return Optional.empty();
}
private record ChatTask(OllamaChatClient chatClient, Prompt prompt) implements Callable<String> {
@Override
public String call() {
ChatResponse call = chatClient.call(prompt);
return call.getResult().getOutput().getContent();
}
}
}

@ -0,0 +1,78 @@
#服务器端口
server:
port: 9201
servlet:
context-path: /know-sub
undertow:
# HTTP post内容的最大大小。当值为-1时默认值为大小是无限的
max-http-post-size: -1
# 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
# 每块buffer的空间大小,越小的空间被利用越充分
buffer-size: 512
# 是否分配的直接内存
direct-buffers: true
spring:
main:
allow-bean-definition-overriding: true
servlet:
multipart:
max-file-size: 100MB
max-request-size: 100MB
## 数据源配置
datasource:
type: com.alibaba.druid.pool.DruidDataSource
druid:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://192.168.10.138:3306/know_sub?useUnicode=true&characterEncoding=utf-8&useSSL=true&nullCatalogMeansCurrent=true&serverTimezone=GMT%2B8
username: root
password: '123456'
initial-size: 5 # 初始化大小
min-idle: 10 # 最小连接数
max-active: 20 # 最大连接数
max-wait: 60000 # 获取连接时的最大等待时间
min-evictable-idle-time-millis: 300000 # 一个连接在池中最小生存的时间,单位是毫秒
time-between-eviction-runs-millis: 60000 # 多久才进行一次检测需要关闭的空闲连接,单位是毫秒
filters: stat,wall # 配置扩展插件stat-监控统计log4j-日志wall-防火墙防止SQL注入去掉后监控界面的sql无法统计
validation-query: SELECT 1 # 检测连接是否有效的 SQL语句为空时以下三个配置均无效
test-on-borrow: true # 申请连接时执行validationQuery检测连接是否有效默认true开启后会降低性能
test-on-return: true # 归还连接时执行validationQuery检测连接是否有效默认false开启后会降低性能
test-while-idle: true # 申请连接时如果空闲时间大于timeBetweenEvictionRunsMillis执行validationQuery检测连接是否有效默认false建议开启不影响性能
stat-view-servlet:
enabled: true # 是否开启 StatViewServlet
loginUsername: admin
loginPassword: 123456
filter:
stat:
enabled: true # 是否开启 FilterStat默认true
log-slow-sql: true # 是否开启 慢SQL 记录默认false
slow-sql-millis: 5000 # 慢 SQL 的标准,默认 3000单位毫秒
merge-sql: false # 合并多个连接池的监控数据默认false
mybatis-plus:
mapper-locations: classpath*:mapper/**/*.xml
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# springdoc-openapi项目配置
springdoc:
# 默认是false需要设置为true 解决GET请求时,用自定义对象接受现实错误的问题
default-flat-param-object: true
swagger-ui:
path: /swagger-ui.html
tags-sorter: alpha
operations-sorter: alpha
api-docs:
path: /v3/api-docs
group-configs:
- group: 'default'
paths-to-match: '/**'
packages-to-scan: com.supervision
# knife4j的增强配置不需要增强可以不配
knife4j:
enable: true
setting:
language: zh_cn
user:
# 默认密码
default:
password: 123456

@ -1,6 +1,92 @@
#服务器端口
server:
port: 9201
servlet:
context-path: /know-sub
undertow:
# HTTP post内容的最大大小。当值为-1时默认值为大小是无限的
max-http-post-size: -1
# 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
# 每块buffer的空间大小,越小的空间被利用越充分
buffer-size: 512
# 是否分配的直接内存
direct-buffers: true
spring:
elasticsearch:
uris: http://192.168.10.137:9200
ai:
vectorstore:
elasticsearch:
index-name: 11
main:
allow-bean-definition-overriding: true
servlet:
multipart:
max-file-size: 100MB
max-request-size: 100MB
## 数据源配置
datasource:
type: com.alibaba.druid.pool.DruidDataSource
druid:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://192.168.10.137:3306/know_sub?useUnicode=true&characterEncoding=utf-8&useSSL=true&nullCatalogMeansCurrent=true&serverTimezone=GMT%2B8
username: root
password: '123456'
initial-size: 5 # 初始化大小
min-idle: 10 # 最小连接数
max-active: 20 # 最大连接数
max-wait: 60000 # 获取连接时的最大等待时间
min-evictable-idle-time-millis: 300000 # 一个连接在池中最小生存的时间,单位是毫秒
time-between-eviction-runs-millis: 60000 # 多久才进行一次检测需要关闭的空闲连接,单位是毫秒
filters: stat,wall # 配置扩展插件stat-监控统计log4j-日志wall-防火墙防止SQL注入去掉后监控界面的sql无法统计
validation-query: SELECT 1 # 检测连接是否有效的 SQL语句为空时以下三个配置均无效
test-on-borrow: true # 申请连接时执行validationQuery检测连接是否有效默认true开启后会降低性能
test-on-return: true # 归还连接时执行validationQuery检测连接是否有效默认false开启后会降低性能
test-while-idle: true # 申请连接时如果空闲时间大于timeBetweenEvictionRunsMillis执行validationQuery检测连接是否有效默认false建议开启不影响性能
stat-view-servlet:
enabled: true # 是否开启 StatViewServlet
loginUsername: admin
loginPassword: 123456
filter:
stat:
enabled: true # 是否开启 FilterStat默认true
log-slow-sql: true # 是否开启 慢SQL 记录默认false
slow-sql-millis: 5000 # 慢 SQL 的标准,默认 3000单位毫秒
merge-sql: false # 合并多个连接池的监控数据默认false
mybatis-plus:
mapper-locations: classpath*:mapper/**/*.xml
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# springdoc-openapi项目配置
springdoc:
# 默认是false需要设置为true 解决GET请求时,用自定义对象接受现实错误的问题
default-flat-param-object: true
swagger-ui:
path: /swagger-ui.html
tags-sorter: alpha
operations-sorter: alpha
api-docs:
path: /v3/api-docs
group-configs:
- group: 'default'
paths-to-match: '/**'
packages-to-scan: com.supervision
# knife4j的增强配置不需要增强可以不配
knife4j:
enable: true
setting:
language: zh_cn
user:
# 默认密码
default:
password: 123456
#spring:
# elasticsearch:
# uris: http://192.168.10.137:9200
embedding:
url: http://192.168.10.137:8711/embeddings/

@ -20,6 +20,7 @@
<module>know_sub_business</module>
<module>know_sub_model</module>
<module>know_sub_rag</module>
<module>know_sub_etl</module>
</modules>

Loading…
Cancel
Save