Elasticsearch（三）

最新推荐文章于 2024-08-07 23:51:53 发布
最新推荐文章于 2024-08-07 23:51:53 发布
阅读量453 收藏
点赞数
分类专栏： # 实用篇 文章标签： elasticsearch 搜索引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xcxcxcxx1/article/details/130693038
版权

Elasticsearch(三)

数据聚合

聚合的分类

文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations.html

聚合可以实现对文档数据的统计、分析、运算。聚合常见的有三类：

  • 桶聚合：用来对文档做分组

    • TermAggregation：按文档字段值分组
    • Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组

  • 度量聚合：可以计算一些值，比如：最大值、最小值、平均值等

    • Avg：求平均值
    • Max：求最大值
    • Min：求最小值
    • Stats：同时求max、min、avg、sum等

  • 管道聚合：其它聚合的结果为基础做聚合

DSL实现Bucket聚合

现在，我们要统计所有数据中的酒店品牌有几种，此时可以根据酒店品牌名称做聚合。类型为term类型，DSL示例：

GET /hotel/_search
{
  "size":0,  // 设置size为0，结果中不包含文档，只包含聚合结果
  "aggs": {  // 定义聚合
    "brandAgg": {  //给聚合起个名字
      "terms": {   //集合类型，按照品牌值聚合，所以选择term
        "field": "brand",  // 参与聚合的字段
        "size": 20 // 希望获取聚合结果数量
      }
    }
  }
}

Bucket聚合-聚合结果排序

默认情况下，Bucket聚合会统计Bucket的文档数量，记为_count，并且按照_count降序排序。

我们可以修改结果排序方式：

GET /hotel/_search
{
  "size":0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": {
          "_count": "asc" // 按照_count升序排序
        }
      }
    }
  }
}

Bucket聚合-限定聚合范围

默认情况下，Bucket聚合是对索引库的所有文档做聚合，我们可以限定要聚合文档范围，只要添加query条件即可：

GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "lte": 200 // 只对200元以下的文档聚合
      }
    }
  }, 
  "size":0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}

DSL实现Metrics聚合

例如，我们要求获取每个品牌的用户评分min、max、avg等值。

我们可以利用stats聚合：

GET /hotel/_search
{
  "size":0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20
      },
      "aggs": {
        "scoreAgg": {
          "stats": {
            "field": "score"
          }
        }
      }
    }
  }
}

对结果的平均值做排序

GET /hotel/_search
{
  "size":0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order":{
            "scoreAgg.avg": "desc" // 排序
          }
      },
      "aggs": {
        "scoreAgg": {
          "stats": {
            "field": "score"
          }
        }
      }
    }
  }
}

RestAPI实现聚合

img

解析聚合结果

img

案例：在IUserService中定义方法，实现对品牌、城市、星级的聚合

声明接口

Map<String, List<String>> filters();

实现

    @Override
    public Map<String, List<String>> filters(){
        // 1.准备Request
        SearchRequest request = new SearchRequest("hotel");
        request.source().size(0);
        request.source().aggregation(AggregationBuilders
                .terms("brandAgg")
                .field("brand")
                .size(100));
        request.source().aggregation(AggregationBuilders
                .terms("cityAgg")
                .field("city")
                .size(100));
        request.source().aggregation(AggregationBuilders
                .terms("starAgg")
                .field("starName")
                .size(100));
        SearchResponse search = null;
        Map<String,List<String>> map = new HashMap<>();
        try {
            search = client.search(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        List<String> brandList = getAggByName(search, "brandAgg");
        map.put("品牌",brandList);
        List<String> cityList = getAggByName(search, "cityAgg");
        map.put("城市",cityList);
        List<String> starList = getAggByName(search, "starAgg");
        map.put("星级",starList);
        return map;
    }

    private static List<String> getAggByName(SearchResponse search, String aggName) {
        Aggregations aggregations = search.getAggregations();
        Terms brandTerms = aggregations.get(aggName);
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        ArrayList<String> list = new ArrayList<>();
        for (Terms.Bucket bucket : buckets) {
            String key = bucket.getKeyAsString();
            list.add(key);
        }
        return list;
    }

对接前端

    @Override
    public Map<String, List<String>> filters(RequestParams params){
        // 1.准备Request
        SearchRequest request = new SearchRequest("hotel");
        buildBasicQuery(params, request);
        request.source().size(0);
        buildAggregation(request);
        SearchResponse search = null;
        Map<String,List<String>> map = new HashMap<>();
        try {
            search = client.search(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        List<String> brandList = getAggByName(search, "brandAgg");
        map.put("品牌",brandList);
        List<String> cityList = getAggByName(search, "cityAgg");
        map.put("城市",cityList);
        List<String> starList = getAggByName(search, "starAgg");
        map.put("星级",starList);
        return map;
    }

    private static void buildAggregation(SearchRequest request) {
        request.source().aggregation(AggregationBuilders
                .terms("brandAgg")
                .field("brand")
                .size(100));
        request.source().aggregation(AggregationBuilders
                .terms("cityAgg")
                .field("city")
                .size(100));
        request.source().aggregation(AggregationBuilders
                .terms("starAgg")
                .field("starName")
                .size(100));
    }

    private static List<String> getAggByName(SearchResponse search, String aggName) {
        Aggregations aggregations = search.getAggregations();
        Terms brandTerms = aggregations.get(aggName);
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        ArrayList<String> list = new ArrayList<>();
        for (Terms.Bucket bucket : buckets) {
            String key = bucket.getKeyAsString();
            list.add(key);
        }
        return list;
    }

    private static void buildBasicQuery(RequestParams params, SearchRequest request) {
        // 2.准备DSL
        // 构建BooleanQuery
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        // 关键字搜索
        String key = params.getKey();
        if (StringUtils.isBlank(key)) {
            boolQuery.must(QueryBuilders.matchAllQuery());
        } else {
            boolQuery.must(QueryBuilders.matchQuery("all", key));
        }
        // 城市条件
        if (params.getCity() != null && !params.getCity().equals("")) {
            boolQuery.filter(QueryBuilders.termQuery("city", params.getCity()));
        }
        // 品牌条件
        if (params.getBrand() != null && !params.getBrand().equals("")) {
            boolQuery.filter(QueryBuilders.termQuery("brand", params.getBrand()));
        }
        // 星级条件
        if (params.getStarName() != null && !params.getStarName().equals("")) {
            boolQuery.filter(QueryBuilders.termQuery("starName", params.getStarName()));
        }
        // 价格条件
        if (params.getMinPrice() != null && params.getMaxPrice() != null) {
            boolQuery.filter(QueryBuilders.rangeQuery("price").gte(params.getMinPrice()).lte(params.getMaxPrice()));
        }
        // 2.算分
        FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders
                .functionScoreQuery(boolQuery, new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
                        new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                QueryBuilders.termQuery("isAD",true),
                                ScoreFunctionBuilders.weightFactorFunction(10)
                        )
                });

        request.source().query(functionScoreQueryBuilder);
    }

自动补全

使用拼音分词器

官网：https://github.com/medcl/elasticsearch-analysis-pinyin

  • 解压
  • 上传到虚拟机中，elasticsearch的plugin目录
  • 重启es
  • 测试

自定义分词器

elasticsearch中分词器的组成包含三部分：

  • character filters：在tokenizer之前对文本进行处理。例如删除字符、替换字符
  • tokenizer：将文本按照一定的规则切割成词条。例如keyword，就是不分词；还有ik_smart
  • tokenizer filter：将tokenizer输出的词条做进一步处理。例如大小写转换、同义词处理、拼音处理等

img

可以通过创建索引库时，通过settings来配置自定义analyzer（分词器）：

img

// 自定义拼音分词器
PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": { 
        "my_analyzer": { 
          "tokenizer": "ik_max_word",
          "filter": "py"
        }
      },
      "filter": {
        "py": { 
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  }
}

拼音分词器适合在创建倒排索引的时候使用，但不能在搜索的时候使用。

img

因此字段在创建倒排索引时应该使用my_analyzer分词器；字段在搜索时应该使用ik_smart分词器

PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": { 
        "my_analyzer": { 
          "tokenizer": "ik_max_word",
          "filter": "py"
        }
      },
      "filter": {
        "py": { 
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "analyzer": "my_analyzer",
        "search_analyzer": "ik_smart"
      }
    }
  }
}

completion suggester查询

es提供了Completion Suggester查询来实现自动补全功能。这个查询会匹配以用户输入内容开头的词条并返回。为了提高补全查询效率，对于文档中字段的类型有一些约束：

  • 参与补全查询的字段必须时completion类型
  • 字段的内容一般是用来补全的多个词条形成的数组。

img

查询语法：

GET /test2/_search
{
  "suggest": {
    "titleSuggest": {
      "text": "s",
      "completion": {
        "field": "title",
        "skip_duplicates":true,
        "size":10
      }
    }
  }
}

案例：实现hotel索引库的自动补全、拼音搜索功能

1.修改hotel索引库，设置自定义拼音分词器

2.修改索引库的name、all字段、使用自定义分词器

3.索引库添加一个新字段suggestion，类型为completion类型，使用自定义分词器

4.给HotelDoc类添加suggestion类型，内容包含brand、business

5.重新导入数据到hotel库

PUT /hotel
{
  "settings": {
    "analysis": {
      "analyzer": {
        "text_anlyzer": {
          "tokenizer": "ik_max_word",
          "filter": "py"
        },
        "completion_analyzer": {
          "tokenizer": "keyword",
          "filter": "py"
        }
      },
      "filter": {
        "py": {
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "id":{
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "text_anlyzer",
        "search_analyzer": "ik_smart",
        "copy_to": "all"
      },
      "address":{
        "type": "keyword",
        "index": false
      },
      "price":{
        "type": "integer"
      },
      "score":{
        "type": "integer"
      },
      "brand":{
        "type": "keyword",
        "copy_to": "all"
      },
      "city":{
        "type": "keyword"
      },
      "starName":{
        "type": "keyword"
      },
      "business":{
        "type": "keyword",
        "copy_to": "all"
      },
      "location":{
        "type": "geo_point"
      },
      "pic":{
        "type": "keyword",
        "index": false
      },
      "all":{
        "type": "text",
        "analyzer": "text_anlyzer",
        "search_analyzer": "ik_smart"
      },
      "suggestion":{
          "type": "completion",
          "analyzer": "completion_analyzer"
      }
    }
  }
}

RestAPI实现自动补全

请求构造API：

img

结果解析

img

案例：实现酒店搜索页面输入框的自动补全

    @Override
    public List<String> getSuggestions(String prefix) {
        SearchRequest request = new SearchRequest("hotel");
        request.source().suggest(new SuggestBuilder().addSuggestion(
                "suggestions",
                SuggestBuilders.completionSuggestion("suggestion")
                        .prefix(prefix)
                        .skipDuplicates(true)
                        .size(10)
        ));
        SearchResponse search = null;
        try {
            search = client.search(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        Suggest suggest = search.getSuggest();
        CompletionSuggestion suggestions = suggest.getSuggestion("suggestions");
        List<String> list = new ArrayList<>();
        for (CompletionSuggestion.Entry.Option option : suggestions.getOptions()) {
            String text = option.getText().string();
            list.add(text);
        }
        return list;
    }

数据同步

数据同步问题分析

es中的酒店数据来自于mysql数据库，因此mysql数据发生改变时，es也必须跟着改变，这个就是es的数据同步

img

方案一：同步调用

  • 优点：实现简单，粗暴
  • 缺点：业务耦合度高

img

方案二：异步调用

  • 优点：低耦合，实现难度一般
  • 缺点：依赖mq的可靠性

img

方案三：监听binlog

  • 优点：完全解除服务间耦合
  • 缺点：开启binlog增加数据库负担、实现复杂度高

img

案例：利用MQ实现mysql与es数据同步

定义交换机，队列，routingkey的常量

package cn.itcast.hotel.constants;

/**
 * @author xc
 * @date 2023/5/12 13:06
 */
public class MqConstants {
    /**
     * 交换机
     */
    private final static String HOTEL_EXCHANGE = "hotel.topic";

    /**
     * 监听新增和修改的队列
     */
    private final static String HOTEL_INSERT_QUEUE = "hotel.insert.queue";

    /**
     * 监听删除的队列
     */
    private final static String HOTEL_DELETE_QUEUE = "hotel.delete.queue";

    /**
     * 新增或修改的RoutingKey
     */
    private final static String HOTEL_INSERT_KEY = "hotel.insert";
    /**
     * 删除key
     */
    private final static String HOTEL_DELETE_KEY = "hotel.delete";

}

声明exchange、queue、RoutingKey

package cn.itcast.hotel.config;

import cn.itcast.hotel.constants.MqConstants;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author xc
 * @date 2023/5/12 13:30
 */
@Configuration
public class MqConfig {
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(MqConstants.HOTEL_EXCHANGE,true,false);
    }

    @Bean
    public Queue insertQueue(){
        return new Queue(MqConstants.HOTEL_INSERT_QUEUE,true);
    }

    @Bean
    public Queue deleteQueue(){
        return new Queue(MqConstants.HOTEL_DELETE_QUEUE,true);
    }

    @Bean
    public Binding insertQueueBinding(){
        return BindingBuilder.bind(insertQueue()).to(topicExchange()).with(MqConstants.HOTEL_INSERT_KEY);
    }

    @Bean
    public Binding deleteQueueBinding(){
        return BindingBuilder.bind(deleteQueue()).to(topicExchange()).with(MqConstants.HOTEL_DELETE_KEY);
    }
}

发送消息

    @PostMapping
    public void saveHotel(@RequestBody Hotel hotel){
        hotelService.save(hotel);
        rabbitTemplate.convertAndSend(MqConstants.HOTEL_EXCHANGE,MqConstants.HOTEL_INSERT_KEY,hotel.getId());
    }

    @PutMapping()
    public void updateById(@RequestBody Hotel hotel){
        if (hotel.getId() == null) {
            throw new InvalidParameterException("id不能为空");
        }
        hotelService.updateById(hotel);
        rabbitTemplate.convertAndSend(MqConstants.HOTEL_EXCHANGE,MqConstants.HOTEL_INSERT_KEY,hotel.getId());

    }

    @DeleteMapping("/{id}")
    public void deleteById(@PathVariable("id") Long id) {
        hotelService.removeById(id);
        rabbitTemplate.convertAndSend(MqConstants.HOTEL_EXCHANGE,MqConstants.HOTEL_DELETE_KEY,id);

    }

监听消息

    @Override
    public void deleteById(Long id) {
        DeleteRequest request = new DeleteRequest("hotel",id.toString());
        try {
            client.delete(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void insertById(Long id) {
        Hotel hotel = getById(id);
        HotelDoc hotelDoc = new HotelDoc(hotel);
        IndexRequest request = new IndexRequest("hotel").id(hotel.getId().toString());
        request.source(JSON.toJSONString(hotelDoc), XContentType.JSON);
        try {
            client.index(request,RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

集群

ES集群结构

单机的elasticsearch做数据存储，必然面临两个问题：海量数据存储问题、单点故障问题。

  • 海量数据存储问题：检索库从逻辑上拆分为N个片，存储到多个节点
  • 单点故障问题：将分片数据在不同节点备份

部署es集群

我们会在单机上利用docker容器运行多个es实例来模拟es集群。不过生产环境推荐大家每一台服务节点仅部署一个es的实例。

部署es集群可以直接使用docker-compose来完成，但这要求你的Linux虚拟机至少有4G的内存空间

1.创建es集群

首先编写一个docker-compose文件，内容如下：

version: '2.2'
services:
  es01:
    image: elasticsearch:7.12.1
    container_name: es01
    environment:
      - node.name=es01
      - cluster.name=es-docker-cluster
      - discovery.seed_hosts=es02,es03
      - cluster.initial_master_nodes=es01,es02,es03
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    volumes:
      - data01:/usr/share/elasticsearch/data
    ports:
      - 9200:9200
    networks:
      - elastic
  es02:
    image: elasticsearch:7.12.1
    container_name: es02
    environment:
      - node.name=es02
      - cluster.name=es-docker-cluster
      - discovery.seed_hosts=es01,es03
      - cluster.initial_master_nodes=es01,es02,es03
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    volumes:
      - data02:/usr/share/elasticsearch/data
    ports:
      - 9201:9200
    networks:
      - elastic
  es03:
    image: elasticsearch:7.12.1
    container_name: es03
    environment:
      - node.name=es03
      - cluster.name=es-docker-cluster
      - discovery.seed_hosts=es01,es02
      - cluster.initial_master_nodes=es01,es02,es03
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    volumes:
      - data03:/usr/share/elasticsearch/data
    networks:
      - elastic
    ports:
      - 9202:9200
volumes:
  data01:
    driver: local
  data02:
    driver: local
  data03:
    driver: local

networks:
  elastic:
    driver: bridge

es运行需要修改一些linux系统权限，修改/etc/sysctl.conf文件

vi /etc/sysctl.conf

添加下面的内容：

vm.max_map_count=262144

然后执行命令，让配置生效：

sysctl -p

通过docker-compose启动集群：

docker-compose up -d

2.集群状态监控

kibana可以监控es集群，不过新版本需要依赖es的x-pack 功能，配置比较复杂。

这里推荐使用cerebro来监控es集群状态，官方网址：https://github.com/lmenezes/cerebro

img

访问http://localhost:9000 即可进入管理界面：

输入你的elasticsearch的任意节点的地址和端口，点击connect即可：

绿色的条，代表集群处于绿色（健康状态）。

img

3.创建索引库

1）利用kibana的DevTools创建索引库

在DevTools中输入指令：

PUT /itcast
{
  "settings": {
    "number_of_shards": 3, // 分片数量
    "number_of_replicas": 1 // 副本数量
  },
  "mappings": {
    "properties": {
      // mapping映射定义 ...
    }
  }
}
2）利用cerebro创建索引库

利用cerebro还可以创建索引库：

img

填写索引库信息：

img

点击右下角的create按钮：

4.查看分片效果

回到首页，即可查看索引库分片效果：

img

ES集群的节点角色

es中集群节点有不同的职责划分：

img

es中每个节点角色都有自己的不同职责，因此建议集群部署时，每个节点都有独立的角色。

img

ES集群的脑裂

默认情况下，每个节点都是master eligible节点，因此一旦master节点宕机，其他候选节点选举一个成为主节点。当主节点与其它节点网络故障时，可能发生脑裂问题。

为了避免脑裂，需要要求选票超过（eligible节点数量+1）/2才能当选为主，因此eligible节点数量最好是奇数。

ES集群的分布式存储

当新增文档时，应该保存到不同分片，保证数据均衡，那么coordinating node如何确定数据该存储到哪个分片呢？

es会通过hash算法来计算文档应该存储到哪个分片

img

说明：

  • _routing默认是文档id
  • 算法与分片数量有关，因此索引库一旦创建，分片数量不能修改

img

img

ES集群的故障转移

集群的master节点会监控集群中的节点状态，如果发现有节点宕机，会立即将宕机节点分片数据迁移到其它节点，确保数据安全，这个叫做故障转移。

img

xc6
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Go】elasticsearch + go-mysql-elasticsearch 实现中文分词、高亮效果
weixin_45685541的博客
05-14 754
引言 本文使用的开源项目库如下：1.MySQL数据实时同步到elasticsearch的工具库：https://github.com/go-mysql-org/go-mysql-elasticsearch 2.elasticsearch 中文分词插件：https://github.com/medcl/elasticsearch-analysis-ik 温馨提示：本文使用的是7.17.3版本的elasticsearch，故安装的IK分词器插件也是7.17.3版本的，小伙伴们可以根据自身elasticsea
微服务中java保存elasticSearch实例
Phor的博客
11-12 1602
微服务中java保存elasticSearch实例 微服务中java保存elasticSearch实例 场景： 商品服务：product elasticSearch服务：search 商品服务product需要存储的数据已经封装好了，通过feign调用search存储。 场景步骤带入 1 .封装好需要存储的结构 List<SkuEsModel> uoProducts 2.search服务配置 @Configuration public class GuilimallElasticSearc
Elasticsearch（二）
xcxcxcxx1的博客
05-14 949
文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html常见查询类型包括：查询所有：查询出所有数据，一般测试用。如：match_all全文检索查询：利用分词器对用户输入的内容分词，然后去倒排索引库中匹配。如精确查询：根据精确词条查找数据，一般是查找keyword、数值、日期、boolean等字符。地理查询：根据经纬度查询。复合查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。如。
ElasticSearch logo 分布式搜索引擎 ElasticSearch
weixin_30510153的博客
09-14 122
原文来自：http://www.oschina.net/p/elasticsearch Elastic Search 是一个基于Lucene构建的开源，分布式，RESTful搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。支持通过HTTP使用JSON进行数据索引。 ElasticSearch 提供多种语言的客户端 API： Java API — 1.x ...
Elasticsearch 分布式搜索引擎 -- RestClient操作索引库
天行健 君子以自强不息，地势坤 君子以厚德载物。
04-01 2459
Elasticsearch 分布式搜索引擎 -- RestClient操作索引库
Elasticsearch三节点集群搭建
weixin_41907960的博客
11-18 1343
Elasticsearch三节点集群搭建 1、Elasticsearch简介 Elasticsearch是一款近实时的分布式搜索、分析引擎，可以动态横向扩展以应对数据的增长。 2、Elasticsearch cluster 搭建 本文采用了三服务器节点，进行集群搭建（采用elasticsearch6.8版本） 172.29.136.30 172.29.136.31 192.29.136.32 其中30节点作为master-eligible部署,(考虑部分节点不可用，或者因为网络原因引发脑裂导致服务不可用，建
Elasticsearch三种分页方式
赶路人儿
10-13 8493
Elasticsearch中数据都存储在分片中，当执行搜索时每个分片独立搜索后，数据再经过整合返回。那么，如何实现分页查询呢？ 按照一般的查询流程来说，如果我想查询前10条数据： 客户端请求发给某个节点 节点将请求转发到集群其他节点，各节点返回是否包含该请求信息，然后该节点再发送二次请求给具体包含该query倒排的节点上进行计算，查询每个分片上的前10条 结果返回给节点，整合数据，提取前10条 返回给请求客户端 那么当我想要查询第10条到第20条的数据该怎么办呢？这个时候就用到分页查询了。在Ela
Es三节点+vip集群搭建部署方案
大雪冬至的博客
12-26 1931
! 解压后的文件目录结构 初始化Es用户 修改Es配置文件(必要的重点设置项) 官方参考： https://elasticsearch.bookhub.tech/set_up_elasticsearch/configuring_elasticsearch/ 重点配置设置： https://elasticsearch.bookhub.tech/set_up_elasticsearch/configuring_elasticsearch/import_elasticsearc
ElasticSearch官方测试数据
09-14
Elasticsearch（ES）是一种流行的开源全文搜索引擎，它基于Lucene库构建，被广泛用于大数据分析、日志聚合、实时搜索和索引等场景。官方提供的测试数据集是检验Elasticsearch功能、性能和稳定性的关键资源，可以帮助...
elasticsearch(es)
08-12
Elasticsearch（ES）是搜索和数据分析领域的技术栈中最流行的开源搜索引擎，它提供了实时搜索、数据分析、数据存储等功能。本文将介绍如何使用Docker容器部署Elasticsearch单点集群和Kibana可视化界面，以及安装IK...
elasticsearch 7.10
12-08
Elasticsearch 支持丰富的第三方插件，如 Kibana 用于数据可视化，Logstash 进行数据收集和预处理，Beats 用于轻量级数据发送等。7.10 版本可能对这些生态组件进行了升级，以更好地与 Elasticsearch 配合。 **10. ...
chrome浏览器插件elasticsearch
10-10
Chrome浏览器插件Elasticsearch（通常称为"es-head"）是一种强大的工具，它为开发者和数据分析师提供了在浏览器中直接访问和管理Elasticsearch实例的能力。这个插件提供了丰富的可视化界面，使得操作Elasticsearch...
ElasticSearch.zip
06-13
Elasticsearch（简称 ES）是一种基于 Lucene 的开源全文搜索引擎，被广泛应用于大数据分析、日志收集、实时搜索等领域。它的设计目标是分布式、可扩展、高可用且易用，支持RESTful API，使得与ES交互变得简单。 **...
【doghead】mac构建 2： player 端 clion构建
突围
08-04 86
fargo player in mac
Obsidian插件安装与开发
weixin_45411898的博客
08-02 905
obsidian插件安装和开发
【Git学习笔记】零基础入门学习Git
weixin_62533201的博客
08-04 1057
介绍了git的相关概念，如工作区、暂存区、版本库的区别，以及git版本管理操作，如撤销、修改、回退等操作，还介绍了git的分支管理、远程仓库、标签管理等操作
介绍ES全称Elasticsearch
最新发布
lw的博客
08-07 255
ES，全称Elasticsearch，是一个分布式的RESTful搜索和分析引擎，由Shay Banon在2010年发布。未来，ES可能会进一步优化其性能、扩展其功能，并与其他技术更加紧密地集成，以满足更加复杂和多样化的业务需求。总之，Elasticsearch是一个功能强大、灵活易用的分布式搜索和分析引擎，在日志分析、全文搜索、业务分析等领域具有广泛的应用前景。搜索和分析引擎：ES不仅提供高效的搜索功能，还支持对数据进行复杂分析。可扩展性：随着数据和查询量的增长，ES的分布式特性使其能够无缝扩展。
python 中 file.read(), file.readline()和file.readlines()区别和用法
weixin_51524504的博客
08-04 387
一次性读取整个文件的内容。返回一个包含文件所有内容的字符串。适用于小文件或需要将文件内容作为字符串处理的情况。逐行读取文件。每次调用返回一行。适用于大文件或需要逐行处理的情况。一次性读取文件中的所有行。返回一个包含每一行的列表。适用于小文件或需要将所有行存储到内存中处理的情况。
谷粒商城实战笔记-116-全文检索-ElasticSearch-进阶-filter过滤
epitomizelu的专栏
08-03 907
在Elasticsearch中，布尔查询（Boolean Query）除了包含mustmust_not和should子句之外，还有一个重要的子句叫做filter。filter子句在布尔查询中扮演着过滤的角色，用于指定文档必须满足的条件，在语义上，和must非常相近，但与must不同的是，filter子句不会影响文档的相关性得分（_score以下是filter过滤作用filter子句用于过滤结果，确保返回的文档集合满足特定的条件。不计分：与must不同，filter子句不会对文档的得分产生影响。
springboot集成es三种方式
03-16
1. 使用Spring Data Elasticsearch：Spring Data Elasticsearch是Spring Data家族的一员，提供了一套简单易用的API，可以方便地与Elasticsearch进行交互。只需要在pom.xml中添加相应的依赖，然后在代码中使用注解和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值