1. Toy模板网首页
  2. > Toy博客

Elasticsearch_分词器、搜索文档以及原生JAVA操作

10月前 作者：帅得真的是无敌了 分类：Toy博客 阅读(46) 违法举报

这篇具有很好参考价值的文章主要介绍了Elasticsearch_分词器、搜索文档以及原生JAVA操作。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、ES分词器

1、默认分词器

ES文档的数据拆分成一个个有完整含义的关键词，并将关键词与文档对应，这样就可以通过关键词查询文档。要想正确的分词，需要选择合适的分词器。
standard analyzer：Elasticsearch的默认分词器，根据空格和标点符号对应英文进行分词，会进行单词的大小写转换。
默认分词器是英文分词器，对中文是一字一词。

  1. 测试默认分词器的效果

    GET /_analyze
{
  "text":"z z x",
  "analyzer": "standard"
}

2、IK分词器

2.1 IK分词器安装及测试

IK分词器提供了两种算法：
1）ik_smart：最少切分
2）ik_max_word：最细粒度划分

  1. 关闭docker容器中的ES服务和kibana：docker stop elasticsearch，docker stop kibana

  2. 下载IKAnalyzer：https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v8.6.1/elasticsearch-analysis-ik-8.6.1.zip

  3. 通过mobax上传至虚拟机的目录/，然后进行解压缩：unzip elasticsearch-analysis-ik-8.6.1.zip -d /usr/local/elasticsearch/plugins/analysis-ik

  4. 切换至es用户：su es

  5. 进入bin目录：cd /usr/local/elasticsearch/bin

  6. 启动ES服务并在后台运行：./elasticsearch -d

  7. 切换到kibana的bin目录：cd ../../kibana-8.6.1/bin/

  8. 启动kibana：./kibana

  9. 测试IK分词器ik_smart(最少切分)

    GET /_analyze
{
  "text":"我是要成为海贼王的男人",
  "analyzer": "ik_smart"
}

    即一段话中的字只会被划分一次

  10. 测试IK分词器ik_max_word（最细粒度划分）

    GET /_analyze
{
  "text":"我是要成为海贼王的男人",
  "analyzer": "ik_max_word"
}

    即一段话中的字可能会被划分多次

2.2 IK分词器词典

IK分词器根据词典进行分词，词典文件在IK分词器的config目录中。
main.dic：IK中内置的词典。记录了IK统计的所有中文单词。
IKAnalyzer.cfg.xml：用于配置自定义词库。

  1. 进入到IK分词器的配置目录：cd /usr/local/elasticsearch/plugins/analysis-ik/config

  2. 切换root用户进行修改：su root

  3. 修改配置文件：vim IKAnalyzer.cfg.xml，修改如下：

    <entry key="ext_dict">ext_dict.dic</entry>
<entry key="ext_stopwords">ext_stopwords.dic</entry>

  4. 创建并编辑扩展词：vim ext_dict.dic，添加如下：

    率土之滨

    此时率土之滨会被分成一个词。

  5. 创建并编辑停用词：vim ext_stopwords.dic，添加如下

    率土

    此时率土不会被分成一个词。

  6. 切换到es用户：su es

  7. 重启ES服务
    1）找到对应的进程id：ps -ef |grep elastic
    2）根据id杀死该进程：kill -9 ID号
    3）进入到elasticsearch的bin目录：cd /usr/local/elasticsearch/bin
    4）启动ES服务：./elasticsearch -d

  8. 重启kibana服务
    1）找到对应的进程id：netstat -anp | grep 5601
    2）根据id杀死该进程：kill -9 ID号
    3）进入到kibana的bin目录：cd ../../kibana-8.6.1/bin/
    4）重启kibana服务：./kibana

3、拼音分词器

  1. 下载拼音分词器：https://github.com/medcl/elasticsearch-analysis-pinyin/releases/download/v8.6.1/elasticsearch-analysis-pinyin-8.6.1.zip

  2. 通过mobax上传到虚拟机的/目录，解压到elasticsearch的plugins/analysis-pinyin目录下：unzip elasticsearch-analysis-pinyin-8.6.1.zip -d /usr/local/elasticsearch/plugins/analysis-pinyin

  3. 切换到es用户：su es

  4. 重启ES服务
    1）找到对应的进程id：ps -ef |grep elastic
    2）根据id杀死该进程：kill -9 ID号
    3）进入到elasticsearch的bin目录：cd /usr/local/elasticsearch/bin
    4）启动ES服务：./elasticsearch -d

  5. 重启kibana服务
    1）找到对应的进程id：netstat -anp | grep 5601
    2）根据id杀死该进程：kill -9 ID号
    3）进入到kibana的bin目录：cd ../../kibana-8.6.1/bin/
    4）重启kibana服务：./kibana

  6. 测试拼音分词器

    GET /_analyze
{
  "text":"我是要成为海贼王的男人",
  "analyzer": "pinyin"
}

4、自定义分词器

需要对一段内容既进行文字分词，又进行拼音分词，此时需要自定义ik+pinyin分词器。

  1. 在创建索引时设置自定义分词器

    PUT student3
{
  "settings": {
    "analysis": {
      "analyzer": {
        "ik_pinyin":{//自定义分词器名
          "tokenizer":"ik_max_word",//基本分词器
          "filter":"pinyin_filter"//配置过滤分词器
        }
      },
      "filter": {
        "pinyin_filter":{
          "type":"pinyin",//另一个分词器
          "keep_separete_first_letter":false,//是否分词每个字的首字母
          "keep_full_pinyin":true,//是否全拼分词
          "keep_original":true,//是否保留原始输入
          "remove_duplicated_term":true//是否删除重复项
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "age":{
        "type": "integer"
      },
      "name":{
        "type": "text",
        "store": true,
        "index": true,
        "analyzer": "ik_pinyin"
      }
    }
  }
}

    即在ik分词器分词后，再用拼音分词器进行分词。

  2. 测试自定义分词器ik+pinyin

    GET /student3/_analyze
{
  "text":"我是要成为海贼王的男人",
  "analyzer": "ik_pinyin"
}

    “keep_separete_first_letter”:false，所以没有wsycwhzwdnr这一段首字母拼音。
    “keep_full_pinyin”:true，所以每个字的全拼都会被分词。
    “keep_original”:true，所以ik分词器分词后的结果也还在。
    “remove_duplicated_term”:true，所以分词器分词后显示的结果不会重复。

二、搜索文档

1、添加文档数据

  1. 创建students索引

    PUT /students
{
  "mappings": {
    "properties": {
      "id": {
        "type": "integer",
        "index": true
      },
      "name": {
        "type": "text",
        "store": true,
        "index": true,
        "analyzer": "ik_smart"
      },
      "info": {
        "type": "text",
        "store": true,
        "index": true,
        "analyzer": "ik_smart"
      }
    }
  }
}

  2. 在students索引中创建文档

    POST /students/_doc
{
  "id":1,
  "name":"羚羊王子",
  "info":"阿里嘎多美羊羊桑"
}
POST /students/_doc
{
  "id":2,
  "name":"沸羊羊",
  "info":"吃阿里嘎多美羊羊桑"
}
POST /students/_doc
{
  "id":3,
  "name":"美羊羊",
  "info":"沸羊羊，你八嘎呀lua"
}
POST /students/_doc
{
  "id":4,
  "name":"李青",
  "info":"一库一库"
}
POST /students/_doc
{
  "id":5,
  "name":"亚索",
  "info":"面对疾风吧"
}

2、搜索方式

  1. 查询所有文档

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

  2. 将查询条件分词后再进行搜索

    GET /students/_search
{
  "query": {
    "match": {
      "info":"阿里嘎多"
    }
  }
}

    即将跟分词后的结果，一个一个进行搜索。

  3. ES纠错功能(即模糊查询)

    GET /students/_search
{
  "query": {
    "match": {
      "info":{
        "query": "lue",
        "fuzziness": 1//最多错误字符数,不能超过2
      }
    }
  }
}

使用match方式可以实现模糊查询，但是模糊查询对中文的支持效果一般。

  1. 对数字类型的字段进行范围搜索

    GET /students/_search
{
  "query": {
    "range": {
      "id": {
        "gte": 1,
        "lte": 3
      }
    }
  }
}

    此时gt是大于，lt是小于，后面的e是等于。

  2. 短语检索，搜索条件不做任何分词解析，在搜索字段对应的倒排索引中精确匹配。

    GET /students/_search
{
  "query": {
    "match_phrase": {
      "info": "八嘎"
    }
  }
}

    它用于关键词检索，但是得是分词器认为是关键词才算是关键词，例如美羊羊就不算，但是沸羊羊就算。也可以在ik的扩展词文件中去设置关键词。

  3. 单词/词组搜索。搜索条件不做任何分词解析，在搜索字段对应的倒排索引中精确匹配。
    1）单词搜索

    GET /students/_search
{
  "query": {
    "term": {
      "info": "疾风"
    }
  }
}

    单词搜索时跟短语检索很像。但是此时沸羊羊在单词这边查询不到，估计是单词时，条件的字符数不超过2个。
    2）词组搜索

    GET /students/_search
{
  "query": {
    "terms": {
      "info": ["疾风","沸"]
    }
  }
}

    可以多个单词分别作为条件同时搜索。

  4. 复合搜索
    1）must，多个搜索方式必须都满足

    GET /students/_search
{
  "query": {
    "bool": {
      "must": [
        {
         "term":{
            "info": "嘎"
          }
        },
        { 
          "range": {
           "id": {
              "gte": 2,
              "lte": 4
            }
          }
        }
      ]
    }
  }
}

    2）should，多个搜索方式任意满足一个

    GET /students/_search
{
  "query": {
    "bool": {
      "should": [
        {
         "term":{
            "info": "嘎"
          }
        },
        { 
          "range": {
           "id": {
              "gte": 2,
              "lte": 4
            }
          }
        }
      ]
    }
  }
}

    3）must_not，多个搜索方式都必须不满足

    GET /students/_search
{
  "query": {
    "bool": {
      "must": [
        {
         "term":{
            "info": "嘎"
          }
        }
      ],
      "must_not": [
        { 
          "range": {
           "id": {
              "gte": 1,
              "lte": 2
            }
          }
        }
      ]
    }
  }
}

3、ES搜索文档的过滤处理

3.1 结果排序

  1. 默认排序，是根据查询条件的匹配度分数进行排序的

    GET /students/_search
{
  "query": {
    "match": {
      "info": "阿里噶多美羊羊桑"
    }
  }
}

  2. 按照id进行升序排序

    GET /students/_search
{
  "query": {
    "match": {
      "info": "阿里噶多美羊羊桑"
    }
  },
  "sort": [
    {
      "id": {
        "order": "asc"
      }
    }
  ]
}

    降序则把asc改成desc。

3.2 分页查询

  1. 将查询结果从from条开始（不包括from），到from+size条结束（包括from+size）

    GET /students/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 2
}

3.3 高亮查询

  1. 为查询的关键词设置高亮，即在关键词前面和后面加上后缀，再由前端的CS代码设置。

    GET /students/_search
{
  "query": {
    "match": {
      "info": "面对一库阿里噶多美羊羊桑"
    }
  },
  "highlight": {
    "fields": {
      "info": {
        "fragment_size": 100,//返回高亮数据的最大长度
        "number_of_fragments": 5 //返回结果最多可以包含几段不连续的文字
      }
    },
    "pre_tags": ["<em>"],
    "post_tags": ["</em>"]
  }
}

3.4 SQL查询

在ES7之后，支持SQL语句查询文档，但是只支持部分SQL语句。并且开源版本不支持Java操作SQL进行查询。

  1. 使用简单的SQL语句查询文档
    GET /_sql?format=txt
{
  "query": "SELECT * FROM students"
}

三、原生JAVA操作ES

1、搭建项目

  1. 创建一个空项目
    elasticsearch分词器使用 java,分布式,elasticsearch,java,搜索引擎

  2. 在空项目下创建一个maven模块
    elasticsearch分词器使用 java,分布式,elasticsearch,java,搜索引擎

  3. 在maven模块项目中的pom.xml文件中引入依赖

    <dependencies>
    <!--    es    -->
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>7.17.9</version>
    </dependency>
    <!--    es客户端    -->
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-high-level-client</artifactId>
        <version>7.17.9</version>
    </dependency>


    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13</version>
    </dependency>
</dependencies>

    因为最新的客户端只更新到8.0，但是好像不能用，只能用7.17.9版本。

2、索引操作

  1. 创建一个空索引

    //创建空索引
@Test
public void createIndex() throws IOException {
    //1.创建客户端对象，连接ES
    RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.126.24", 9200, "http")));
    //2.创建请求对象
    CreateIndexRequest studentx = new CreateIndexRequest("studentx");
    //3.发送请求
    CreateIndexResponse response = client.indices().create(studentx, RequestOptions.DEFAULT);
    //4.操作响应结果
    System.out.println(response.index());
    //5.关闭客户端
    client.close();
}

  2. 给空索引添加结构

    //给索引添加结构
@Test
public void mappingIndex() throws IOException {
    //1.创建客户端对象，连接ES
    RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.126.24", 9200, "http")));
    //2.创建请求对象
    PutMappingRequest request = new PutMappingRequest("studentx");
    request.source(" {\n" +
            "    \"properties\": {\n" +
            "      \"id\": {\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"name\": {\n" +
            "        \"type\": \"text\"\n" +
            "      },\n" +
            "      \"age\": {\n" +
            "        \"type\": \"integer\"\n" +
            "      }\n" +
            "    }\n" +
            "  }", XContentType.JSON);
    //3.发送请求
    AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
    //4.操作响应结果
    System.out.println(response.isAcknowledged());
    //5.关闭客户端
    client.close();
}

  3. 删除索引

    //删除索引
@Test
public void deleteIndex() throws IOException {
    //1.创建客户端对象，连接ES
    RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.126.24", 9200, "http")));
    //2.创建请求对象
    DeleteIndexRequest request = new DeleteIndexRequest("studentx");
    //3.发送请求
    AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
    //4.操作响应结果
    System.out.println(response.isAcknowledged());
    //5.关闭客户端
    client.close();
}

3、文档操作

  1. 新增/修改文档操作

    // 新增/修改文档
@Test
public void addDocument() throws IOException {
    //1.创建客户端对象，连接ES
    RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.126.24", 9200, "http")));
    //2.创建请求对象
    IndexRequest request = new IndexRequest("studentx").id("1");
    request.source(XContentFactory.jsonBuilder()
            .startObject()
            .field("id",1)
            .field("name","z z x")
            .field("age",18)
            .endObject());
    //3.发送请求
    IndexResponse response = client.index(request, RequestOptions.DEFAULT);
    //4.操作响应结果
    System.out.println(response.status());
    //5.关闭客户端
    client.close();
}

    新增文档成功，但是报了个错Unable to parse response body for Response，意思是无法解析响应的正文。有可能是ES服务用的是8.6.1，但是JAVA依赖的版本是7.17.9，版本不一致导致的。

  2. 根据id查询文档

    // 根据id查询文档
@Test
public void findByIdDocument() throws IOException {
    //1.创建客户端对象，连接ES
    RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.126.24", 9200, "http")));
    //2.创建请求对象
    GetRequest request = new GetRequest("studentx", "1");
    //3.发送请求
    GetResponse response = client.get(request, RequestOptions.DEFAULT);
    //4.操作响应结果
    System.out.println(response.getSourceAsString());
    //5.关闭客户端
    client.close();
}

  3. 删除文档

    // 删除文档
@Test
public void deleteDocument() throws IOException {
    //1.创建客户端对象，连接ES
    RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.126.24", 9200, "http")));
    //2.创建请求对象
    DeleteRequest request = new DeleteRequest("studentx", "1");
    //3.发送请求
    DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
    //4.操作响应结果
    System.out.println(response.status());
    //5.关闭客户端
    client.close();
}

4、搜索文档

  1. 查找所有文档

    // 搜索所有文档
@Test
public void queryAllDocument() throws IOException {
    //1.创建客户端对象，连接ES
    RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.126.24", 9200, "http")));
    //2.创建搜索条件
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.query(QueryBuilders.matchAllQuery());
    //3.创建请求对象
    SearchRequest request = new SearchRequest("studentx").source(searchSourceBuilder);
    //4.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    //5.操作响应结果
    SearchHits hits = response.getHits();
    for (SearchHit hit:hits) {
        System.out.println(hit.getSourceAsString());
    }
    //6.关闭客户端
    client.close();
}

  2. 根据关键词搜索文档文章来源地址https://www.toymoban.com/news/detail-778398.html

    // 根据关键词搜索文档
@Test
public void queryTermDocument() throws IOException {
    //1.创建客户端对象，连接ES
    RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.126.24", 9200, "http")));
    //2.创建搜索条件
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.query(QueryBuilders.termQuery("name","x"));
    //3.创建请求对象
    SearchRequest request = new SearchRequest("studentx").source(searchSourceBuilder);
    //4.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    //5.操作响应结果
    SearchHits hits = response.getHits();
    for (SearchHit hit:hits) {
        System.out.println(hit.getSourceAsString());
    }
    //6.关闭客户端
    client.close();
}

总结：

  1. 1）默认分词器是standard analyzer，是英文分词器，根据空格和标点符号对应英文进行分词，会进行单词的大小写转换。
    2）IK分词器，是中文分词器，分别有两种算法ik_smart：最少切分，即一段话中的字只会被划分一次；ik_max_word：最细粒度划分，即一段话中的字可能会被划分多次。IK分词器中可以在IKAnalyzer.cfg.xml文件中配置自定义词库，其中ext_stopwords是停用词，即不使用；ext_dict是扩展词，即使用。
    3）拼音分词器，将中文进行转换成拼音并且进行分词。即单个文字以及整段文字的拼音进行分词。
    4）自定义分词器可以将ik和拼音分词器进行一个组合，将ik分词器分词后的结果让拼音分词器再进行分词。
  2. GET /students/_search，即GET + 索引+ _search是用来搜索文档的固定格式。
    1）搜索方式有match_all，即搜索该索引全部的文档。
    match，根据查询条件分词后，再按分词的结果一个一个查询，并且match可以实现模糊查询，但是错误的字符数量不能超过两个，使用fuzziness设置。
    range，对数字类型的字段进行范围搜索，gt是大于，lt是小于，后面的e是等于。
    match_phrase，关键词搜索，此时你的搜索条件要与分词器分词后的结果相同才会查询到结构，并且它是精确搜索，不会再分词。
    term是单词搜索，条件的字符数不超过2个，也就是说可能match_phare的搜索范围是包含term的。
    terms是词组搜索，可以多个单词分别作为条件同时搜索。
    复合搜索，must，多个搜索方式必须都满足；should，多个搜索方式任意一个满足；must_not，多个条件都必须不满足。
  3. 由于ES对text类型字段数据会做分词处理，使用哪个单词做排序都是不合理的，所以ES中默认不允许text类型的字段做排序，可以使用keyword类型的字段作为排序依据，因为keyword字段不做分词处理。
    ES默认排序是按查询条件的相关度分数排序，也可以使用sort，依据字段做升序和降序的排序。
    使用from和size进行分页查询，从from（不包括from）位置开始到from+size位置结束。
    highlight，为查询的关键词设置高亮，即在关键词前面和后面加上后缀，再由前端的CS代码设置。
    在ES7之后，支持SQL语句查询文档，但是只支持部分SQL语句。并且开源版本不支持Java操作SQL进行查询。
  4. 原生JAVA操作ES时，索引操作时，使用CreateIndexRequest，PutMappingRequest，DeleteIndexRequest类进行索引的操作。
    文档操作时，使用IndexRequest，GetRequest，DeleteRequest类进行文档的操作。
    搜索文档时，使用SearchRequest类进行搜索的操作。
    每次访问ES时，都需要创建客户端对象去连接ES，创建请求对象，发送请求到ES，然后ES返回一个响应，对这个响应进行处理，最后关闭这个客户端。

到了这里，关于Elasticsearch_分词器、搜索文档以及原生JAVA操作的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包