elasticsearch基础大全

已于 2024-02-20 21:51:54 修改
阅读量243 收藏
点赞数
文章标签： elasticsearch 大数据 搜索引擎
于 2021-04-20 16:48:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaobo5264063/article/details/114680902
版权

                                            elasticsearch6版本

  • elasticsearch介绍 
  1.   介绍以及应用场景
     es是一个基于Lucene构建的开源的高扩展的分布式全文搜索引擎。 它可以在很短的时间内存储、搜索和分析大量的数据。
     支持简易的横向扩展，可以轻松地对服务进行扩/缩容，能够扩展至数以百计的服务器来存储以及处理PB级的数据。
     采用Java语言开发，通过简单的RESTful API来实现Lucene的复杂性操作。
     
    官网: Elasticsearch：官方分布式搜索和分析引擎 | Elastic
             https://www.elastic.co/cn/elasticsearch/features 
  2.   存储结构
     Elasticsearch是面向文档型数据库，一条数据在这里就是一个文档，用JSON作为文档序列化的格式，比如下面这条数据： 
    {
  "name":"张三",
  "age":28,
  "phone":"13111111111",
  "address":"安徽省合肥市"
}
    es与数据库对照
    elasticsearch数据库
    索引Index数据库Database
    类型Type表Table
    文档Document数据行Row
    字段Field数据列Column
  1.  正向索引 
     正排表是以文档的 ID 为关键字，记录文档中每个词的位置信息，查找时扫描表中每个文档中词的信息，直到找出所有包含查询关键字的文档。
     
    正向索引在建立索引的时候结构简单，方便维护，但是在查询时需对所有的文档进行扫描，且如果文档中对应的关键词过多，就会造成资源浪费，从而使检索时间过长，检索效率变低。
  2.  倒排索引 
     倒排表以字或词为关键字进行索引，表中关键词对应着出现这个词的所有文档，表中记录该文档的ID和字符在该文档中出现的位置情况。
          倒排索引由于每个字或词对应的文档数量在动态变化，所以倒排表的建立和维护都较为复杂，但是在查询的时候可以一次得到查询关键词所对应的所有文档，所以效率高于正排表。 
     
     es在保存文档时，默认情况下会保存两份内容，一份是_source  中的数据，另一份则是通过分词、排序等一系列过程生成的倒排索引文件，倒排索引中保存了词项和文档之间的对应关系。
    搜索时，当 es 接收到用户的搜索请求之后，就会去倒排索引中查询，通过的倒排索引中维护的倒排记录表找到关键词对应的文档集合，然后对文档进行评分、排序、高亮等处理，处理完成后返回文档。
     
  • 文档映射 
     
          文档映射就是给文档中的字段指定类型、分词器等属性。  
  1.   核心数据类型
     
    类别数据类型
    核心类型text，keyword，long， integer，short，byte，double，date，boolean等等
    复杂类型Object(单个json对象)，Nested(json对象数组)
    地理类型geo_point(纬度/经度)，geo_shape(多边形等复杂形状)
    专用类型ip，completion，token_count(令牌计算)，join(父子关系文档)，mapper_murmur3等等
    ............
     文档:  Field datatypes | Elasticsearch Guide [6.4] | Elastic
     
     字符串分为： 
            text：支持分词，但不能用来排序和聚合。 适用于新闻内容、产品描述等等。
            keyword：不支持分词，但可以被用来检索过滤、排序和聚合。适用于结构化的字段，例如标签、email、手机号码等等。
     
      
  • Elasticsearch中文分词
  1.  因为Elasticsearch中默认的标准分词器分词器对中文分词不是很友好，会将中文词语拆分成一个一个中文的汉子。因此引入中文分词器es-ik插件。
       
    
### 默认分词
 GET /source/_analyze
{
  "analyzer": "standard",
  "text": "床前明月光"
}
 
### 指定分词1
 GET /source/_analyze
{
  "analyzer": "ik_smart",
  "text": "床前明月光"
}

### 指定分词2
 GET /source/_analyze
{
  "analyzer": "ik_max_word",
  "text": "床前明月光"
}
  •   Elasticsearch数据操作
  1.  基本操作 
    #######1、创建索引
PUT /basic

#######2、查询索引
GET /basic

#######3、添加/编辑文档  方式: /索引/文档/id    编辑同样使用该方法
PUT /basic/user/1
{
  "name":"张三",
  "age":11,
  "phone":"13111111111",
  "address":"安徽省合肥市"
}

#######4、查询文档  方式: /索引/文档/id
GET /basic/user/1

#######5、查看文档类型
GET /basic/user/_mapping

#######6、查看文档对应的分片位置
GET _cat/shards/basic?v

#######7、删除索引
DELETE /basic

#######8、查看全部索引
GET _cat/indices

#######9、添加数据自动返回ID
POST /basic/user/
{
  "name":"李四",
  "age":22,
  "phone":"15222222222",
  "address":"上海市"
}
  2.   初始数据  
    PUT /source
#######设置文档类型
POST /source/_mapping/book
{
  "book":{
    "properties":{
       "author":{
         "type":"keyword"
       },
       "title":{
         "type":"text",
         "analyzer":"ik_max_word",
         "search_analyzer":"ik_max_word"
       },
       "content":{
         "type":"text",
         "analyzer":"ik_max_word",
         "search_analyzer":"ik_max_word"
       },
       "time":{
         "type":"date"
       },
       "price":{
         "type":"long"
       }
    }
  }
}

PUT /source/book/1
{
  "author":"李白",
  "title":"早发白帝城",
  "content":"朝辞白帝彩云间,千里江陵一日还,两岸猿声啼不住,轻舟已过万重山",
  "time":"2015-11-11",
  "price":11
}

PUT /source/book/2
{
  "author":"崔护",
  "title":"题都城南庄",
  "content":"去年今日此门中,人面桃花相映红,人面不知何处去,桃花依旧笑春风",
  "time":"2016-12-12",
  "price":22
}

PUT /source/book/3
{
  "author":"白居易",
  "title":"大林寺桃花",
  "content":"人间四月芳菲尽,山寺桃花始盛开,长恨春归无觅处,不知转入此中来",
  "time":"2016-12-12",
  "price":33
}
PUT /source/book/4
{
  "author":"李白",
  "title":"静夜思",
  "content":"床前明月光,疑是地上霜,举头望明月,低头思故乡",
  "time":"2017-07-07",
  "price":44
}

PUT /source/book/5
{
  "author":"贺知章",
  "title":"咏柳",
  "content":"碧玉妆成一树高，万条垂下绿丝绦。不知细叶谁裁出，二月春风似剪刀",
  "time":"2018-10-10",
  "price":55
}
     
  3. 查询与过滤 
    ES中的查询请求有两种方式，一种是简易版的URL查询，另一种是基于JSON的结构化查询（DSL）  
      URL查询 
    
#######1、查询所有数据
GET /source/book/_search

#######2、根据id集合查询
GET /source/book/_mget
{
  "ids":[1,2]  
}

#######3、查询价格为22的文档
GET /source/book/_search?q=price:22

#######4、查询价格在20-50的并排序
GET /source/book/_search?q=count[20 TO 50]&sort=price:desc

#######5、排序并分页查询
GET /source/book/_search?sort=price:desc&from=0&size=2

#######6、只展示name、age字段的属性值
GET /source/book/_search?&_source=title,author
     DSL语言 
    ###查询所有并排序
GET /source/book/_search
{
  "query": {
        "match_all": {}
  },
  "sort":{
    "count":"desc"
  }
}
###根据内容搜索  默认词与词是 or的关系
GET /source/book/_search
{
  "query": {
    "match": {
      "content": "春风桃花"
    }
  }
}
###根据内容搜索  设置词与词是 and 的关系
GET /source/book/_search
{
  "query": {
    "match": {
      "content": {
        "query": "春风桃花",
        "operator": "and"
      }
    }
  }
}
###指定多个查询字段条件
GET /source/book/_search
{
  "query": {
    "multi_match": {
      "query": "静夜思桃花",
      "fields": ["tite","content"]
    }
  }
}
###根据日期范围查询
GET /source/book/_search
{
  "query":{
    "range":{
      "time":{
        "gte":"2016-11-11",
        "lte":"2017-11-11"
      }
    }
  }
}
###根据id查询并分页
GET /source/book/_search
{
  "_source":["author","title"],
  "query":{
    "ids":{
      "values":[1,2,3]
    }
  },
	"from": 0,
	"size": 2
}


###must: 必须全部匹配  should: 可以匹配任意   must_not必须全部不匹配
###符合条件查询 查询作者是李白的且价格不在43-45之间   
GET /source/book/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "author": {
              "value": "李白"
            }
          }
        }
      ],
      "must_not": [
        {
          "range": {
            "price": {
              "gte": 43,
              "lte": 45
            }
          }
        }
      ],
      "should": [
        {
          "match": {
            "content": "春眠不觉晓"
          }
        }
      ]
    }
  }
}

###搜索结果高亮
POST /source/book/_search
{
    "query": {
        "match": {
            "content": "桃花春风"
        }
    },
    "highlight": {
        "pre_tags": [
            "<span>"
        ],
        "post_tags": [
            "</span>"
        ],
        "fields": {
            "content": {}
        }
    }
}

###分组查询  根据author统计文档数量 获取2条
 POST /source/book/_search
{
  "aggs":{
    "group_by_author_count":{
        "terms": {
          "field": "author",
          "size": 2
        }
    }
  }
}
###查询价格的最大值
GET /source/book/_search
{
  "aggs": {
    "max_price": {
      "max": {
        "field": "price"
      }
    }
  }
}
###查询价格的信息
POST /source/book/_search
{
  "aggs":{
    "book_count_info":{
        "stats": {
          "field": "price"
        }
    }
  }
}
###统计价格在20-50之间的所有数据count的平均值
POST /source/book/_search
{
  "aggs": {
    "NAME": {
      "filter": {
        "range": {
					"price": {
						"gt": 20,
						"lte": 50
					}
				}

      },
      "aggs": {
        "avg_price": {
          "avg": {
            "field": "price"
          }
        }
      }
    }
  }
}
 
###filter查询
GET /source/book/_search
{
	"query": {
		"bool": {
			"must": [{
				"match_all": {}
			}],
			"filter": {
				"range": {
					"price": {
						"gt": 21,
						"lte": 51
					}
				}
			}
		}
	},
	"from": 0,
	"size": 10,
	"_source": ["author", "title", "price"]
}
       ##match查询相当于模糊匹配,先分词在查询
       ##term是代表完全匹配，即不进行分词器分析，文档中必须包含整个搜索的词汇 
       https://www.elastic.co/guide/en/elasticsearch/reference/6.4/query-dsl.html   深入搜索 | Elasticsearch: 权威指南 | Elastic
  •   springboot整合elasticsearch
  1.   创建Springboot项目，pom.xml引入依赖 
     <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.5.RELEASE</version>
    <relativePath /> <!-- lookup parent from repository -->
  </parent>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
    </dependency>
  </dependencies>
  2.   application.yml配置如下
      
    server:
  port: 8001
  servlet:
    context-path: /es
spring:
  data:
    elasticsearch:
      ####集群名称
      cluster-name: elasticsearch
      ####集群节点  多个则以逗号隔开  192.168.2.117:9300,192.168.2.118:9300,192.168.2.119:9300
      cluster-nodes: 121.4.227.23:9300
      
  3.   创建实体类 BookEntity.java
      
    import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;

import java.util.Date;

@Data
@ApiModel
@Document(indexName = "source", type = "book")
public class BookEntity {

    @Id
    @ApiModelProperty(value = "id", name = "id", example = "101")
    private String id;
    @ApiModelProperty(value = "作者", name = "author", example = "柳宗元")
    private String author;
    @ApiModelProperty(value = "诗名", name = "title", example = "江雪")
    private String title;
    @ApiModelProperty(value = "内容", name = "content", example = "千山鸟飞绝,万径人踪灭,孤舟蓑笠翁,独钓寒江雪")
    private String content;
    @ApiModelProperty(value = "上线时间", name = "time", example = "2018-08-08")
    private Date time;
    @ApiModelProperty(value = "价格", name = "price", example = "100")
    private Integer price;
     indexName:索引名称
     type: 文档类型名称
      
  4.   创建UserDAO.java
      
    import com.basic.entity.BookEntity;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.annotations.Query;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

import java.util.List;

public interface BookRepository extends ElasticsearchRepository<BookEntity, String> {

    List<BookEntity> findByAuthorIn(List<String> authors);
    List<BookEntity> findByAuthorAndPrice(String author, Integer price);
    Page<BookEntity> findByAuthorNot(String author, Pageable page);  // 非
    List<BookEntity> findByAuthorContains(String author); // 模糊查询  *白*
    Integer countByAuthor(String author); // 统计
    List<BookEntity> findByPriceBetween(Integer start, Integer end);// 范围查询
    int deleteByAuthor(String author);

    @Query("{\"bool\":{\"should\":[{\"term\":{\"author\": \"?0\"}},{\"term\":{\"price\": \"?1\"}}]}}")
    Page<BookEntity> shouldByAuthorOrPrice(String author, Integer price, Pageable pageable);
}
  5.   创建IndexController.java
      
    import com.basic.repository.BookRepository;
import com.basic.entity.BookEntity;
import com.google.common.collect.Lists;
import io.swagger.annotations.*;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.aggregations.*;
import org.elasticsearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.SearchQuery;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RestController
@Api(tags = "elasticsearch接口")
public class IndexController {

    @Autowired
    private BookRepository bookRepository;

    @GetMapping("/selectById")
    @ApiOperation(value = "ID查询", notes = "根据ID查询", httpMethod = "GET")
    @ApiImplicitParam(name = "id", value = "文档ID", dataType = "String", example = "1")
    public BookEntity findBook(@RequestParam("id") String id) {
        return bookRepository.findById(id).get();
    }

    @GetMapping("/selectFun")
    @ApiOperation(value = "方法查询", notes = "方法查询", httpMethod = "GET")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "author", value = "作何", dataType = "String", example = "李白"),
            @ApiImplicitParam(name = "price", value = "价格", dataType = "int", example = "44")
    })
    public List<BookEntity> findByAuthorAndPrice(@RequestParam("author") String author,
                                                 @RequestParam("price") int price) {
        return bookRepository.findByAuthorAndPrice(author, price);
    }


    @GetMapping("/selectSort")
    @ApiOperation(value = "分页排序", notes = "根据价格排序并分页", httpMethod = "GET")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "page", value = "页码", dataType = "int", example = "0"),
            @ApiImplicitParam(name = "size", value = "页容量", dataType = "int", example = "2")
    })
    public Page<BookEntity> selectList(@RequestParam("page") int page,
                                       @RequestParam("size") int size) {
        Sort sort = new Sort(Sort.Direction.DESC, "price");
        Pageable pageable = PageRequest.of(page, size, sort);
        Page<BookEntity> pages = bookRepository.findAll(pageable);
        return pages;
    }

    @PostMapping("/selectLogic")
    @ApiOperation(value = "逻辑查询", notes = "逻辑关系查询", httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "word", value = "分词", dataType = "String", example = "大林寺/寺院"),
            @ApiImplicitParam(name = "price", value = "价格", dataType = "int", example = "44")
    })
    public List<BookEntity> selectLogic(@RequestParam("word") String word,
                                        @RequestParam("price") Integer price) {
//        must 相当于 &(与)条件。
//        must not 相当于~(非)条件。
//        should 相当于 | (或)条件。
//        filter 类似must，区别在于它不参与计算分值，在不需要用到分值计算的时候效率更高
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        // 精确查询
//        queryBuilder.must(QueryBuilders.termQuery("author","李白"));
        // 分词查询
//        queryBuilder.must(QueryBuilders.matchQuery("content", "春风十里不如你"));
        // 匹配多个字段
//        queryBuilder.must(QueryBuilders.multiMatchQuery("春风十里不如你", "title", "content"));
        // 前缀查询
//        queryBuilder.must(QueryBuilders.prefixQuery("author", "李"));
        // 模糊查询
//        queryBuilder.must(QueryBuilders.fuzzyQuery("title", "白帝"));
        // 区间查询
//        queryBuilder.must(QueryBuilders.rangeQuery("price").gt(20).lt(40));
        // 通配符查询
//        queryBuilder.must(QueryBuilders.wildcardQuery("title", "*白帝*")); // 注意中文适配问题
        // id的in查询
//        queryBuilder.must(QueryBuilders.idsQuery().addIds("1", "2"));
        // price不等于空
//        queryBuilder.must(QueryBuilders.existsQuery("price"));
        // 时间范围查询
//        queryBuilder.filter(QueryBuilders.rangeQuery("time").from("2017-07-01").to("2017-07-11"));
        if (StringUtils.hasText(word)) {
            queryBuilder.should(QueryBuilders.matchQuery("title", word));
        }
        if (price != null) {
            queryBuilder.should(QueryBuilders.matchQuery("price", price));
        }
        Iterable<BookEntity> results = bookRepository.search(queryBuilder);
        return Lists.newArrayList(results);
    }

    @PostMapping("/selectMulti")
    @ApiOperation(value = "多属性查询", notes = "多属性查询", httpMethod = "POST")
    public Page<BookEntity> selectMulti() {
        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withFields("title", "content", "price")  // 指定字段
                .withQuery(QueryBuilders.multiMatchQuery("春风桃花", "title", "content")) //搜索条件
                .withSort(SortBuilders.fieldSort("price").order(SortOrder.DESC)) // 排序
                .withPageable(PageRequest.of(0, 2))  // 分页
                .build();
        Page<BookEntity> pages = bookRepository.search(searchQuery);
        return pages;
    }

    @GetMapping("/dsl")
    @ApiOperation(value = "DSL查询", notes = "DSL查询", httpMethod = "GET")
    public Page<BookEntity> dsl() {
        Sort sort = new Sort(Sort.Direction.DESC, "price");
        Pageable pageable = PageRequest.of(0, 2, sort);
        Page<BookEntity> pages = bookRepository.shouldByAuthorOrPrice("李白", 33, pageable);
        return pages;
    }

    @PostMapping("/add")
    @ApiOperation(value = "新增文档", notes = "新增文档", httpMethod = "POST")
    public BookEntity add(@RequestBody BookEntity book) {
        return bookRepository.save(book);
    }


    @GetMapping("/deleteById")
    @ApiOperation(value = "删除文档", notes = "删除文档", httpMethod = "GET")
    @ApiImplicitParam(name = "id", value = "文档id", dataType = "String", example = "3")
    public void deleteById(@RequestParam("id") String id) {
        bookRepository.deleteById(id);
    }

    @GetMapping("/selectAgg")
    @ApiOperation(value = "聚合查询", notes = "聚合查询", httpMethod = "GET")
    public Object selectAgg() {
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
//         // 查询所有书的价格平均值  avg
//        queryBuilder.addAggregation(AggregationBuilders.avg("avg_price").field("price"));
//         // 查询所有书的价格之和  sum
//        queryBuilder.addAggregation(AggregationBuilders.sum("sum_price").field("price"));
//        // 查询所有书最低的价格值  min
//        queryBuilder.addAggregation(AggregationBuilders.min("min_price").field("price"));
//        // 根据作者分组并求和  group by sum
//        TermsAggregationBuilder groupBuilder = AggregationBuilders.terms("group_author").field("author");
//        AggregationBuilder sumBuilder = AggregationBuilders.sum("sum_price").field("price");
//        queryBuilder.addAggregation(groupBuilder.subAggregation(sumBuilder));
        // 查询作者李白书中最高的price  max
        FilterAggregationBuilder filterBuilder = AggregationBuilders.filter("param_author",
                QueryBuilders.termQuery("author", "李白"))
                .subAggregation(AggregationBuilders.max("max_price").field("price"));
        queryBuilder.addAggregation(filterBuilder);

        AggregatedPage<BookEntity> aggPage = (AggregatedPage<BookEntity>) bookRepository.search(queryBuilder.build());
        Aggregations aggregations = aggPage.getAggregations();
//        Terms terms = aggregations.get("group_author");
//        for (Terms.Bucket bucket : terms.getBuckets()) {
//        }
        return aggregations;
    }

}
  6.   启动类
      
    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;

@SpringBootApplication
@EnableElasticsearchRepositories(basePackages = "com.basic.repository")
public class AppServer
{
    public static void main( String[] args )
    {
        SpringApplication.run(AppServer.class, args);
    }
}
    @EnableElasticsearchRepositories配置扫包范围
     
  7.   测试
      http://127.0.0.1:8001/es/doc.html
       
     
    文档: 
     Spring Data Elasticsearch
     Bucket aggregations | Java Transport Client (deprecated) [7.17] | Elastic 
     
  •   ES集群和高可用
     
  1.  elasticsearch节点类型  
     一个 Elasticsearch 实例是一个节点，一组节点组成了集群。Elasticsearch 集群中的节点可以配置为 3 种不同的角色(不限3种)： 
     
    主节点：负责管理集群的状态并广播到其他节点，并接收其他节点的响应。通过elasticsearch.yml中的node.master: true成为主节点。
    数据节点：存储索引数据，并对文档进行操作  。通过elasticsearch.yml中的node.data: true成为数据节点。
    客户端节点：扮演一个负载均衡的角色，将到来的请求路由到集群中的对应分片上。   
    ...................
    如果使用ES默认配置，一个节点启动后会承担上述所有的节点类型角色，建议每个节点只配置一种节点类型角色。
    Node | Elasticsearch Guide [6.4] | Elastic
  2. elasticsearch的分片机制   
     主分片:  elasticsearch会将一个索引数据分别存放在多个分片上(默认5个)，每个分片都会部署在多个不同的节点上，该分片称为主分片 (primary shard) 。
     复制分片:  每一个主分片为了实现高可用，提高系统的容错性，防止某个节点或分片出现故障导致数据丢失，所以每个主分片对应1个或多个副本(replica shards)。 
    ###创建索引并指定索引的分片数量
PUT back
{
    "settings": {
        "number_of_shards": 3,
        "number_of_replicas": 1
    }
}
###查看索引信息
GET /back/_settings
      "number_of_shards":"3"       表示: 主分片为3个
      "number_of_replicas":"1"     表示: 每个主分片都会对应1个副分片
       查询默认分片信息  http://121.4.227.23:9200/source/_settings  
  3.  elasticsearch的路由策略 
     elasticsearch在写入数据时，是通过路由来确定具体写入哪一个分片中，大致路由过程如下： 
    shard = hash(routing) % number_of_primary_shards

    routing默认时文档的_id，支持自定义。routing通过hash得到的数字，再根据number_of_primary_shards(主分片的数量) 求余 ，就是该文档对应的分片位置。 

  4.  elasticsearch集群

     集群健康 | Elasticsearch: 权威指南 | Elastic
     https://www.elastic.co/guide/en/elasticsearch/reference/6.4/modules-discovery-zen.html 
  •  elasticsearch7.x新特性
  1. 自带JDK
  2. 默认分片数量为1 ，不再是5
  3. 移除type
  4.  kibana支持暗黑模式， 以及集群的协调功能
  5.  查询速度优化，使用Term查询性能提升3700%
  6.  对内存管理更加健壮，降低OOM(内存溢出)发生
  7.  时间戳支持纳秒级别
  8. ....................
  •   elasticsearch最佳实践
  1.  官方建议分片大小控制在30GB-50GB以内 
  2.  索引分片数为数据节点的倍数 
     
     
     
     
xiaobo5264063
关注
Elasticsearch语法大全
qq_41911898的博客
11-24 7242
ElasticSearch常见操作语法Elasticsearch语法大全一、 ElasticSearch 创建index、type、field语法1、Elasticsearch和关系型数据库数据模型对应关系表2、创建索引并查看3、删除索引并查看4、文档操作4.1、查看文档类型4.2、在索引中添加文档4.3、在索引中查看文档4.4、在索引中修改文档4.5、在索引中删除文档4.6、在索引中批量操作文档5、创建一个数据模型样例（包含index、type、field）：6、Elasticsearch给type增加一
Spring Boot elasticsearch7.6.2基础操作：创建索引、新增数据、查询数据
04-29
以上就是使用Spring Boot和Elasticsearch 7.6.2进行基础操作的基本流程。通过这种方式，你可以轻松地在应用中集成Elasticsearch，实现高效的搜索功能。记住，Elasticsearch的强大还在于它的聚合分析、地理位置搜索等...
StreamTask数据流
墨玉浮白的博客
06-21 430
将OperatorChain的HeadOperator作为主要参数，就是为了能让DataOutput组件可以将InputGate接入的BufferOrEvent数据，传递给OperatorChain中的HeadOperator，做进一步的处理、转换。根据不同的数据来源，StreamTaskInput分为：从网络获取数据的StreamTaskNetworkInput、从外部系统获取数据的StreamTaskSourceInput。此时StreamTask就已经具备了接收外部数据并处理的能力了。
elasticsearch - 使用大全
jxm的博客
11-28 950
1.term term 根据 keyword字段 精确匹配 实例 GET index3/_search { "query": { "term": { "book_name": "设计" } } } 2. terms terms 根据 keyword字段 精确匹配 实例 GET index3/_search { "query": { "terms": { "book_name": ["设计", "李四"] } } } 3. m
Elasticsearch核心知识点大全
qq_42292373的博客
12-06 1342
1.为什么要使用Elasticsearch框架 1.响应时间 MySQL 背景：+ 小刘在做测试时，发现当数据库中的文档数仅仅上万条时，关键词查询就比较慢了。如果一旦到企业级的数据，响应速度就会更加不可接受。 原因： 在数据库做模糊查询时，如LIKE语句，它会遍历整张表，同时进行字符串匹配。 例如，当小刘在数据库查询“市场”时，数据库会在每一条记录去匹配“市场”这两字是否出现。实际上，并不是所有记...
ElasticSearch操作命令大全
qq422243639的博客
09-06 919
创建索引和映射 1、手动创建索引 curl -XPUT ‘localhost:9200/new-index’ 2、获取映射 curl ‘localhost:9200/get-together/_mapping/group?pretty’ 3、搜索获取数据 ES默认使用了_all字段，索引了所有字段内容 curl ‘localhost:9200/get-together/group/_se...
最完整的Elasticsearch 基础教程
05-26
本教程将深入浅出地介绍Elasticsearch的基础知识，帮助初学者快速上手。 1. **Elasticsearch 概述** - Elasticsearch 是一个基于 Lucene 的分布式、RESTful 风格的搜索和数据分析引擎。 - 它的核心特性包括实时性...
ES基础入门培训-零基础门槛
08-16
ElasticSearch（ES）是一个强大的、基于Lucene的开源搜索服务器，专门设计用于云计算环境。它提供了实时、稳定、可靠且可扩展的搜索和分析功能，支持RESTful接口，使得操作简单易用。作为Java开发的项目，ES在Apache...
Elasticsearch 基础介绍及索引原理分析
08-25
Elasticsearch 基础介绍及索引原理分析 Elasticsearch 是一个分布式可扩展的实时搜索和分析引擎，建立在全文搜索引擎 Apache Lucene(TM) 基础上。它不仅包括了全文搜索功能，还可以进行分布式实时文件存储，并将每...
elasticsearch基础原理大全解析
11-14
在学习中总结的关于elasticsearch的基本的相关组件服务的原理阐述，以及总结
ElasticSearch处理更新冲突
热门推荐
职场里拉开差距的不是知识，而是认知！
07-16 2万+
当使用index API更新文档的时候，我们读取原始文档，做修改，然后将整个文档(whole document)一次性重新索引。最近的索引请求会生效——Elasticsearch中只存储最后被索引的任何文档。如果其他人同时也修改了这个文档，他们的修改将会丢失。 很多时候，这并不是一个问题。或许我们主要的数据存储在关系型数据库中，然后拷贝数据到Elasticsearch中只是为了可以用于搜索。或许
Elasticsearch检索分类深入详解—基础篇
铭毅天下Elasticsearch
08-27 2万+
题记ES中当我们设立完Mapping（分词器、字段类型）完毕后，就可以按照设定的方式导入数据。 有了数据后，我们就需要对数据进行检索操作。根据实际开发需要，我们需要支持： * 1）精确匹配,类似mysql中的 “=”操作； * 2）模糊匹配，类似mysql中的”like %关键词% “查询操作； * 3）前缀匹配； * 4）通配符匹配； * 5）正则表达式匹配； * 6）跨索引匹配；
ElasticSearch 索引查询使用指南——详细版
weixin_30892889的博客
09-01 5170
　　 我们通常用用_cat API检测集群是否健康。 确保9200端口号可用: 　　curl 'localhost:9200/_cat/health?v' 　　绿色表示一切正常, 黄色表示所有的数据可用但是部分副本还没有分配,红色表示部分数据因为某些原因不可用. 　...
ElasticSearch汇总
东风麦芽糖
08-27 1727
1、Elasticsearch介绍和安装 2、kibana的安装配置使用 3、操作索引、映射配置 4、增删改查、高级查询、排序过滤 5、聚合aggregations 6、Spring Data Elasticsearch
elasticsearch 语法大全
zhaojikun521521的博客
07-10 1173
更新操作 post 路径 _update_by_query 更新字段 avatar 查询条件query { "script": { "source": "ctx._source['avatar']='http://192.168.25.121/verify/face/gets?imageId=50ccc157ace047a4be7c05b32c4c2a...
elasticsearch插件
soledede
10-21 507
Elasticsearch扩展性非常好，有很多官方和第三方开发的插件，下面以分词、同步、数据传输、脚本支持、站点、其它这几个类别进行划分。 分词插件 Combo Analysis Plugin (作者 Olivier Favre, Yakaz) 简介：组合分词器，可以把多个分词器的结果组合在一起。 Smart Chinese Analysis Plugin (作者 elastics...
Elasticsearch实战 | 如何从数千万手机号中识别出情侣号？
铭毅天下Elasticsearch
03-22 7456
1、问题描述您好，请教个问题。我现在有2千多万的手机号码信息保存在es里。5个分片，3个节点。现在的需求是将后八位相同的号码匹配到一起，重新放到一个in...
Elasticsearch操作命令
tanfei113的博客
07-17 1万+
elasticsearch
git操作pull的时候出现冲突怎么解决
最新发布
fury的博客
10-08 733
问：回答：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值