JAVA操作 ElasticSearch6.x 查询(内含中文测试数据)-阿里云开发者社区

准备工作

SmsLogs类

public class SmsLogs {
    private String id;// 唯一ID 1
    private Date createDate;// 创建时间
    private Date sendDate; // 发送时间
    private String longCode;// 发送的长号码
    private String mobile;// 下发手机号
    private String corpName;// 发送公司名称
    private String smsContent; // 下发短信内容
    private Integer state; // 短信下发状态 0 成功 1 失败
    private Integer operatorId; // '运营商编号 1 移动 2 联通 3 电信
    private String province;// 省份
    private String ipAddr; //下发服务器IP地址
    private Integer replyTotal; //短信状态报告返回时长（秒）
    private Integer fee;  // 费用
    public SmsLogs() {
    }
    public SmsLogs(String id, Date createDate, Date sendDate, String longCode, String mobile, String corpName, String smsContent, Integer state, Integer operatorId, String province, String ipAddr, Integer replyTotal, Integer fee) {
        this.id = id;
        this.createDate = createDate;
        this.sendDate = sendDate;
        this.longCode = longCode;
        this.mobile = mobile;
        this.corpName = corpName;
        this.smsContent = smsContent;
        this.state = state;
        this.operatorId = operatorId;
        this.province = province;
        this.ipAddr = ipAddr;
        this.replyTotal = replyTotal;
        this.fee = fee;
    }
getter()... setter()...
}

测试数据

public class TestData {
    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";
    /**
     * 创建索引
     * @throws IOException
     */
    @Test
    public void createSmsLogsIndex() throws IOException {
        //1. settings
        Settings.Builder settings = Settings.builder()
                .put("number_of_shards", 3)
                .put("number_of_replicas", 1);
        //2. mapping.
        XContentBuilder mapping = JsonXContent.contentBuilder()
                .startObject()
                .startObject("properties")
                .startObject("createDate")
                .field("type", "date")
                .endObject()
                .startObject("sendDate")
                .field("type", "date")
                .endObject()
                .startObject("longCode")
                .field("type", "keyword")
                .endObject()
                .startObject("mobile")
                .field("type", "keyword")
                .endObject()
                .startObject("corpName")
                .field("type", "keyword")
                .endObject()
                .startObject("smsContent")
                .field("type", "text")
                .field("analyzer", "ik_max_word")
                .endObject()
                .startObject("state")
                .field("type", "integer")
                .endObject()
                .startObject("operatorId")
                .field("type", "integer")
                .endObject()
                .startObject("province")
                .field("type", "keyword")
                .endObject()
                .startObject("ipAddr")
                .field("type", "ip")
                .endObject()
                .startObject("replyTotal")
                .field("type", "integer")
                .endObject()
                .startObject("fee")
                .field("type", "long")
                .endObject()
                .endObject()
                .endObject();
        //3. 添加索引.
        CreateIndexRequest request = new CreateIndexRequest(index);
        request.settings(settings);
        request.mapping(type, mapping);
        client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println("OK!!");
    }
    /**
     * 文档
     * @throws IOException
     */
    @Test
    public void addTestData() throws IOException {
        BulkRequest request = new BulkRequest();
        SmsLogs smsLogs = new SmsLogs();
        smsLogs.setMobile("13800000000");
        smsLogs.setCorpName("途虎养车");
        smsLogs.setCreateDate(new Date());
        smsLogs.setSendDate(new Date());
        smsLogs.setIpAddr("10.126.2.9");
        smsLogs.setLongCode("10690000988");
        smsLogs.setReplyTotal(10);
        smsLogs.setState(0);
        smsLogs.setSmsContent("【途虎养车】亲爱的张三先生/女士，您在途虎购买的货品(单号TH123456)已 到指定安装店多日，" + "现需与您确认订单的安装情况，请点击链接按实际情况选择（此链接有效期为72H）。您也可以登录途 虎APP进入" + "“我的-待安装订单”进行预约安装。若您在服务过程中有任何疑问，请致电400-111-8868向途虎咨 询。");
        smsLogs.setProvince("北京");
        smsLogs.setOperatorId(1);
        smsLogs.setFee(3);
        request.add(new IndexRequest(index, type, "21").source(mapper.writeValueAsString(smsLogs), XContentType.JSON));
        smsLogs.setMobile("13700000001");
        smsLogs.setProvince("上海");
        smsLogs.setSmsContent("【途虎养车】亲爱的刘红先生/女士，您在途虎购买的货品(单号TH1234526)已 到指定安装店多日，" + "现需与您确认订单的安装情况，请点击链接按实际情况选择（此链接有效期为72H）。您也可以登录途 虎APP进入" + "“我的-待安装订单”进行预约安装。若您在服务过程中有任何疑问，请致电400-111-8868向途虎咨 询。");
        request.add(new IndexRequest(index, type, "22").source(mapper.writeValueAsString(smsLogs), XContentType.JSON));
        // -------------------------------------------------------------------------------------------------------------------
        SmsLogs smsLogs1 = new SmsLogs();
        smsLogs1.setMobile("13100000000");
        smsLogs1.setCorpName("盒马鲜生");
        smsLogs1.setCreateDate(new Date());
        smsLogs1.setSendDate(new Date());
        smsLogs1.setIpAddr("10.126.2.9");
        smsLogs1.setLongCode("10660000988");
        smsLogs1.setReplyTotal(15);
        smsLogs1.setState(0);
        smsLogs1.setSmsContent("【盒马】您尾号12345678的订单已开始配送，请在您指定的时间收货不要走开 哦~配送员：" + "刘三，电话：13800000000");
        smsLogs1.setProvince("北京");
        smsLogs1.setOperatorId(2);
        smsLogs1.setFee(5);
        request.add(new IndexRequest(index, type, "23").source(mapper.writeValueAsString(smsLogs1), XContentType.JSON));
        smsLogs1.setMobile("18600000001");
        smsLogs1.setProvince("上海");
        smsLogs1.setSmsContent("【盒马】您尾号7775678的订单已开始配送，请在您指定的时间收货不要走开 哦~配送员：" + "王五，电话：13800000001");
        request.add(new IndexRequest(index, type, "24").source(mapper.writeValueAsString(smsLogs1), XContentType.JSON));
        // -------------------------------------------------------------------------------------------------------------------
        SmsLogs smsLogs2 = new SmsLogs();
        smsLogs2.setMobile("15300000000");
        smsLogs2.setCorpName("滴滴打车");
        smsLogs2.setCreateDate(new Date());
        smsLogs2.setSendDate(new Date());
        smsLogs2.setIpAddr("10.126.2.8");
        smsLogs2.setLongCode("10660000988");
        smsLogs2.setReplyTotal(50);
        smsLogs2.setState(1);
        smsLogs2.setSmsContent("【滴滴单车平台】专属限时福利！青桔/小蓝月卡立享5折，特惠畅骑30天。" + "戳 https://xxxxxx退订TD");
        smsLogs2.setProvince("上海");
        smsLogs2.setOperatorId(3);
        smsLogs2.setFee(7);
        request.add(new IndexRequest(index, type, "25").source(mapper.writeValueAsString(smsLogs2), XContentType.JSON));
        smsLogs2.setMobile("18000000001");
        smsLogs2.setProvince("武汉");
        smsLogs2.setSmsContent("【滴滴单车平台】专属限时福利！青桔/小蓝月卡立享5折，特惠畅骑30天。" + "戳 https://xxxxxx退订TD");
        request.add(new IndexRequest(index, type, "26").source(mapper.writeValueAsString(smsLogs2), XContentType.JSON));
        // -------------------------------------------------------------------------------------------------------------------
        SmsLogs smsLogs3 = new SmsLogs();
        smsLogs3.setMobile("13900000000");
        smsLogs3.setCorpName("招商银行");
        smsLogs3.setCreateDate(new Date());
        smsLogs3.setSendDate(new Date());
        smsLogs3.setIpAddr("10.126.2.8");
        smsLogs3.setLongCode("10690000988");
        smsLogs3.setReplyTotal(50);
        smsLogs3.setState(0);
        smsLogs3.setSmsContent("【招商银行】尊贵的李四先生,恭喜您获得华为P30 Pro抽奖资格,还可领100 元打" + "车红包,仅限1天");
        smsLogs3.setProvince("上海");
        smsLogs3.setOperatorId(1);
        smsLogs3.setFee(8);
        request.add(new IndexRequest(index, type, "27").source(mapper.writeValueAsString(smsLogs3), XContentType.JSON));
        smsLogs3.setMobile("13990000001");
        smsLogs3.setProvince("武汉");
        smsLogs3.setSmsContent("【招商银行】尊贵的李四先生,恭喜您获得华为P30 Pro抽奖资格,还可领100 元打" + "车红包,仅限1天");
        request.add(new IndexRequest(index, type, "28").source(mapper.writeValueAsString(smsLogs3), XContentType.JSON));
        // -------------------------------------------------------------------------------------------------------------------
        SmsLogs smsLogs4 = new SmsLogs();
        smsLogs4.setMobile("13700000000");
        smsLogs4.setCorpName("中国平安保险有限公司");
        smsLogs4.setCreateDate(new Date());
        smsLogs4.setSendDate(new Date());
        smsLogs4.setIpAddr("10.126.2.8");
        smsLogs4.setLongCode("10690000998");
        smsLogs4.setReplyTotal(18);
        smsLogs4.setState(0);
        smsLogs4.setSmsContent("【中国平安】奋斗的时代，更需要健康的身体。中国平安为您提供多重健康保 障，在奋斗之路上为您保驾护航。退订请回复TD");
        smsLogs4.setProvince("武汉");
        smsLogs4.setOperatorId(1);
        smsLogs4.setFee(5);
        request.add(new IndexRequest(index, type, "29").source(mapper.writeValueAsString(smsLogs4), XContentType.JSON));
        smsLogs4.setMobile("13990000002");
        smsLogs4.setProvince("武汉");
        smsLogs4.setSmsContent("【招商银行】尊贵的王五先生,恭喜您获得iphone 56抽奖资格,还可领5 元打" + "车红包,仅限100天");
        request.add(new IndexRequest(index, type, "30").source(mapper.writeValueAsString(smsLogs4), XContentType.JSON));
        // -------------------------------------------------------------------------------------------------------------------
        SmsLogs smsLogs5 = new SmsLogs();
        smsLogs5.setMobile("13600000000");
        smsLogs5.setCorpName("中国移动");
        smsLogs5.setCreateDate(new Date());
        smsLogs5.setSendDate(new Date());
        smsLogs5.setIpAddr("10.126.2.8");
        smsLogs5.setLongCode("10650000998");
        smsLogs5.setReplyTotal(60);
        smsLogs5.setState(0);
        smsLogs5.setSmsContent("【北京移动】尊敬的客户137****0000，5月话费账单已送达您的139邮箱，" + "点击查看账单详情 http://y.10086.cn/; " + " 回Q关闭通知，关注“中国移动139邮箱”微信随时查账单【中国移动 139邮箱】");
        smsLogs5.setProvince("武汉");
        smsLogs5.setOperatorId(1);
        smsLogs5.setFee(4);
        request.add(new IndexRequest(index, type, "31").source(mapper.writeValueAsString(smsLogs5), XContentType.JSON));
        smsLogs5.setMobile("13990001234");
        smsLogs5.setProvince("山西");
        smsLogs5.setSmsContent("【北京移动】尊敬的客户137****1234，8月话费账单已送达您的126邮箱，\" + \"点击查看账单详情 http://y.10086.cn/; \" + \" 回Q关闭通知，关注“中国移动126邮箱”微信随时查账单【中国移动 126邮箱】");
        request.add(new IndexRequest(index, type, "32").source(mapper.writeValueAsString(smsLogs5), XContentType.JSON));
        // -------------------------------------------------------------------------------------------------------------------
        client.bulk(request,RequestOptions.DEFAULT);
        System.out.println("OK!");
    }
}

term & terms查询

term查询 ：term是代表完全匹配，也就是精确查询，搜索前不会再对搜索词进行分词，所以我们的搜索词必须是文档分词集合中的一个

from：从哪开始查 size：返回几条结果 比如这里精确查找省份

from 与 size 之和不能超过10000

通过JAVA操作看一下上图的结构，在java中操作，最终我们要获取到 hists ——> hits ——> _source中的数据

public class DemoThree {
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";
    /**
     * 使用term方式查询
     * @throws IOException
     */
    @Test
    public void TermQuery() throws IOException {
        //获取request对象
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.from(0);
        builder.size(3);
        builder.query(QueryBuilders.termQuery("province","北京"));
        request.source(builder);
        //执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //获取_source的数据，并展示
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit searchHit: hits) {
            Map<String, Object> result = searchHit.getSourceAsMap();
            System.out.println(result);
        }
    }
}

terms查询

和term查询一样，搜索前不会再对搜索词进行分词，但是可以查询多个

@Test
    public void TermsQuery() throws IOException {
        //获取Request对象
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.from(0);
        builder.size(10);
        builder.query(QueryBuilders.termsQuery("province","山西","北京"));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            Map<String, Object> result = hit.getSourceAsMap();
            System.out.println(result);
        }
    }

match查询

match查询属于高层查询，它会根据查询字段类型的不同，采用不同的查询方式。

查询的如果是日期或者数值，它会把基于字符串查询的内容转换为日期或者数值对待。
如果查询的内容是不能被分词的内容（keyword），match查询不会对你指定的查询关键字进行分词。
如果查询的内容是可以被分词的内容（text），match会将指定的查询内容根据一定方式进行分词，去分词库中匹配指定的内容。

macth_all查询 : 查询全部内容，不指定任何查询条件

/**
     * matchAll
     * @throws IOException
     */
    @Test
    public void matchAllQuery() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchAllQuery());
        // 默认只显示10条数据，想查询更多，需要设置size
        //builder.size(20);
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            Map<String, Object> result = hit.getSourceAsMap();
            System.out.println(result);
        }
    }

match查询

/**
     * match查询
     * @throws IOException
     */
    @Test
    public void matchQuery() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchQuery("smsContent","收获安装"));
        // 默认只显示10条数据，想查询更多，需要设置size
        //builder.size(20);
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            Map<String, Object> result = hit.getSourceAsMap();
            System.out.println(result);
        }
    }

布尔match查询

布尔match就是里面加上query和operator这两个进行指定信息；query用于指定查询内容；operator用于指定是and还是or

/**
     * booleanMatch查询
     * @throws IOException
     */
    @Test
    public void booleanMatchQuery() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //Operator.AND   Operator.OR
        builder.query(QueryBuilders.matchQuery("smsContent","中国 健康").operator(Operator.AND));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            Map<String, Object> result = hit.getSourceAsMap();
            System.out.println(result);
        }
    }

multi_match查询:查询为能在多个字段上反复执行相同查询提供了一种便捷方式

/**
     * multiMatch查询
     * @throws IOException
     */
    @Test
    public void MultiMatchQuery() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //多字段
        builder.query(QueryBuilders.multiMatchQuery("北京","province","smsContent"));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            Map<String, Object> result = hit.getSourceAsMap();
            System.out.println(result);
        }
    }

id & ids 查询

在kibana中操作如下

对应的在java中通过id查询

@Test
    public void idSearch() throws IOException {
        GetRequest request = new GetRequest(index,type,"21");
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        System.out.println(response.getSourceAsMap());
    }

ids查询类似mysql中的 where id in(id1,id2.....)

@Test
    public void idsSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.idsQuery().addIds("21","22","23"));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

prefix查询

通过一个关键字去指定一个Field的前缀，从而查询到指定的文档

@Test
    public void prefixSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.prefixQuery("corpName","途虎"));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

fuzzy查询

模糊查询通过kibana可以看到，虽然把 "盒马鲜生" 写错了，但是也可以查到 prefix_length表示前多少个字符不能出错

@Test
    public void fuzzySearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.fuzzyQuery("corpName","盒马先生").prefixLength(2));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

wildcard查询

通配查询，查询时在字符串中指定通配符* 和占位符？

@Test
    public void wildCardSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.wildcardQuery("corpName","中国*"));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

range查询

范围查询，只针对数值类型，对某一个field进行大于或者小于的指定

@Test
    public void rangeSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //gt >  gte >=   lt <  lte <=
        builder.query(QueryBuilders.rangeQuery("fee").gt(5).lte(10));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

regexp查询：通过正则表达式匹配内容

上文提到的 prefix、fuzzy、wildcard以及这里的regexp查询效率都比较低，要求效率比较高时尽量避免使用。

@Test
    public void regexpSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.regexpQuery("mobile","180[0-9]{8}"));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

深分页scroll查询

将用户指定的关键进行分词
将词汇到分词库中进行检索，得到多个文档的id
把文档id存放在es上下文中
根据指定的size检索指定的数据，拿完数据的文档id，会从上下文中移除
如果需要下一页数据，会直接从es上下文中找后续内容
循环4和5

初始搜索请求和随后的每个滚动请求都返回 scroll_id。虽然_scroll_id在请求之间可能会改变，但它并不总是改变——在任何情况下，应该只使用最近接收到的 scroll_id。

查询下一页数据

删除scroll在上下文中的数据

通过java操作代码

@Test
    public void scrollSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //指定scroll信息
        //指定scroll生存时间
        request.scroll(TimeValue.MINUS_ONE);
        //指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.size(4);
        builder.sort("fee", SortOrder.DESC);
        builder.query(QueryBuilders.matchAllQuery());
        request.source(builder);
        //获取返回结构scrollId,source
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        String scrollId = response.getScrollId();
        System.out.println("-----首页-----");
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
        while (true){
            //循环 创建SearchScrollRequest   指定scrollId
            SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);
            //指定scrollId生存时间
            scrollRequest.scroll(TimeValue.MINUS_ONE);
            //执行查询获取返回结果
            SearchResponse searchResponse = client.scroll(scrollRequest, RequestOptions.DEFAULT);
            //判断是否查询到了数据，输出
            SearchHit[] hits = searchResponse.getHits().getHits();
            if (hits != null && hits.length > 0){
                System.out.println("----下一页----");
                for (SearchHit hit : hits) {
                    System.out.println(hit.getSourceAsMap());
                }
            }else{
                //判断没有查到数据，退出循环
                System.out.println("----结束----");
                break;
            }
        }
        //创建clearScrollRequest
        ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
        //指定scrollId
        clearScrollRequest.addScrollId(scrollId);
        //删除
        ClearScrollResponse clearScrollResponse = client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);
        System.out.println("删除scroll:"+clearScrollResponse.isSucceeded());
    }

复合查询

bool查询

复合过滤器，将多个查询条件，以一定的逻辑组合在一起

must 所有的条件，用must组合在一起，表示And的意思
must_not must_not中的条件全部都不匹配，表示Not的意思
should 所有的条件用should组合在一起，表示 Or 的意思

@Test
    public void boolSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.should(QueryBuilders.termQuery("province","武汉"));
        boolQueryBuilder.should(QueryBuilders.termQuery("province","北京"));
        boolQueryBuilder.mustNot(QueryBuilders.termQuery("operatorId","2"));
        boolQueryBuilder.must(QueryBuilders.matchQuery("smsContent","中国"));
        boolQueryBuilder.must(QueryBuilders.matchQuery("smsContent","平安"));
        builder.query(boolQueryBuilder);
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

boosting查询

boosting查询可以帮助我们影响查询后的score

positive：只有匹配上positive的内容，才会被放入结果集中
negative：如果匹配上positive并且也匹配上negative，就可以降低这样的文档分数
negative_boost：指定系数，必须小于1

关于查询时，分数如何计算：

搜索的关键字在文档中出现频次越高则分数越高
指定的文档内容越短，则分数越高
搜索时，指定的关键字被分词，被分词的内容与分词库匹配的个数越多，则分数越高

@Test
    public void boostingSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoostingQueryBuilder boostingQueryBuilder = QueryBuilders.boostingQuery(
                QueryBuilders.matchQuery("smsContent", "收获安装"),
                QueryBuilders.matchQuery("smsContent", "刘红")
        ).negativeBoost(0.5f);
        builder.query(boostingQueryBuilder);
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

filter查询

filter根据查询条件去查询文档，不计算分数，会对经常被过滤的数据进行缓存

先看一下kibana中

@Test
    public void filterSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.filter(QueryBuilders.termQuery("corpName","盒马鲜生"));
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("fee").lte("5"));
        builder.query(boolQueryBuilder);
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

高亮查询

用户输入的关键字，以一定的特殊样式展示，es会提供一个highlight属性，和query同级别

fragment_size：指定高亮数据展示多少个字符
fields：指定哪几个field高亮显示
pre_tags：指定前缀标签举个例子<font color="red">
post_tags：指定后缀标签举例</font>

@Test
    public void highLightSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchQuery("smsContent","盒马"));
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("smsContent",10).preTags("<font color='orange'>").postTags("</font>");
        builder.highlighter(highlightBuilder);
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getHighlightFields().get("smsContent"));
        }
    }

聚合查询

去重计数统计

Cardinality 即不重复的字段有多少（相当于sql中的distinct）

@Test
    public void cardinality() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.aggregation( AggregationBuilders.cardinality("agg").field("province"));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        Cardinality cardinality = response.getAggregations().get("agg");
        System.out.println(cardinality.getValueAsString());
    }

范围统计

统计一定范围内出现的文档个数，比如：针对某一个field的值在0-100,200-300之间文档出现的个数分别是多少。

范围统计可以针对普通的数值，针对时间类型，针对ip类型都可以做相应统计（range、date_range、ip_range）

@Test
    public void rangeCountSearch() throws IOException {
         SearchRequest request = new SearchRequest(index);
         request.types(type);
         SearchSourceBuilder builder = new SearchSourceBuilder();
         builder.aggregation(AggregationBuilders.range("agg").field("fee")
                             .addUnboundedTo(5)
                             .addRange(5,10)
                             .addUnboundedFrom(10));
         request.source(builder);
         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
         Range agg = response.getAggregations().get("agg");
         for (Range.Bucket bucket : agg.getBuckets()) {
             String key = bucket.getKeyAsString();
             Object from = bucket.getFrom();
             Object to = bucket.getTo();
             long docCount = bucket.getDocCount();
             System.out.println(String.format("key:%s,from:%s,to:%s,docCount:%s",key,from,to,docCount));
         }
     }

统计聚合查询

@Test
    public void extendedSearch() throws IOException {
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.aggregation(AggregationBuilders.extendedStats("agg").field("fee"));
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        ExtendedStats agg = response.getAggregations().get("agg");
        double max = agg.getMax();
        double min = agg.getMin();
        System.out.println(String.format("max:%s,min:%s",max,min));
    }

更多的聚合查询可以去查看官方文档

地图经纬度搜索

es支持两种类型的地理数据

geo_point 支持经纬度
geo_shape 支持点、线、圆、多边形、多面体等

#创建一个索引，指定一个name,location
PUT /map
{
  "settings": {
    "number_of_shards": 5, 
    "number_of_replicas": 1
  },
  "mappings": {
    "map": {
      "properties": {
        "name": {
          "type": "text"
        },
        "location": {
          "type": "geo_point"
        }
      }
    }
  }
}

#添加测试数据
PUT /map/map/1
{
  "name": "合肥野生动物园",
  "location": {
    "lon": 117.174075,
    "lat": 31.840982
  }
}
PUT /map/map/2
{
  "name": "大蜀山",
  "location": {
    "lon": 117.183561,
    "lat": 31.847116
  }
}

该组中的查询方式有：

geo_shape ：查找具有与指定几何形状相交，包含在其中或不与指定几何形状相交的几何形状的文档
geo_bounding_box ：查找具有落入指定矩形的地理位置的文档。
geo_distance ： 查找地理点在中心点指定距离内的文档。（比如点外卖，选3km以内卖家）
geo_polygon ： 查找具有指定多边形内的地理点的文档。

使用java操作

@Test
    public void geoSearch() throws IOException {
        SearchRequest request = new SearchRequest("map");
        request.types("map");
        SearchSourceBuilder builder = new SearchSourceBuilder();
        GeoDistanceQueryBuilder location = QueryBuilders.geoDistanceQuery("location");
        location.point(31.840982,117.174075);
        location.distance("3000");
        builder.query(location);
        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

JAVA操作 ElasticSearch6.x 查询(内含中文测试数据)

准备工作

term & terms查询

match查询

id & ids 查询

prefix查询

fuzzy查询

wildcard查询

range查询

regexp查询：通过正则表达式匹配内容

深分页scroll查询

复合查询

filter查询

高亮查询

聚合查询

地图经纬度搜索

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

JAVA操作 ElasticSearch6.x 查询(内含中文测试数据)

准备工作

term & terms查询

match查询

id & ids 查询

prefix查询

fuzzy查询

wildcard查询

range查询

regexp查询：通过正则表达式匹配内容

深分页scroll查询

复合查询

filter查询

高亮查询

聚合查询

地图经纬度搜索

热门文章

最新文章

相关课程

相关电子书

相关实验场景