需求
产品希望我们这边能够实现用户上传PDF,WORD,TXT之内得文本内容，然后用户可以根据附件名称或文件内容模糊查询文件信息，并可以在线查看文件内容
一、环境
项目开发环境：
后台管理系统springboot+mybatis_plus+mysql+es
搜索引擎：elasticsearch7.9.3 +kibana图形化界面
二、功能实现
1.搭建环境
es+kibana的搭建这里就不介绍了，网上多的是
后台程序搭建也不介绍，这里有一点很重要，Java使用的连接es的包的版本一定要和es的版本对应上，不然你会有各种问题
2.文件内容识别
第一步： 要用es实现文本附件内容的识别，需要先给es安装一个插件：Ingest Attachment Processor Plugin（这知识一个内容识别的插件，还有其它的例如OCR之类的其它插件，有兴趣的可以去搜一下了解一下）
Ingest Attachment Processor Plugin是一个文本抽取插件，本质上是利用了Elasticsearch的ingest node功能，提供了关键的预处理器attachment。在安装目录下运行以下命令即可安装。
到es的安装文件bin目录下执行
elasticsearch-plugin install ingest-attachment因为我们这里es是使用docker安装的，所以需要进入到es的docker镜像里面的bin目录下安装插件
[root@iZuf63d0pqnjrga4pi18udZ plugins]# docker exec -it es bash
[root@elasticsearch elasticsearch]# ls
LICENSE.txt NOTICE.txt README.asciidoc bin config data jdk lib logs modules plugins
[root@elasticsearch elasticsearch]# cd bin/
[root@elasticsearch bin]# ls
elasticsearch elasticsearch-certutil elasticsearch-croneval elasticsearch-env-from-file elasticsearch-migrate elasticsearch-plugin elasticsearch-setup-passwords elasticsearch-sql-cli elasticsearch-syskeygen x-pack-env x-pack-watcher-env
elasticsearch-certgen elasticsearch-cli elasticsearch-env elasticsearch-keystore elasticsearch-node elasticsearch-saml-metadata elasticsearch-shard elasticsearch-sql-cli-7.9.3.jar elasticsearch-users x-pack-security-env
[root@elasticsearch bin]# elasticsearch-plugin install ingest-attachment
-> Installing ingest-attachment
-> Downloading ingest-attachment from elastic
[=================================================] 100%??
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@ WARNING: plugin requires additional permissions @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
* java.lang.RuntimePermission accessClassInPackage.sun.java2d.cmm.kcms
* java.lang.RuntimePermission accessDeclaredMembers
* java.lang.RuntimePermission getClassLoader
* java.lang.reflect.ReflectPermission suppressAccessChecks
* java.security.SecurityPermission createAccessControlContext
* java.security.SecurityPermission insertProvider
* java.security.SecurityPermission putProviderProperty.BC
See http://docs.oracle.com/javase/8/docs/technotes/guides/security/permissions.html
for descriptions of what these permissions allow and the associated risks.
Continue with installation? [y/N]y
-> Installed ingest-attachment
显示installed 就表示安装完成了，然后重启es，不然第二步要报错
第二步：创建一个文本抽取的管道
主要是用于将上传的附件转换成文本内容，支持（word，PDF，txt，excel没试，应该也支持）
{
"description": "Extract attachment information",
"processors": [
{
"attachment": {
"field": "content",
"ignore_missing": true
}
},
{
"remove": {
"field": "content"
}
}
]
}第三步：定义我们内容存储的索引
{
"mappings": {
"properties": {
"id":{
"type": "keyword"
},
"fileName":{
"type": "text",
"analyzer": "my_ana"
},
"contentType":{
"type": "text",
"analyzer": "my_ana"
},
"fileUrl":{
"type": "text"
},
"attachment": {
"properties": {
"content":{
"type": "text",
"analyzer": "my_ana"
}
}
}
}
},
"settings": {
"analysis": {
"filter": {
"jieba_stop": {
"type": "stop",
"stopwords_path": "stopword/stopwords.txt"
},
"jieba_synonym": {
"type": "synonym",
"synonyms_path": "synonym/synonyms.txt"
}
},
"analyzer": {
"my_ana": {
"tokenizer": "jieba_index",
"filter": [
"lowercase",
"jieba_stop",
"jieba_synonym"
]
}
}
}
}
}mapping：定义的是存储的字段格式
setting:索引的配置信息，这边定义了一个分词（使用的是jieba的分词）
注意：内容检索的是attachment.content字段，一定要使用分词，不使用分词的话，检索会检索不出来内容
第四步：测试
{
"id":"1",
"name":"进口红酒",
"filetype":"pdf",
"contenttype":"文章",
"content":"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"
}测试内容需要将附件转换成base64格式
在线转换文件的地址：任意文件转base64-直接拖进来
查询刚刚上传的文件：
{
"took": 861,
"timed_out": false,
"_shards": {
"total": 1,
"successful": 1,
"skipped": 0,
"failed": 0
},
"hits": {
"total": {
"value": 5,
"relation": "eq"
},
"max_score": 1.0,
"hits": [
{
"_index": "fileinfo",
"_type": "_doc",
"_id": "lkPEgYIBz3NlBKQzXYX9",
"_score": 1.0,
"_source": {
"fileName": "测试_20220809164145A002.docx",
"updateTime": 1660034506000,
"attachment": {
"date": "2022-08-09T01:38:00Z",
"content_type": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
"author": "DELL",
"language": "lt",
"content": "什么是PolarDB\n更新时间：2022-06-06 17:36\n我的收藏\nPolarDB是阿里巴巴自研的新一代云原生关系型数据库，在存储计算分离架构下，利用了软硬件结合的优势，为用户提供具备极致弹性、高性能、海量存储、安全可靠的数据库服务。PolarDB 100%兼容MySQL 5.6/5.7/8.0，PostgreSQL 11，高度兼容Oracle。\nPolarDB采用存储和计算分离的架构，所有计算节点共享一份数据，提供分钟级的配置升降级、秒级的故障恢复、全局数据一致性和免费的数据备份容灾服务。PolarDB既融合了商业数据库稳定可靠、高性能、可扩展的特征，又具有开源云数据库简单开放、自我迭代的优势，例如PolarDB MySQL引擎作为超级MySQL，性能最高可达开源MySQL的6倍（在1024并发sysbench_insert场景下，PolarDB MySQL引擎与开启主备半同步Semi-Sync的开源MySQL的性能对比），而成本只有商用数据库的1/10，每小时最低只需1.3元即可体验完整的产品功能。PolarDB MySQL引擎100%兼容原生MySQL和RDS MySQL，您可以在不修改应用程序任何代码和配置的情况下，将MySQL数据库迁移至PolarDB MySQL引擎。\n· 计算与存储分离，共享分布式存储。\n采用计算与存储分离的设计理念，满足业务弹性扩展的需求。各计算节点通过分布式文件系统（PolarFileSystem）共享底层的存储（PolarStore），极大降低了用户的存储成本。\n· 一写多读，读写分离。\nPolarDB集群版采用多节点集群的架构，集群中有一个主节点（可读可写）和至少一个只读节点。当应用程序使用集群地址时，PolarDB通过内部的代理层（PolarProxy）对外提供服务，应用程序的请求都先经过代理，然后才访问到数据库节点。代理层不仅可以做安全认证和保护，还可以解析SQL，把写操作发送到主节点，把读操作均衡地分发到多个只读节点，实现自动的读写分离。对于应用程序来说，就像使用一个单点的数据库一样简单。\n产品优势\n您可以像使用MySQL、PostgreSQL、Oracle一样使用PolarDB。此外，PolarDB还有传统数据库不具备的优势：\n· 大容量\n最高100 TB，您不再需要因为单机容量的天花板而去购买多个实例做分片，由此简化应用开发，降低运维负担。\n· 低成本\n· 共享存储：计算与存储分离，每增加一个只读节点只收取计算资源的费用，而传统的只读节点同时包含计算和存储资源，每增加一个只读节点需要支付相应的存储费用。\n· 弹性存储：存储空间无需配置，根据数据量自动伸缩，您只需为实际使用的数据量按小时付费。\n· 存储包：PolarDB推出了预付费形式的存储包。当您的数据量较大时，推荐您使用存储包，相比按小时付费，预付费购买存储包有折扣，购买的容量越大，折扣力度越大。\n· 计算包：PolarDB首创计算包，用于抵扣计算节点的费用，计算包兼顾了包年包月付费方式的经济性和按量付费方式的灵活性。您还可以将计算包与自动扩缩容配合使用，在业务峰值前后实现自动弹性升降配，轻松应对业务量波动。\n· 高性能\n大幅提升OLTP性能，支持超过50万次/秒的读请求以及超过15万次/秒的写请求。\n· 分钟级扩缩容\n存储与计算分离的架构，配合容器虚拟化技术和共享存储，增减节点只需5分钟。存储容量自动在线扩容，无需中断业务。\n· 读一致性\n集群地址利用LSN（Log Sequence Number）确保读取数据时的全局一致性，避免因为主备延迟引起的不一致。\n· 毫秒级延迟（物理复制）\n利用基于Redo的物理复制代替基于Binlog的逻辑复制，提升主备复制的效率和稳定性。即使对大表进行加索引、加字段等DDL操作，也不会造成数据库的延迟。\n· 秒级快速备份\n不论多大的数据量，全库备份只需30秒，而且备份过程不会对数据库加锁，对应用程序几乎无影响，全天24小时均可进行备份。\nPolarDB定价\n详情请参见计费项概览和购买PolarDB集群。\n如何使用PolarDB\n您可以通过以下方式管理PolarDB集群，包括创建集群、创建数据库、创建账号等。\n· 控制台：提供图形化的Web界面，操作方便。\n· CLI：控制台上所有的操作都可以通过CLI实现。\n· SDK：控制台上所有的操作都可以通过SDK实现。\n· API：控制台上所有的操作都可以通过API实现。\n创建PolarDB集群后，您可以通过以下方式连接PolarDB集群：\n· DMS：您可以通过DMS连接PolarDB集群，在Web界面进行数据库开发工作。\n· 客户端：您可以使用通用的数据库客户端工具连接PolarDB集群。例如，MySQL-Front、pgAdmin等。\n相关概念\n了解以下概念，将帮助您更好地选购和使用PolarDB：\n· 集群：PolarDB集群版采用集群架构，一个集群版集群中可包含一个主节点和最多15个只读节点。\n· 地域：地域是指物理的数据中心。一般情况下，PolarDB集群应该和ECS实例位于同一地域，以实现最高的访问性能。\n· 可用区：可用区是指在某个地域内拥有独立电力和网络的物理区域。同一地域的不同可用区之间没有实质性区别。\n· 规格：每个节点的资源配置，例如2核8 GB。\n相关服务\n· ECS：ECS是云服务器，通过内网访问同一地域的PolarDB集群时，可实现PolarDB集群的最佳性能。ECS搭配PolarDB集群是典型的业务访问架构。\n· Redis：Redis提供持久化的内存数据库服务。当业务访问量较大时，ECS 、PolarDB和Redis的组合可以支持更多的读请求，同时减少响应时间。\n· MongoDB：提供稳定可靠、弹性伸缩、完全兼容MongoDB协议的数据库服务。数据结构多样时，可以选择将结构化数据存储在PolarDB，将非结构化数据存储在MongoDB，满足业务的多样化存储需求。\n· DTS：您可以使用数据传输服务DTS将本地数据库迁移到云上的PolarDB。\n· OSS：对象存储服务OSS是阿里云提供的海量、安全、低成本、高可靠的云存储服务。",
"content_length": 2572
},
"createTime": 1660034506000,
"fileUrl": "http://localhost:8092/fileInfo/profile/upload/fileInfo/2022/08/09/测试_20220809164145A002.docx",
"id": 1306333192,
"contentType": "文章",
"fileType": "docx"
}
},
{
"_index": "fileinfo",
"_type": "_doc",
"_id": "mUPHgYIBz3NlBKQzwIVW",
"_score": 1.0,
"_source": {
"fileName": "测试_20220809164527A001.docx",
"updateTime": 1660034728000,
"attachment": {
"date": "2022-08-09T01:38:00Z",
"content_type": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
"author": "DELL",
"language": "lt",
"content": "什么是PolarDB\n更新时间：2022-06-06 17:36\n我的收藏\nPolarDB是阿里巴巴自研的新一代云原生关系型数据库，在存储计算分离架构下，利用了软硬件结合的优势，为用户提供具备极致弹性、高性能、海量存储、安全可靠的数据库服务。PolarDB 100%兼容MySQL 5.6/5.7/8.0，PostgreSQL 11，高度兼容Oracle。\nPolarDB采用存储和计算分离的架构，所有计算节点共享一份数据，提供分钟级的配置升降级、秒级的故障恢复、全局数据一致性和免费的数据备份容灾服务。PolarDB既融合了商业数据库稳定可靠、高性能、可扩展的特征，又具有开源云数据库简单开放、自我迭代的优势，例如PolarDB MySQL引擎作为超级MySQL，性能最高可达开源MySQL的6倍（在1024并发sysbench_insert场景下，PolarDB MySQL引擎与开启主备半同步Semi-Sync的开源MySQL的性能对比），而成本只有商用数据库的1/10，每小时最低只需1.3元即可体验完整的产品功能。PolarDB MySQL引擎100%兼容原生MySQL和RDS MySQL，您可以在不修改应用程序任何代码和配置的情况下，将MySQL数据库迁移至PolarDB MySQL引擎。\n· 计算与存储分离，共享分布式存储。\n采用计算与存储分离的设计理念，满足业务弹性扩展的需求。各计算节点通过分布式文件系统（PolarFileSystem）共享底层的存储（PolarStore），极大降低了用户的存储成本。\n· 一写多读，读写分离。\nPolarDB集群版采用多节点集群的架构，集群中有一个主节点（可读可写）和至少一个只读节点。当应用程序使用集群地址时，PolarDB通过内部的代理层（PolarProxy）对外提供服务，应用程序的请求都先经过代理，然后才访问到数据库节点。代理层不仅可以做安全认证和保护，还可以解析SQL，把写操作发送到主节点，把读操作均衡地分发到多个只读节点，实现自动的读写分离。对于应用程序来说，就像使用一个单点的数据库一样简单。\n产品优势\n您可以像使用MySQL、PostgreSQL、Oracle一样使用PolarDB。此外，PolarDB还有传统数据库不具备的优势：\n· 大容量\n最高100 TB，您不再需要因为单机容量的天花板而去购买多个实例做分片，由此简化应用开发，降低运维负担。\n· 低成本\n· 共享存储：计算与存储分离，每增加一个只读节点只收取计算资源的费用，而传统的只读节点同时包含计算和存储资源，每增加一个只读节点需要支付相应的存储费用。\n· 弹性存储：存储空间无需配置，根据数据量自动伸缩，您只需为实际使用的数据量按小时付费。\n· 存储包：PolarDB推出了预付费形式的存储包。当您的数据量较大时，推荐您使用存储包，相比按小时付费，预付费购买存储包有折扣，购买的容量越大，折扣力度越大。\n· 计算包：PolarDB首创计算包，用于抵扣计算节点的费用，计算包兼顾了包年包月付费方式的经济性和按量付费方式的灵活性。您还可以将计算包与自动扩缩容配合使用，在业务峰值前后实现自动弹性升降配，轻松应对业务量波动。\n· 高性能\n大幅提升OLTP性能，支持超过50万次/秒的读请求以及超过15万次/秒的写请求。\n· 分钟级扩缩容\n存储与计算分离的架构，配合容器虚拟化技术和共享存储，增减节点只需5分钟。存储容量自动在线扩容，无需中断业务。\n· 读一致性\n集群地址利用LSN（Log Sequence Number）确保读取数据时的全局一致性，避免因为主备延迟引起的不一致。\n· 毫秒级延迟（物理复制）\n利用基于Redo的物理复制代替基于Binlog的逻辑复制，提升主备复制的效率和稳定性。即使对大表进行加索引、加字段等DDL操作，也不会造成数据库的延迟。\n· 秒级快速备份\n不论多大的数据量，全库备份只需30秒，而且备份过程不会对数据库加锁，对应用程序几乎无影响，全天24小时均可进行备份。\nPolarDB定价\n详情请参见计费项概览和购买PolarDB集群。\n如何使用PolarDB\n您可以通过以下方式管理PolarDB集群，包括创建集群、创建数据库、创建账号等。\n· 控制台：提供图形化的Web界面，操作方便。\n· CLI：控制台上所有的操作都可以通过CLI实现。\n· SDK：控制台上所有的操作都可以通过SDK实现。\n· API：控制台上所有的操作都可以通过API实现。\n创建PolarDB集群后，您可以通过以下方式连接PolarDB集群：\n· DMS：您可以通过DMS连接PolarDB集群，在Web界面进行数据库开发工作。\n· 客户端：您可以使用通用的数据库客户端工具连接PolarDB集群。例如，MySQL-Front、pgAdmin等。\n相关概念\n了解以下概念，将帮助您更好地选购和使用PolarDB：\n· 集群：PolarDB集群版采用集群架构，一个集群版集群中可包含一个主节点和最多15个只读节点。\n· 地域：地域是指物理的数据中心。一般情况下，PolarDB集群应该和ECS实例位于同一地域，以实现最高的访问性能。\n· 可用区：可用区是指在某个地域内拥有独立电力和网络的物理区域。同一地域的不同可用区之间没有实质性区别。\n· 规格：每个节点的资源配置，例如2核8 GB。\n相关服务\n· ECS：ECS是云服务器，通过内网访问同一地域的PolarDB集群时，可实现PolarDB集群的最佳性能。ECS搭配PolarDB集群是典型的业务访问架构。\n· Redis：Redis提供持久化的内存数据库服务。当业务访问量较大时，ECS 、PolarDB和Redis的组合可以支持更多的读请求，同时减少响应时间。\n· MongoDB：提供稳定可靠、弹性伸缩、完全兼容MongoDB协议的数据库服务。数据结构多样时，可以选择将结构化数据存储在PolarDB，将非结构化数据存储在MongoDB，满足业务的多样化存储需求。\n· DTS：您可以使用数据传输服务DTS将本地数据库迁移到云上的PolarDB。\n· OSS：对象存储服务OSS是阿里云提供的海量、安全、低成本、高可靠的云存储服务。",
"content_length": 2572
},
"createTime": 1660034728000,
"fileUrl": "http://localhost:8092/fileInfo/profile/upload/fileInfo/2022/08/09/测试_20220809164527A001.docx",
"id": 1306333193,
"contentType": "文章",
"fileType": "docx"
}
},
{
"_index": "fileinfo",
"_type": "_doc",
"_id": "JDqshoIBbkTNu1UgkzFK",
"_score": 1.0,
"_source": {
"fileName": "txt测试_20220810153351A001.txt",
"updateTime": 1660116831000,
"attachment": {
"content_type": "text/plain; charset=UTF-8",
"language": "lt",
"content": "产品优势\r\n您可以像使用MySQL、PostgreSQL、Oracle一样使用PolarDB。此外，PolarDB还有传统数据库不具备的优势：\r\n•\t大容量\r\n最高100 TB，您不再需要因为单机容量的天花板而去购买多个实例做分片，由此简化应用开发，降低运维负担。\r\n•\t低成本\r\no\t共享存储：计算与存储分离，每增加一个只读节点只收取计算资源的费用，而传统的只读节点同时包含计算和存储资源，每增加一个只读节点需要支付相应的存储费用。\r\no\t弹性存储：存储空间无需配置，根据数据量自动伸缩，您只需为实际使用的数据量按小时付费。\r\no\t存储包：PolarDB推出了预付费形式的存储包。当您的数据量较大时，推荐您使用存储包，相比按小时付费，预付费购买存储包有折扣，购买的容量越大，折扣力度越大。\r\no\t计算包：PolarDB首创计算包，用于抵扣计算节点的费用，计算包兼顾了包年包月付费方式的经济性和按量付费方式的灵活性。您还可以将计算包与自动扩缩容配合使用，在业务峰值前后实现自动弹性升降配，轻松应对业务量波动。\r\n•\t高性能\r\n大幅提升OLTP性能，支持超过50万次/秒的读请求以及超过15万次/秒的写请求。\r\n•\t分钟级扩缩容\r\n存储与计算分离的架构，配合容器虚拟化技术和共享存储，增减节点只需5分钟。存储容量自动在线扩容，无需中断业务。\r\n•\t读一致性\r\n集群地址利用LSN（Log Sequence Number）确保读取数据时的全局一致性，避免因为主备延迟引起的不一致。\r\n•\t毫秒级延迟（物理复制）\r\n利用基于Redo的物理复制代替基于Binlog的逻辑复制，提升主备复制的效率和稳定性。即使对大表进行加索引、加字段等DDL操作，也不会造成数据库的延迟。\r\n•\t秒级快速备份\r\n不论多大的数据量，全库备份只需30秒，而且备份过程不会对数据库加锁，对应用程序几乎无影响，全天24小时均可进行备份。",
"content_length": 804
},
"createTime": 1660116831000,
"fileUrl": "http://localhost:8092/fileInfo/profile/upload/fileInfo/2022/08/10/txt测试_20220810153351A001.txt",
"id": 1306333194,
"contentType": "告示",
"fileType": "txt"
}
}
]
}
}我们调用上传的接口，可以看到文本内容已经抽取到es里面了，后面就可以直接分词检索内容，高亮显示了
三.代码
介绍下代码实现逻辑：文件上传，数据库存储附件信息和附件上传地址；调用es实现文本内容抽取，将抽取的内容放到对应索引下；提供小程序全文检索的api实现根据文件名称关键词联想，文件名称内容全文检索模糊匹配，并高亮显示分词匹配字段；直接贴代码
yml配置文件：
# 数据源配置
spring:
# 服务模块
devtools:
restart:
# 热部署开关
enabled: true
# 搜索引擎
elasticsearch:
rest:
url: 127.0.0.1
uris: 127.0.0.1:9200
connection-timeout: 1000
read-timeout: 3000
username: elastic
password: 123456elsticsearchConfig（连接配置）
package com.yj.rselasticsearch.domain.config;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.Duration;
@Configuration
public class ElasticsearchConfig {
@Value("${spring.elasticsearch.rest.url}")
private String edUrl;
@Value("${spring.elasticsearch.rest.username}")
private String userName;
@Value("${spring.elasticsearch.rest.password}")
private String password;
@Bean
public RestHighLevelClient restHighLevelClient() {
//设置连接的用户名密码
final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userName, password));
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
new HttpHost(edUrl, 9200,"http"))
.setHttpClientConfigCallback(httpClientBuilder -> {
httpClientBuilder.disableAuthCaching();
//保持连接池处于链接状态，该bug曾导致es一段时间没使用，第一次连接访问超时
httpClientBuilder.setKeepAliveStrategy(((response, context) -> Duration.ofMinutes(5).toMillis()));
return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
})
);
return client;
}
}
文件上传保存文件信息并抽取内容到es
实体对象FileInfo
package com.yj.common.core.domain.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.yj.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import java.util.Date;
@Setter
@Getter
@Document(indexName = "fileinfo",createIndex = false)
public class FileInfo {
/**
* 主键
*/
@Field(name = "id", type = FieldType.Integer)
private Integer id;
/**
* 文件名称
*/
@Field(name = "fileName", type = FieldType.Text,analyzer = "jieba_index",searchAnalyzer = "jieba_index")
private String fileName;
/**
* 文件类型
*/
@Field(name = "fileType", type = FieldType.Keyword)
private String fileType;
/**
* 内容类型
*/
@Field(name = "contentType", type = FieldType.Text)
private String contentType;
/**
* 附件内容
*/
@Field(name = "attachment.content", type = FieldType.Text,analyzer = "jieba_index",searchAnalyzer = "jieba_index")
@TableField(exist = false)
private String content;
/**
* 文件地址
*/
@Field(name = "fileUrl", type = FieldType.Text)
private String fileUrl;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新时间
*/
private Date updateTime;
}controller类
package com.yj.rselasticsearch.controller;
import com.yj.common.core.controller.BaseController;
import com.yj.common.core.domain.AjaxResult;
import com.yj.common.core.domain.entity.FileInfo;
import com.yj.rselasticsearch.service.FileInfoService;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
/**
* (file_info)表控制层
*
* @author xxxxx
*/
@RestController
@RequestMapping("/fileInfo")
public class FileInfoController extends BaseController {
/**
* 服务对象
*/
@Resource
private FileInfoService fileInfoService;
@PutMapping("uploadFile")
public AjaxResult uploadFile(String contentType, MultipartFile file) {
return fileInfoService.uploadFileInfo(contentType,file);
}
}serviceImpl实现类
package com.yj.rselasticsearch.service.impl;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yj.common.config.RuoYiConfig;
import com.yj.common.core.domain.AjaxResult;
import com.yj.common.utils.FastUtils;
import com.yj.common.utils.StringUtils;
import com.yj.common.utils.file.FileUploadUtils;
import com.yj.common.utils.file.FileUtils;
import com.yj.framework.config.ServerConfig;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import com.yj.common.core.domain.entity.FileInfo;
import com.yj.rselasticsearch.mapper.FileInfoMapper;
import com.yj.rselasticsearch.service.FileInfoService;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Base64;
@Service
@Slf4j
public class FileInfoServiceImpl implements FileInfoService{
@Resource
private ServerConfig serverConfig;
@Autowired
@Qualifier("restHighLevelClient")
private RestHighLevelClient client;
@Resource
private FileInfoMapper fileInfoMapper;
/**
* 上传文件并进行文件内容识别上传到es
* @param contentType
* @param file
* @return
*/
@Override
public AjaxResult uploadFileInfo(String contentType, MultipartFile file) {
if (FastUtils.checkNullOrEmpty(contentType,file)){
return AjaxResult.error("请求参数不能为空");
}
try {
// 上传文件路径
String filePath = RuoYiConfig.getUploadPath() + "/fileInfo";
FileInfo fileInfo = new FileInfo();
// 上传并返回新文件名称
String fileName = FileUploadUtils.upload(filePath, file);
String prefix = fileName.substring(fileName.lastIndexOf(".")+1);
File files = File.createTempFile(fileName, prefix);
file.transferTo(files);
String url = serverConfig.getUrl() + "/fileInfo" + fileName;
fileInfo.setFileName(FileUtils.getName(fileName));
fileInfo.setFileType(prefix);
fileInfo.setFileUrl(url);
fileInfo.setContentType(contentType);
int result = fileInfoMapper.insertSelective(fileInfo);
if (result > 0) {
fileInfo = fileInfoMapper.selectOne(new LambdaQueryWrapper<FileInfo>().eq(FileInfo::getFileUrl,fileInfo.getFileUrl()));
byte[] bytes = getContent(files);
String base64 = Base64.getEncoder().encodeToString(bytes);
fileInfo.setContent(base64);
IndexRequest indexRequest = new IndexRequest("fileinfo");
//上传同时，使用attachment pipline进行提取文件
indexRequest.source(JSON.toJSONString(fileInfo), XContentType.JSON);
indexRequest.setPipeline("attachment");
IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);
log.info("indexResponse:" + indexResponse);
}
AjaxResult ajax = AjaxResult.success(fileInfo);
return ajax;
} catch (Exception e) {
return AjaxResult.error(e.getMessage());
}
}
/**
* 文件转base64
*
* @param file
* @return
* @throws IOException
*/
private byte[] getContent(File file) throws IOException {
long fileSize = file.length();
if (fileSize > Integer.MAX_VALUE) {
log.info("file too big...");
return null;
}
FileInputStream fi = new FileInputStream(file);
byte[] buffer = new byte[(int) fileSize];
int offset = 0;
int numRead = 0;
while (offset < buffer.length
&& (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {
offset += numRead;
}
// 确保所有数据均被读取
if (offset != buffer.length) {
throw new ServiceException("Could not completely read file "
+ file.getName());
}
fi.close();
return buffer;
}
}
高亮分词检索
参数请求WarningInfoDto
package com.yj.rselasticsearch.domain.dto;
import com.yj.common.core.domain.entity.WarningInfo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
/**
* 前端请求数据传输
* WarningInfo
* @author luoY
*/
@Data
@ApiModel(value ="WarningInfoDto",description = "告警信息")
public class WarningInfoDto{
/**
* 页数
*/
@ApiModelProperty("页数")
private Integer pageIndex;
/**
* 每页数量
*/
@ApiModelProperty("每页数量")
private Integer pageSize;
/**
* 查询关键词
*/
@ApiModelProperty("查询关键词")
private String keyword;
/**
* 内容类型
*/
private List<String> contentType;
/**
* 用户手机号
*/
private String phone;
}
controller类
package com.yj.rselasticsearch.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yj.common.core.controller.BaseController;
import com.yj.common.core.domain.AjaxResult;
import com.yj.common.core.domain.entity.FileInfo;
import com.yj.common.core.domain.entity.WarningInfo;
import com.yj.rselasticsearch.service.ElasticsearchService;
import com.yj.rselasticsearch.service.WarningInfoService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;
import com.yj.rselasticsearch.domain.dto.WarningInfoDto;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
/**
* es搜索引擎
*
* @author luoy
*/
@Api("搜索引擎")
@RestController
@RequestMapping("es")
public class ElasticsearchController extends BaseController {
@Resource
private ElasticsearchService elasticsearchService;
/**
* 告警信息关键词联想
*
* @param warningInfoDto
* @return
*/
@ApiOperation("关键词联想")
@ApiImplicitParams({
@ApiImplicitParam(name = "contenttype", value = "文档类型", required = true, dataType = "String", dataTypeClass = String.class),
@ApiImplicitParam(name = "keyword", value = "关键词", required = true, dataType = "String", dataTypeClass = String.class)
})
@PostMapping("getAssociationalWordDoc")
public AjaxResult getAssociationalWordDoc(@RequestBody WarningInfoDto warningInfoDto, HttpServletRequest request) {
List<String> words = elasticsearchService.getAssociationalWordOther(warningInfoDto,request);
return AjaxResult.success(words);
}
/**
* 告警信息高亮分词分页查询
*
* @param warningInfoDto
* @return
*/
@ApiOperation("高亮分词分页查询")
@ApiImplicitParams({
@ApiImplicitParam(name = "keyword", value = "关键词", required = true, dataType = "String", dataTypeClass = String.class),
@ApiImplicitParam(name = "pageIndex", value = "页码", required = true, dataType = "Integer", dataTypeClass = Integer.class),
@ApiImplicitParam(name = "pageSize", value = "页数", required = true, dataType = "Integer", dataTypeClass = Integer.class),
@ApiImplicitParam(name = "contenttype", value = "文档类型", required = true, dataType = "String", dataTypeClass = String.class)
})
@PostMapping("queryHighLightWordDoc")
public AjaxResult queryHighLightWordDoc(@RequestBody WarningInfoDto warningInfoDto,HttpServletRequest request) {
IPage<FileInfo> warningInfoListPage = elasticsearchService.queryHighLightWordOther(warningInfoDto,request);
return AjaxResult.success(warningInfoListPage);
}
}
serviceImpl实现类
package com.yj.rselasticsearch.service.impl;
import com.alibaba.fastjson.JSON;
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.yj.common.constant.DataConstants;
import com.yj.common.constant.HttpStatus;
import com.yj.common.core.domain.entity.FileInfo;
import com.yj.common.core.domain.entity.WarningInfo;
import com.yj.common.core.domain.entity.WhiteList;
import com.yj.common.core.redis.RedisCache;
import com.yj.common.exception.ServiceException;
import com.yj.common.utils.FastUtils;
import com.yj.rselasticsearch.domain.dto.RetrievalRecordDto;
import com.yj.rselasticsearch.domain.dto.WarningInfoDto;
import com.yj.rselasticsearch.domain.vo.MemberVo;
import com.yj.rselasticsearch.service.*;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.*;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.stream.Collectors;
@Service
@Slf4j
public class ElasticsearchServiceImpl implements ElasticsearchService {
@Resource
private WhiteListService whiteListService;
@Autowired
@Qualifier("restHighLevelClient")
private RestHighLevelClient client;
@Autowired
private RedisCache redisCache;
@Resource
private TokenService tokenService;
/**
* 文档信息关键词联想(根据输入框的词语联想文件名称)
*
* @param warningInfoDto
* @return
*/
@Override
public List<String> getAssociationalWordOther(WarningInfoDto warningInfoDto, HttpServletRequest request) {
//需要查询的字段
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery()
.should(QueryBuilders.matchBoolPrefixQuery("fileName", warningInfoDto.getKeyword()));
//contentType标签内容过滤
boolQueryBuilder.must(QueryBuilders.termsQuery("contentType", warningInfoDto.getContentType()));
//构建高亮查询
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
.withQuery(boolQueryBuilder)
.withHighlightFields(
new HighlightBuilder.Field("fileName")
)
.withHighlightBuilder(new HighlightBuilder().preTags("<span style='color:red'>").postTags("</span>"))
.build();
//查询
SearchHits<FileInfo> search = null;
try {
search = elasticsearchRestTemplate.search(searchQuery, FileInfo.class);
} catch (Exception ex) {
ex.printStackTrace();
throw new ServiceException(String.format("操作错误，请联系管理员！%s", ex.getMessage()));
}
//设置一个最后需要返回的实体类集合
List<String> resultList = new LinkedList<>();
//遍历返回的内容进行处理
for (org.springframework.data.elasticsearch.core.SearchHit<FileInfo> searchHit : search.getSearchHits()) {
//高亮的内容
Map<String, List<String>> highlightFields = searchHit.getHighlightFields();
//将高亮的内容填充到content中
searchHit.getContent().setFileName(highlightFields.get("fileName") == null ? searchHit.getContent().getFileName() : highlightFields.get("fileName").get(0));
if (highlightFields.get("fileName") != null) {
resultList.add(searchHit.getContent().getFileName());
}
}
//list去重
List<String> newResult = null;
if (!FastUtils.checkNullOrEmpty(resultList)) {
if (resultList.size() > 9) {
newResult = resultList.stream().distinct().collect(Collectors.toList()).subList(0, 9);
} else {
newResult = resultList.stream().distinct().collect(Collectors.toList());
}
}
return newResult;
}
/**
* 高亮分词搜索其它类型文档
*
* @param warningInfoDto
* @param request
* @return
*/
@Override
public IPage<FileInfo> queryHighLightWordOther(WarningInfoDto warningInfoDto, HttpServletRequest request) {
//分页
Pageable pageable = PageRequest.of(warningInfoDto.getPageIndex() - 1, warningInfoDto.getPageSize());
//需要查询的字段，根据输入的内容分词全文检索fileName和content字段
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery()
.should(QueryBuilders.matchBoolPrefixQuery("fileName", warningInfoDto.getKeyword()))
.should(QueryBuilders.matchBoolPrefixQuery("attachment.content", warningInfoDto.getKeyword()));
//contentType标签内容过滤
boolQueryBuilder.must(QueryBuilders.termsQuery("contentType", warningInfoDto.getContentType()));
//构建高亮查询
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
.withQuery(boolQueryBuilder)
.withHighlightFields(
new HighlightBuilder.Field("fileName"), new HighlightBuilder.Field("attachment.content")
)
.withHighlightBuilder(new HighlightBuilder().preTags("<span style='color:red'>").postTags("</span>"))
.build();
//查询
SearchHits<FileInfo> search = null;
try {
search = elasticsearchRestTemplate.search(searchQuery, FileInfo.class);
} catch (Exception ex) {
ex.printStackTrace();
throw new ServiceException(String.format("操作错误，请联系管理员！%s", ex.getMessage()));
}
//设置一个最后需要返回的实体类集合
List<FileInfo> resultList = new LinkedList<>();
//遍历返回的内容进行处理
for (org.springframework.data.elasticsearch.core.SearchHit<FileInfo> searchHit : search.getSearchHits()) {
//高亮的内容
Map<String, List<String>> highlightFields = searchHit.getHighlightFields();
//将高亮的内容填充到content中
searchHit.getContent().setFileName(highlightFields.get("fileName") == null ? searchHit.getContent().getFileName() : highlightFields.get("fileName").get(0));
searchHit.getContent().setContent(highlightFields.get("content") == null ? searchHit.getContent().getContent() : highlightFields.get("content").get(0));
resultList.add(searchHit.getContent());
}
//手动分页返回信息
IPage<FileInfo> warningInfoIPage = new Page<>();
warningInfoIPage.setTotal(search.getTotalHits());
warningInfoIPage.setRecords(resultList);
warningInfoIPage.setCurrent(warningInfoDto.getPageIndex());
warningInfoIPage.setSize(warningInfoDto.getPageSize());
warningInfoIPage.setPages(warningInfoIPage.getTotal() % warningInfoDto.getPageSize());
return warningInfoIPage;
}
}
代码测试：
--请求jason
{
"keyword":"全库备份",
"contentType":["告示"],
"pageIndex":1,
"pageSize":10
}
--响应
{
"msg": "操作成功",
"code": 200,
"data": {
"records": [
{
"id": 1306333194,
"fileName": "txt测试_20220810153351A001.txt",
"fileType": "txt",
"contentType": "告示",
"content": "•\t秒级快速<span style='color:red'>备份</span>\r\n不论多大的数据量，<span style='color:red'>全库</span><span style='color:red'>备份</span>只需30秒，而且<span style='color:red'>备份过程</span>不会对数据库加锁，对应用程序几乎无影响，全天24小时均可进行<span style='color:red'>备份</span>。",
"fileUrl": "http://localhost:8092/fileInfo/profile/upload/fileInfo/2022/08/10/txt测试_20220810153351A001.txt",
"createTime": "2022-08-10T15:33:51.000+08:00",
"updateTime": "2022-08-10T15:33:51.000+08:00"
}
],
"total": 1,
"size": 10,
"current": 1,
"orders": [],
"optimizeCountSql": true,
"searchCount": true,
"countId": null,
"maxLimit": null,
"pages": 1
}
}返回的内容将分词检索到匹配的内容，并将匹配的词高亮显示
668
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
