Elasticsearch搜索引擎

已于 2023-05-07 18:21:04 修改
阅读量2.4k 收藏
点赞数 1
分类专栏： Elasticsearch 文章标签： elasticsearch nosql java
于 2022-12-29 18:21:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55648724/article/details/128485542
版权

The Elastic Stack, 包括 Elasticsearch【搜索，分析】、 Kibana【可视化】、 Beats 和 Logstash【数据的搜集】（也称为 ELK Stack）。能够安全可靠地获取任何来源、任何格式的数据，然后实时地对数据进行搜索、分析和可视化。

Elaticsearch，简称为 ES， ES 是一个开源的高扩展的分布式全文搜索引擎， 是整个 ElasticStack 技术栈的核心。

它可以近乎实时的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理 PB 级别的数据。

文章目录

目录

文章目录

前言

一、倒排索引

二、es的安装 

三、ES中常见的概念

四、ES常用API接口

4.1查询匹配

 4.2多条件查询

4.3匹配数组

4.4精确匹配  

五、ik分词器 

六、spring boot整合es 

总结

前言

使用场景

国外：

  • 维基百科，类似百度百科，“网络七层协议”的维基百科，全文检索，高亮，搜索推荐

  • Stack Overflow（国外的程序讨论论坛），相当于程序员的贴吧。遇到it问题去上面发帖，热心网友下面回帖解答。

  • GitHub（开源代码管理），搜索上千亿行代码。

  • 电商网站，检索商品

  • 日志数据分析，logstash采集日志，ES进行复杂的数据分析（ELK技术，elasticsearch+logstash+kibana）

  • 商品价格监控网站，用户设定某商品的价格阈值，当低于该阈值的时候，发送通知消息给用户，比如说订阅《java编程思想》的监控，如果价格低于27块钱，就通知我，我就去买。

  • BI系统，商业智能（Business Intelligence）。大型连锁超市，分析全国网点传回的数据，分析各个商品在什么季节的销售量最好、利润最高。成本管理，店面租金、员工工资、负债等信息进行分析。从而部署下一个阶段的战略目标。

国内：

  • 百度搜索，第一次查询，使用es。

  • OA、ERP系统站内搜索。

一、倒排索引

倒排索引源于实际应用中需要根据属性的值来查找记录。这种索引表中的每一项都包括一个属性值和具有该属性值的各记录的地址。由于不是由记录来确定属性值，而是由属性值来确定记录的位置，因而称为倒排索引(inverted index)。带有倒排索引的文件我们称为倒排索引文件，简称倒排文件(inverted file)。  

二、es的安装 

需要电脑有jdk环境

1.下载安装包并解压

下载地址：下载 Elastic 产品 | Elastic/

解压后，进入 bin 文件目录，点击 elasticsearch.bat 文件启动 ES 服务 。

注意： 9300 端口为 Elasticsearch 集群间组件的通信端口， 9200 端口为浏览器访问的 http协议 RESTful 端口。

打开浏览器，输入地址： http://localhost:9200，测试返回结果

 2.kibana是es数据的前端展现，数据分析时，可以方便地看到数据。

历史版本下载：Past Releases of Elastic Stack Software | Elastic/

1、下载，解压kibana。

2、启动Kibana：bin\kibana.bat

3、浏览器访问 http://localhost:5601 进入Dev Tools界面。像plsql一样支持代码提示。

4、发送get请求，查看集群状态GET _cluster/health。相当于浏览器访问。

三、ES中常见的概念

集群

集群这一概念已经遍及天下了，在Elasticsearch中也不例外，可以将多台Elasticsearch节点组成集群使用，可以在任意一台节点上进行搜索。

节点

节点是一台Elasticsearch服务器，可以存储、查询、创建索引，也可以与其它节点一共组成一个集群。

索引---数据库

索引是具有某种相似特性的文档集合，熟悉mysql的应该不会对于这个名词陌生，Elasticsearch使用的是倒排索引。

文档---一条记录

一个文档是一个可以被索引的基础信息单元。

分片

单个索引包含数据太大的话，将会降低索引速度。为此，Elasticsearch提供了将索引细分成多个片段的能力，就是分片。

副本

副本是ElasticSearch索引分片的备份，主要应对与节点故障时保存数据的可用性。副本与它的原始分片不会在同一个节点上，以此来保存单节点故障时的高可用。

注意: ES6.0以后Type这个概念模糊了，7.0以后不在使用Type. 默认索引的type都是_doc

  1. 索引----数据库

  2. 类型---表

  3. 文档---一条记录

  4. 字段---列

Elasticsearch 是面向文档型数据库，一条数据在这里就是一个文档。 为了方便大家理解，我们将 Elasticsearch 里存储文档数据和关系型数据库 MySQL 存储数据的概念进行一个类比

ES 里的 Index 可以看做一个库，而 Types 相当于表， Documents 则相当于表的行。这里 Types 的概念已经被逐渐弱化， Elasticsearch 6.X 中，一个 index 下已经只能包含一个type， Elasticsearch 7.X 中, Type 的概念已经被删除了。

四、ES常用API接口

#查询所有
GET /qy158-index/_search
{
  "query": {
    "match_all": {
      
    }
  }
}
#创建索引
PUT /myindex
{
  "mappings": {
    "properties": {
      "id":{"type": "integer"},
      "name":{"type": "text"},
      "age":{"type": "integer"}
    }
  }
}
#获取索引的结构
GET /qy158-index
#查询kibana里面所有的索引
GET /_cat/indices?v
#删除索引
DELETE /myindex
#添加文档
PUT /myindex/_doc/4
{
  "name":"likeyou",
  "age":11
}
#根据id查询文档
GET  /qy158-index/_doc/6

#修改文档内容
POST /myindex/_doc/1/_update
{
  "doc":{
    "name":"修改为张三"
  }
}

#删除1号文档文档
DELETE  /qy158-index/_doc/1
#传递参数查询
GET /myindex/_search?q=name:修

#模糊查询 term精度匹配
GET /qy158-index/_search
{
  "query": {
    "match": {
      "name": "张"
    }
  }
}
#范围匹配
GET /myindex/_search
{
  "query": {
    "range": {
      "age": {
        "gte":16
      }
    }
  }
}
#排序
GET /myindex/_search
{
   "query": {
    "match": {
      "name": "老"
    }
  },
  "_source": ["name","age"],
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ]
}
#分页查询
GET /myindex/_search
{
  "query": {
    "match": {
      "name": "老"
    }
  },
  "from": 1,
  "size": 1
}
#多条件查询
GET /myindex/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "老"
          }
        },
        {
          "match": {
            "age": 11
          }
        }
      ]
    }
  }
}
#自定义高亮的前缀和后缀
GET /myindex/_search
{
  "query": {
    "match": {
      "name": "老"
    }
  },
  "highlight": {
    "pre_tags": "<font color:'red'>",
    "post_tags": "</font>",
     "fields": {
        "name": {}
    }
  }
}


GET _search
{
  "query": {
    "match_all": {}
  }
}

4.1查询匹配

  • match：匹配（会使用分词器解析（先分析文档，然后进行查询））

  • _source：过滤字段

  • sort：排序

  • form、size 分页

  // 查询匹配
  GET /blog/user/_search
  {
    "query":{
      "match":{
        "name":"流"
      }
    }
    ,
    "_source": ["name","desc"]
    ,
    "sort": [
      {
        "age": {
          "order": "asc"
        }
      }
    ]
    ,
    "from": 0
    ,
    "size": 1
  } 

 4.2多条件查询

  • must 相当于 and

  • should 相当于 or

  • must_not 相当于 not (... and ...)

  • filter 过滤

/// bool 多条件查询
must <==> and
should <==> or
must_not <==> not (... and ...)
filter数据过滤
boost
minimum_should_match
GET /blog/user/_search
{
  "query":{
    "bool": {
      "must": [
        {
          "match":{
            "age":3
          }
        },
        {
          "match": {
            "name": "流"
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "gte": 1,
            "lte": 3
          }
        }
      }
    }
  }
}

4.3匹配数组

  • 貌似不能与其它字段一起使用

  • 可以多关键字查（空格隔开）— 匹配字段也是符合的

  • match 会使用分词器解析（先分析文档，然后进行查询）

  • 搜词

// 匹配数组 貌似不能与其它字段一起使用
// 可以多关键字查（空格隔开）
// match 会使用分词器解析（先分析文档，然后进行查询）
GET /blog/user/_search
{
  "query":{
    "match":{
      "desc":"年龄 牛 大"
    }
  }
}


4.4精确匹配  

  • term 直接通过 倒排索引 指定词条查询

  • 适合查询 number、date、keyword ，不适合text

// 精确查询（必须全部都有，而且不可分，即按一个完整的词查询）
// term 直接通过 倒排索引 指定的词条 进行精确查找的
GET /blog/user/_search
{
  "query":{
    "term":{
      "desc":"年 "
    }
  }
} 

五、ik分词器 

下载地址：Releases · medcl/elasticsearch-analysis-ik · GitHub

注意下载对应版本和es

需要解压到ElasticSearch的plugins目录ik文件夹下

重新启动es 就能加载插件了

text和keyword

  • text：

    • 支持分词，全文检索、支持模糊、精确查询,不支持聚合,排序操作;

    • text类型的最大支持的字符长度无限制,适合大字段存储；

  • keyword：

    • 不进行分词，直接索引、支持模糊、支持精确匹配，支持聚合、排序操作。

    • keyword类型的最大支持的长度为——32766个UTF-8类型的字符,可以通过设置ignore_above指定自持字符长度，超过给定长度后的数据将不被索引，无法通过term精确匹配检索返回结果。

// 测试keyword和text是否支持分词
// 设置索引类型
PUT /test
{
  "mappings": {
    "properties": {
      "text":{
        "type":"text"
      },
      "keyword":{
        "type":"keyword"
      }
    }
  }
}
// 设置字段数据
PUT /test/_doc/1
{
  "text":"测试keyword和text是否支持分词",
  "keyword":"测试keyword和text是否支持分词"
}
// text 支持分词
// keyword 不支持分词
GET /test/_doc/_search
{
  "query":{
   "match":{
      "text":"测试"
   }
  }
}// 查的到
GET /test/_doc/_search
{
  "query":{
   "match":{
      "keyword":"测试"
   }
  }
}// 查不到，必须是 "测试keyword和text是否支持分词" 才能查到
GET _analyze
{
  "analyzer": "keyword",
  "text": ["测试liu"]
}// 不会分词，即 测试liu
GET _analyze
{
  "analyzer": "standard",
  "text": ["测试liu"]
}// 分为 测 试 liu

高亮查询

/// 高亮查询
GET blog/user/_search
{
  "query": {
    "match": {
      "name":"流"
    }
  }
  ,
  "highlight": {
    "fields": {
      "name": {}
    }
  }
}
// 自定义前缀和后缀
GET blog/user/_search
{
  "query": {
    "match": {
      "name":"流"
    }
  }
  ,
  "highlight": {
    "pre_tags": "<p class='key' style='color:red'>",
    "post_tags": "</p>", 
    "fields": {
      "name": {}
    }
  }
}

六、spring boot整合es 

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.70</version>
</dependency>
<!-- lombok需要安装插件 -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

创建配置类

@Configuration
public class ElaticsearchConfig {

    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("127.0.0.1",9200,"http")));

        return client;
    }
}

测试

package com.rcg;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.rcg.entity.User;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
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.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
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.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.IndicesClient;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.index.query.MatchQueryBuilder;
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.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.elasticsearch.xcontent.XContentType;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

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

@SpringBootTest
class SpringbootEsApplicationTests {


    @Autowired
    private RestHighLevelClient restHighLevelClient;

    @Test
    void contextLoads() {
    }

    //判断索引是否存在
    @Test
    public void test01() throws IOException {
        //获取es连接
        IndicesClient indices = restHighLevelClient.indices();
        //索引的名字
        GetIndexRequest myindex = new GetIndexRequest("myindex");
        //判断
        boolean exists = indices.exists(myindex, RequestOptions.DEFAULT);
        System.out.println("是否存在："+exists);
        //关闭连接资源
        restHighLevelClient.close();
    }

    //创建索引
    @Test
    public void test02() throws IOException {
        //获取索引操作的类对象
        IndicesClient indices = restHighLevelClient.indices();
        //获取创建索引的请求对象 封装了关于索引的信息
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("qy158-jd");
        //操作
        CreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);
        System.out.println("是否创建成功" + createIndexResponse.isAcknowledged());
        //关闭连接资源
        restHighLevelClient.close();
    }


    //删除索引
    @Test
    public void test03() throws IOException {
        IndicesClient indices = restHighLevelClient.indices();
        DeleteIndexRequest myindex = new DeleteIndexRequest("myindex");
        AcknowledgedResponse delete = indices.delete(myindex, RequestOptions.DEFAULT);
        System.out.println("delete = " + delete.isAcknowledged());
        //关闭连接资源
        restHighLevelClient.close();
    }


    //添加文档
    @Test
    public void test04() throws IOException {
        IndexRequest indexRequest = new IndexRequest("qy158-index");
        //自定义id
        indexRequest.id("1");
        //指定字段
        User user = new User("张老三",16,"南京");
        indexRequest.source(JSON.toJSONString(user), XContentType.JSON);
        IndexResponse index = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        DocWriteResponse.Result result = index.getResult();
        System.out.println("result = " + result);
        //关闭连接资源
        restHighLevelClient.close();
    }


    @Test
    public void test05() throws IOException {
        GetRequest getRequest = new GetRequest("qy158-index", "6");
        GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);

        Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();
        System.out.println("sourceAsMap = " + sourceAsMap);
        String s = getResponse.getSourceAsString();
        System.out.println("s = " + s);
        //字符串转对象
        JSONObject jsonObject = new JSONObject(JSON.parseObject(s));
        User user = jsonObject.toJavaObject(jsonObject, User.class);
        System.out.println("user = " + user);
        //关闭连接资源
        restHighLevelClient.close();
    }


    //删除文档
    @Test
    public void test06() throws IOException {
        DeleteRequest deleteRequest = new DeleteRequest("qy158-index", "1");
        DeleteResponse delete = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println("delete = " + delete.getResult());
        //关闭连接资源
        restHighLevelClient.close();
    }

    //修改文档
    @Test
    public void test07() throws IOException {
        UpdateRequest updateRequest = new UpdateRequest("qy158-index", "1");
        User user = new User("李四",18,"东京");
        //更新的内容字段
        updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
        //操作
        UpdateResponse update = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println("update = " + update.getResult());
        //关闭连接资源
        restHighLevelClient.close();
    }


    //批量添加
    @Test
    public void test08() throws IOException {
        BulkRequest bulkRequest = new BulkRequest("qy158-index");
        List<User> list=new ArrayList<>();
        list.add(new User("刘德华",12, "香港"));
        list.add(new User("张学友",16, "北京"));
        list.add(new User("黎明", 28,"郑州"));
        list.add(new User("郭富城", 36,"上海"));

        for (int i = 0; i < list.size(); i++) {
            IndexRequest indexRequest = new IndexRequest();
            indexRequest.id(String.valueOf(i+2));
            indexRequest.source(JSON.toJSONString(list.get(i)),XContentType.JSON);
            bulkRequest.add(indexRequest);
        }
        BulkResponse bulk = restHighLevelClient.bulk(bulkRequest,RequestOptions.DEFAULT);
        //关闭连接资源
        restHighLevelClient.close();
    }

    //高级搜索
    @Test
    public void test09() throws IOException {
        //搜索的请求对象
        SearchRequest searchRequest = new SearchRequest("qy158-index");
        //构建一个条件类对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //match多条件匹配条件
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("name", "张");


        //加入各种条件

        //加入多条件匹配
        searchSourceBuilder.query(matchQueryBuilder);
        //加入排序
        searchSourceBuilder.sort("age", SortOrder.DESC);
        //加入分页
        searchSourceBuilder.from(0);
        searchSourceBuilder.size(2);
        //加入高亮
        HighlightBuilder highlightBuilder=new HighlightBuilder();
        highlightBuilder.field("name");
        highlightBuilder.preTags("<font color='red'>");
        highlightBuilder.postTags("</font>");
        searchSourceBuilder.highlighter(highlightBuilder);


        //把条件对象封装到请求里
        searchRequest.source(searchSourceBuilder);

        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        //获取相响应信息
        SearchHits hits = searchResponse.getHits();
        //解析结果
        SearchHit[] hits1= hits.getHits();
        for(SearchHit hit:hits1){
            //得到旧的字段
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            //得到高亮的字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            //把旧的字段覆盖 只显示高亮的
            sourceAsMap.put("name",highlightFields.get("name").getFragments()[0]);

            System.out.println(sourceAsMap);
        }

        //关闭连接资源
        restHighLevelClient.close();
    }

}

总结

待补充

勤奋上进的兔子
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ElasticSearch搜索引擎教程实战篇
09-19
ElasticSearch搜索引擎教程实战篇是ElasticSearch搜索引擎的实践教程，旨在帮助读者从基础知识到高级应用掌握ElasticSearch搜索引擎的使用。该教程涵盖了ElasticSearch搜索引擎的基础概念、安装、配置、使用Kibana、...
Elasticsearch7.6.x学习笔记（超详细）
DramaLifes的博客
09-28 1724
Elasticsearch和solr比较 当单纯的对已有的数据进行搜索时，solr更快 当实时建立索引时，Solr会产生io阻塞，查询性能交叉，ElasticSearch具有明显优势 随着数量的增加，Solr的搜索效率会变得更低，而ElasticSearch却没有明显的变化 ElasticSearch和Solr的比较总结 es基本是开箱即用(解压就可以使用) 非常简单 Solr安装略微复杂一丢丢 Solr利用Zookeeper进行分布式管理，而ElasticSearch 自身带有分布式协调管理功能 S
Elasticsearch入门
LF991的博客
06-25 840
Elasticsearch
ElasticSearch全文搜索引擎
Casual_Lei的博客
06-13 1863
​ Lucene是apache下的一个开源的全文检索引擎工具包(一堆jar包)。它为软件开发人员提供一个简单易用的工具包（类库），以方便的在小型目标系统中实现全文检索的功能。Lucene适用于中小型项目 ，ES适用于中大型项目（它底层是基于lucene实现的）​ 虽然全文搜索领域，Lucene可以被认为是迄今为止最先进、性能最好的、功能最全的搜索引擎库。但是，Lucene只是一个库。
Elasticsearch（三）——Es搜索（简单使用、全文查询、复合查询）、地理位置查询、特殊查询、聚合操作、桶聚合、管道聚合
热门推荐
qq_41824825的博客
04-06 3万+
Elasticsearch（三）——Es搜索（简单使用、全文查询、复合查询）、地理位置查询、特殊查询、聚合操作、桶聚合、管道聚合
ElasticSearch 全文搜索引擎；ES 搜索引擎
lhorse003的博客
03-02 4439
默认情况下，每个节点都会被安排加入到一个叫做 “elasticsearch” 的集群中，这意味着，如果你在你的网络中启动了若干个节点，并假定它们能够相互发现彼此，它们将会自动地形成并加入到一个叫做 “elasticsearch” 的集群中。当然我们下载的 ElasticSearch 中包含了一个 jdk ，如果你的 jdk 版本不兼容，可以直接将你 JAVA_HOME 变量改为 ElasticSearch 中的 jdk 目录即可（建议备份原理的 JAVA_HOME，因为你之前的项目都是用的原来的）
ES搜索引擎入门+最佳实践(一)
柳老师的博客
08-03 2787
本篇文章计划给大家介绍什么ES,ES的架构,以及ES搜索入门.我尽量用简单不拖沓的语言给大家介绍,水平有限,时间也有限,各位读者如发现文中有不当之处,请留言指正.ES的全称是Elasticsearch,翻译过来就是弹性搜索,知道就可以,不用纠结这个词的含义,我觉得这个词并不能表述ES的含义.ES并不是传统意义上的数据库,所以不需要用传到的数据库例如Oracle,mysql等数据库与ES进行类比.ES是建立在Lucene(全文搜索)基础上的分布式准实时搜索引擎.
ElasticSearch——全文搜索引擎
hl404的博客
05-28 9162
一、为什么需要全文搜索引擎？ 首先先来了解一个概念，在我们生活中一般来说有两种数据：结构化数据、非结构化数据 结构化数据：指具有固定格式或有限长度的数据，如数据库，元数据等。 非结构化数据： 非结构化数据又可称为全文数据，指不定长或无固定格式的数据，如邮件，word文档等。 对于结构化数据我们可以直接从数据库查询，而对于非结构化的数据此时就要用到全文检索的方式查询，比如对一个文档或者网页中的内容文本每个词建立一个索引，把这些非结构化的变成结构化的方式然后来查询。 全文搜索引擎百度百科定义：全文搜索引擎是目前
Es搜索引擎
05-14
**Elasticsearch 搜索引擎详解** Elasticsearch 是一个开源的全文搜索引擎，它基于 Lucene 库，并且提供了分布式、RESTful 风格的搜索和数据分析能力。Elasticsearch 的设计目标是易于使用、可扩展性强、实时性高，...
es搜索引擎.doc
10-16
**Elasticsearch 搜索引擎详解** Elasticsearch（ES）是一个高效、可扩展的分布式搜索服务器，基于Apache Lucene构建，具有丰富的功能和强大的性能。它不仅提供了开箱即用的体验，还通过RESTful接口简化了Lucene的...
ElasticSearch 全文搜索引擎；从0到1教你学会ES 搜索引擎
最新发布
07-19
ElasticSearch 全文搜索引擎；从0到1教你学会ES 搜索引擎
es搜索引擎配置文件完整配置版本
08-23
在"es搜索引擎配置文件完整配置版本"中，我们可以找到适用于Elasticsearch 7.13.0版本的配置文件，这包括了默认设置以及一些高级选项。 ### 1. 配置文件位置 Elasticsearch的主配置文件名为`elasticsearch.yml`，...
搜索引擎——Elasticsearch
qq_52030824的博客
01-20 3701
Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎，**它可以快速地储存、搜索和分析海量数据。**作为 Elastic Stack 的核心，Elasticsearch 会集中存储您的数据，让您飞快完成搜索，微调相关性，进行强大的分析，并轻松缩放规模。Elasticsearch：官方分布式搜索和分析引擎 | Elastic**Mapping 是用来定义一个文档（document），以及它所包含的属性（field）是如何存储和索引的。**当添加数据时，他会自动处理属性类型。
es搜索引擎
m0_73858774的博客
10-25 2134
es
详解最热门搜索引擎——ES
会编程的小郑
08-09 1万+
一、产生背景 ​ 互联网发展早期的时候，对于一般的公司储存的数据量不是那么的大，所以很多公司更倾向于使用数据库去存储和查询数据，如：现在去MySQL中查询数据，大概的查询方式就是：select * from table where filed like “%XXX%”或者其他方式，但是，如果我们在查询的时候没有用到或命中数据库建立的索引话，则会扫描整张表，即便是MySQL做过单表查询能力优化，但是他的极限也只在400万左右，且还会经常出现超时现象，让后为了解决这些问题，。很多公司就开始对数据库进
全文检索 Elasticsearch(简称es)
CORN的博客
06-04 1万+
全文检索 Elasticsearch 研究 1. ElasticSearch 介绍 1.1 介绍 **Elasticsearch**是一个基于Lucene库的搜索引擎。它提供了一个分布式、支持多租户的全文搜索引擎，具有HTTP Web接口和无模式JSON文档。Elasticsearch是用Java开发的，并在Apache许可证下作为开源软件发布。官方客户端在Java、.NET（C#）、PHP、Py...
强大的搜索开源框架Elastic Search介绍
lgxzzz的博客
01-16 3934
项目背景 近期工作需要，需要从成千上万封邮件中搜索一些关键字并返回对应的邮件内容，经调研我选择了Elastic Search。 Elastic Search简介 Elasticsearch ，简称ES 。是一个全文搜索服务器，也可以作为NoSQL 数据库，存储任意格式的文档和数据，同时，也可以做大数据的分析，是一个跨界开源产品。ES 有如下特点： 全文搜索引擎， ES 是建立在Lucene 上的开源搜索引擎，可以用来进行全文搜索、地理信息搜索。Wikipedia、 GitHub 、StackOver
Elasticsearch (ES) 搜索引擎: 搜索功能：搜索分页、搜索匹配、全文搜索、搜索建议、字段排序
谢TS的博客
08-17 2662
全文搜索一般指对文本(text)类型数据的搜索。与 term、range 等全匹配的结构化搜索不同，全文搜索可以部分匹配。全文搜索首先对搜索词进行分析（分词），根据分析结果再构建出多个子查询。
Elasticsearch (ES) 搜索引擎: 简介、简单安装 与 基础概念
谢TS的博客
08-17 712
Elasticsearch（简称为 ES）是一个分布式、高扩展、高实时的搜索与数据分析引擎。ES 是建立在 Lucene 基础之上的分布式搜索引擎，并且提供了比 Lucene 更简单、更灵活的使用方式。Lucene 是 Apache 的项目，但它不是一个完整的全文检索引擎，只提供了全文检索引擎所需要的架构。Lucene 使用 Java 语言开发，并且提供了 Java API 接口。ES 基于 Lucene，也是使用 Java 语言开发，但提供了 REST 风格的 HTTP API 接口。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值