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

从零开始搭建公司搜索平台架构技术栈（基于 ElasticSearch），这套架构绝了！...

作者：IT小白 | 2024-02-29 20:36:57

赞

踩

网站平台架构

286a302a959bf1cfd261a0c87e47a359.png

来源：blog.csdn.net/weixin_44671737/

article/details/114456257

大家好！我是宝哥。

目录

  • 摘要

  • 1 技术选型

  • 2 环境准备

  • 3 项目架构

  • 4 实现效果

    • 4.1 搜索页面

    • 4.2 搜索结果页面

  • 5 具体代码实现

    • 5.1 全文检索的实现对象

    • 5.2 客户端配置

    • 5.3 业务代码编写

    • 5.4 对外接口

    • 5.5 页面

  • 6 小结

摘要

对于一家公司而言，数据量越来越多，如果快速去查找这些信息是一个很难的问题，在计算机领域有一个专门的领域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分词插件。

  • 安装elasticSearch elasticsearch官网. 笔者使用的是7.5.1。

  • ik插件下载 ik插件github地址. 注意下载和你下载elasticsearch版本一样的ik插件。

  • 将ik插件放入elasticsearch安装目录下的plugins包下，新建报名ik，将下载好的插件解压到该目录下即可，启动es的时候会自动加载该插件。

46de19a7ac573792d17656531a7bb1cc.png

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

baadc530356950a06440dbb1239feb3a.png

3 项目架构

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

  • 将数据存储在es引擎中

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

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

d3e93d9c65de2b262dcbeae7b0b72919.png

4 实现效果

4.1 搜索页面

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

6404cf3c1f9aaf7766f84050171c1dbe.png

4.2 搜索结果页面

1d06ea7c6b1e1720ffd44b3a378cbcfe.png

点击第一个搜索结果是我个人的某一篇博文，为了避免数据版权问题，笔者在es引擎中存放的全是个人的博客数据。另外推荐：Java进阶视频资源

91e93bb96e32858152c88ec411da03c0.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 业务代码编写

包括一些检索文章的信息，可以从文章标题，文章内容以及作者信息这些维度来查看相关信息。另外推荐：Java进阶视频资源

  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程序相同。

  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) 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这类搜索引擎而言在大数据的情况下具有良好的表现。每一次写实战笔者其实都感觉有些无从下手，因为不知道做啥？所以也希望得到一些有意思的点子笔者会将实战做出来。

往期推荐

int(1) 和 int(10) 有什么区别？资深开发竟然都理解错了！

推荐一个分布式JVM监控工具，非常实用！

不小心将测试代码提交到生产环境，教你 6 种方法秒解决！

基于 Java 的疫情防控管理系统

一款IDEA插件神器，帮你一键转换DTO、VO、BO、PO、DO，再见工具类！

我们公司用了5年的前后端分离接口规范

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

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

  

闽ICP备14008679号