devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot整合elasticsearch5.x以及IK分词器做全文检索_springboot elasticsearch 使用ik analyzer查询

作者：盐析白兔 | 2024-05-21 20:35:45

赞

踩

springboot elasticsearch 使用ik analyzer查询

文章我会分三部分来讲解：

第一部分，window下搭建elasticsearch的环境，以及其他插件

第二部分，springboot整合elasticsearch（有一定的分词能力）

第三部分，springboot整合elasticsearch以及ik分词器，做全字段检索（完全分词）

（我的第二篇，《springboot2.x 整合 elasticsearch 创建索引的方式》有更实用的意义，弃用postman创建索引方式，附上项目GitHub地址）

一：window安装部署elasticsearch和elasticsearch-head

现在直接在window下安装部署elasticsearch5.5.3。

这里是下载elasticsearch的官网网址：Download Elasticsearch | Elastic

步骤如下：

接着到github主页，下载相应的版本的zip压缩包。

然后解压到磁盘的某个路径，路径不要包含中文字符。

然后进入bin目录下，双击elasticsearch.bat文件，启动elasticsearch。也可以用控制台，输入elasticsearch.bat，然后按回车键，启动elasticsearch。

启动完成后，在浏览器，输入localhost:9200。查看启动效果，如下图，则表示安装启动elasticsearch5.5.3成功。

接下来，对elasticsearch5.5.3进行一些配置，让elasticsearch-head可以访问elasticsearch。elasticsearch-head是让elasticsearch数据可视化的插件。

在window下使用elasticsearch-head插件，要有node.js环境

安装node.js： node.js下载：Download | Node.js 

安装grunt： 

  • grunt是一个很方便的构建工具，可以进行打包压缩、测试、执行等等的工作，5.x里的head插件就是通过grunt启动的。因此需要安装grunt
  • 注意：路径切到nodejs安装目录下，[我安装在C:\Program Files\nodejs]，输入命令： npm install -g grunt-cli
  • -g代表全局安装
  • 查看版本号， 输入命令：grunt -version

elasticsearch-head的下载官网网址：GitHub - mobz/elasticsearch-head: A web front end for an elastic search cluster

同样下载zip包，然后指定路径解压，路径也不要有中文字符。（我是将elasticsearch和elasticsearch-head放在E盘路径下）。

①：修改elasticsearch-head配置，找到 elasticsearch-head-master下的Gruntfile.js,文件， 新增：hostname: '0.0.0.0'.

  1. connect: {        	
  2.            server: {           		 
  3.               options: {               			
  4.                  hostname: '0.0.0.0',               			
  5.                  port: 9100,                		 
  6.                  base: '.',                		 
  7.                  keepalive: true           			 
  8.                    }       			
  9.              }  		
  10.       }

②： 修改elasticsearch的配置文件，进入elasticsearch的config目录下，修改elasticsearch.yml文件里面的配置。

  1. cluster.name: elasticsearch
  2. node.name: node-es
  3.  
  4. network.host: 127.0.0.1
  5. http.port: 9200
  6. transport.tcp.port: 9300
  7.  
  8. # 增加新的参数，这样head插件就可以访问es
  9. http.cors.enabled: true
  10. http.cors.allow-origin: "*"

上面7行配置代码，全部都是需要往elasticsearch.yml新增的配置，我特意将它们分割三部分。第一部分的配置，可以在启动elasticsearch之后的页面直接能看到（如我上面启动后截图的①②所示）。 最后两个，http.cors.enabled: true, 和 http.cors.allow-origin: "*"， 是让head插件访问链接用的配置，不可缺少。

重启elasticsearch。接着在elasticsearch-head-master的目录下，输入命令：grunt server，启动head插件

然后在浏览器输入： localhost:9100

到这里，elasticsearch和elasticsearch-head的安装与配置已经完成。

elasticsearch以及elasticsearch-head的安装与配置，推荐一个网址，这个哥们写得很好，我的配置都是按他的来配置的：在Windows上安装Elasticsearch 5.x - 秦岭过客 - 博客园

二：springboot整合elasticsearch

到springboot官网看你就知道，整合elasticsearch有三种方式：

  1. Connecting to Elasticsearch by REST clients
  2. Connecting to Elasticsearch by Using Jest
  3. Connecting to Elasticsearch by Using Spring Data

这里我是使用第三种方式，spring Data elasticsearch

新建一个springboot工程，我的springboot版本是2.0.0

我的pom.xml文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         // 可以直接在这里修改你的springboot版本，我的springboot新建时是2.1.6的，然后在这里修改为2.0.0
  9.         <version>2.0.0.RELEASE</version>     
  10.         <relativePath/>
  11.     </parent>
  12.     <groupId>com.gosuncn</groupId>
  13.     <artifactId>esdemo</artifactId>
  14.     <version>0.0.1-SNAPSHOT</version>
  15.     <name>esdemo</name>
  16.     <description>Demo project for Spring Boot</description>
  17.  
  18.     <properties>
  19.         <java.version>1.8</java.version>
  20.         <elasticsearch.version>5.5.3</elasticsearch.version>
  21.     </properties>
  22.  
  23.     <dependencies>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>org.elasticsearch.client</groupId>
  30.             <artifactId>transport</artifactId>
  31.             <version>5.5.3</version>
  32.         </dependency>
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             <artifactId>spring-boot-starter-web</artifactId>
  36.         </dependency>
  37.  
  38.         <dependency>
  39.             <groupId>org.projectlombok</groupId>
  40.             <artifactId>lombok</artifactId>
  41.             <optional>true</optional>
  42.         </dependency>
  43.         <dependency>
  44.             <groupId>org.springframework.boot</groupId>
  45.             <artifactId>spring-boot-starter-test</artifactId>
  46.             <scope>test</scope>
  47.         </dependency>
  48.     </dependencies>
  49.  
  50.     <build>
  51.         <plugins>
  52.             <plugin>
  53.                 <groupId>org.springframework.boot</groupId>
  54.                 <artifactId>spring-boot-maven-plugin</artifactId>
  55.             </plugin>
  56.         </plugins>
  57.     </build>
  58.  
  59. </project>

然后可以看你springboot导入的elasticsearch.jar的版本

因为spring data elasticsearch 与elasticsearch是要进行版本适配的，不匹配，是不能进行连接的。 

细心的朋友，可能已经发现，我的elasticsearch已经存在一个local_library索引了。那我们就以这个索引为例。

这里，我先说明一下，我的local_library索引是怎样创建的。使用postman，提交PUT请求，即可创建local_library索引，以及这个索引下的book类型。

body实体里面的内容如下：在local_library索引下，创建一个book类型。

  1. {
  2.     "mappings":{
  3.         "book":{
  4.             "properties":{
  5.                 "book_id":{
  6.                     "type":"long",
  7.                     "fields":{
  8.                         "keyword":{
  9.                             "type":"keyword"
  10.                         }
  11.                     }
  12.                 },
  13.                 "book_code":{
  14.                     "type":"text",
  15.                     "fields":{
  16.                         "keyword":{
  17.                             "type":"keyword"
  18.                         }
  19.                     }
  20.                 },
  21.                 "book_name":{
  22.                     "type":"text",
  23.                     "fields":{
  24.                         "keyword":{
  25.                             "type":"keyword"
  26.                         }
  27.                     }
  28.                 },
  29.                 "book_price":{
  30.                     "type":"integer",
  31.                     "fields":{
  32.                         "keyword":{
  33.                             "type":"keyword"
  34.                         }
  35.                     }
  36.                 },
  37.                 "book_author":{
  38.                     "type":"text",
  39.                     "fields":{
  40.                         "keyword":{
  41.                             "type":"keyword"
  42.                         }
  43.                     }
  44.                 },
  45.                 "book_desc":{
  46.                     "type":"text",
  47.                     "fields":{
  48.                         "keyword":{
  49.                             "type":"keyword"
  50.                         }
  51.                     }
  52.                 }
  53.             }
  54.         }
  55.     }
  56. }

在elasticsearch-head查看效果如下：(备注：)

接着，有索引，有类型了，可以开始插入数据。插入数据有两种方式，第一种是用postman， 第二种是在springboot工程的测试类中插入。

①：用postman插入数据示例：

插入的效果，可以看上面数据截图。

②：用实体类插入数据（包括新增、查询）

新建一个Library实体类：（备注，实体类已经使用lombok插件了）

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. @Document(indexName = "local_library", type = "book")
  5. public class Library {
  6.     /**
  7.      *     index：是否设置分词
  8.      *     analyzer：存储时使用的分词器
  9.      *          ik_max_word
  10.      *          ik_word
  11.      *     searchAnalyze：搜索时使用的分词器
  12.      *     store：是否存储
  13.      *     type: 数据类型
  14.      */
  15.  
  16.     @Id
  17.     private Integer book_id;
  18.     private String book_code;    
  19.     private String book_name;   
  20.     private Integer book_price;   
  21.     private String book_author;    
  22.     private String book_desc;
  23.  
  24. }

然后编写一个LibraryRepository:

  1. @Repository
  2. public interface LibraryRepository extends ElasticsearchRepository<Library, Long> {
  3. }

然后在测试类中，插入数据：

  1. import com.gosuncn.esdemo.domin.Library;
  2. import com.gosuncn.esdemo.repository.LibraryRepository;
  3. import org.elasticsearch.index.query.QueryBuilders;
  4. import org.elasticsearch.index.query.QueryStringQueryBuilder;
  5. import org.junit.Test;
  6. import org.junit.runner.RunWith;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.boot.test.context.SpringBootTest;
  9. import org.springframework.data.domain.Page;
  10. import org.springframework.data.domain.PageRequest;
  11. import org.springframework.data.domain.Sort;
  12. import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
  13. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  14. import org.springframework.test.context.junit4.SpringRunner;
  15. import java.util.ArrayList;
  16. import java.util.Iterator;
  17. import java.util.List;
  18.  
  19. @RunWith(SpringRunner.class)
  20. @SpringBootTest
  21. public class EsdemoApplicationTests {
  22.  
  23.     @Autowired
  24.     ElasticsearchTemplate elasticsearchTemplate;
  25.     @Autowired
  26.     LibraryRepository libraryRepository;
  27.  
  28.     /**
  29.      * 插入数据
  30.      */
  31.     @Test
  32.     public void testInsert(){
  33.         libraryRepository.save(new Library(42, "A00042", "明史简述", 59, "吴晗", "吴晗背景uniworsity厉害"));
  34.         libraryRepository.save(new Library(43, "A00043", "傅雷家书", 99, "傅聪", "都是NB，class大家u"));
  35.         libraryRepository.save(new Library(24, "A00942", "时间简史", 169, "霍金", "教授宇宙大爆发的59年历史"));
  36.         libraryRepository.save(new Library(25, "A00925", "我的前半生", 39, "方舟89子", "都是生活，每晚9点"));
  37.         libraryRepository.save(new Library(29, "A00029", "围9城", 139, "钱钟书", "你想出城？不存在的"));
  38.     }
  39. }

到此，这是第二种插入数据的方式。

然后数据有了，就可以进行查询了。查询代码如下：

  1.     // 全字段查询,不分页
  2.     @Test
  3.     public void testSearch(){
  4.         try {
  5.             String searchStr = "三西阿";
  6.             QueryStringQueryBuilder builder = new QueryStringQueryBuilder(searchStr);
  7.             Iterable<Library> search = libraryRepository.search(builder);
  8.             Iterator<Library> iterator = search.iterator();
  9.             while (iterator.hasNext()){
  10.                 System.out.println("--> 数据："+iterator.next());
  11.             }
  12.         }catch (Exception e){
  13.             System.out.println("---> 异常信息： "+e);
  14.         }
  15.     }
  16.     // 全字段查询, 已经分页
  17.     @Test
  18.     public void testSearchByPage(){
  19.         try {
  20.             String searchStr = "三西阿";
  21.             QueryStringQueryBuilder builder = new QueryStringQueryBuilder(searchStr);
  22.             Iterable<Library> search = libraryRepository.search(builder, PageRequest.of(0,2));
  23.             Iterator<Library> iterator = search.iterator();
  24.             while (iterator.hasNext()){
  25.                 System.out.println("--> 数据："+iterator.next());
  26.             }
  27.         }catch (Exception e){
  28.             System.out.println("---> 异常信息： "+e);
  29.         }
  30.     }

运行第一个test的结果是：

  1. --> 数据：Library{book_id=3, book_code='A0003', book_name='西游记', book_price=99, book_author='吴承恩', book_desc='冒险小说！'}
  2. --> 数据：Library{book_id=6, book_code='A0006', book_name='欢乐颂', book_price=399, book_author='阿耐', book_desc='都是生活真实隐射！'}
  3. --> 数据：Library{book_id=7, book_code='A0007', book_name='都挺好', book_price=299, book_author='阿耐', book_desc='折射现实家庭矛盾！'}
  4. --> 数据：Library{book_id=5, book_code='A0005', book_name='三国演义', book_price=198, book_author='罗贯中', book_desc='三国霸王游戏！'}
  5. --> 数据：Library{book_id=18, book_code='A00018', book_name='编译原理', book_price=79, book_author='赵建华', book_desc='三十多小时，98.5'}
  6. --> 数据：Library{book_id=1, book_code='A0001', book_name='琴帝', book_price=180, book_author='唐家三少', book_desc='最好看的玄幻小说！'}
  7. --> 数据：Library{book_id=12, book_code='A00012', book_name='三重门', book_price=69, book_author='韩寒', book_desc='这是一个批评现实的真实故事'}

三：IK分词器的使用

前面的都是小case，到这里才是我们做全文检索的重点。

3.1：为什么要使用IK分词器

ik分词器，会将你的查询条件语句拆分成一个一个词。比如：查询语句是“我爱中华人民共和国”，使用ik_max_word来分词，则会出现下面的结果： 【“我”，“爱”，“中华人民共和国”，“中华人民”，“中华”，“华人”，“人民共和国”，“人民”，“人民共和国”，“共和”，“国”】。具体看下图：（使用postman）

body结果代码如下:

  1. {
  2.     "tokens": [
  3.         {
  4.             "token": "我",
  5.             "start_offset": 0,
  6.             "end_offset": 1,
  7.             "type": "CN_CHAR",
  8.             "position": 0
  9.         },
  10.         {
  11.             "token": "爱",
  12.             "start_offset": 1,
  13.             "end_offset": 2,
  14.             "type": "CN_CHAR",
  15.             "position": 1
  16.         },
  17.         {
  18.             "token": "中华人民共和国",
  19.             "start_offset": 2,
  20.             "end_offset": 9,
  21.             "type": "CN_WORD",
  22.             "position": 2
  23.         },
  24.         {
  25.             "token": "中华人民",
  26.             "start_offset": 2,
  27.             "end_offset": 6,
  28.             "type": "CN_WORD",
  29.             "position": 3
  30.         },
  31.         {
  32.             "token": "中华",
  33.             "start_offset": 2,
  34.             "end_offset": 4,
  35.             "type": "CN_WORD",
  36.             "position": 4
  37.         },
  38.         {
  39.             "token": "华人",
  40.             "start_offset": 3,
  41.             "end_offset": 5,
  42.             "type": "CN_WORD",
  43.             "position": 5
  44.         },
  45.         {
  46.             "token": "人民共和国",
  47.             "start_offset": 4,
  48.             "end_offset": 9,
  49.             "type": "CN_WORD",
  50.             "position": 6
  51.         },
  52.         {
  53.             "token": "人民",
  54.             "start_offset": 4,
  55.             "end_offset": 6,
  56.             "type": "CN_WORD",
  57.             "position": 7
  58.         },
  59.         {
  60.             "token": "共和国",
  61.             "start_offset": 6,
  62.             "end_offset": 9,
  63.             "type": "CN_WORD",
  64.             "position": 8
  65.         },
  66.         {
  67.             "token": "共和",
  68.             "start_offset": 6,
  69.             "end_offset": 8,
  70.             "type": "CN_WORD",
  71.             "position": 9
  72.         },
  73.         {
  74.             "token": "国",
  75.             "start_offset": 8,
  76.             "end_offset": 9,
  77.             "type": "CN_CHAR",
  78.             "position": 10
  79.         }
  80.     ]
  81. }

补充说明一下的区别：ik_max_word 和 ik_smart 

  1. ik_max_word 会将文本做最细粒度的拆分。
  2. ik_smart 会做最粗粒度的拆分。

ik_max_word  和 ik_smart 是两个不同类型的分词器。

3.2 安装ik分词器

ik分词器的下载与安装：（备注：ik分词器的版本，必须与elasticsearch版本一致）

GitHub下载地址： Releases · medcl/elasticsearch-analysis-ik · GitHub

找到5.5.3版本的

点击下载elasticsearch-analysis-ik-5.5.3.zip 包，然后解压，打开解压后的文件夹，里面有如下文件

接着，把这里的所有文件复制到elasticsearch的plugins目录下，自己新建的ik文件夹里面（说明： ik文件夹是自己新建的，至于为什么要新建一个ik文件夹。其实到后来，你会在使用elasticsearch时添加很多的插件，每一个插件都是放在plugins目录下的，所以建一个文件夹，单独存放某个插件，会有一个很清晰的文件目录）

然后重启elasticsearch。

出现红圈所示，则说明插件安装成功。

检验效果：启动elasticsearch成功后，直接在浏览器输入：http://localhost:9200/_analyze?analyzer=ik_max_word&pretty=true&text=我爱中华人民共和国

备注：

如果是ik分词插件是6.x版本的，只能用postman测试，而且查询条件要放在body体内，如下图：

如果直接在url加上查询条件，如： http://localhost:9200/_analyze?analyzer=ik_max_word&pretty=true&text=大胆爱，不用地阿达女，加

会抛出异常：

  1. {
  2.   "error": {
  3.     "root_cause": [
  4.       {
  5.         "type": "parse_exception",
  6.         "reason": "request body or source parameter is required"
  7.       }
  8.     ],
  9.     "type": "parse_exception",
  10.     "reason": "request body or source parameter is required"
  11.   },
  12.   "status": 400
  13. }

3.3 自定义分词器

上面说的ik_max_word 和ik_smart 这两种分词器，其实不是我想要的效果。比如我要查询“cla好好学习，15成功”。

浏览器输入：http://localhost:9200/_analyze?analyzer=ik_max_word&pretty=true&text=cla好好学习，15成功

我想要将查询条件分拆成：【"c", "l", "a", "好", "好", "学", "习", "，", "1", "5", "成", "功"】这种，单个字，单个词，单个数字的最小粒度。但是ik_max_word 已经是不能满足我的需求了，那我们就自定义一个分词器(analyzer)

使用NGram 来定义一个分词器： 官网：NGram Tokenizer | Elasticsearch Guide [6.4] | Elastic

这个网址里面的内容很重要，看不懂英文的小伙伴，可以用浏览器的插件，将它翻译成中文。

这句话：They are useful for querying languages that don’t use spaces or that have long compound words, like German.

意思是：它们对于查询不使用空格或具有长复合词的语言非常有用，比如德语。

我就直接使用官网的例子进行说明：输入的查询条件是：“Quick Fox”.

  1. POST _analyze
  2. {
  3.   "tokenizer": "ngram",
  4.   "text": "Quick Fox"
  5. }

分词后的结果是：

[ Q, Qu, u, ui, i, ic, c, ck, k, "k ", " ", " F", F, Fo, o, ox, x ]

可以给 ngram 配置下面三个参数：

①：min_gram ：字符的最小长度，默认是1.

②：max_gram：字符的最大长度，默认是2.

③：token_chars： 可以理解为elasticsearch分割字符的点。其中又可以包含5个属性。letter ，digit ，whitespace ，punctuation ，symbol 。

知道这些配置后，开始实例：（实例里面，自定义一个 myanalyzer 分词器，并创建my_user索引，和user类型）

  1. PUT localhost:9200/my_user/
  2.  
  3. {
  4. 	"settings": {
  5.     	"analysis": {
  6.     		"analyzer": {
  7.         		"myanalyzer": {
  8.         			"tokenizer": "mytokenizer"
  9.         		}
  10.     		},
  11.     		"tokenizer": {
  12.         		"mytokenizer": {
  13.         		"type": "ngram",
  14.         		"min_gram": 1,
  15.         		"max_gram": 2,
  16.         		"token_chars": [
  17.             		"letter",
  18.             		"digit",
  19.             		"whitespace",
  20.             		"punctuation",
  21.             		"symbol"
  22.         		]
  23.         		}
  24.     		}
  25.     	}
  26. 	},
  27.     "mappings":{
  28.         "user":{
  29.             "properties":{
  30.                 "id":{
  31.                     "type":"long",
  32.                     "store": true,
  33.                     "index": false,
  34.                     "fields":{
  35.                         "keyword":{
  36.                             "type":"keyword"
  37.                         }
  38.                     }
  39.                 },
  40.                 "username":{
  41.                     "type":"text",
  42.                     "store": true,
  43.                     "index": true,
  44.                     "analyzer": "myanalyzer",
  45.                     "fields":{
  46.                         "keyword":{
  47.                             "type":"keyword"
  48.                         }
  49.                     }
  50.                 },
  51.                 "password":{
  52.                     "type":"text",
  53.                     "store": true,
  54.                     "index": true,
  55.                     "analyzer": "myanalyzer",
  56.                     "fields":{
  57.                         "keyword":{
  58.                             "type":"keyword"
  59.                         }
  60.                     }
  61.                 },
  62.                 "age":{
  63.                     "type":"integer",
  64.                     "fields":{
  65.                         "keyword":{
  66.                             "type":"keyword"
  67.                         }
  68.                     }
  69.                 },
  70.                 "ip":{
  71.                     "type":"text",
  72.                     "store": true,
  73.                     "index": true,
  74.                     "analyzer": "myanalyzer",
  75.                     "fields":{
  76.                         "keyword":{
  77.                             "type":"keyword"
  78.                         }
  79.                     }
  80.                 }
  81.             }
  82.         }
  83.     }
  84. }

postman截图：

或者可以使用这种方式：

  1. POST localhost:9200/my_user/_analyze?analyzer=myanalyzer&pretty=true
  2.  
  3. {
  4.   "text": "2 Quick Fo18陈xes姥爷."
  5. }

接着用postman查询构建的这个my_user索引，类型为user。

  1. POST localhost:9200/my_user/_analyze
  2.  
  3. {
  4.   "analyzer": "myanalyzer",
  5.   "text": "2 Quick Fo18陈xes姥爷."
  6. }
  7.  
  8.  
  9. // 结果
  10. {
  11.     "tokens": [
  12.         {
  13.             "token": "2",
  14.             "start_offset": 0,
  15.             "end_offset": 1,
  16.             "type": "word",
  17.             "position": 0
  18.         },
  19.         {
  20.             "token": "2 ",
  21.             "start_offset": 0,
  22.             "end_offset": 2,
  23.             "type": "word",
  24.             "position": 1
  25.         },
  26.         {
  27.             "token": " ",
  28.             "start_offset": 1,
  29.             "end_offset": 2,
  30.             "type": "word",
  31.             "position": 2
  32.         },
  33.         {
  34.             "token": " Q",
  35.             "start_offset": 1,
  36.             "end_offset": 3,
  37.             "type": "word",
  38.             "position": 3
  39.         },
  40.         {
  41.             "token": "Q",
  42.             "start_offset": 2,
  43.             "end_offset": 3,
  44.             "type": "word",
  45.             "position": 4
  46.         },
  47.         {
  48.             "token": "Qu",
  49.             "start_offset": 2,
  50.             "end_offset": 4,
  51.             "type": "word",
  52.             "position": 5
  53.         },
  54.         {
  55.             "token": "u",
  56.             "start_offset": 3,
  57.             "end_offset": 4,
  58.             "type": "word",
  59.             "position": 6
  60.         },
  61.         {
  62.             "token": "ui",
  63.             "start_offset": 3,
  64.             "end_offset": 5,
  65.             "type": "word",
  66.             "position": 7
  67.         },
  68.         {
  69.             "token": "i",
  70.             "start_offset": 4,
  71.             "end_offset": 5,
  72.             "type": "word",
  73.             "position": 8
  74.         },
  75.         {
  76.             "token": "ic",
  77.             "start_offset": 4,
  78.             "end_offset": 6,
  79.             "type": "word",
  80.             "position": 9
  81.         },
  82.         {
  83.             "token": "c",
  84.             "start_offset": 5,
  85.             "end_offset": 6,
  86.             "type": "word",
  87.             "position": 10
  88.         },
  89.         {
  90.             "token": "ck",
  91.             "start_offset": 5,
  92.             "end_offset": 7,
  93.             "type": "word",
  94.             "position": 11
  95.         },
  96.         {
  97.             "token": "k",
  98.             "start_offset": 6,
  99.             "end_offset": 7,
  100.             "type": "word",
  101.             "position": 12
  102.         },
  103.         {
  104.             "token": "k ",
  105.             "start_offset": 6,
  106.             "end_offset": 8,
  107.             "type": "word",
  108.             "position": 13
  109.         },
  110.         {
  111.             "token": " ",
  112.             "start_offset": 7,
  113.             "end_offset": 8,
  114.             "type": "word",
  115.             "position": 14
  116.         },
  117.         {
  118.             "token": " F",
  119.             "start_offset": 7,
  120.             "end_offset": 9,
  121.             "type": "word",
  122.             "position": 15
  123.         },
  124.         {
  125.             "token": "F",
  126.             "start_offset": 8,
  127.             "end_offset": 9,
  128.             "type": "word",
  129.             "position": 16
  130.         },
  131.         {
  132.             "token": "Fo",
  133.             "start_offset": 8,
  134.             "end_offset": 10,
  135.             "type": "word",
  136.             "position": 17
  137.         },
  138.         {
  139.             "token": "o",
  140.             "start_offset": 9,
  141.             "end_offset": 10,
  142.             "type": "word",
  143.             "position": 18
  144.         },
  145.         {
  146.             "token": "o1",
  147.             "start_offset": 9,
  148.             "end_offset": 11,
  149.             "type": "word",
  150.             "position": 19
  151.         },
  152.         {
  153.             "token": "1",
  154.             "start_offset": 10,
  155.             "end_offset": 11,
  156.             "type": "word",
  157.             "position": 20
  158.         },
  159.         {
  160.             "token": "18",
  161.             "start_offset": 10,
  162.             "end_offset": 12,
  163.             "type": "word",
  164.             "position": 21
  165.         },
  166.         {
  167.             "token": "8",
  168.             "start_offset": 11,
  169.             "end_offset": 12,
  170.             "type": "word",
  171.             "position": 22
  172.         },
  173.         {
  174.             "token": "8陈",
  175.             "start_offset": 11,
  176.             "end_offset": 13,
  177.             "type": "word",
  178.             "position": 23
  179.         },
  180.         {
  181.             "token": "陈",
  182.             "start_offset": 12,
  183.             "end_offset": 13,
  184.             "type": "word",
  185.             "position": 24
  186.         },
  187.         {
  188.             "token": "陈x",
  189.             "start_offset": 12,
  190.             "end_offset": 14,
  191.             "type": "word",
  192.             "position": 25
  193.         },
  194.         {
  195.             "token": "x",
  196.             "start_offset": 13,
  197.             "end_offset": 14,
  198.             "type": "word",
  199.             "position": 26
  200.         },
  201.         {
  202.             "token": "xe",
  203.             "start_offset": 13,
  204.             "end_offset": 15,
  205.             "type": "word",
  206.             "position": 27
  207.         },
  208.         {
  209.             "token": "e",
  210.             "start_offset": 14,
  211.             "end_offset": 15,
  212.             "type": "word",
  213.             "position": 28
  214.         },
  215.         {
  216.             "token": "es",
  217.             "start_offset": 14,
  218.             "end_offset": 16,
  219.             "type": "word",
  220.             "position": 29
  221.         },
  222.         {
  223.             "token": "s",
  224.             "start_offset": 15,
  225.             "end_offset": 16,
  226.             "type": "word",
  227.             "position": 30
  228.         },
  229.         {
  230.             "token": "s姥",
  231.             "start_offset": 15,
  232.             "end_offset": 17,
  233.             "type": "word",
  234.             "position": 31
  235.         },
  236.         {
  237.             "token": "姥",
  238.             "start_offset": 16,
  239.             "end_offset": 17,
  240.             "type": "word",
  241.             "position": 32
  242.         },
  243.         {
  244.             "token": "姥爷",
  245.             "start_offset": 16,
  246.             "end_offset": 18,
  247.             "type": "word",
  248.             "position": 33
  249.         },
  250.         {
  251.             "token": "爷",
  252.             "start_offset": 17,
  253.             "end_offset": 18,
  254.             "type": "word",
  255.             "position": 34
  256.         },
  257.         {
  258.             "token": "爷.",
  259.             "start_offset": 17,
  260.             "end_offset": 19,
  261.             "type": "word",
  262.             "position": 35
  263.         },
  264.         {
  265.             "token": ".",
  266.             "start_offset": 18,
  267.             "end_offset": 19,
  268.             "type": "word",
  269.             "position": 36
  270.         }
  271.     ]
  272. }

postman截图：

得到的结果是：分词成功。

3.4 重新构建springboot使用myanalyzer分词器，做全文检索

新建一个User实体：（对应elasticsearch中的my_user索引，和user类型）

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. @Document(indexName = "my_user", type = "user")
  5. public class User {
  6.     /**
  7.      *     index：是否设置分词
  8.      *     analyzer：存储时使用的分词器
  9.      *     searchAnalyze：搜索时使用的分词器
  10.      *     store：是否存储
  11.      *     type: 数据类型
  12.      */
  13.  
  14.     @Id
  15.     @Field(store = true, index = false, type =FieldType.Integer)
  16.     private Integer id;
  17.     @Field(store = true, index = true, type = FieldType.keyword, analyzer = "myanalyzer", searchAnalyzer = "myanalyzer")
  18.     private String username;
  19.     @Field(store = true, index = true, type = FieldType.keyword, analyzer = "myanalyzer", searchAnalyzer = "myanalyzer")
  20.     private String password;
  21.     @Field(store = true, index = true, type = FieldType.Integer, analyzer = "myanalyzer", searchAnalyzer = "myanalyzer")
  22.     private Integer age;
  23.     @Field(store = true, index = true, type = FieldType.keyword, analyzer = "myanalyzer", searchAnalyzer = "myanalyzer")
  24.     private String ip;
  25.     
  26. }

新建UserRepository接口。

  1. @Repository
  2. public interface UserRepository extends ElasticsearchRepository<User, Long> {
  3. }

在测试类中进行测试： （插入数据）

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class UserTest {
  4.  
  5.     @Autowired
  6.     UserRepository userRepository;
  7.  
  8.     // 插入数据
  9.     @Test
  10.     public void testInsert(){
  11.         userRepository.save(new User(3, "高新兴", "gao45", 18, "我登录的ip地址是：127.145.0.11"));
  12.         userRepository.save(new User(4, "神州@数码", "shen18", 18, "我登录的ip地址是：127.124.0.11"));
  13.         userRepository.save(new User(6, "西南大学", "xida", 18, "我登录的ip地址是：127.126.0.11"));
  14.         userRepository.save(new User(7, "北京大学", "beida", 18, "我记录的ip地址是：127.127.0.11"));
  15.         userRepository.save(new User(8, "姚#明", "yao210", 18, "我登录的@#%ip地址是：127.248.0.11"));
  16.         userRepository.save(new User(9, "邓紫棋", "dengml", 18, "我使用的ip地址是：127.249.0.11"));
  17.         userRepository.save(new User(10, "李荣浩", "li06", 18, "我使用的@ip地址是：127.234.0.11"));
  18.         userRepository.save(new User(11, "陈奕迅", "19ch8en", 18, "我登录的ip地址是：127.219.0.11"));
  19.         userRepository.save(new User(12, "周杰伦", "xiayu2014", 18, "我登录的ip地址是：127.0.0.11"));
  20.         userRepository.save(new User(13, "林俊杰", "zho99", 18, "我登录,的ip地址是：127.111.0.11"));
  21.         userRepository.save(new User(137, "林薇因", "zho99", 18, "我登录,的ip地址是：127.111.0.11"));
  22.     }

插入数据后， elasticsearch里面的数据显示如下：

查询数据：

  1.     @Test
  2.     public void testQueryByStr(){
  3.         try {
  4.             String searchStr = "陈夏天u马立,@45";
  5.             QueryStringQueryBuilder builder = new QueryStringQueryBuilder(searchStr);
  6.  
  7.             //  重点是下面这行代码
  8.             builder.analyzer("myanalyzer").field("username").field("password").field("ip");
  9.             Iterable<User> search = userRepository.search(builder);
  10.             Iterator<User> iterator = search.iterator();
  11.             while (iterator.hasNext()){
  12.                 System.out.println("---> 匹配数据： "+iterator.next());
  13.             }
  14.         }catch (Exception e){
  15.             System.out.println("---> 异常信息 "+e);
  16.         }
  17.     }

查询结果：

  1. ---> 匹配数据： User(id=33, username=陈%喜华, password=gao45, age=18, ip=我登录的ip地址是：127.145.0.11)
  2. ---> 匹配数据： User(id=3, username=高新兴, password=gao45, age=18, ip=我登录的ip地址是：127.145.0.11)
  3. ---> 匹配数据： User(id=35, username=马@,#立志, password=ling009, age=18, ip=我记录的ip地址是：127.125.0.11)
  4. ---> 匹配数据： User(id=48, username=郭才莹, password=yao210, age=18, ip=我登录的,@#%ip地址是：127.248.0.11)
  5. ---> 匹配数据： User(id=126, username=夏雨, password=xiayu2014, age=18, ip=我登录的ip地址是：127.0.0.11)
  6. ---> 匹配数据： User(id=12, username=周杰伦, password=xiayu2014, age=18, ip=我登录的ip地址是：127.0.0.11)
  7. ---> 匹配数据： User(id=115, username=朱&@#%夏宇, password=19ch8en, age=18, ip=我登录的ip地址是：127.219.0.11)
  8. ---> 匹配数据： User(id=8, username=姚#明, password=yao210, age=18, ip=我登录的@#%ip地址是：127.248.0.11)
  9. ---> 匹配数据： User(id=10, username=李荣浩, password=li06, age=18, ip=我使用的@ip地址是：127.234.0.11)
  10. ---> 匹配数据： User(id=104, username=黄小群, password=li06, age=18, ip=我使用的@ip地址是：127.234.0.11)
  11. ---> 匹配数据： User(id=36, username=陈耀鹏, password=xida, age=18, ip=我登录的ip地址是：127.126.0.11)
  12. ---> 匹配数据： User(id=11, username=陈奕迅, password=19ch8en, age=18, ip=我登录的ip地址是：127.219.0.11)
  13. ---> 匹配数据： User(id=137, username=林薇因, password=zho99, age=18, ip=我登录,的ip地址是：127.111.0.11)
  14. ---> 匹配数据： User(id=13, username=林俊杰, password=zho99, age=18, ip=我登录,的ip地址是：127.111.0.11)
  15. ---> 匹配数据： User(id=4, username=神州@数码, password=shen18, age=18, ip=我登录的ip地址是：127.124.0.11)
  16. ---> 匹配数据： User(id=5, username=岭南师范, password=ling009, age=18, ip=我记录的ip地址是：127.125.0.11)
  17. ---> 匹配数据： User(id=9, username=邓紫棋, password=dengml, age=18, ip=我使用的ip地址是：127.249.0.11)
  18. ---> 匹配数据： User(id=34, username=钟楚莹, password=shen18, age=18, ip=我登录的ip地址是：127.124.0.11)
  19. ---> 匹配数据： User(id=49, username=黄群, password=dengml, age=18, ip=我使用的ip地址是：127.249.0.11)

到处，springboot整合elasticsearch以及ik分词器，做全文检索完成了。

先告一段落，文章写得不是很好。但希望你能看懂。如果有不懂的，底下留言。我会及时更新

希望此文帮助到你！

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/604535
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号