ElasticSearch学习总结（二）

大梦谁先觉i

已于 2022-03-11 17:18:32 修改

阅读量1.2k

点赞数

分类专栏：中间件文章标签： elasticsearch 学习 java

于 2022-03-08 23:17:02 首次发布

本文链接：https://blog.csdn.net/qq_45228323/article/details/118280203

版权

中间件专栏收录该内容

10 篇文章 2 订阅

订阅专栏

1 Bulk批量操作

1.1 脚本操作

   #批量操作
    POST _bulk
    {"delete":{"_index":"person1","_id":"5"}}	#删除5号
    {"create":{"_index":"person1","_id":"8"}}	#新增8号(下边是新增的数据)
    {"name":"八号","age":18,"address":"北京"}
    {"update":{"_index":"person1","_id":"2"}}	#更新2号 name为2号
    {"doc":{"name":"2号"}}

2 导入数据库数据

2.1 分析&创建索引

# 需要根据数据库字段信息,定义出来es的索引和映射配置,且手动执行一下
PUT goods
{
	"mappings": {
		"properties": {
			"title": {
				"type": "text",
				"analyzer": "ik_smart"
			},
			"price": { 
				"type": "double"
			},
			"createTime": {
				"type": "date"
			},
			"categoryName": {	
				"type": "keyword"
			},
			"brandName": {	
				"type": "keyword"
			},	
			"spec": {		
				"type": "object"
			},
			"saleNum": {	
				"type": "integer"
			},			
			"stock": {	
				"type": "integer"
			}
		}
	}
}

2.2 代码实现

@Data
@AllArgsConstructor
@NoArgsConstructor
@Document(indexName = "goods")  //索引的名
public class Good {
    @Id
    private Double id;
    @Field(type = FieldType.Text ,analyzer = "ik_smart")
    private String title;
    private Double price;
    private Double stock;
    private Double saleNum;
    private Date createTime;
    @Field(analyzer = "keyword")
    private String categoryName;
    @Field(analyzer = "keyword")
    private String brandName;
    private LinkedHashMap spec;
    public void setSpec(String spec) {
        LinkedHashMap parse = JSON.parseObject(spec, LinkedHashMap.class);
        this.spec = parse;
    }
}

 

@SpringBootTest
class EsBulkTests {
    @Autowired
    private ElasticsearchRestTemplate restTemplate;

    @Autowired
    private GoodMapper goodMapper;

//批量添加
    @Test
    public  void  bulkAddTest(){
        //从数据库中获取所有的数据zho
        List<Good> list = goodMapper.findAll();
        //把数据批量添加到es中
        restTemplate.save(list);
    }

    //批量删除
    @Test
    public  void bulkDeleteTest(){
        //指定删除条件
        CriteriaQuery query = new CriteriaQuery(Criteria.where("id").notIn("-1"));
        //根据条件进行批量删除
        restTemplate.delete(query,Good.class);
    }

}

3 ElasticSearch查询

3.1 matchAll

脚本

  # matchAll: 查询所有
    # 默认情况下，es一次展示10条数据,通过from和size来控制分页
    # 查询结果详解
    GET goods/_search
    {
      "query": {
        "match_all": {}
      },
      "from": 0,
      "size": 100
    }

API

   /**
     * 查询所有
     *  1. matchAll
     *  2. 将查询结果封装为Goods对象，装载到List中
     *  3. 分页。默认显示10条
     */
     @Test
        public void matchAllQueryTest2() {
            QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
            Query query = new NativeSearchQueryBuilder().withQuery(queryBuilder)
                    .withSort(SortBuilders.fieldSort("price").order(SortOrder.DESC))  //查询结果按price进行排序
                    .withPageable(Pageable.ofSize(10).withPage(0))  //进行分页操作size指定大小，page 指定页码
                    .build();
            SearchHits<Good> hits = restTemplate.search(query, Good.class);
            System.out.println(hits);
    
            long totalHits = hits.getTotalHits();
    
            System.out.println("查询到的总数：" + totalHits);
    
            //把查询到的结果,转换为List集合
            List<Good> list = hits.get().map(hit -> hit.getContent()).collect(Collectors.toList());
    
            for (Good good : list) {
                System.out.println(good);
            }
    
        }
    

    public void executeQuery(QueryBuilder queryBuilder) {
            Query query = new NativeSearchQueryBuilder().withQuery(queryBuilder)
                    .withSort(SortBuilders.fieldSort("price").order(SortOrder.DESC))  //查询结果按price进行排序
                    .withPageable(Pageable.ofSize(10).withPage(0))  //进行分页操作size指定大小，page 指定页码
                    .build();
            SearchHits<Good> hits = restTemplate.search(query, Good.class);
            long totalHits = hits.getTotalHits();
            System.out.println("查询到的总数：" + totalHits);
    
            //把查询到的结果,转换为List集合
            List<Good> list = hits.get().map(hit -> hit.getContent()).collect(Collectors.toList());
    
            for (Good good : list) { //打印每条信息
                System.out.println(good);
            }
        }

3.2 termQuery

注意：因为term是“完整词条查询”，所以，这种查询适合keyword 、numeric、date

脚本

 GET 索引名称/_search
    {
        "query": {
            "term": {
                "字段名称": {
                    "value": "查询条件"
                }
            }
        }
    }

API

 //2.termQuery 词条等值查询
    @Test
    public void termQueryTest() {
        //如果指定的列不分词则，则要求，该列必须和“华为手机”一模一样
        //如果指定的列分词，则要求词条中有和“华为手机”一摸一样的词条
        QueryBuilder queryBuilder = QueryBuilders.termsQuery("title", "华为");
        executeQuery(queryBuilder);
    }

3.3 matchQuery

注意：match查询会对查询条件进行分词，然后将分词后的查询条件和词条进行等值匹配，默认取并集（OR）

脚本

 # 语法一
    GET 索引名称/_search
    {
    	"query": {
    		"match": {
    			"字段名称": "查询条件"
    		}
    	}
    }
    
    # 语法二
    GET 索引名称/_search
    {
    	"query": {
    		"match": {
    			"字段名称": {
              		"query": "查询条件",
                    "operator": "操作(or或者and)"
    			}
    		}
    	}
    }

API

 //3.matchQuery先分词,然后等值查询. 只能查询已经分词的列
    @Test
    public void matchQueryTest() {
        //先对华为手机进行分词，然后根据分词后的的词条查询执行的列
        //operator指分别查询寻后的操作 or表示去并集，and 表示取并集
        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "华为手机").operator(Operator.OR);
        executeQuery(queryBuilder);
    }								   //求并集

3.4 模糊查询

3.4.1 wildcard查询

wildcard查询：会对查询条件进行分词。还可以使用通配符 ?（任意单个字符）和 * （0个或多个字符）

   # wildcard 查询。查询条件分词，模糊查询
    GET goods/_search
    {
      "query": {
        "wildcard": {
          "title": {
            "value": "华*"
          }
        }
      }
    }

API

   //1.wildcard对词条进行模糊查询
    @Test
    public void wildcardQueryTest() {
        // 如果指定的列, 不分词, 则要求, 该列的值, 必须满足条件.  *代表任意多个任意字符, ?代表一个任意字符
        // 判断指定的列, 分词了, 则要求, "词条"中, 必须满足条件. 有就获取, 没有就不要
        QueryBuilder queryBuilder = QueryBuilders.wildcardQuery("title", "华*");
        executeQuery(queryBuilder);
    }

3.4.2 regexp正则查询

正则查询取决于正则表达式的效率

   GET goods/_search
    {
      "query": {
        "regexp": {
          "title": "\\w+(.)*"
        }
      }
    }

API

 //2.正则查询
    @Test
    public void regexQueryTest() {
        // 如果指定的列, 不分词, 则要求, 该列的值, 必须满足正则表达式
        // 判断指定的列, 分词了, 则要求, "词条"中, 必须满足正则表达式. 有就获取, 没有就不要
        QueryBuilder queryBuilder = QueryBuilders.regexpQuery("title", "\\w+(.)*");
        executeQuery(queryBuilder);
    }

3.4.3 prefix前缀查询

对keyword类型支持比较好，其他类型数据不太适合

  # 前缀查询 对keyword类型支持比较好
    GET goods/_search
    {
      "query": {
        "prefix": {
          "brandName": {
            "value": "三"
          }
        }
      }
    }

API

//3.前缀查询
    @Test
    public void prefixQueryTest() {
        // prefixQuery: 前缀匹配. 其实就是wildcardQuery关键字后边加*
        // 如果指定的列, 不分词, 则要求, 该列的值, 必须满足正则表达式
        // 判断指定的列, 分词了, 则要求, "词条"中, 必须满足正则表达式. 有就获取, 没有就不要
        QueryBuilder queryBuilder = QueryBuilders.prefixQuery("brandName", "三");
        executeQuery(queryBuilder);
    }

3.5 范围&排序查询

脚本

  # 范围查询
    GET goods/_search
    {
      "query": {
        "range": {
          "price": {		# 按照价格price查询
            "gte": 2000,	# 大于等于2000，gt:大于
            "lte": 3000		# 小于等于3000，lt:小于
          }
        }
      },
      "sort": [					# 排序，可选
        {
          "price": {
            "order": "desc"		# 按照价格，降序排列
          }
        }
      ]
    }

API

   //1.范围&排序查询
        @Test
        public void rangedQueryTest() {
            QueryBuilder queryBuilder = QueryBuilders.rangeQuery("price").gte(1000).lte(5000);
            executeQuery(queryBuilder);
        }

3.6 QueryString查询

3.6.1 概述

QueryString是多条件查询。会对查询条件进行分词，然后将分词后的查询条件和词条进行等值匹配，默认取并集（OR）。

QueryString可以指定多个查询字段

QueryString的查询分两种"query_string"和"simple_query_string"

3.6.2 query_string

   GET goods/_search
    {
      "query": {
        "query_string": {
          "fields": ["title","categoryName","brandName"], 
          "query": "华为 AND 手机"
        }
      }
    }
    
    # 注意：
    # 	query可以书写多个词条，这些词条也会被默认分词，词条之间，默认“OR”
    
    # "华为 AND 手机": 
    # 检查一整条数据中的"title","categoryName","brandName"字段，"华为"和"手机"词条同时存在。
    # 注意："华为"和"手机"词条可以在不同字段中，但整条数据中必须全部存在
    
    # "华为 OR 手机": 
    # 检查一整条数据中的"title","categoryName","brandName"字段，任意字段，只要包含"华为"或"手机"中的任何词条，都满足要求

3.6.3 simple_query_string

   GET goods/_search
    {
      "query": {
        "simple_query_string": {
          "fields": ["title","categoryName","brandName"], 
          "query": "华为 AND 手机"
        }
      }
    }
    # 注意：
    # 	query可以书写多个词条，这些词条也会被默认分词，词条之间，使用OR
    #	simple_query_string不支持"AND"连接符。如："华为 AND 手机"，查询时会将 “华为”、"and"、“手机”分别进行查询

3.6.4 default_operator

GET goods/_search
{
  "query": {
    "query_string": {
      "fields": ["title","brandName","categoryName"],
      "query": "华为手机",
      "default_operator": "AND"
    }
  }
}

# 注意：
# 	1.default_operator: 默认为"OR"
#   2.default_operator一般不和query中的关键字同时使用

# "default_operator": "AND" 
# 求满足词条要求的交集

# "query": "华为 手机"，"default_operator": "OR" 
# 求满足词条要求的并集

3.6.5 API

   QueryStringQueryBuilder query = QueryBuilders.queryStringQuery("华为手机")
        .field("titl //1.queryString查询(多条件查询)
        @Test
        public void queryStringTest() {
            //查询: 一条数据中,title/categoryName/brandName三列中,必须同时包含"华为"和"手机"
            QueryBuilder queryBuilder = QueryBuilders.queryStringQuery("华为 AND 手机").field("title").field("categoryName").field("bandName");
            executeQuery(queryBuilder);
        }e").field("categoryName").field("brandName")
        .defaultOperator(Operator.AND);
              
      //2.
        @Test
        public  void  simpleQueryStringQuery(){
            //查询: match查询title, match查询categoryName, match查询brandName, 求并集
            //注意: 使用该种查询的时候,要保证"查询的所有列"都是"分词列"
            QueryBuilder queryBuilder = QueryBuilders.simpleQueryStringQuery("华为手机").field("title").field("categoryName").field("bandName").defaultOperator(Operator.AND);
            executeQuery(queryBuilder);
        }

simple_query_string：有default_operator连接符的脚本

GET goods/_search
{
  "query": {
    "simple_query_string": {
      "fields": ["title","brandName","categoryName"],
      "query": "华为手机 "
      , "default_operator": "OR"
    }
  }
}

注意：query中的or and 是查询时匹配条件是否同时出现----or 出现一个即可，and 两个条件同时出现

default_operator的or and 是对结果进行并集（or）、交集（and）

3.7 布尔查询

boolQuery：对多个查询条件连接。连接方式：

must（and）：条件必须成立，条件可以有多个
must_not（not）：条件必须不成立，条件可以有多个
should（or）：条件可以成立，条件可以有多个
filter：条件必须成立，性能比must高。不会计算得分，条件可以有多个。（得分: 即条件匹配度,匹配度越高，得分越高）

脚本

  GET goods/_search
    {
      "query": {
        "bool": {
          "must": [
           {
              "term": {
                "brandName": {
                  "value": "华为"
                }
              }
            }
          ],
          "filter":[ 
           {
               "term": {
                  "title": "手机"
               }
           },
           {
               "range":{
                     "price": {
                        "gte": 2000,
                        "lte": 3000
                     }
                }
            }      
          ]
        }
      }
    }
    
    #filter 单独使用   filter可以是单个条件，也可多个条件（数组形式）
    GET goods/_search
    {
      "query": {
        "bool": {
          "filter": [
            {
              "term": {
                "brandName": {
                  "value": "华为"
                }
              }
            }
          ]
        }
      }
    }

API

 //布尔查询（即多条条件一并成立）
        @Test
        public void testBoolQuery() {
            //多条件查询
            QueryBuilder queryBuilder =  QueryBuilders.boolQuery()
                    .must(QueryBuilders.termQuery("brandName","华为"))
                    .filter(QueryBuilders.matchQuery("title","手机"))
                    .filter(QueryBuilders.rangeQuery("price").gte(2000).lte(3000));
            executeQuery(queryBuilder);
    
            //Query query = new NativeSearchQueryBuilder()
            //        .withQuery(QueryBuilders.termQuery("brandName","华为"))
            //        .withFilter(QueryBuilders.matchQuery("title","手机"))
            //        .withFilter(QueryBuilders.rangeQuery("price").gte(2000).lte(3000))
            //        .build();
        }

3.8 聚合查询

3.8.1 指标聚合

相当于MySQL的聚合函数。max、min、avg、sum等

脚本

 # 指标聚合-聚合函数
    GET goods/_search
    {  
      "query": {			// 基础查询
        "match": {
          "title": "手机"
        }
      },
      "aggs": {					// 在基础查询的基础上，开始聚合
        "max_price": {			// 结果所存储的字段名，名称自定义
          "max": {				// 聚合类型
            "field": "price"	// 聚合依据（也就是按照price列进行聚合）
          }
        }
      }
    }

API

  @Autowired
    private ElasticsearchRestTemplate restTemplate;

    /**
     * 聚合函数-指标聚合
     */
    @Test
    public void maxTest() {
        //准备查询条件
        QueryBuilder queryBuilder = QueryBuilders.termQuery("title", "手机");
        //编译查询条件
        NativeSearchQuery query = new NativeSearchQueryBuilder().withQuery(queryBuilder).addAggregation(AggregationBuilders.max("price_max").field("price")).build();//对brandName进行分组统计
        //执行查询条件
        SearchHits<Good> hits = restTemplate.search(query, Good.class);
        long totalHits = hits.getTotalHits();
        System.out.println("查询到的总数："+totalHits);
        Aggregations aggregations = hits.getAggregations();
        Max price_max = aggregations.get("price_max");
        double price_maxValue = price_max.getValue();
        System.out.println(price_maxValue);
    }

3.8.2 指标聚合

相当于MySQL的 group by 分组查询。

注意：不要对text类型的数据进行分组，会失败。

脚本

  # 桶聚合-分组查询
    GET goods/_search
    {
      "query": {
        "match": {
          "title": "手机"
        }
      },
      "aggs": {
        "goods_brands": {
          "terms": {
            "field": "brandName",
            "size": 100				// 查询结果数量（默认分页显示，只显示前10条）
          }
        }
      }
    }

API

  /**
         *   分组查询-桶聚合
         */
        @Test
        public void GroupByTest() {
            //准备查询条件
            QueryBuilder queryBuilder = QueryBuilders.termQuery("title", "手机");
            //编译查询条件
            NativeSearchQuery query = new NativeSearchQueryBuilder().withQuery(queryBuilder).addAggregation(AggregationBuilders.terms("brands").field("brandName")).build();
            //执行查询条件
            SearchHits<Good> hits = restTemplate.search(query, Good.class);
            long totalHits = hits.getTotalHits();
            System.out.println("查询到的总数："+totalHits);
            Aggregations aggregations = hits.getAggregations();
            Terms brands = aggregations.get("brands");
            List<? extends Terms.Bucket> buckets = brands.getBuckets();
            for (Terms.Bucket bucket : buckets) {
                String keyAsString = bucket.getKeyAsString();
                long docCount = bucket.getDocCount();
                System.out.println(keyAsString+"....."+docCount);
            }
        }
    }

3.9 高亮查询

所谓高亮查询，其实就是把查询结果中的"关键词"的前后，加上前后缀。

脚本

  # 对title查询，对查询到的结果中的"电视"，加上前后缀
    GET goods/_search
    {
      "query": {
        "match": {
          "title": "电视"
        }
      },
      "highlight": {
        "fields": {
          "title": {
            "pre_tags": "<font color='red'>",	// 前缀
            "post_tags": "</font>"				// 后缀
          }
        }
      }
    }
    
    # 注意：
    # 	如果不加前后缀，默认前缀时<em>，后缀</em>
    #	查询结果并不是在原字段上加前后缀，而是会有一个新的列，叫做highlight，高亮处理后的文本在那里边

API

   @Autowired
        private ElasticsearchRestTemplate restTemplate;
    
        /**
         * 高亮查询
         */
        @Test
        public void highlightTest() {
            //1.准备查询条件(title包含电视的)
            QueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "电视");
            //2.编译查询条件
            NativeSearchQuery query = new NativeSearchQueryBuilder().withQuery(queryBuilder).withHighlightBuilder(new HighlightBuilder().field("title").preTags("。。前面。。").postTags("..后面..")).withPageable(Pageable.ofSize(10).withPage(0)).build();
            //3.执行查询
            SearchHits<Good> hits = restTemplate.search(query, Good.class);
            long totalHits = hits.getTotalHits();
            System.out.println("查询到的总数：" + totalHits);
    
            //4.获取高亮
            List<Good> list = new ArrayList<>();
            for (SearchHit<Good> hit : hits) {
                Good good = hit.getContent();
                List<String> title_list = hit.getHighlightField("title");
                String titleStr = "";
                for (String s : title_list) {
                    titleStr += s;
                }
                good.setTitle(titleStr);
                list.add(good);
            }
            System.out.println(list);
        }
    }

3.10 重建索引&索引别名

3.10.1 查询别名

#查询别名 默认别名无法查看，默认别名同索引名
GET goods/_alias/
#结果
{
  "goods" : {
    "aliases" : { }
  }
}

3.10.2 添加别名

POST 索引名/_alias/别名

注意：

索引可以有多个别名
多个索引可以指向同一个别名，查询时查询的是并集，然不能做添加。强烈不建议让多个索引指向同一个别名
删除索引后，别名自动删除。
当别名没有被索引引用时，自动删除
当索引有别名后，操作别名和操作索引没区别。但不能执行删除索引库操作。

3.10.3 删除别名

   POST _aliases
    {
        "actions": [
            { 
                "remove": { "index": "student_index_v1", "alias": "student_index_v11" }
            }
        ]
    }

3.10.4 修改别名

POST /_aliases
{
    "actions": [
        { "remove": { "index": "索引名", "alias": "旧别名" }},
        { "add":    { "index": "索引名", "alias": "新别名" }}
    ]
}

3.10.5 拷贝数据

   # 拷贝数据
    POST _reindex
    {
      "source": {
        "index": "原索引"
      },
      "dest": {
        "index": "目标索引"
      }
    }

3.10.6 API

   /**
     * 获取所有的别名
     * @throws IOException
     */
    @Test
    public void getAliases() throws IOException {
        IndicesClient indicesClient = client.indices();
        GetAliasesRequest getAliasesRequest = new GetAliasesRequest();
        GetAliasesResponse response = indicesClient.getAlias(getAliasesRequest,RequestOptions.DEFAULT);
        Map<String, Set<AliasMetaData>> aliases = response.getAliases();
        for (String s : aliases.keySet()) {
            System.out.println(s+":"+aliases.get(s));
        }
    }
    
    /**
     * 获取指定索引的别名
     * @throws IOException
     */
    @Test
    public void getAliasesByIndex() throws IOException {
        IndicesClient indicesClient = client.indices();
        GetIndexRequest getIndexRequest = new GetIndexRequest("student_index_v1");
        GetIndexResponse response = indicesClient.get(getIndexRequest, RequestOptions.DEFAULT);
        Map<String, List<AliasMetaData>> aliases = response.getAliases();
        for (String s : aliases.keySet()) {
            System.out.println(s+":"+aliases.get(s));
        }
    }
    
    /**
     * 给索引添加别名
     * @throws IOException
     */
    @Test
    public void addAliasesByIndex() throws IOException {
        IndicesClient indicesClient = client.indices();
        IndicesAliasesRequest request = new IndicesAliasesRequest();
        IndicesAliasesRequest.AliasActions alias = IndicesAliasesRequest.AliasActions.add();
        alias.index("student_index_v1");    //索引
        alias.alias("student_index_v12");   //别名
        request.addAliasAction(alias);
        AcknowledgedResponse response = indicesClient.updateAliases(request, RequestOptions.DEFAULT);
        System.out.println(response.isAcknowledged());
    }
    
    /**
     * 删除索引的别名
     * @throws IOException
     */
    @Test
    public void removeAliasesByIndex() throws IOException {
        IndicesClient indicesClient = client.indices();
        IndicesAliasesRequest request = new IndicesAliasesRequest();
        IndicesAliasesRequest.AliasActions alias = IndicesAliasesRequest.AliasActions.remove();
        alias.index("student_index_v1");    //索引
        alias.alias("student_index_v12");   //别名
        request.addAliasAction(alias);
        AcknowledgedResponse response = indicesClient.updateAliases(request, RequestOptions.DEFAULT);
        System.out.println(response.isAcknowledged());
    }
    
    
    /**
     * 数据迁移
     * @throws IOException
     */
    @Test
    public void sourceToDest() throws IOException {
        IndicesClient indicesClient = client.indices();
    
        //1.获取操作文档的对象
        ReindexRequest reindexRequest = new ReindexRequest();
        reindexRequest.setSourceIndices("student_index_v1");
        reindexRequest.setDestIndex("student_index_v2");
        //添加数据，获取结果
        BulkByScrollResponse response = client.reindex(reindexRequest, RequestOptions.DEFAULT);
        //打印响应结果
        System.out.println(response.getTotal());
    }

大梦谁先觉i

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
ElasticSearch学习总结（二）

ElasticSearch高级操作1 Bulk批量操作1.1 脚本操作#批量操作POST _bulk{“delete”:{"_index":“person1”,"_id":“5”}} #删除5号{“create”:{"_index":“person1”,"_id":“8”}} #新增8号(下边是新增的数据){“name”:“八号”,“age”:18,“address”:“北京”}{“update”:{"_index":“person1”,"_id":“2”}} #更新2号 nam
复制链接

扫一扫