我的網站集成ElasticSearch初體驗

在WPF開發應用中，動畫不僅可以引起用戶的註意與興趣，而且還使軟體更加便於使用。前面幾篇文章講解了畫筆（Brush），形狀（Shape），幾何圖形（Geometry），變換（Transform）等相關內容，今天繼續講解動畫相關內容和知識點，僅供學習分享使用，如有不足之處，還請指正。 ...

最近，我給我的網站(https://www.xiandanplay.com/)嘗試集成了一下es來實現我的一個搜索功能，因為這個是我第一次瞭解運用elastic，所以如果有不對的地方，大家可以指出來，話不多說，先看看我的一個大致流程

這裡我採用的sdk的版本是Elastic.Clients.Elasticsearch, Version=8.0.0.0，官方的網址Installation | Elasticsearch .NET Client [8.0] | Elastic

我的es最開始打算和我的應用程式一起部署到ubuntu上面，結果最後安裝kibana的時候，各種問題，雖好無奈，只好和我的SqlServer一起安裝到windows上面，對於一個2G內容的伺服器來說，屬實有點遭罪了。

1、配置es

在es裡面，我開啟了密碼認證。下麵是我的配置

"Search": {
    "IsEnable": "true",
    "Uri": "http://127.0.0.1:9200/",
    "User": "123",
    "Password": "123"
  }
然後新增一個程式集

然後再ElasticsearchClient裡面去寫一個構造函數去配置es

using Core.Common;
using Core.CPlatform;
using Core.SearchEngine.Attr;
using Elastic.Clients.Elasticsearch;
using Elastic.Clients.Elasticsearch.IndexManagement;
using Elastic.Transport;

namespace Core.SearchEngine.Client
{
    public class ElasticSearchClient : IElasticSearchClient
    {
        private ElasticsearchClient elasticsearchClient;
        public ElasticSearchClient()
        {
            string uri = ConfigureProvider.configuration.GetSection("Search:Uri").Value;
            string username = ConfigureProvider.configuration.GetSection("Search:User").Value;
            string password = ConfigureProvider.configuration.GetSection("Search:Password").Value;
            var settings = new ElasticsearchClientSettings(new Uri(uri))
                          .Authentication(new BasicAuthentication(username, password)).DisableDirectStreaming();
            elasticsearchClient = new ElasticsearchClient(settings);
        }
        public ElasticsearchClient GetClient()
        {
            return elasticsearchClient;
        }
    }
}

　　然後，我們看skd的官網有這個這個提示

客戶端應用程式應創建一個該實例，該實例在整個應用程式中用於整個應用程式輩子。在內部，客戶端管理和維護與節點的 HTTP 連接，重覆使用它們以優化性能。如果您使用依賴項註入容器中，客戶端實例應註冊到單例生存期

所以我直接給它來一個AddSingleton

using Core.SearchEngine.Client;
using Microsoft.Extensions.DependencyInjection;

namespace Core.SearchEngine
{
    public static class ConfigureSearchEngine
    {
        public static void AddSearchEngine(this IServiceCollection services)
        {
            services.AddSingleton<IElasticSearchClient, ElasticSearchClient>();
        }
    }
}

2、提交文章並且同步到es

然後就是同步文章到es了，我是先寫入資料庫，再同步到rabbitmq，通過事件匯流排（基於事件匯流排EventBus實現郵件推送功能）寫入到es

先定義一個es模型

using Core.SearchEngine.Attr;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using XianDan.Model.BizEnum;

namespace XianDan.Domain.Article
{
    [ElasticsearchIndex(IndexName ="t_article")]//自定義的特性，sdk並不包含這個特性
    public class Article_ES
    {
        public long Id { get; set; }
        /// <summary>
        /// 作者
        /// </summary>
        public string Author { get; set; }
        /// <summary>
        /// 標題                                                                               
        /// </summary>
        public string Title { get; set; }
        /// <summary>
        /// 標簽
        /// </summary>
        public string Tag { get; set; }
        /// <summary>
        /// 簡介                                                                              
        /// </summary>
        public string Description { get; set; }
        /// <summary>
        /// 內容
        /// </summary>
        public string ArticleContent { get; set; }
        /// <summary>
        /// 專欄
        /// </summary>
        public long ArticleCategoryId { get; set; }
        /// <summary>
        /// 是否原創
        /// </summary>
        public bool? IsOriginal { get; set; }
        /// <summary>
        /// 評論數
        /// </summary>
        public int? CommentCount { get; set; }
        /// <summary>
        /// 點贊數
        /// </summary>
        public int? PraiseCount { get; set; }
        /// <summary>
        /// 瀏覽次數
        /// </summary>
        public int? BrowserCount { get; set; }
        /// <summary>
        /// 收藏數量
        /// </summary>
        public int? CollectCount { get; set; }
        /// <summary>
        /// 創建時間
        /// </summary>
        public DateTime CreateTime { get; set; }
    }
}

然後創建索引

 string index = esArticleClient.GetIndexName(typeof(Article_ES));
            await esArticleClient.GetClient().Indices.CreateAsync<Article_ES>(index, s =>
            s.Mappings(
                x => x.Properties(
                    t => t.LongNumber(l => l.Id)
                         .Text(l=>l.Title,z=>z.Analyzer(ik_max_word))
                         .Keyword(l=>l.Author)
                         .Text(l=>l.Tag,z=>z.Analyzer(ik_max_word))
                         .Text(l=>l.Description,z=>z.Analyzer(ik_max_word))
                         .Text(l=>l.ArticleContent,z=>z.Analyzer(ik_max_word))
                         .LongNumber(l=>l.ArticleCategoryId)
                         .Boolean(l=>l.IsOriginal)
                         .IntegerNumber(l=>l.BrowserCount)
                         .IntegerNumber(l=>l.PraiseCount)
                         .IntegerNumber(l=>l.PraiseCount)
                         .IntegerNumber(l=>l.CollectCount)
                         .IntegerNumber(l=>l.CommentCount)
                         .Date(l=>l.CreateTime)
                    )
                )
            );

然後每次增刪改文章的時候寫入到mq，例如

 private async Task SendToMq(Article article, Operation operation)
        {
            ArticleEventData articleEventData = new ArticleEventData();
            articleEventData.Operation = operation;
            articleEventData.Article_ES = MapperUtil.Map<Article, Article_ES>(article);
            TaskRecord taskRecord = new TaskRecord();
            taskRecord.Id = CreateEntityId();
            taskRecord.TaskType = TaskRecordType.MQ;
            taskRecord.TaskName = "發送文章";
            taskRecord.TaskStartTime = DateTime.Now;
            taskRecord.TaskStatu = (int)MqMessageStatu.New;
            articleEventData.Unique = taskRecord.Id.ToString();
            taskRecord.TaskValue = JsonConvert.SerializeObject(articleEventData);
            await unitOfWork.GetRepository<TaskRecord>().InsertAsync(taskRecord);
            await unitOfWork.CommitAsync();
            try
            {
                eventBus.Publish(GetMqExchangeName(), ExchangeType.Direct, BizKey.ArticleQueueName, articleEventData);
            }
            catch (Exception ex)
            {
                var taskRecordRepository = unitOfWork.GetRepository<TaskRecord>();
                TaskRecord update = await taskRecordRepository.SelectByIdAsync(taskRecord.Id);
                update.TaskStatu = (int)MqMessageStatu.Fail;
                update.LastUpdateTime = DateTime.Now;
                update.TaskResult = "發送失敗";
                update.AdditionalData = ex.Message;
                await taskRecordRepository.UpdateAsync(update);
                await unitOfWork.CommitAsync();
            }

        }

mq訂閱之後寫入es，具體的增刪改的方法就不寫了吧

3、開始查詢es

等待寫入文章之後，開始查詢文章，這裡sdk提供的查詢的方法比較複雜，全都是通過lmbda一個個鏈式去拼接的，但是我又沒有找到更好的方法，所以就先這樣吧

先創建一個集合存放查詢的表達式

List<Action<QueryDescriptor<Article_ES>>> querys = new List<Action<QueryDescriptor<Article_ES>>>();

然後定義一個幾個需要查詢的欄位

我這裡使用MultiMatch來實現多個欄位匹配同一個查詢條件，並且指定使用ik_smart分詞

Field[] fields =
                {
                    new Field("title"),
                    new Field("tag"),
                    new Field("articleContent"),
                    new Field("description")
                };
 querys.Add(s => s.MultiMatch(y => y.Fields(Fields.FromFields(fields)).Analyzer(ik_smart).Query(keyword).Type(TextQueryType.MostFields)));

定義查詢結果高亮，給查詢出來的匹配到的分詞的欄位添加標簽，同時前端需要對這個樣式處理，

:deep(.search-words) em { color: #ee0f29; font-style: initial; }

 Dictionary<Field, HighlightField> highlightFields = new Dictionary<Field, HighlightField>();
            highlightFields.Add(new Field("title"), new HighlightField()
            {
                PreTags = new List<string> { "<em>" },
                PostTags = new List<string> { "</em>" },
            });
            highlightFields.Add(new Field("description"), new HighlightField()
            {
                PreTags = new List<string> { "<em>" },
                PostTags = new List<string> { "</em>" },
            });
            Highlight highlight = new Highlight()
            {
                Fields = highlightFields
            };

為了提高查詢的效率，我只查部分的欄位

 SourceFilter sourceFilter = new SourceFilter();
            sourceFilter.Includes = Fields.FromFields(new Field[] { "title", "id", "author", "description", "createTime", "browserCount", "commentCount" });
            SourceConfig sourceConfig = new SourceConfig(sourceFilter);
            Action<SearchRequestDescriptor<Article_ES>> configureRequest = s => s.Index(index)
            .From((homeArticleCondition.CurrentPage - 1) * homeArticleCondition.PageSize)
            .Size(homeArticleCondition.PageSize)
            .Query(x => x.Bool(y => y.Must(querys.ToArray())))
            .Source(sourceConfig)
             .Sort(y => y.Field(ht => ht.CreateTime, new FieldSort() { Order=SortOrder.Desc}))

獲取查詢的分詞結果

 var analyzeIndexRequest = new AnalyzeIndexRequest
            {
                Text = new string[] { keyword },
                Analyzer = analyzer
            };
            var analyzeResponse = await elasticsearchClient.Indices.AnalyzeAsync(analyzeIndexRequest);
            if (analyzeResponse.Tokens == null)
                return new string[0];
            return analyzeResponse.Tokens.Select(s => s.Token).ToArray();

到此，這個就是大致的查詢結果，完整的如下

 public async Task<Core.SearchEngine.Response.SearchResponse<Article_ES>> SelectArticle(HomeArticleCondition homeArticleCondition)
        {
            string keyword = homeArticleCondition.Keyword.Trim();
            bool isNumber = Regex.IsMatch(keyword, RegexPattern.IsNumberPattern);
            List<Action<QueryDescriptor<Article_ES>>> querys = new List<Action<QueryDescriptor<Article_ES>>>();
            if (isNumber)
            {
                querys.Add(s => s.Bool(x => x.Should(
                    should => should.Term(f => f.Field(z => z.Title).Value(keyword))
                    , should => should.Term(f => f.Field(z => z.Tag).Value(keyword))
                    , should => should.Term(f => f.Field(z => z.ArticleContent).Value(keyword))
                    )));
            }
            else
            {
                Field[] fields =
                {
                    new Field("title"),
                    new Field("tag"),
                    new Field("articleContent"),
                    new Field("description")
                };
                querys.Add(s => s.MultiMatch(y => y.Fields(Fields.FromFields(fields)).Analyzer(ik_smart).Query(keyword).Type(TextQueryType.MostFields)));
            }
            if (homeArticleCondition.ArticleCategoryId.HasValue)
            {
                querys.Add(s => s.Term(t => t.Field(f => f.ArticleCategoryId).Value(FieldValue.Long(homeArticleCondition.ArticleCategoryId.Value))));
            }
            string index = esArticleClient.GetIndexName(typeof(Article_ES));
            Dictionary<Field, HighlightField> highlightFields = new Dictionary<Field, HighlightField>();
            highlightFields.Add(new Field("title"), new HighlightField()
            {
                PreTags = new List<string> { "<em>" },
                PostTags = new List<string> { "</em>" },
            });
            highlightFields.Add(new Field("description"), new HighlightField()
            {
                PreTags = new List<string> { "<em>" },
                PostTags = new List<string> { "</em>" },
            });
            Highlight highlight = new Highlight()
            {
                Fields = highlightFields
            };
            SourceFilter sourceFilter = new SourceFilter();
            sourceFilter.Includes = Fields.FromFields(new Field[] { "title", "id", "author", "description", "createTime", "browserCount", "commentCount" });
            SourceConfig sourceConfig = new SourceConfig(sourceFilter);
            Action<SearchRequestDescriptor<Article_ES>> configureRequest = s => s.Index(index)
            .From((homeArticleCondition.CurrentPage - 1) * homeArticleCondition.PageSize)
            .Size(homeArticleCondition.PageSize)
            .Query(x => x.Bool(y => y.Must(querys.ToArray())))
            .Source(sourceConfig)
             .Sort(y => y.Field(ht => ht.CreateTime, new FieldSort() { Order=SortOrder.Desc})).Highlight(highlight);
            var resp = await esArticleClient.GetClient().SearchAsync<Article_ES>(configureRequest);
            foreach (var item in resp.Hits)
            {
                if (item.Highlight == null)
                    continue;
                foreach (var dict in item.Highlight)
                {
                    switch (dict.Key)
                    {
                        case "title":
                            item.Source.Title = string.Join("...", dict.Value);
                            break;
                        case "description":
                            item.Source.Description = string.Join("...", dict.Value);
                            break;

                    }
                }
            }
            string[] analyzeWords = await esArticleClient.AnalyzeAsync(homeArticleCondition.Keyword);
            List<Article_ES> articles = resp.Documents.ToList();
            return new Core.SearchEngine.Response.SearchResponse<Article_ES>(articles, analyzeWords);
        }