ES简单使用

最新推荐文章于 2023-05-20 21:28:23 发布
最新推荐文章于 2023-05-20 21:28:23 发布
阅读量619 收藏
点赞数
文章标签： elasticsearch 大数据 big data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/javaambition/article/details/120994005
版权 
GET /bank/_search
{
  "query": { "match": { "address": "mill lane" } }
}

# 匹配address包含mill lane的
GET /bank/_search
{
  "query": {
    "match": {
      "address": "mill lane"
    }
  }, 
  "size": 5
}

# 配置address包含mill lane的 mill
# lane是一个整体不走分词
GET /bank/_search
{
  "query": {
    "match_phrase": {
      "address": "mill lane"
    }
  }
}

# 多字段匹配
GET /bank/_search
{
  "query": {
    "multi_match": {
      "query": "mill",
      "fields": ["state","address"]
    }
  }
}

# bool复合查询，must:必须，must_not必须不匹配，shoud  
#:应该匹配
GET /bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "age": "40"
          }
        }
      ],
      "must_not": [
        {
          "match": {
            "state": "ID"
          }
        }
      ],
      "should": [
        {
          "match": {
            "lastname": "Wallace"
          }
        }
      ]
    }
  }
}

# match_all:匹配所有,filter:过滤
GET /bank/_search
{
  "query": {
    "bool": {
      "must": [
        {"match_all": {}}
      ],
      "filter": {
        "range": {
          "balance": {
            "gte": 20000,
            "lte": 30000
          }
        }
      }
    }
  }
}


# 查询地址包含mill的分析出年龄分布，平均年龄，平均余
# size:0 不要记录只看分析结果
GET /bank/_search
{
  "query": {
    "match": {
      "address": "mill"
    }
  },
  "aggs": {
    "ageAGG": {
      "terms": {
        "field": "age"
      }
    },
    "aggAVG":{
      "avg": {
        "field": "age"
      }
    },
    "balance":{
      "avg": {
        "field": "balance"
      }
    }
  },
  "size": 0
}

# 新建索引
PUT /my_index
{
  "mappings": {
    "properties": {
      "age":{
        "type": "integer"
      },
      "email":{
        "type": "keyword"
      },
      "name":{
        "type": "text"
      }
    }
  }
}

# 添加字段并设置不可被索引
PUT /my_index/_mapping
{
  "properties":{
    "empId":{
      "type":"keyword",
      "index":false
    }
  }
}
GET /my_index/_search
# 插入数据put是指定id，post是自动生成id
# PUT /my_index/_doc/1
POST /my_index/_doc
{
  "empId":"2",
  "name":"edg",
  "email":"s11EDG",
  "age":11
}

# 修改数据,不填的字段会被置空?pretty不会影响其他字段
PUT /my_index/_doc/SjlRwHwBAoX3eHnJSU9q?pretty
{
  "name":"啥",
  "age":12
}

# 删除数据
DELETE /my_index/_doc/SjlRwHwBAoX3eHnJSU9q

# 对于已创建的字段映射不可以直接修改，
# 可以新建索引把旧数据迁移过去
# step 1
PUT /my_index1
{
  "mappings": {
    "properties": {
      "age": {
        "type": "integer"
      },
      "email": {
        "type": "text"
      },
      "name": {
        "type": "text"
      }
    }
  }
}
# step2
POST _reindex
{
  "source": {
    "index": "my_index"
  },
  "dest": {
    "index": "my_index1"
  }
}


# 默认是英文分词器，如果text为中文的话
# 就会分割成一个个汉字，需要自己的分词器
POST _analyze
{
  "analyzer": "standard",
  "text": "我是中国人"
}

POST _analyze
{
  "analyzer": "ik_max_word",
  "text": "我是中国人"
}

POST _analyze
{
  "analyzer": "ik_smart",
  "text": "我是中国人"
}


package com.ghl.es;

import com.alibaba.fastjson.JSON;
import com.ghl.es.config.ESConfig;
import com.ghl.es.config.EsConstant;
import com.ghl.es.model.Account;
import org.apache.lucene.util.ArrayUtil;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateRequestBuilder;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.ElasticsearchClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.ToXContent;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.*;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.index.reindex.UpdateByQueryRequest;
import org.elasticsearch.script.Script;
import org.elasticsearch.script.ScriptType;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.ParsedAggregation;
import org.elasticsearch.search.aggregations.bucket.nested.ParsedNested;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedLongTerms;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.AvgAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.ParsedAvg;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

@SpringBootTest
class EsdemoApplicationTests {

    @Resource
    private RestHighLevelClient client;

    /**
     * 匹配address包含mill lane的
     */
    @Test
    void test1() throws IOException {
        SearchRequest request = new SearchRequest();
        request.indices(EsConstant.PRODUCT_INDEX);

        SearchSourceBuilder builder = new SearchSourceBuilder();
        //builder.query(QueryBuilders.matchQuery("address","mill lane"));
        //如果不想分词就用短句匹配
        //builder.query(QueryBuilders.matchPhraseQuery("address","mill lane"));
        //可以多个字段都匹配
        //builder.query(QueryBuilders.multiMatchQuery("mill","address","state"));
        builder.query(QueryBuilders.termQuery("account_number",9));
        builder.size(5);

        request.source(builder);
        SearchResponse response = client.search(request, ESConfig.COMMON_OPTIONS);
        printData(response,Account.class);
        printDSL(builder);
    }

    /**
     * # bool复合查询，must:必须，must_not必须不匹配，shoud应该匹配
     */
    @Test
    void test2() throws IOException {
        SearchRequest request = new SearchRequest();
        request.indices(EsConstant.PRODUCT_INDEX);

        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.must(QueryBuilders.matchQuery("age",40));
        boolQuery.mustNot(QueryBuilders.matchQuery("state","ID"));
        boolQuery.should(QueryBuilders.matchQuery("lastname","Wallace"));
        builder.query(boolQuery);
        builder.size(5);

        request.source(builder);

        SearchResponse response = client.search(request, ESConfig.COMMON_OPTIONS);
        printData(response,Account.class);
        printDSL(builder);
    }

    /**
     * 匹配所有并过滤出余额在20000-30000的人
     */
    @Test
    void test3() throws IOException {
        SearchRequest request = new SearchRequest();
        request.indices(EsConstant.PRODUCT_INDEX);

        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.must(QueryBuilders.matchAllQuery());

        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("balance");
        rangeQuery.gte(20000);
        rangeQuery.lte(30000);

        boolQuery.filter(rangeQuery);

        builder.query(boolQuery);
        builder.size(5);

        request.source(builder);

        SearchResponse response = client.search(request, ESConfig.COMMON_OPTIONS);
        printData(response,Account.class);
        printDSL(builder);
    }

    /**
     *
     * 查询地址包含mill的分析出年龄分布，平均年龄，平均余额（
     * size:0 不要记录只看分析结果
     */
    @Test
    void test4() throws IOException{
        SearchRequest request = new SearchRequest();
        request.indices(EsConstant.PRODUCT_INDEX);

        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchQuery("address","mill"));
        builder.size(0);

        TermsAggregationBuilder aggAgg = AggregationBuilders.terms("ageAgg").field("age");
        aggAgg.subAggregation(AggregationBuilders.terms("numberAgg").field("account_number"));
        builder.aggregation(aggAgg);

        AvgAggregationBuilder aggAVG = AggregationBuilders.avg("aggAVG").field("age");
        builder.aggregation(aggAVG);

        AvgAggregationBuilder balanceAgg = AggregationBuilders.avg("balance").field("balance");
        builder.aggregation(balanceAgg);

        request.source(builder);
        SearchResponse response = client.search(request, ESConfig.COMMON_OPTIONS);
        printDSL(builder);
        printData(response,Account.class);
        printAGG(response);
    }

    /**
     * 添加数据单条
     */
    @Test
    void add() throws IOException {
        IndexRequest request = new IndexRequest(EsConstant.PRODUCT_INDEX);
        //如果id已经存在es将做修改操作
        request.id("1003");
        Account account = new Account();
        account.setAccount_number(1000);
        account.setAddress("河南省");
        account.setAge(22);
        account.setBalance(100000000);
        account.setCity("上海市");
        account.setEmail("201176170@qq.com");
        account.setEmployer("熊二");
        account.setFirstname("光头强");
        account.setLastname("熊大");
        account.setGender("男");
        account.setState("OK");
        String data = JSON.toJSONString(account);

        request.source(data,XContentType.JSON);
        IndexResponse index = client.index(request, ESConfig.COMMON_OPTIONS);
        System.out.println(request);
    }

    /**
     * 批量插入
     */
    @Test
    void bulkAdd() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        for (int i = 1028; i < 1058; i++) {
            IndexRequest request = new IndexRequest(EsConstant.PRODUCT_INDEX);
            //如果id已经存在es将覆盖原数据
            request.id(String.valueOf(i));
            Account account = new Account();
            account.setAccount_number(i);
            account.setAddress("俄罗斯"+i);
            request.source(JSON.toJSONString(account),XContentType.JSON);
            bulkRequest.add(request);
        }
        BulkResponse bulk = client.bulk(bulkRequest, ESConfig.COMMON_OPTIONS);
        if (bulk.hasFailures()){
            List<String> collect = Arrays.asList(bulk.getItems()).stream().map(item -> item.getId()).collect(Collectors.toList());
            System.out.println("插入失败的id");
            collect.forEach(System.out::println);
        }
    }

    /*
    单个删除
     */
    @Test
    void del() throws IOException {
        DeleteRequest request = new DeleteRequest();
        request.index(EsConstant.PRODUCT_INDEX);
        request.id("1002");
        DeleteResponse delete = client.delete(request, ESConfig.COMMON_OPTIONS);
        System.out.println(delete);
    }
    /*
    批量删除
     */
    @Test
    void batchDel1() throws IOException {
        DeleteByQueryRequest request = new DeleteByQueryRequest();
        request.indices(EsConstant.PRODUCT_INDEX);
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(QueryBuilders.matchQuery("address","俄罗斯"));

        request.setQuery(boolQueryBuilder);
        BulkByScrollResponse deleteByQuery = client.deleteByQuery(request, ESConfig.COMMON_OPTIONS);
        System.out.println(deleteByQuery);
        System.out.println("=");
        System.out.println(boolQueryBuilder);
    }

    /*
    单个修改
     */
    @Test
    void edit() throws IOException {
        UpdateRequest request = new UpdateRequest();
        request.index(EsConstant.PRODUCT_INDEX);
        request.id("1002");
        Account account = new Account();
        account.setAddress("河南");
        request.doc(JSON.toJSONString(account),XContentType.JSON);

        UpdateResponse update = client.update(request, ESConfig.COMMON_OPTIONS);
        System.out.println(update);
    }
    /*
    按条件修改
   */
    @Test
    void batchEdit() throws IOException {
        UpdateByQueryRequest request = new UpdateByQueryRequest(EsConstant.PRODUCT_INDEX);
        request.setQuery(QueryBuilders.matchQuery("address", "河南"));
        request.setScript(
                new Script(
                        ScriptType.INLINE, "painless",
                        "if (ctx._source.address == '河南') {ctx._source.address == '开封'}",
                        Collections.emptyMap()));
        client.updateByQuery(request,ESConfig.COMMON_OPTIONS);
    }



    private <T> void printData(SearchResponse esResponse, Class<T> classType){
        System.out.println("===========================================查询结果=======================================");
        SearchHit[] hits1 = esResponse.getHits().getHits();
        if ((hits1 == null || hits1.length == 0) || classType == null){
            System.out.println("没有查询到数据");
            return;
        }
        SearchHit[] hits = esResponse.getHits().getHits();
        List<T> modelList = null;
        if (hits != null && hits.length > 0){
            modelList = new ArrayList<>();
            for (SearchHit hit : hits) {
                String sourceAsString = hit.getSourceAsString();
                T t = JSON.parseObject(sourceAsString, classType);
                modelList.add(t);
            }
        }
        modelList.forEach(System.out::println);
    }
    private void printDSL(SearchSourceBuilder dsl){
        System.out.println("===========================================查询DSL=======================================");
        System.out.println(dsl.toString());
    }
    private void printAGG(SearchResponse response){
        System.out.println("===========================================解析聚合=======================================");
        Aggregations aggregations = response.getAggregations();
        Map<String, Aggregation> asMap = aggregations.getAsMap();
        for (Map.Entry<String, Aggregation> map : asMap.entrySet()) {
            recursionAgg(map.getKey(),map.getValue());
        }

    }

    private void recursionAgg(String name,Aggregation agg) {
        System.out.println("====================================="+name+"聚合==============================");
        String type = agg.getType();
        if ("avg".equalsIgnoreCase(type)){
            ParsedAvg parseAgg = (ParsedAvg) agg;
            double value = parseAgg.getValue();
            System.out.println(value);
        }else if ("lterms".equalsIgnoreCase(type)){
            ParsedLongTerms parseAgg = (ParsedLongTerms) agg;
            List<? extends Terms.Bucket> buckets = parseAgg.getBuckets();
            for (Terms.Bucket bucket : buckets) {
                Aggregations aggregations = bucket.getAggregations();
                if (aggregations != null){
                    System.out.println("----"+name+"子聚合");
                    Map<String, Aggregation> subAggs = aggregations.asMap();
                    for (Map.Entry<String, Aggregation> sub : subAggs.entrySet()) {
                        recursionAgg(sub.getKey(),sub.getValue());
                    }
                }
                System.out.println(bucket.getKeyAsString());
                System.out.println(bucket.getDocCount());
            }
        }else {
            System.out.println("...");
        }
    }
}
觅风丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ElasticSearch简单教程及简单使用案例
06-30
ElasticSearch简单教程及简单使用案例
elasticsearch-java api之搜索（二）——聚合
赶路人儿
12-06 1803
前面一篇文章描述了es一些基本搜索的用法（match、term、fruzzy、matchPhraseQuery等），这篇文章我们着重讲解一下聚合查询的用法。 假设es中有如下数据 1、group by /count： select team,count(*) from table group by team; 1）代码： public static void aggre1Quer
es searchResponse.getAggregations().get("xxx")用法
wwq_vracle的博客
07-31 1万+
这里分组根据时间字符串 SearchResponse searchResponse = client.prepareSearch("company") .addAggregation(AggregationBuilders.terms("group_country").field("country") .subAggregation(Aggregatio...
ElasticSearch - 聚合 aggs 详解
weixin_46742102的博客
09-29 5698
聚合概念 ElasticSearch除了致力于搜索之外，也提供了聚合实时分析数据的功能 如果把搜索比喻为大海捞针(从海量的文档中找出符合条件的那一个)，那麽聚合就是去分析大海中的针们的特性，像是 在大海里有多少针？ 针的平均长度是多少？ 按照针的製造商来划分，针的长度中位值是多少？ 每月加入到海中的针有多少？ 这里面有异常的针麽？ 因此透过聚合，我们可以得到一个数据的
Elasticsearch笔记（七）：聚合查询
热门推荐
布道
01-08 4万+
聚合框架有助于根据搜索查询提供聚合数据。聚合查询是数据库中重要的功能特性，ES作为搜索引擎兼数据库，同样提供了强大的聚合分析能力。它基于查询条件来对数据进行分桶、计算的方法。有点类似于 SQL 中的 group by 再加一些函数方法的操作。聚合可以嵌套，由此可以组成复杂的操作（Bucketing聚合可以包含sub-aggregation）。 聚合计算的值可以取字段的值，也可是脚本计算的结果。查...
Java之ES更新操作
清风自来
10-09 7714
下面记录来记录并分享ES相关操作： 单个文件更新实现方式如下所示： /** * create by wxy_jdhk */ public class ElasticSearchUtils { //更新方式1 public void updateDocumentOne(TransportClient client) { UpdateRequest updateRequest = new Up...
easy-ES框架使用，轻松操作查询Elasticsearch
最新发布
06-01
为了简化对ES的操作，开发者们设计了各种框架，其中"easy-ES"就是一个旨在使Elasticsearch操作更简单易用的框架。本文将详细介绍如何使用easy-ES来轻松地进行Elasticsearch的数据操作和查询。 ### 1. easy-ES框架...
java使用elasticsearch分组进行聚合查询过程解析
08-25
Java 使用 Elasticsearch 进行分组聚合查询过程解析 Java 使用 Elasticsearch 进行分组聚合查询是一个常见的需求，特别是在大数据处理和数据分析领域。Elasticsearch 提供了强大的聚合功能，可以对数据进行分组、...
springboot 集成elasticsearch ,api的使用
08-02
Spring Data Elasticsearch提供了一整套API来支持这些操作，使得与Elasticsearch的交互变得简单而高效。 总的来说，Spring Boot与Elasticsearch的集成使得开发者能够轻松地在Java应用中利用Elasticsearch的强大功能...
es 多字段聚合 in golang
WZP_LOVE的专栏
11-30 3855
前言 es中如何实现多字段聚合统计？类似于mysql的： select a,b from my_table grroup by a,b; golang如何借助第三方类oliver elastic实现es原生DSL（domain special language 特殊领域查询语言）的构造？ 正文 先来看单字段聚合统计的es原生DSL语句的写法： { "query": { "bool": { "must": [ { "query_stri
ES的使用
qq_46020806的博客
05-20 1949
5. 查询数据：ES提供了非常强大的查询功能，你可以使用各种查询语句来检索数据。例如，你可以使用match查询查找包含特定关键字的文档，也可以使用bool查询来组合多个条件进行查询。3. 创建索引：在ES中，所有的数据都是存储在索引中的。你可以使用ES提供的API创建一个新的索引，并定义其中包含的字段和类型。以上是一些常用的ES查询语句，当然ES还有很多其他的高级用法和查询方式，需要根据具体场景进行学习和掌握。6. 聚合数据：除了查询功能外，ES还提供了丰富的聚合功能，可以对搜索结果进行分组、分析和汇总。
ES的基本使用
pshdhx的博客
07-10 9432
elasticsearch的基础语法+聚合函数+IK分词器+java的API的高阶调用
（十）ES 入门教程
taoge512的博客
05-11 7592
本文为学习笔记，主要用于记录本人学习过程。部分内容为转载！！！！. 1、 ElasticSearch介绍 1.1 介绍 官方网址：https://www.elastic.co/cn/products/elasticsearch Github：https://github.com/elastic/elasticsearch 总结： 1、elasticsearch是一个基于Lucene的高扩展的分布式搜索服务器，支持开箱即用。 2、elasticsearch隐藏了Lucene的复杂性，对外提供Rest
ES快速入门
LIUHUA121的博客
10-12 3242
1 ES的基本信息 1基本概念： Relational DB Elasticsearch 数据库（database） 索引（indices） 表（tables） types 行（rows) documents 字段（columns） fields 2 ES的适用和不适用场景 2.1 ES适合
Elasticsearch入门系列03----ES简单操作
qq_46147786的博客
08-27 1956
ES作为一个索引及搜索服务，对外提供丰富的REST接口，快速入门部分的实例使用kibana来测试，目的是对ES的使用方法及流程有个初步的认识。
ElasticSearch基本使用
我们仍未知道那天所见花的名字,但是她的香味却留在我心间
08-21 2876
Elaticsearch，简称为es，es是一个，它可以近乎;本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据。es也使用lava开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的来隐藏Lucene的复杂性，从而让全文搜索变得简单。据国际权威的数据库产品评测机构DB Engines的统计，在2016年1月，ElasticSearch已超过Solr等，成为排名第一的搜索引擎类应用。它用于以及将这三者混合使用。
ES入门和简单使用
creaylei的小花园
06-23 595
遇见ElasticSeach
ES使用
jionli的博客
04-22 1730
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、ES介绍二、ES基本命令介绍1.命令介绍2.ES表结构创建3.ES命令使用3.1简单查询命令3.2组合查询布尔逻辑3.3 聚合查询总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、ES介绍 ES是一个基于RESTful web接口并且构建在Apa
elasticsearch简单使用
10-13
以下是elasticsearch的简单使用方法： 1. 安装elasticsearch：可以从官网下载并安装elasticsearch，也可以使用Docker等方式进行安装。 2. 启动elasticsearch：启动elasticsearch服务，可以使用命令行或者图形界面...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值