devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于 ElasticSearch 实现站内全文搜索，写得太好了！

作者：2023面试高手 | 2024-03-25 00:12:21

赞

踩

easy-es 实现全文检索

aff69f179231b67065d5f79574514946.png

程序员的成长之路

互联网/程序员/技术/资料共享 

关注

阅读本文大概需要 11 分钟。

来自：blog.csdn.net/weixin_44671737/article/details/114456257

摘要

对于一家公司而言，数据量越来越多，如果快速去查找这些信息是一个很难的问题，在计算机领域有一个专门的领域IR（Information Retrival）研究如果获取信息，做信息检索。

在国内的如百度这样的搜索引擎也属于这个领域，要自己实现一个搜索引擎是非常难的，不过信息查找对每一个公司都非常重要，对于开发人员也可以选则一些市场上的开源项目来构建自己的站内搜索引擎，本文将通过ElasticSearch来构建一个这样的信息检索项目。

1 技术选型

  • 搜索引擎服务使用ElasticSearch

  • 提供的对外web服务选则springboot web

1.1 ElasticSearch

Elasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。Elasticsearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。

官方客户端在Java、.NET（C#）、PHP、Python、Apache Groovy、Ruby和许多其他语言中都是可用的。根据DB-Engines的排名显示，Elasticsearch是最受欢迎的企业搜索引擎，其次是Apache Solr，也是基于Lucene。1

现在开源的搜索引擎在市面上最常见的就是ElasticSearch和Solr，二者都是基于Lucene的实现，其中ElasticSearch相对更加重量级，在分布式环境表现也更好，二者的选则需考虑具体的业务场景和数据量级。对于数据量不大的情况下，完全需要使用像Lucene这样的搜索引擎服务，通过关系型数据库检索即可。

1.2 springBoot

Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”.2

现在springBoot在做web开发上是绝对的主流，其不仅仅是开发上的优势，在布署，运维各个方面都有着非常不错的表现，并且spring生态圈的影响力太大了，可以找到各种成熟的解决方案。

1.3 ik分词器

elasticSearch本身不支持中文的分词，需要安装中文分词插件，如果需要做中文的信息检索，中文分词是基础，此处选则了ik，下载好后放入elasticSearch的安装位置的plugin目录即可。

2 环境准备

需要安装好elastiSearch以及kibana（可选）,并且需要lk分词插件。

8494655861a995d0f1e1aa7c640e990d.png

  • 搭建springboot项目 idea ->new project ->spring initializer

53b921363db4f0df850b26587f6605ae.png

3 项目架构

  • 获取数据使用ik分词插件

  • 将数据存储在es引擎中

  • 通过es检索方式对存储的数据进行检索

  • 使用es的java客户端提供外部服务

f2e7cb12ec62a6d6ba0b9bb4a3762e70.png

4 实现效果

4.1 搜索页面

简单实现一个类似百度的搜索框即可。

569be2033ff0fd4c95f62084efe81dd1.png

4.2 搜索结果页面

aa4104f457e3ed738591a9515fb0e8c9.png

点击第一个搜索结果是我个人的某一篇博文，为了避免数据版权问题，笔者在es引擎中存放的全是个人的博客数据。

c992b7e9ac94949049731f5f90d6eb05.png

5 具体代码实现

5.1 全文检索的实现对象

按照博文的基本信息定义了如下实体类，主要需要知道每一个博文的url，通过检索出来的文章具体查看要跳转到该url。

  1. package com.lbh.es.entity;
  2.  
  3. import com.fasterxml.jackson.annotation.JsonIgnore;
  4.  
  5. import javax.persistence.*;
  6.  
  7. /**
  8.  * PUT articles
  9.  * {
  10.  * "mappings":
  11.  * {"properties":{
  12.  * "author":{"type":"text"},
  13.  * "content":{"type":"text","analyzer":"ik_max_word","search_analyzer":"ik_smart"},
  14.  * "title":{"type":"text","analyzer":"ik_max_word","search_analyzer":"ik_smart"},
  15.  * "createDate":{"type":"date","format":"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd"},
  16.  * "url":{"type":"text"}
  17.  * } },
  18.  * "settings":{
  19.  *     "index":{
  20.  *       "number_of_shards":1,
  21.  *       "number_of_replicas":2
  22.  *     }
  23.  *   }
  24.  * }
  25.  * ---------------------------------------------------------------------------------------------------------------------
  26.  * Copyright(c)lbhbinhao@163.com
  27.  * @author liubinhao
  28.  * @date 2021/3/3
  29.  */
  30. @Entity
  31. @Table(name = "es_article")
  32. public class ArticleEntity {
  33.     @Id
  34.     @JsonIgnore
  35.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  36.     private long id;
  37.     @Column(name = "author")
  38.     private String author;
  39.     @Column(name = "content",columnDefinition="TEXT")
  40.     private String content;
  41.     @Column(name = "title")
  42.     private String title;
  43.     @Column(name = "createDate")
  44.     private String createDate;
  45.     @Column(name = "url")
  46.     private String url;
  47.  
  48.     public String getAuthor() {
  49.         return author;
  50.     }
  51.  
  52.     public void setAuthor(String author) {
  53.         this.author = author;
  54.     }
  55.  
  56.     public String getContent() {
  57.         return content;
  58.     }
  59.  
  60.     public void setContent(String content) {
  61.         this.content = content;
  62.     }
  63.  
  64.     public String getTitle() {
  65.         return title;
  66.     }
  67.  
  68.     public void setTitle(String title) {
  69.         this.title = title;
  70.     }
  71.  
  72.     public String getCreateDate() {
  73.         return createDate;
  74.     }
  75.  
  76.     public void setCreateDate(String createDate) {
  77.         this.createDate = createDate;
  78.     }
  79.  
  80.     public String getUrl() {
  81.         return url;
  82.     }
  83.  
  84.     public void setUrl(String url) {
  85.         this.url = url;
  86.     }
  87. }

5.2 客户端配置

通过java配置es的客户端。

  1. package com.lbh.es.config;
  2.  
  3. import org.apache.http.HttpHost;
  4. import org.elasticsearch.client.RestClient;
  5. import org.elasticsearch.client.RestClientBuilder;
  6. import org.elasticsearch.client.RestHighLevelClient;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10.  
  11. import java.util.ArrayList;
  12. import java.util.List;
  13.  
  14. /**
  15.  * Copyright(c)lbhbinhao@163.com
  16.  * @author liubinhao
  17.  * @date 2021/3/3
  18.  */
  19. @Configuration
  20. public class EsConfig {
  21.  
  22.     @Value("${elasticsearch.schema}")
  23.     private String schema;
  24.     @Value("${elasticsearch.address}")
  25.     private String address;
  26.     @Value("${elasticsearch.connectTimeout}")
  27.     private int connectTimeout;
  28.     @Value("${elasticsearch.socketTimeout}")
  29.     private int socketTimeout;
  30.     @Value("${elasticsearch.connectionRequestTimeout}")
  31.     private int tryConnTimeout;
  32.     @Value("${elasticsearch.maxConnectNum}")
  33.     private int maxConnNum;
  34.     @Value("${elasticsearch.maxConnectPerRoute}")
  35.     private int maxConnectPerRoute;
  36.  
  37.     @Bean
  38.     public RestHighLevelClient restHighLevelClient() {
  39.         // 拆分地址
  40.         List<HttpHost> hostLists = new ArrayList<>();
  41.         String[] hostList = address.split(",");
  42.         for (String addr : hostList) {
  43.             String host = addr.split(":")[0];
  44.             String port = addr.split(":")[1];
  45.             hostLists.add(new HttpHost(host, Integer.parseInt(port), schema));
  46.         }
  47.         // 转换成 HttpHost 数组
  48.         HttpHost[] httpHost = hostLists.toArray(new HttpHost[]{});
  49.         // 构建连接对象
  50.         RestClientBuilder builder = RestClient.builder(httpHost);
  51.         // 异步连接延时配置
  52.         builder.setRequestConfigCallback(requestConfigBuilder -> {
  53.             requestConfigBuilder.setConnectTimeout(connectTimeout);
  54.             requestConfigBuilder.setSocketTimeout(socketTimeout);
  55.             requestConfigBuilder.setConnectionRequestTimeout(tryConnTimeout);
  56.             return requestConfigBuilder;
  57.         });
  58.         // 异步连接数配置
  59.         builder.setHttpClientConfigCallback(httpClientBuilder -> {
  60.             httpClientBuilder.setMaxConnTotal(maxConnNum);
  61.             httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
  62.             return httpClientBuilder;
  63.         });
  64.         return new RestHighLevelClient(builder);
  65.     }
  66.  
  67. }

5.3 业务代码编写

包括一些检索文章的信息，可以从文章标题，文章内容以及作者信息这些维度来查看相关信息。

  1. package com.lbh.es.service;
  2.  
  3. import com.google.gson.Gson;
  4. import com.lbh.es.entity.ArticleEntity;
  5. import com.lbh.es.repository.ArticleRepository;
  6. import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
  7. import org.elasticsearch.action.get.GetRequest;
  8. import org.elasticsearch.action.get.GetResponse;
  9. import org.elasticsearch.action.index.IndexRequest;
  10. import org.elasticsearch.action.index.IndexResponse;
  11. import org.elasticsearch.action.search.SearchRequest;
  12. import org.elasticsearch.action.search.SearchResponse;
  13. import org.elasticsearch.action.support.master.AcknowledgedResponse;
  14. import org.elasticsearch.client.RequestOptions;
  15. import org.elasticsearch.client.RestHighLevelClient;
  16. import org.elasticsearch.client.indices.CreateIndexRequest;
  17. import org.elasticsearch.client.indices.CreateIndexResponse;
  18. import org.elasticsearch.common.settings.Settings;
  19. import org.elasticsearch.common.xcontent.XContentType;
  20. import org.elasticsearch.index.query.QueryBuilders;
  21. import org.elasticsearch.search.SearchHit;
  22. import org.elasticsearch.search.builder.SearchSourceBuilder;
  23. import org.springframework.stereotype.Service;
  24.  
  25. import javax.annotation.Resource;
  26. import java.io.IOException;
  27.  
  28. import java.util.*;
  29.  
  30. /**
  31.  * Copyright(c)lbhbinhao@163.com
  32.  * @author liubinhao
  33.  * @date 2021/3/3
  34.  */
  35. @Service
  36. public class ArticleService {
  37.  
  38.     private static final String ARTICLE_INDEX = "article";
  39.  
  40.     @Resource
  41.     private RestHighLevelClient client;
  42.     @Resource
  43.     private ArticleRepository articleRepository;
  44.  
  45.     public boolean createIndexOfArticle(){
  46.         Settings settings = Settings.builder()
  47.                 .put("index.number_of_shards", 1)
  48.                 .put("index.number_of_replicas", 1)
  49.                 .build();
  50. // {"properties":{"author":{"type":"text"},
  51. // "content":{"type":"text","analyzer":"ik_max_word","search_analyzer":"ik_smart"}
  52. // ,"title":{"type":"text","analyzer":"ik_max_word","search_analyzer":"ik_smart"},
  53. // ,"createDate":{"type":"date","format":"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd"}
  54. // }
  55.         String mapping = "{\"properties\":{\"author\":{\"type\":\"text\"},\n" +
  56.                 "\"content\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\",\"search_analyzer\":\"ik_smart\"}\n" +
  57.                 ",\"title\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\",\"search_analyzer\":\"ik_smart\"}\n" +
  58.                 ",\"createDate\":{\"type\":\"date\",\"format\":\"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd\"}\n" +
  59.                 "},\"url\":{\"type\":\"text\"}\n" +
  60.                 "}";
  61.         CreateIndexRequest indexRequest = new CreateIndexRequest(ARTICLE_INDEX)
  62.                 .settings(settings).mapping(mapping,XContentType.JSON);
  63.         CreateIndexResponse response = null;
  64.         try {
  65.             response = client.indices().create(indexRequest, RequestOptions.DEFAULT);
  66.         } catch (IOException e) {
  67.             e.printStackTrace();
  68.         }
  69.         if (response!=null) {
  70.             System.err.println(response.isAcknowledged() ? "success" : "default");
  71.             return response.isAcknowledged();
  72.         } else {
  73.             return false;
  74.         }
  75.     }
  76.  
  77.     public boolean deleteArticle(){
  78.         DeleteIndexRequest request = new DeleteIndexRequest(ARTICLE_INDEX);
  79.         try {
  80.             AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
  81.             return response.isAcknowledged();
  82.         } catch (IOException e) {
  83.             e.printStackTrace();
  84.         }
  85.         return false;
  86.     }
  87.  
  88.     public IndexResponse addArticle(ArticleEntity article){
  89.         Gson gson = new Gson();
  90.         String s = gson.toJson(article);
  91.         //创建索引创建对象
  92.         IndexRequest indexRequest = new IndexRequest(ARTICLE_INDEX);
  93.         //文档内容
  94.         indexRequest.source(s,XContentType.JSON);
  95.         //通过client进行http的请求
  96.         IndexResponse re = null;
  97.         try {
  98.             re = client.index(indexRequest, RequestOptions.DEFAULT);
  99.         } catch (IOException e) {
  100.             e.printStackTrace();
  101.         }
  102.         return re;
  103.     }
  104.  
  105.     public void transferFromMysql(){
  106.         articleRepository.findAll().forEach(this::addArticle);
  107.     }
  108.  
  109.     public List<ArticleEntity> queryByKey(String keyword){
  110.         SearchRequest request = new SearchRequest();
  111.         /*
  112.          * 创建  搜索内容参数设置对象:SearchSourceBuilder
  113.          * 相对于matchQuery，multiMatchQuery针对的是多个fi eld，也就是说，当multiMatchQuery中，fieldNames参数只有一个时，其作用与matchQuery相当；
  114.          * 而当fieldNames有多个参数时，如field1和field2，那查询的结果中，要么field1中包含text，要么field2中包含text。
  115.          */
  116.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  117.  
  118.         searchSourceBuilder.query(QueryBuilders
  119.                 .multiMatchQuery(keyword, "author","content","title"));
  120.         request.source(searchSourceBuilder);
  121.         List<ArticleEntity> result = new ArrayList<>();
  122.         try {
  123.             SearchResponse search = client.search(request, RequestOptions.DEFAULT);
  124.             for (SearchHit hit:search.getHits()){
  125.                 Map<String, Object> map = hit.getSourceAsMap();
  126.                 ArticleEntity item = new ArticleEntity();
  127.                 item.setAuthor((String) map.get("author"));
  128.                 item.setContent((String) map.get("content"));
  129.                 item.setTitle((String) map.get("title"));
  130.                 item.setUrl((String) map.get("url"));
  131.                 result.add(item);
  132.             }
  133.             return result;
  134.         } catch (IOException e) {
  135.             e.printStackTrace();
  136.         }
  137.         return null;
  138.     }
  139.  
  140.     public ArticleEntity queryById(String indexId){
  141.         GetRequest request = new GetRequest(ARTICLE_INDEX, indexId);
  142.         GetResponse response = null;
  143.         try {
  144.             response = client.get(request, RequestOptions.DEFAULT);
  145.         } catch (IOException e) {
  146.             e.printStackTrace();
  147.         }
  148.         if (response!=null&&response.isExists()){
  149.             Gson gson = new Gson();
  150.             return gson.fromJson(response.getSourceAsString(),ArticleEntity.class);
  151.         }
  152.         return null;
  153.     }
  154. }

5.4 对外接口

和使用springboot开发web程序相同。

Spring Boot 基础就不介绍了，推荐下这个实战教程：https://github.com/javastacks/spring-boot-best-practice

  1. package com.lbh.es.controller;
  2.  
  3. import com.lbh.es.entity.ArticleEntity;
  4. import com.lbh.es.service.ArticleService;
  5. import org.elasticsearch.action.index.IndexResponse;
  6. import org.springframework.web.bind.annotation.*;
  7.  
  8. import javax.annotation.Resource;
  9. import java.util.List;
  10.  
  11. /**
  12.  * Copyright(c)lbhbinhao@163.com
  13.  * @author liubinhao
  14.  * @date 2021/3/3
  15.  */
  16. @RestController
  17. @RequestMapping("article")
  18. public class ArticleController {
  19.  
  20.     @Resource
  21.     private ArticleService articleService;
  22.  
  23.     @GetMapping("/create")
  24.     public boolean create(){
  25.         return articleService.createIndexOfArticle();
  26.     }
  27.  
  28.     @GetMapping("/delete")
  29.     public boolean delete() {
  30.         return articleService.deleteArticle();
  31.     }
  32.  
  33.     @PostMapping("/add")
  34.     public IndexResponse add(@RequestBody ArticleEntity article){
  35.         return articleService.addArticle(article);
  36.     }
  37.  
  38.     @GetMapping("/fransfer")
  39.     public String transfer(){
  40.         articleService.transferFromMysql();
  41.         return "successful";
  42.     }
  43.  
  44.     @GetMapping("/query")
  45.     public List<ArticleEntity> query(String keyword){
  46.         return articleService.queryByKey(keyword);
  47.     }
  48. }

5.5 页面

此处页面使用thymeleaf，主要原因是笔者真滴不会前端，只懂一丢丢简单的h5，就随便做了一个可以展示的页面。

搜索页面
  1. <!DOCTYPE html>
  2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
  3. <head>
  4.     <meta charset="UTF-8" />
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  6.     <title>YiyiDu</title>
  7.     <!--
  8.         input:focus设定当输入框被点击时，出现蓝色外边框
  9.         text-indent: 11px;和padding-left: 11px;设定输入的字符的起始位置与左边框的距离
  10.     -->
  11.     <style>
  12.         input:focus {
  13.             border: 2px solid rgb(62, 88, 206);
  14.         }
  15.         input {
  16.             text-indent: 11px;
  17.             padding-left: 11px;
  18.             font-size: 16px;
  19.         }
  20.     </style>
  21.     <!--input初始状态-->
  22.     <style class="input/css">
  23.         .input {
  24.             width: 33%;
  25.             height: 45px;
  26.             vertical-align: top;
  27.             box-sizing: border-box;
  28.             border: 2px solid rgb(207, 205, 205);
  29.             border-right: 2px solid rgb(62, 88, 206);
  30.             border-bottom-left-radius: 10px;
  31.             border-top-left-radius: 10px;
  32.             outline: none;
  33.             margin: 0;
  34.             display: inline-block;
  35.             background: url(/static/img/camera.jpg?watermark/2/text/5YWs5LyX5Y-377ya6IqL6YGT5rqQ56CB/font/5a6L5L2T/fontsize/400/fill/cmVk) no-repeat 0 0;
  36.             background-position: 565px 7px;
  37.             background-size: 28px;
  38.             padding-right: 49px;
  39.             padding-top: 10px;
  40.             padding-bottom: 10px;
  41.             line-height: 16px;
  42.         }
  43.     </style>
  44.     <!--button初始状态-->
  45.     <style class="button/css">
  46.         .button {
  47.             height: 45px;
  48.             width: 130px;
  49.             vertical-align: middle;
  50.             text-indent: -8px;
  51.             padding-left: -8px;
  52.             background-color: rgb(62, 88, 206);
  53.             color: white;
  54.             font-size: 18px;
  55.             outline: none;
  56.             border: none;
  57.             border-bottom-right-radius: 10px;
  58.             border-top-right-radius: 10px;
  59.             margin: 0;
  60.             padding: 0;
  61.         }
  62.     </style>
  63. </head>
  64. <body>
  65. <!--包含table的div-->
  66. <!--包含input和button的div-->
  67.     <div style="font-size: 0px;">
  68.         <div align="center" style="margin-top: 0px;">
  69.             <img src="../static/img/yyd.png" th:src = "@{/static/img/yyd.png}"  alt="一亿度" width="280px" class="pic" />
  70.         </div>
  71.         <div align="center">
  72.             <!--action实现跳转-->
  73.             <form action="/home/query">
  74.                 <input type="text" class="input" name="keyword" />
  75.                 <input type="submit" class="button" value="一亿度下" />
  76.             </form>
  77.         </div>
  78.     </div>
  79. </body>
  80. </html>
搜索结果页面
  1. <!DOCTYPE html>
  2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
  3. <head>
  4.     <link rel="stylesheet" href="https://cdn.staticfile.org/twitter-bootstrap/4.3.1/css/bootstrap.min.css">
  5.     <meta charset="UTF-8">
  6.     <title>xx-manager</title>
  7. </head>
  8. <body>
  9. <header th:replace="search.html"></header>
  10. <div class="container my-2">
  11.     <ul th:each="article : ${articles}">
  12.         <a th:href="${article.url}"><li th:text="${article.author}+${article.content}"></li></a>
  13.     </ul>
  14. </div>
  15. <footer th:replace="footer.html"></footer>
  16. </body>
  17. </html>

6 小结

上班撸代码，下班继续撸代码写博客，花了两天研究了以下es，其实这个玩意儿还是挺有意思的，现在IR领域最基础的还是基于统计学的，所以对于es这类搜索引擎而言在大数据的情况下具有良好的表现。

每一次写实战笔者其实都感觉有些无从下手，因为不知道做啥？所以也希望得到一些有意思的点子笔者会将实战做出来。

<END>

推荐阅读：

战火之下，乌克兰开发者还在提交代码

7种方式，教你提升 SpringBoot 项目的吞吐量

互联网初中高级大厂面试题(9个G)

内容包含Java基础、JavaWeb、MySQL性能优化、JVM、锁、百万并发、消息队列、高性能缓存、反射、Spring全家桶原理、微服务、Zookeeper、数据结构、限流熔断降级......等技术栈！

⬇戳阅读原文领取！                                  朕已阅 cdf67667ea9341742399631d70cb2ebf.gif

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

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

  

闽ICP备14008679号