Elasticsearch的学习

Z时代
2024-01-10
分类：综合

1.ES是什么？

es是一个基于Lucene的搜索服务器，是一个基于分布式多用户能力的全文搜索引擎，基于restful web接口。
大白话：是一个分布式、高性能、高可用、可伸缩的搜索和分析系统。

2.ES的功能？

此种场景不支持包含频繁更新、事务（transaction）的操作。

a.分布式的搜索引擎和数据分析引擎
b.全文检索，结构化检索，数据分析
c.对海量数据进行近实时的处理。
d.elasticsearch作为传统数据库的一个补充，比如全文检索，同义词处理，相关度排名（如热度），复杂数据分析。

简单点来说就是：
查询快并且可以复杂模糊查询等 , 数据分析，速度快，可扩展性，灵活性。

3.ES和我们常用的数据库有什么不同呢？

1.响应时间非常快（PB级数据是毫秒反应）
在大数据相似的计算与查找或简单计算时，es的分布式并行计算有绝对优势。
在某一个唯一的值（如：用会员id找会员）这是用mysql好一点。
2.分词（倒排索引）
倒排索引建立的是分词（Trem）和文档（Document）之间的映射关系，在倒排索引中，数据是面向词的（Term）而不是面向文档的。
倒排索引-----查询过程
查询包含“搜索引擎”的文档
1.通过倒排序获得“搜索引擎”对应的文档id列表，有1,3
2.通过正排序索引查询1和3的完整内容。
3.返回做种结果。
4.遍历方式
ES有分片的概念，一个大的索引会被分成多个分片进行存储数据，使用分布式的架构对分片进行并行搜索（基于倒排）
传统数据库遍历，属于正向全表扫描。

ES没有事务的概念，不支持回滚，无法恢复删除数据。

Relational DB -> Databases -> Tables -> Rows -> Columns关系型数据库数据库表行列 Elasticsearch -> Indices -> Types -> Documents -> FieldsElasticsearch 索引(indexName) 类型 (type) 文档域（字段）

4.ES的使用场景？

1.记录和日志分析

Logstash是一个开源的服务器端数据处理管道，支持各种输入选择，可以在同一时间从多常用来源捕捉事件，可以同时从多个数据源获取数据，并对其进行转换，发到我们常用ES中。

2.采集和组合公共数据

与日志数据一样，Elastic Stack拥有大象工具，可以轻松抓取和索引远程数据。

3.全文检索

4.事件数据和指标

ES可以很好的处理时间序列数据，如指标和应用程序事件。

5.数据可视化

elasticsearch都有常用查询。

matchQuery（null,null）基本匹配查询（分词查询）不支持通配符，

multiQuery多个document field查询，

FuzzyQuery模糊查询

boolQuery组合查询，and ， not ，or 。

termQuery 精确查询（一个参数是，完全匹配），（多个参数，是批量匹配）

boostingQuery

functionScoreQuery 权重分查询

spanNearQuery跨度查询

nestedQuery嵌套查询

{
    "_index":"earth",
    "_type":"earth2",
    "_id":"n-3",
    "_version":1,
    "_score":1,
    "_source":{
        "jid":"n-3",
        "udateTime":"2018-01-30 14:10:04",
        "orderItem":[
            {
                "orderType":"RO",
                "orderDate":"20170708",
                "orderItems":[
                    {
                        "skuNo":"154018",
                        "stockSite":"0001",
                        "costOfSale":108.9
                    }
                ]
            }
        ]
    }
}
{
  "query": {
    "bool": {
      "must": [
        {
          "nested": {
            "path": "orderItem.orderItems",
            "query": {
              "bool": {
                "must": [
                  {
                    "match": {
                      "orderItem.orderItems.skuNo": "154018"
                    }
                  },
                  {
                    "match": {
                      "orderItem.orderItems.stockSite": "0001"
                    }
                  }
                ]
              }
            }
          }
        },
        {
          "nested": {
            "path": "orderItem",
            "query": {
              "bool": {
                "must": [
                  {
                    "match": {
                      "orderItem.orderType": "RO"
                    }
                  },
                  {
                    "match": {
                      "orderItem.orderDate": "20170708"
                    }
                  }
                ]
              }
            }
          }
        }
      ]
    }
  }
}

		QueryBuilder orderItemsQuery = QueryBuilders.nestedQuery("orderItem.orderItems",
				QueryBuilders.boolQuery()
						.must(QueryBuilders.matchQuery("orderItem.orderItems.stockSite", "0001"))
						.must(QueryBuilders.matchQuery("orderItem.orderItems.skuNo", "154018")),
				ScoreMode.Total);
		QueryBuilder orderQuery = QueryBuilders.nestedQuery("orderItem",
				QueryBuilders.boolQuery()
						.must(QueryBuilders.matchQuery("orderItem.orderType", "RO"))
						.must(QueryBuilders.matchQuery("orderItem.orderDate", "20170708")),
				ScoreMode.Total);
		QueryBuilder queryBuilder = QueryBuilders.boolQuery().must(orderQuery).must(orderItemsQuery);
		Iterable<OrderItem> it = orderRepository.search(queryBuilder);
		List<OrderItem> list = Lists.newArrayList(it);
		System.out.println(list);

nativeSearchQueryBuilder:将连接条件和聚合函数等组合

addAggregation.代表一组添加聚合函数统计后的数据

  NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
        //聚合   title分组为例   出现的频率按照降序排名，（热度排名）
        nativeSearchQueryBuilder
                .withIndices("aegis")
                .withTypes("positions")
                .withQuery(QueryBuilders.matchAllQuery());
        TermsAggregationBuilder aggregationBuilder = AggregationBuilders.terms("agg").field("brand.keyword")
                .subAggregation(AggregationBuilders.terms("agg").field("title.keyword"));
       // MinAggregationBuilder minAggregationBuilder = AggregationBuilders.min("price");
        nativeSearchQueryBuilder.addAggregation(aggregationBuilder);
        Aggregations aggregations = elasticsearchTemplate.query(nativeSearchQueryBuilder.build(), new ResultsExtractor<Aggregations>() {
            @Override
            public Aggregations extract(SearchResponse searchResponse) {
                return searchResponse.getAggregations() ; //.get("agg");
            }
        });
        //StringTerms title_term = (StringTerms) aggregations.asMap().get("agg");
        Map<String, Aggregation> stringAggregationMap = aggregations.asMap();
         System.out.println(stringAggregationMap.get("agg"));

5.属性注解类型

1.Document 文档对象(索引信息，文档索引)

(1) indexName : 索引库的名称，建议使用项目名称
(2) type：类型，建议使用实体类名称
(3) indexStoreType：索引文件存储类型
(4) shards：默认分区数
(5) refreshInterval：刷新间隔

Field 每个文档的字段配置（类型，是否分词，是否存储，分词器）

(1)type：FieldType.Auto ，自动检测性的类型
5.x以后，string 变成了，Text和Keyword。
text默认分词，不排序。
keyword排序
复杂的数据类型
Array
Object
Nested
(2) index：FieldIndex.analyzed，默认情况下分词，一般默认分词就好，除非这个字段不会被查到
(3) format：DateFormat.none，时间类型格式化
(4) store 默认情况下不存储原文
(5) searchAnalyzer：指定字段使用的分词器
(6) Analyzer：指定字段建立索引时指定的分词器
(7) ignoreFields：如果某个子弹需要被忽略