es新建索引，搜索

已于 2022-08-09 15:30:44 修改
阅读量3.1k 收藏 1
点赞数
分类专栏： es 文章标签： elasticsearch 大数据 big data
于 2021-11-01 17:23:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csgarten/article/details/121084349
版权 
PUT /order_auto/
{
"settings":{
"index":{
"number_of_shards" : "3",
"number_of_replicas" : "0"
}
}
}
 
PUT /order_auto/_doc/_mappings?include_type_name=true
{
"properties": {
"id": {
"type": "keyword"
},
"orderNo": {
"type": "keyword"
},
"status": {
"type": "text"
},
"pushed": {
"type": "keyword"
},
"requestDecisionNo": {
"type": "keyword"
},
"initParam": {
"type": "keyword"
},
"customerId": {
"type": "keyword"
},
"name": {
"type": "keyword"
},
"channelId": {
"type": "keyword"
},
"channelName": {
"type": "keyword"
},
"idCard": {
"type": "keyword"
},
"phone": {
"type": "text"
},
"operateType": {
"type": "keyword"
},
"requestDecisionParam": {
"type": "keyword"
},
"requestManualParam": {
"type": "keyword"
},
"manualResult": {
"type": "keyword"
},
"decisionResult": {
"type": "keyword"
},
"sceneNo": {
"type": "keyword"
},
"storeFlag": {
"type": "keyword"
},
"artificialFlag": {
"type": "keyword"
},
"manualPushed": {
"type": "keyword"
},
"branchInfo": {
"type": "keyword"
},
"createTime": {
"type": "date",
"format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
},
"updateTime": {
"type": "date",
"format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
}
}
}

上面，新建es索引。

es搜索

package com.mark.order.web.base.configures.es;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.mark.order.domain.consts.Const;
import com.mark.order.domain.dto.OrderEs;
import com.mark.order.domain.enums.order.OrderStateEnum;
import com.mark.order.domain.enums.order.OrderStateVOEnum;
import com.mark.order.domain.vo.orderquery.OrderQueryReqParam;
import com.mark.order.domain.vo.orderquery.OrderQueryRespVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.beanutils.BeanUtils;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;


/**
 * @author : mark
 * @desc : es工具类
 * @since : 2021/8/27 15:33
 */
@Slf4j
@Component
public class ElasticSearchOperation {

    @Resource
    EsConfig esConfig;

    private final RestHighLevelClient restHighLevelClient;

    public ElasticSearchOperation(RestHighLevelClient restHighLevelClient) {
        this.restHighLevelClient = restHighLevelClient;
    }

    /**
     * 新增数据到es
     *
     * @param indexName 索引名称
     * @param data      对象
     * @param indexId   索引id
     */
    public boolean add(String indexName, Object data, String indexId) {
        if (indexName == null || data == null || indexId == null) {
            return false;
        }
        IndexRequest request = new IndexRequest(indexName);
        request.id(indexId);
        request.source(JSONObject.toJSONString(data), XContentType.JSON);
        try {
            IndexResponse indexResponse = restHighLevelClient.index(request, RequestOptions.DEFAULT);
            if (indexResponse == null) {
                return false;
            }
            log.info("写入es成功，风控订单号：{}", indexId);
            return (indexResponse.getResult() == DocWriteResponse.Result.CREATED
                    || indexResponse.getResult() == DocWriteResponse.Result.UPDATED);
        } catch (Throwable e) {
            log.error(
                    "ElasticSearchGateway#add's params  indexName={} and data={} and indexId = {} and Exception Occurred:",
                    indexName, JSONObject.toJSONString(data), indexId, e);
        }
        return false;
    }


    /**
     * 更新数据
     */
    public Boolean update(OrderEs orderEs) {
        log.info("更新订单到es请求参数:{}", JSON.toJSONString(orderEs));
        UpdateRequest updateRequest = new UpdateRequest(esConfig.getIndexName(), String.valueOf(orderEs.getId()));
        updateRequest.retryOnConflict(3);
        updateRequest.doc(JSON.toJSONString(orderEs), XContentType.JSON);
        // 操作ES
        UpdateResponse updateResponse = null;
        try {
            log.info("es更新数据,rq:{}", JSON.toJSONString(updateRequest));
            updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        } catch (Exception e) {
            log.error("es订单更新失败", e);
        }
        return updateResponse != null && updateResponse.status().getStatus() == 200;
    }


    /**
     * 查询es
     */
    public Map<String, Object> search(OrderQueryReqParam entity) throws IOException {
        BoolQueryBuilder boolBuilder = QueryBuilders.boolQuery();
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        String status = entity.getStatus();
        if (StrUtil.isNotEmpty(status)) {
            //待决策和初始化
            if (String.valueOf(OrderStateVOEnum.待审核.getCode()).equals(status)) {
                TermsQueryBuilder termsQuery = QueryBuilders.termsQuery("status",
                        OrderStateEnum.待决策.getCode(), String.valueOf(OrderStateEnum.初始化.getCode()));
                boolBuilder.must(termsQuery);
            }
            //待人工审核，人工审核中
            if (String.valueOf(OrderStateVOEnum.电核中.getCode()).equals(status)) {
                TermsQueryBuilder termsQuery = QueryBuilders.termsQuery("status",
                        OrderStateEnum.待人工审核.getCode(), String.valueOf(OrderStateEnum.人工审核中.getCode()));
                boolBuilder.must(termsQuery);
            }
            //机核挂起
            MatchQueryBuilder matchQueryBuilder = null;
            if (String.valueOf(OrderStateVOEnum.机核挂起.getCode()).equals(status)) {
                matchQueryBuilder = QueryBuilders.matchQuery("status",
                        OrderStateEnum.挂起.getCode());
                boolBuilder.must(matchQueryBuilder);
            }
            //外部取消
            if (String.valueOf(OrderStateVOEnum.外部取消.getCode()).equals(status)) {
                matchQueryBuilder = QueryBuilders.matchQuery("status",
                        OrderStateEnum.已取消.getCode());
            }
            if (String.valueOf(OrderStateVOEnum.审核通过.getCode()).equals(status)) {
                matchQueryBuilder = QueryBuilders.matchQuery("status", status);
            }
            if (String.valueOf(OrderStateVOEnum.审核拒绝.getCode()).equals(status)) {
                matchQueryBuilder = QueryBuilders.matchQuery("status", status);
            }
            boolBuilder.must(matchQueryBuilder);
        }
        if (Const.STORE_ORDER.equals(entity.getStoreFlag())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("storeFlag", entity.getStoreFlag());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getOrderNo())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("orderNo", entity.getOrderNo());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getCustomerId())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("customerId", entity.getCustomerId());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getChannelId())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("channelId", entity.getChannelId());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getFkOrderNo())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("id", entity.getFkOrderNo());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getBranchInfo())) {
            WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery("branchInfo", "*" + entity.getBranchInfo() + "*");
            boolBuilder.must(wildcardQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getDecisionResult())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("decisionResult", entity.getDecisionResult());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getArtificialFlag())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("artificialFlag", entity.getArtificialFlag());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getSceneCode())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("sceneCode", entity.getSceneCode());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getStartTime()) && StrUtil.isNotEmpty(entity.getEndTime())) {
            RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("createTime");
            rangeQueryBuilder.gte(entity.getStartTime());
            rangeQueryBuilder.lte(entity.getEndTime());
            boolBuilder.must(rangeQueryBuilder);
        }

        sourceBuilder.query(boolBuilder);
        sourceBuilder.from((entity.getPageNum() - 1) * entity.getPageSize());
        sourceBuilder.size(entity.getPageSize());
        sourceBuilder.timeout(new TimeValue(20, TimeUnit.SECONDS));
        String[] fields = {"id", "orderNo", "status", "requestDecisionNo", "customerId", "name", "channelId", "channelName",
                "idCard", "phone", "operateType", "requestDecisionTime", "decisionResult", "sceneNo", "sceneName",
                "createTime", "updateTime", "artificialFlag", "manualPushed", "storeFlag", "branchInfo"};
        sourceBuilder.fetchSource(fields, new String[]{});
        SearchRequest searchRequest = new SearchRequest(esConfig.getIndexName());
        //按照更新时间排序
        FieldSortBuilder fsb = SortBuilders.fieldSort("createTime");
        fsb.order(SortOrder.DESC);
        sourceBuilder.sort(fsb);
        sourceBuilder.query(boolBuilder);
        sourceBuilder.trackTotalHits(true);
        searchRequest.source(sourceBuilder);
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        List<Map<String, Object>> result = setSearchResponse(response);
        log.info("查询响应:{}", result);
        List<OrderQueryRespVO> list = new ArrayList<>();
        for (Map<String, Object> stringObjectMap : result) {
            OrderQueryRespVO vo = MapToBean(stringObjectMap, OrderQueryRespVO.class);
            //做状态映射
            vo.setStatusValue(cast(vo.getStatus()));
            list.add(vo);
        }
        Map<String, Object> map = new HashMap<>(4);
        map.put("list", list);
        map.put("total", response.getHits().getTotalHits().value);
        return map;
    }

    /**
     * 查询结果转map
     */
    private List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse) {
        ArrayList<Map<String, Object>> list = new ArrayList<>();
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            list.add(sourceAsMap);
        }
        return list;
    }


    /**
     * map转对象
     */
    public static <T> T MapToBean(Map<String, ?> map, Class<T> clazz) {
        try {
            T bean = clazz.newInstance();
            BeanUtils.populate(bean, map);
            return bean;
        } catch (Exception e) {
            log.error("map转对象异常");
        }
        return null;
    }


    /**
     * @param status 任务驱动使用的状态
     * @return 展示给页面的状态
     */
    public String cast(Integer status) {
        //待审核
        if (OrderStateEnum.初始化.getCode().equals(status) ||
                OrderStateEnum.待决策.getCode().equals(status)) {
            return OrderStateVOEnum.待审核.getValue();
        }
        //机核中
        if (OrderStateEnum.决策中.getCode().equals(status)) {
            return OrderStateVOEnum.机核中.getValue();
        }
        //电核中
        if (OrderStateEnum.待人工审核.getCode().equals(status) ||
                OrderStateEnum.人工审核中.getCode().equals(status)) {
            return OrderStateVOEnum.电核中.getValue();
        }
        //审核通过
        if (OrderStateEnum.审核通过.getCode().equals(status)) {
            return OrderStateVOEnum.审核通过.getValue();
        }
        //审核拒绝
        if (OrderStateEnum.审核拒绝.getCode().equals(status)) {
            return OrderStateVOEnum.审核拒绝.getValue();
        }
        //外部取消
        if (OrderStateEnum.已取消.getCode().equals(status)) {
            return OrderStateVOEnum.外部取消.getValue();
        }
        return OrderStateVOEnum.机核挂起.getValue();
    }


}

组合查询

现实的查询需求从来都没有那么简单；它们需要在多个字段上查询多种多样的文本，并且根据一系列的标准来过滤。为了构建类似的高级查询，你需要一种能够将多查询组合成单一查询的查询方法。

你可以用 bool 查询来实现你的需求。这种查询将多查询组合在一起，成为用户自己想要的布尔查询(Bool)。

它接收以下参数：

1.must
文档 必须 匹配这些条件才能被包含进来。

相当于sql中的 and

2.must_not
文档 必须不 匹配这些条件才能被包含进来。

相当于sql中的 not

3.should
如果满足这些语句中的任意语句，将增加 _score ，否则，无任何影响。它们主要用于修正每个文档的相关性得分。

相当于sql中的or

4.filter
必须 匹配，但它以不评分、过滤模式来进行。这些语句对评分没有贡献，只是根据过滤标准来排除或包含文档。

每一个子查询都独自地计算文档的相关性得分。一旦他们的得分被计算出来， bool 查询就将这些得分进行合并并且返回一个代表整个布尔操作的得分score。\

示例:下面的查询用于查找 title 字段匹配 how to make millions 并且不被标识为 spam 的文档。那些被标识为 starred 或在2014之后的文档，将比另外那些文档拥有更高的排名。如果 两者 都满足，那么它排名将更高：
 

{
    "bool": {
        "must":     { "match": { "title": "how to make millions" }},
        "must_not": { "match": { "tag":   "spam" }},
        "should": [
            { "match": { "tag": "starred" }},
            { "range": { "date": { "gte": "2014-01-01" }}}
        ]
    }
}

java

   BoolQueryBuilder defaultQueryBuilder = QueryBuilders.boolQuery();
        defaultQueryBuilder.must(QueryBuilders.matchQuery("title", "how to make millions"))
                .mustNot(QueryBuilders.matchQuery("tag", "span"))
                .should(QueryBuilders.matchQuery("tag", "starred"))
                .should(QueryBuilders.rangeQuery("date").gte("2014-01-01"));

filter用法

{
    "bool": {
        "must":     { "match": { "title": "how to make millions" }},
        "must_not": { "match": { "tag":   "spam" }},
        "should": [
            { "match": { "tag": "starred" }}
        ],
        "filter": {
          "range": { "date": { "gte": "2014-01-01" }} 
        }
    }
}

filter中的条件不参与评分score排序

马克Markorg
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ES如何创建索引
Lucy619_的博客
01-08 2万+
环境 环境：ES 6.8.10 os：Centos 7.8.2003 (Core) 创建索引 1、创建新的索引（index） PUT indexTest001 2、索引设置 ES 默认提供了好多索引配置选项，参考https://www.elastic.co/guide/en/elasticsearch/reference/5.6/index-modules.html 修改索引设置参考：https://blog.csdn.net/qq_15958689/article/details/79524291 3
es 创建索引 指定id_Elasticsearch创建索引流程
weixin_34677884的博客
12-30 1661
前言说明：本文章使用的ES版本是：6.7.0由此可知，在ES启动过程中，创建Node对象(new Node(environment))时，初始化了RestHandler，由其名字可以知道这是用来处理Rest请求的。在ES源码中，RestHandlerAction如下图：其中：admincluster：处理集群相关请求indices：处理索引相关请求cat：日常查询document：文档处理inge...
ES创建索引
qq_43720551的博客
06-11 1万+
在 Elasticsearch (ES) 中，创建索引可以通过 REST API 或者编程语言客户端实现。
ElasticSearch(二)— 索引和文档的管理操作
最新发布
敲代码的小小酥的博客
07-21 932
同样在检索文档的时候，它们也不会显示在结果中，所以它们一般都是在检索中以查询条件的形式出现，以减少检索时的性能开销。在上面的代码里，我们使用"fields"就把 name 字段扩充为多字段类型，为name 新增了两个子字段 raw 和 length，raw 设置类型为 keyword，length 设置类型为 token_count，告诉 es 这个字段在保存还需要做词频统计。所以对索引，GET 用来查看索引，PUT 用来创建索引，DELETE用来删除索引，还有一个 HEAD 请求，用来检验索引是否存在。
es添加索引命令行和浏览器添加索引--图文详解
冰恋云的专栏
07-22 2009
配置： /www/canal/adapter/conf/es7/mytest_user.yml。重启客户端（这里用的是canal客户端，同步的mysql数据库）
使用es必须要知道的一些知识点：索引篇_es创建索引
2401_84170623的博客
04-27 2189
无需分词的情况下，可以在Elasticsearch动态模板中，设置所有字符串数据都用"type": "keyword"来存储。举个例子，我们可以创建一个适当的动态模板规则。当Elasticsearch被用作大数据量存储中心时，尤其是从Mysql迁移数据进来的情况下，我们很多场景下其实无需对字符串分词，也就是说字符串存储不使用es中的。es数据底层存储的时候是按照json结构的，Map结构的数据存储到es，key是不固定的，随着数据量的扩张，key的数量可能超过1000，此时es会抛出异常。
ElasticSearch 中的中文分词器以及索引基本操作详解
2401_84046695的博客
04-23 1063
学习技术一定要制定一个明确的学习路线，这样才能高效的学习，不必要做无效功，既浪费时间又得不到什么效率，大家不妨按照我这份路线来学习。大家不妨直接在牛客和力扣上多刷题，同时，我也拿了一些面试题跟大家分享，也是从一些大佬那里获得的，大家不妨多刷刷题，为金九银十冲一波！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！转存中…(img-4EZBFMt2-1713837977700)]
深入Elasticsearch：索引的创建
西代零零发
06-02 931
为了深入学习Elasticsearch和Lucene，本文从Elasticsearch索引的创建过程入手，对Refresh和Flush两个重要的API做一个小实验。从而理解Elasticsearch在接收到一个文档后，是如何对其进行索引的。了解了整个流程，后续我们再深入学习Lucene索引的内存数据结构和磁盘文件格式。注：本文使用Elasticsearch和Kibana 7.10.2。 1.实验环境 1.1 创建索引 创建索引lucene-learning，设置shard数为1，关闭replica，同时关闭
elasticsearch新建索引
08-03
要Elasticsearch中创建一个新的索引，您需要按照以下步骤进行操作： 1. 首先，确保您已经安装并启动了Elasticsearch服务器。您还需要使用一个REST客户端，例如Kibana或Postman，以便与Elasticsearch进行交互。[1] ...
java连接ElasticSearch 8.2.3、新建索引、删除索引、填充数据
weixin_44307338的博客
07-04 2092
java连接ElasticSearch 8.2.3、新建索引、删除索引、填充数据，同步ES库与数据库数据
es创建索引（mapping和setting）
lixiaobai_boke的博客
03-31 914
es创建索引（mapping和setting）
es 新建索引
Kassadin-6d的博客
04-02 974
新建索引后 dac_db_test/test/_mappings post { “test”: { “properties”: { “server_name”: { “type”: “keyword”, “fields”: { “keyword”: { “ignore_above”: 256, “type”: “keyword” } } }, “suspicious_url”: { “type”:...
怎样合理创建es索引_ES（ElasticSearch） 索引创建
weixin_34626572的博客
12-24 3096
环境：ES 6.2.2os：Centos 7kibana:6.2.21、创建新的索引(index)PUT indexTest001结果：2、索引设置ES 默认提供了好多索引配置选项，参考https://www.elastic.co/guide/en/elasticsearch/reference/5.6/index-modules.html，这些配置选项都有经过优化的默认配置值，除非你非常清楚这...
ElasticSearch教程：创建索引的两种途径
学亮编程手记
08-19 4097
ES的索引库是一个逻辑概念，它包括了分词列表及文档列表，同一个索引库中存储了相同类型的文档。它就相当于MySQL中的表，或相当于。关于索引这个词语：索引（名词）：ES是基于Lucene构建的一个搜索服务，它要从索引库搜索符合条件索引数据。索引（动词）：索引库刚创建起来是空的，将数据添加到索引库的过程称为索引。下边介绍两种创建索引库的方法，它们的工作原理是相同的，都是客户端向ES服务发送命令。
es的基本操作（创建索引，添加数据，删除数据，判断索引是否存在）
weixin_51531777的博客
11-22 6577
1、创建索引+ik分词器 /** * 创建es索引 * $indexName 索引名称 */ public function createEsIndex($indexName) { $esClient = $this->esClient; $params = [ 'index' => $indexName,//索引名称 'body' => [
es索引的创建
热门推荐
lucky_ly的博客
05-09 2万+
es是一个分布式的文档数据库，索引的文档都是以json序列化形式存贮的，而不是像关系型数据库那样是列数据行的形式存贮的。 在es 7.0之前，常把es和关系型数据库的名词做如下映射 es mysql index (索引) datasource(数据库) type （类型） table mapping column document row es的index相当于关系数据库的数据库，而type 相当于表,mapping表示某个type的字段的定义，document这相当于表的每
ES-创建索引sql语句
caesar_shf的博客
05-15 1422
PUT index { "mappings": { "type": { "properties": { "text": { "id": "string", "name": "string", "nickName":"string", "skuCode":"string", "dimensionValues":"string", "stock":"string", "salesNum":"string" .
4 创建ES
jianjun200607的专栏
07-17 349
翻译地址：https://www.elastic.co/guide/en/elasticsearch/reference/current/setup.html 这个部分包含如下信息，如何安装ES以及让它运行，包括： 下载 安装 启动 配置 支持的平台
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值