.Net Core3.1 MVC + EF Core+ AutoFac+LayUI+Sqlserver的框架搭建ElasticSearch

    ES数据库配置和搭建以前也已经写过了，感兴趣的可以看我以前写的。现在我就是直接把它集成到我的架构中了。就是在以前的基础上又做了封装。

   ES数据库索引的创建和数据的插入类，单节点模式：

using Nest;
using System;
using System.Collections.Generic;
using System.Text;

namespace Core.Net.Common.Core.Net.Core.ES
{
    /// <summary>
    /// ES数据库连接和创建索引，插入数据
    /// </summary>
    /// <typeparam name="T"></typeparam>
  public  class ESHelper<T> where T:class
    {
        public static readonly string url = "http://ip:port/";
        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="obj">出入的数据</param>
        /// <param name="index">索引</param>
        public static void ManyInsert(List<T> obj, string index)
        {
            //设置连接字符串，DefaultIndex中的表名要小写
            var settings = new ConnectionSettings(new Uri(url)).DefaultIndex(index);
            var client = new ElasticClient(settings);
            try
            {
                var ndexResponse = client.IndexMany<T>(obj);
                Core.FileHelper.AddLog("插入ES数据库成功" + ndexResponse.ToString(), "Log");
            }
            catch (Exception e)
            {

                Core.FileHelper.AddLog("插入ES数据库异常" + e.ToString(), "Log");
            }

        }
        /// <summary>
        /// 单行插入
        /// </summary>
        /// <param name="t">插入的数据</param>
        /// <param name="index">索引</param>
        public static void insert(object t, string index)
        {
            //设置连接字符串，DefaultIndex中的表名要小写
            var settings = new ConnectionSettings(new Uri(url)).DefaultIndex(index);
            var client = new ElasticClient(settings);
            //  client.IndexMany<>
            var doc = t;
            //通过 IndexDocument() 方法插入数据
            var ndexResponse = client.IndexDocument(doc);
        }
        /// <summary>
        /// 连接ES
        /// </summary>
        /// <param name="index">索引</param>
        /// <returns></returns>
        public static ElasticClient Connect_Index(string index)
        {

            //设置连接字符串，DefaultIndex中的表名要小写
            var settings = new ConnectionSettings(new Uri(url)).DefaultIndex(index);
            var client = new ElasticClient(settings);
            return client;

        }
    }
}

多节点模式：

using Elasticsearch.Net;
using Nest;
using System;
using System.Collections.Generic;
using System.Text;

namespace Core.Net.Common.Core.Net.Core.ES
{
    /// <summary>
    /// 步骤ES集群或者创建索引分片的时候可以用
    /// </summary>
   public static class ESManyHelper
    {
        /// <summary>
        /// 单点链接到ElasticSearch
        /// </summary>
        /// <param name="url">ElasticSearch的ip地址</param>
        /// <returns></returns>
        public static  ElasticClient OneConnectES(string url)
        {

            var node = new Uri(url);
            var settings = new ConnectionSettings(node);
            var client = new ElasticClient(settings);
            return client;
        }
        /// <summary>
        /// 指定多个节点使用连接池链接到Elasticsearch集群
        /// </summary>
        /// <param name="serverurl">链接ip数组</param>
        /// <returns></returns>
        public static ElasticClient ManyConnectES(string[] serverurl)
        {
            Uri[] nodes = new Uri[serverurl.Length];
            for (int i = 0; i < serverurl.Length; i++)
            {
                nodes[i] = new Uri(serverurl[i]);
            }
            var pool = new StaticConnectionPool(nodes);
            var settings = new ConnectionSettings(pool);
            var client = new ElasticClient(settings);
            return client;
        }
        /// <summary>
        /// 创建索引
        /// </summary>
        /// <param name="elasticClient"></param>
        public static  CreateIndexResponse CreateIndex(this IElasticClient elasticClient, string indexName, int numberOfReplicas = 1, int numberOfShards = 5)
        {
            IIndexState indexState = new IndexState
            {
                Settings = new IndexSettings
                {
                    NumberOfReplicas = numberOfReplicas,
                    // [副本数量]
                    NumberOfShards = numberOfShards
                }
            };
            Func<CreateIndexDescriptor, ICreateIndexRequest> func = x => x.InitializeUsing(indexState).Map(m => m.AutoMap());
            CreateIndexResponse response = elasticClient.Indices.Create(indexName, func);
            return response;
        }
    }
}

ES数据库查询类封装：

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;

namespace Core.Net.Common.Core.Net.Core.ES
{
        /// <summary>
    /// ES数据库查询通用类
    /// </summary>
    /// <typeparam name="T"></typeparam>
   public class ESSearchHelper<T> where T:class,new()
    {
        /// <summary>
        /// 带有一个查询条件的查询
        /// </summary>
        /// <param name="index">ES数据库索引</param>
        /// <param name="onewhere">查询条件表达式</param>
        /// <param name="onefiled">查询条件字段</param>
        /// <param name="orderby">排序</param>
        /// <param name="startPage">开始页</param>
        /// <param name="endPage">结束页</param>
        /// <returns></returns>
        public static List<T> GetOneESList(string index, Expression<Func<T, bool>> onewhere,string onefiled, Expression<Func<T, bool>> orderby,int startPage,int endPage)
        {
            var client = ESHelper<T>.Connect_Index(index);
            var result = client.Search<T>
                (
                    x => x.Index(index)
                    .Query(q => q.Match(m => m.Field(onewhere).Query(onefiled)))
                    .Sort(q=>q.Descending(orderby))
                    .From(startPage)
                    .Size(endPage)
                ).Documents.ToJson();
            return result.ToList<T>();
        }
        /// <summary>
        /// 带有两个查询条件的查询
        /// </summary>
        /// <param name="index">ES数据库索引</param>
        /// <param name="onewhere">第一个查询条件表达式</param>
        /// <param name="onefiled">第一个查询条件字段</param>
        /// <param name="twowhere">第二个查询条件表达式</param>
        /// <param name="twofiled">第二个查询条件字段</param>
        /// <param name="orderby">排序</param>
        /// <param name="startPage">开始页数</param>
        /// <param name="endPage">结束页数</param>
        /// <returns></returns>
        public static List<T> GetTwoESList(string index, Expression<Func<T, bool>> onewhere, string onefiled, Expression<Func<T, bool>> twowhere,string twofiled, Expression<Func<T, bool>> orderby, int startPage, int endPage)
        {
            var client = ESHelper<T>.Connect_Index(index);
            var result = client.Search<T>
                (
                    x => x.Index(index)
                    .Query(q => q.Match(m => m.Field(onewhere).Query(onefiled)))
                    .Query(q => q.Match(m => m.Field(twowhere).Query(twofiled)))
                    .Sort(q => q.Descending(orderby))
                    .From(startPage)
                    .Size(endPage)
                ).Documents.ToJson();
            return result.ToList<T>();
        }
        /// <summary>
        /// 三个查询条件查询ES数据库
        /// </summary>
        /// <param name="index">ES数据库索引</param>
        /// <param name="onewhere">第一个查询条件表达式</param>
        /// <param name="onefiled">第一个查询条件字段</param>
        /// <param name="twowhere">第二个查询条件表达式</param>
        /// <param name="twofiled">第二个查询条件字段</param>
        /// <param name="threewhere">第三个查询条件表达式</param>
        /// <param name="threefiled">第三个查询条件字段</param>
        /// <param name="orderby">排序</param>
        /// <param name="startPage">开始页数</param>
        /// <param name="endPage">结束页数</param>
        /// <returns></returns>
        public static List<T> GetThreeESList(string index, Expression<Func<T, bool>> onewhere, string onefiled, Expression<Func<T, bool>> twowhere, string twofiled, Expression<Func<T, bool>> threewhere, string threefiled, Expression<Func<T, bool>> orderby, int startPage, int endPage)
        {
            var client = ESHelper<T>.Connect_Index(index);
            var result = client.Search<T>
                (
                    x => x.Index(index)
                    .Query(q => q.Match(m => m.Field(onewhere).Query(onefiled)))
                    .Query(q => q.Match(m => m.Field(twowhere).Query(twofiled)))
                    .Query(q => q.Match(m => m.Field(threefiled).Query(threefiled)))
                    .Sort(q => q.Descending(orderby))
                    .From(startPage)
                    .Size(endPage)
                ).Documents.ToJson();
            return result.ToList<T>();
        }    
        /// <summary>
        /// 除时间外含有一个查询条件
        /// </summary>
        /// <param name="index">ES数据库索引</param>
        /// <param name="onewhere">查询条件表达式</param>
        /// <param name="onefiled">查询条件字段</param>
        /// <param name="timewhere">时间字段表达式</param>
        /// <param name="startTime">开始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <param name="orderby">排序</param>
        /// <param name="startPage">开始页</param>
        /// <param name="endPage">结束页</param>
        /// <returns></returns>
        public static List<T> GetOneTimeESList(string index, Expression<Func<T, bool>> onewhere, string onefiled, Expression<Func<T, bool>> timewhere,DateTime startTime,DateTime endTime, Expression<Func<T, bool>> orderby, int startPage, int endPage)
        {
            var client = ESHelper<T>.Connect_Index(index);
            var result = client.Search<T>
                (
                    x => x.Index(index)
                    .Query(q => q.Match(m => m.Field(onewhere).Query(onefiled)))
                    //注意：这个按时间段查询我试了好多此，好像只要添加这个时间段，就查不出来任何数据，非常奇怪，我百度了一下，好像都是这样干的。
                    .Query(q=>q.DateRange(c=>c.Field(timewhere).LessThanOrEquals(startTime).GreaterThanOrEquals(endTime)))
                    .Sort(q => q.Descending(orderby))
                    .From(startPage)
                    .Size(endPage)
                ).Documents.ToJson();
            return result.ToList<T>();
        }
        /// <summary>
        /// 除时间外含有一个查询条件
        /// </summary>
        /// <param name="index">ES数据库索引</param>
        /// <param name="onewhere">第一个查询条件表达式</param>
        /// <param name="onefiled">第一个查询条件字段</param>
        /// <param name="twowhere">第二个查询条件表达式</param>
        /// <param name="twofiled">第二个查询条件字段</param>
        /// <param name="timewhere">时间字段表达式</param>
        /// <param name="startTime">开始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <param name="orderby">排序</param>
        /// <param name="startPage">开始页</param>
        /// <param name="endPage">结束页</param>
        /// <returns></returns>
        public static List<T> GetTwoTimeESList(string index, Expression<Func<T, bool>> onewhere, string onefiled, Expression<Func<T, bool>> twowhere, string twofiled, Expression<Func<T, bool>> timewhere, DateTime startTime, DateTime endTime, Expression<Func<T, bool>> orderby, int startPage, int endPage)
        {
            var client = ESHelper<T>.Connect_Index(index);
            var result = client.Search<T>
                (
                    x => x.Index(index)
                    .Query(q => q.Match(m => m.Field(onewhere).Query(onefiled)))
                    .Query(q => q.Match(m => m.Field(twowhere).Query(twofiled)))
                    .Query(q => q.DateRange(c => c.Field(timewhere).LessThanOrEquals(startTime).GreaterThanOrEquals(endTime)))
                    .Sort(q => q.Descending(orderby))
                    .From(startPage)
                    .Size(endPage)
                ).Documents.ToJson();
            return result.ToList<T>();
        }
        /// <summary>
        /// 除时间外含有一个查询条件
        /// </summary>
        /// <param name="index">ES数据库索引</param>
        /// <param name="onewhere">第一个查询条件表达式</param>
        /// <param name="onefiled">第一个查询条件字段</param>
        /// <param name="twowhere">第二个查询条件表达式</param>
        /// <param name="twofiled">第二个查询条件字段</param>
        /// <param name="threewhere">第三个查询条件表达式</param>
        /// <param name="threefiled">第三个查询条件字段</param>
        /// <param name="timewhere">时间字段表达式</param>
        /// <param name="startTime">开始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <param name="orderby">排序</param>
        /// <param name="startPage">开始页</param>
        /// <param name="endPage">结束页</param>
        /// <returns></returns>
        public static List<T> GetThreeTimeESList(string index, Expression<Func<T, bool>> onewhere, string onefiled, Expression<Func<T, bool>> twowhere, string twofiled, Expression<Func<T, bool>> timewhere, DateTime startTime, DateTime endTime, Expression<Func<T, bool>> threewhere, string threefiled, Expression<Func<T, bool>> orderby, int startPage, int endPage)
        {
            var client = ESHelper<T>.Connect_Index(index);
            var result = client.Search<T>
                (
                    x => x.Index(index)
                    .Query(q => q.Match(m => m.Field(onewhere).Query(onefiled)))
                    .Query(q => q.Match(m => m.Field(twowhere).Query(twofiled)))
                    .Query(q => q.Match(m => m.Field(threefiled).Query(threefiled)))
                    .Query(q => q.DateRange(c => c.Field(timewhere).LessThanOrEquals(startTime).GreaterThanOrEquals(endTime)))
                    .Sort(q => q.Descending(orderby))
                    .From(startPage)
                    .Size(endPage)
                ).Documents.ToJson();
            return result.ToList<T>();
        }
    }
}