ES elasticserch


ES elasticserch

  • elasticserch 是一个开源的分布式搜索引擎,可以用来实现搜索,日志统计,分析,系统监控等功能

  • elastic stack (ELK)是以elasticsearch为核心的技术栈,包括beats,Logstash,kibana,elasticsearch

  • Lucene 是Apache的开源搜索引擎类库,提供了搜索引擎的核心API

正向索引和倒排索引

  • 文档和词条:

    *文档:每一条数据就是一个文档

    *词条:对文档中的内容分词,得到的词语就是词条

  • 正向索引

    *基于文档id创建索引,查询词条时必须找到文档,然后判断是否包含词条

  • 倒排索引

    *对文档内容分词,对词条创建索引,并记录词条所在文档的信息。查询时现根据词条查询到文档id,而后获取到文档。

基本概念

  • 文档:一条数据就是一个文档,es中式json格式

  • 字段:json文档中的字段

  • 索引:同类型文档的集合

  • 映射:索引中文档的约束,比如字段名称,类型

  • elasticsearch与数据库的关系

    • 数据库负责事务类操作

    • elasticsearch负责海量数据的搜索,分析,计算

  • DSL 是elasticsearch提供的JSON风格的请求语句,用来操作elasticsearch,实现CRUD,

    实现的是Rest风格接口,任何语言可以发HTTP请求,都可以接收DSL

分词器

  • 分词器的作用:

    • 创建倒排索引时对文档分词

    • 用户搜索时,对输入的内容分词

  • IK分词器有几种模式?

    • ik_smart :智能切分,粗粒度

    • ik_max_word: 最细切分,细粒度

  • Ik分词器如何扩展词条?如何停用词条

    • 利用config目录IkAnalyzer.cfg.xml文件添加扩展词典和停用词典

    • 在词典中添加扩展词和停用词条

    • 重启docker

mapping属性

  • mapping常见属性有哪些/

    • type : 数据类型

    • index : 是否索引,默认true

    • analyzer : 分词器

    • properties :子字段

  • type常见的有哪些/

    • 字符串 :text ,keyword(不需要分)

    • 数字:long,integer ,short,byte,double, float

    • 布尔 :boolean

    • 日期 :date

    • 对象 :object

索引库操作

  • 创建索引库 :PUT /索引库名

  • 查询索引库 :GET /索引库名

  • 删除索引库 : DELETE /索引库名

  • 添加索引库 : PUT /索引库名/_mapping

文档操作

  • 创建文档 :PSOT /索引库名 /_doc /文档id {json文档}

  • 查询文档 :GET /索引库名 /_doc /文档id

  • 删除文档 :DELETE /索引库名 /_doc /文档id

  • 修改文档 :

    • 全量修改 : PUT /索引库名 /_doc/文档id {json文档}

    • 增量修改:PSOT /索引库名 /_update /文档id {“doc”:{字段}}

RestClient操作索引库

  • 官方文档地址:https://www.elastic.co/guide/en/elasticsearch/client/index.html

  • 导包

        //要指定版本号,因为springBoot 中指定的版本不一致
      <properties>
          <elasticsearch.version>7.12.1</elasticsearch.version>
      </properties>

          <!--elasticsearch :client-->
          <dependency>
              <groupId>org.elasticsearch.client</groupId>
              <artifactId>elasticsearch-rest-high-level-client</artifactId>
          </dependency>
  • 索引表

    package cn.itcast.hotel.constants;

    public class HotelIndexConstants {
       public static final String MAPPING_TEMPLATE =
               "{/n" +
               " /"mappings/": {/n" +
               "   /"properties/": {/n" +
               "     /"id/": {/n" +
               "       /"type/": /"keyword/"/n" +
               "     },/n" +
               "     /"name/": {/n" +
               "       /"type/": /"text/",/n" +
               "       /"analyzer/": /"ik_max_word/",/n" +
               "       /"copy_to/": /"all/"/n" +
               "     },/n" +
               "     /"address/": {/n" +
               "       /"type/": /"keyword/",/n" +
               "       /"index/": false/n" +
               "     },/n" +
               "     /"price/": {/n" +
               "       /"type/": /"integer/"/n" +
               "     },/n" +
               "     /"score/": {/n" +
               "       /"type/": /"integer/"/n" +
               "     },/n" +
               "     /"brand/": {/n" +
               "       /"type/": /"keyword/",/n" +
               "       /"copy_to/": /"all/"/n" +
               "     },/n" +
               "     /"city/": {/n" +
               "       /"type/": /"keyword/"/n" +
               "     },/n" +
               "     /"starName/": {/n" +
               "       /"type/": /"keyword/"/n" +
               "     },/n" +
               "     /"business/": {/n" +
               "       /"type/": /"keyword/",/n" +
               "       /"copy_to/": /"all/"/n" +
               "     },/n" +
               "     /"pic/": {/n" +
               "       /"type/": /"keyword/",/n" +
               "       /"index/": false/n" +
               "     },/n" +
               "     /"location/": {/n" +
               "       /"type/": /"geo_point/"/n" +
               "     },/n" +
               "     /"all/": {/n" +
               "       /"type/": /"text/",/n" +
               "       /"analyzer/": /"ik_max_word/"/n" +
               "     }/n" +
               "   }/n" +
               " }/n" +
               "}";
    }

 

```file
PUT /hotel
{
  "mappings": {
      "properties": {
          "id": {
              "type": "keyword"
              },
          "name": {
              "type": "text",
              "analyzer": "ik_max_word",
              "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"
              },
          "pic": {
                  "type": "keyword",
                  "index": "false"
              },
          "location": {
                  "type": "geo_point"
            },
          "all": {
                  "type": "text",
                  "analyzer": "ik_max_word"
                }
          }
     
    }
     
}

 

  • Test

    package cn.itcast.hotel;

    import org.apache.http.HttpHost;
    import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
    import org.elasticsearch.client.RequestOptions;
    import org.elasticsearch.client.RestClient;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.elasticsearch.client.indices.CreateIndexRequest;
    import org.elasticsearch.client.indices.GetIndexRequest;
    import org.elasticsearch.common.xcontent.XContentType;
    import org.junit.jupiter.api.AfterEach;
    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.Test;

    import java.io.IOException;

    import static cn.itcast.hotel.constants.HotelIndexConstants.MAPPING_TEMPLATE;

    public class HotelIndexTest {
       //先要初始化
       private RestHighLevelClient client;
       
       @BeforeEach
       void setUp(){
           //初始化
           this.client = new RestHighLevelClient(RestClient.builder(

                   HttpHost.create("http://192.168.142.130:9200")//指定虚拟机的端口号
          ));
      }

       @AfterEach
       void deadDown() throws IOException {

           this.client.close();//关闭
      }
       
       @Test
       void initTest(){
           System.out.println(client);
      }
       @Test
       void createIndexTest() throws IOException {
           //创建索引对象,并指定索引名
           CreateIndexRequest request = new CreateIndexRequest("hotel");
           //加载创建索引的表
           request.source(MAPPING_TEMPLATE, XContentType.JSON);
           //执行:indices()封装了所有的索引API
           client.indices().create(request,RequestOptions.DEFAULT);
      }
       //删除索引
       @Test
       void deleteIndexTest() throws IOException {

           DeleteIndexRequest request = new DeleteIndexRequest("hotel");

           client.indices().delete(request,RequestOptions.DEFAULT);
      }
       //判断索引是否存在
       @Test
       void existIndexTest() throws IOException {

           GetIndexRequest request = new GetIndexRequest("hotel");

           boolean flag = client.indices().exists(request, RequestOptions.DEFAULT);
           System.out.println(flag ? "存在":"不存在");
      }

    }

操作文档

  • test

package cn.itcast.hotel;

import cn.itcast.hotel.pojo.Hotel;
import cn.itcast.hotel.pojo.HotelDoc;
import cn.itcast.hotel.service.IHotelService;
import com.alibaba.fastjson.JSON;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
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 static cn.itcast.hotel.constants.HotelIndexConstants.MAPPING_TEMPLATE;
@SpringBootTest
public class HotelIndexDocumentTest {

   @Autowired
   private IHotelService hotelService;

   private RestHighLevelClient client;
   //操作文档
   @Test
   void selectIndexDocument() throws IOException {
       //查询hotel 对象
       Hotel hotel = hotelService.getById(36934L);
       //对象转换location
       HotelDoc hotelDoc = new HotelDoc(hotel);
       //正确的转json:toJSONString
       String json = JSON.toJSONString(hotelDoc);
       //创建文档对象
       IndexRequest request = new IndexRequest("hotel").id(hotel.getId().toString());
       //将对象转化为json
       //request.source(JSON.toJSON(hotelDoc),XContentType.JSON);
       request.source(json,XContentType.JSON);
       //发送
       client.index(request,RequestOptions.DEFAULT);
  }
   @BeforeEach
   void setUp(){
       //初始化
       this.client = new RestHighLevelClient(RestClient.builder(
               HttpHost.create("http://192.168.142.130:9200")
      ));
  }

   @AfterEach
   void deadDown() throws IOException {

       this.client.close();//关闭
  }
}
  • pojo

package cn.itcast.hotel.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
public class HotelDoc {
   private Long id;
   private String name;
   private String address;
   private Integer price;
   private Integer score;
   private String brand;
   private String city;
   private String starName;
   private String business;
   private String location;
   private String pic;

   public HotelDoc(Hotel hotel) {
       this.id = hotel.getId();
       this.name = hotel.getName();
       this.address = hotel.getAddress();
       this.price = hotel.getPrice();
       this.score = hotel.getScore();
       this.brand = hotel.getBrand();
       this.city = hotel.getCity();
       this.starName = hotel.getStarName();
       this.business = hotel.getBusiness();
       this.location = hotel.getLatitude() + ", " + hotel.getLongitude(); //这里进行了转换
       this.pic = hotel.getPic();
  }
}

查删改

//查询
   @Test
   void getDocumentByIdTest() throws IOException {
       
       //创建获取对象:指定索引和id
       GetRequest request = new GetRequest("hotel", "36934");
       //获取响应结果
       GetResponse response = client.get(request,RequestOptions.DEFAULT);
       //得到source:json原数据
       String json = response.getSourceAsString();
       //将字符串转换成对象
       HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);

       System.out.println(hotelDoc);
  }
   //更新
   @Test
   void updateDocument() throws IOException {
       //创建对象
       UpdateRequest request = new UpdateRequest("hotel", "36934");
       //准备请求参数
       request.doc(
               "starName","四钻",
               "price","1314"
      );
       //发送请求
       client.update(request,RequestOptions.DEFAULT);
  }
   //删除
   @Test
   void deleteDocument() throws IOException {
       DeleteRequest request = new DeleteRequest("hotel", "36934");
       client.delete(request,RequestOptions.DEFAULT);
  }

批量插入

@Test
   void bulkRequest() throws IOException {

       //数据库查询
       List<Hotel> hotels = hotelService.list();

       BulkRequest request = new BulkRequest();
       for (Hotel hotel : hotels) {
           //转换
           HotelDoc hotelDoc = new HotelDoc(hotel);
           //正确的转Json
           String json = JSON.toJSONString(hotelDoc);
           //批量添加数据
           request.add(new IndexRequest("hotel")
                  .id(hotel.getId().toString())
                  .source(json, XContentType.JSON));
      }
       //发送
       client.bulk(request, RequestOptions.DEFAULT);
  }

 

 

原创文章,作者:,如若转载,请注明出处:https://blog.ytso.com/275722.html

(0)
上一篇 2022年7月21日
下一篇 2022年7月21日

相关推荐

发表回复

登录后才能评论