什么是ElastiSearch

壹：入门

一、新增数据

/coustomer/external/1 在coustomer索引下external类型中保留1号数据
1.POST:如果不指定id，会自动生成id，指定id就会修改没有就新增
2.PUT:必须指定id 不指定会报错，指定一般用于修改操作

二、查询数据

1.GET:/coustomer/external/1 查询id为1的数据

三、修改数据

1.PUT乐观锁做并发修改:每次修改_seq_no都会发生改变
2.PUT POST: 带_update 更新会对比源数据，如果没做改变，那么什么都不变
不带 _update 不会检查元数据

四、删除数据

1.DETELE:/coustomer/external/id删除为id的数据

贰：进阶

一、SearchAPI

ES支持两种检索：
1.一个是通过使用REST request uri 发送搜索数据（检索参数）

GET bank/_search?q=*&sort=number:asc

2.另一个是通过 REST request body来发送（请求体）

GET bank/_search
{
  "query": {
    "match_all": {}
  },
"sort":[
    {
      "number:asc"
    }
  ]
}

二、QueryDSL基本使用

match_all：

match全文检索 匹配查询
GET bank/_search
{
  "query": {
    "match": {
      "account_number": "20"
    }
  }
}
也可以模糊
GET bank/_search
{
  "query": {
    "match": {
      "address": "Kings"
    }
  }
}
match_phrase短语匹配
image.png
multi_match多字段匹配
image.png

bool复合查询：

加入多种条件

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "gender": "M"
          }
        },
        {
          "match": {
            "address": "mill"
          }
        }
      ],
      "must_not": [
        {
          "match": {
            "age": "30"
          }
        }
      ],
      "should": [
        {
          "match": {
            "lastname": "Wallace"
          }
        }
      ]
    }
  }
}
总结：must 必须满足 must_not 必须不满足 should 可以不满足也可以满足

filter

GET bank/_search
{
  "query": {
    " filter":{
      "range": {
        "age": {
          "gte": 10,
          "lte": 30
        }
      }
    }
  }
}
用filter过滤区间就不会如上查询获得相关性得分

term查询

term和match一样是查询
term不适合文本字段查询，精确数组查询推荐用term,文本字段检索推荐使用match
.keyword精准匹配 代表匹配文本字段的整个精确值(不分词匹配)

aggregations聚合

查出所有年龄分布，并且这些年龄中M的平均薪资和F的平均薪资以及这个年龄段的总体平均薪资

GET bank/_search
{
  "query": {"match_all": {}},
  "aggs": {
    "ageAgg": {
      "terms": {
        "field": "age",
        "size": 100
      },
      "aggs": {
        "genderAvg": {
          "terms": {
            "field": "gender.keyword",
            "size": 10
          },"aggs": {
            "genderBanlance": {
              "avg": {
                "field": "balance"
              }
            }
          }
        },
        "allBalanceAvg":{
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 0
}

mappings映射

可以在第一次保存数据前可以给索引指定映射，创建索引时指定映射

PUT /my_index
{
  "mappings":{
   "properties" : {
        "account_number" : {
          "type" : "long"
        }
    }
  }
}

数据迁移

老数据有Type的，需要指定type 没有的就不用指定

POST _reindex
{
  "source":{
      "index":"bank",
      "type" :"account"   
  },
  "dest":{
    "index":"newbank"
  }
}

分词

分词器自定义文字，减少检索时间
使用nginx配置分词器，
进入 ES的plugins 中修改 ik分词的配置

range 区间查询

GET /_search 
{
    "query":{
      "bool":{
          "filter":{
            "range":{
              "age":{
                  "gte": 0,
                  "lte":200
          }
        }
      }  
    }
  }

}

整合SpringBoot

一、导入依赖

        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.12.1</version>
        </dependency>

二、创建bean容器

@Configuration
public class GulimallElasticSearchConfig {

    public static final RequestOptions COMMON_OPTIONS;
    static {
        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
        COMMON_OPTIONS = builder.build();
    }

    @Bean
    public RestHighLevelClient esRestClint(){
        RestClientBuilder restClientBuilder = null;
         restClientBuilder = RestClient.builder(new HttpHost("192.168.56.22", 9200, "http"));
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(restClientBuilder);
        return restHighLevelClient;
    }
}

三、实现代码案例

package com.atguigu.gulimail.search;


import com.alibaba.fastjson.JSON;
import com.atguigu.gulimail.search.config.GulimallElasticSearchConfig;
import lombok.Data;
import lombok.ToString;
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.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class GulimailSearchApplicationTests {
    @Autowired
    RestHighLevelClient restHighLevelClient;
    @Data
    @ToString
     static class searchAs{
        private int account_number;
        private int balance;
        private String firstname;
        private String lastname;
        private int age;
        private String gender;
        private String address;
        private String employer;
        private String email;
        private String city;
        private String state;

    }

    @Test
    public void indexEs() throws IOException {
        IndexRequest indexRequest = new IndexRequest("user");
        indexRequest.id("1");
        User user = new User();
        user.setName("张三");
        user.setAddUrl("杭州市");
        String s = JSON.toJSONString(user);
        indexRequest.source(s, XContentType.JSON);
        IndexResponse index = restHighLevelClient.index(indexRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
        System.out.println(index.toString());
    }
    @Test
    public void search() throws IOException {
        //创建检索条件
        SearchRequest searchRequest = new SearchRequest();
        //指定索引
        searchRequest.indices("bank");
        //检索条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchQuery("address","Bristol"));
        TermsAggregationBuilder ageAgg = AggregationBuilders.terms("ageAgg").field("age").size(10);
        searchSourceBuilder.aggregation(ageAgg);
        searchRequest.source(searchSourceBuilder);
        //执行检索
        SearchResponse search = restHighLevelClient.search(searchRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
        //获取检索数据
        SearchHits hits = search.getHits();
        SearchHit[] hits1 = hits.getHits();
        for (SearchHit documentFields : hits1) {
            String sourceAsString = documentFields.getSourceAsString();
            searchAs searchAs = JSON.parseObject(sourceAsString, searchAs.class);
            System.out.println(searchAs.toString());
        }
        Aggregations aggregations = search.getAggregations();
        Terms terms = aggregations.get("ageAgg");
        List<? extends Terms.Bucket> buckets = terms.getBuckets();

    }
    @Data
    class User{
        private String name;
        private String addUrl;
    }
    @Test
    public void contextLoads() {
        System.out.println(restHighLevelClient);
    }

}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容