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);
    }