一、Elasticsearch

Linux系统通过Docker安装Elasticsearch、部署kibana

1.Elasticsearch

Elasticsearch 是位于 Elastic Stack 核心的分布式搜索和分析引擎。Logstash 和 Beats
有助于收集、聚合和丰富您的数据并将其存储在 Elasticsearch 中。Kibana
使您能够以交互方式探索、可视化和分享对数据的见解，并管理和监控堆栈。

简单的说：elasticsearch是一款非常强大的开源搜索引擎，具备非常多强大功能，可以帮助我们从海量数据中快速找到需要的内容

1.1Elasticsearch的一些概念

elasticsearch中有很多独有的概念，与mysql中略有差别，但也有相似之处。

1.1.1.文档和字段

elasticsearch是面向文档（Document）存储的，可以是数据库中的一条商品数据，一个订单信息。

文档数据会被序列化为json格式后存储在elasticsearch中：而Json文档中往往包含很多的字段（Field），类似于数据库中的列。

1.1.2.索引和映射

索引（Index），就是相同类型的文档的集合。

例如：

• 所有用户文档，就可以组织在一起，称为用户的索引；
• 所有商品的文档，可以组织在一起，称为商品的索引；
• 所有订单的文档，可以组织在一起，称为订单的索引；
  

因此，我们可以把索引当做是数据库中的表。

数据库的表会有约束信息，用来定义表的结构、字段的名称、类型等信息。因此，索引库中就有映射（mapping），是索引中文档的字段约束信息，类似表的结构约束。

1.1.3.mysql与elasticsearch

我们统一的把mysql与elasticsearch的概念做一下对比：

MySQL	Elasticsearch	说明
Table	Index	索引(index)，就是文档的集合，类似数据库的表(table)
Row	Document	文档（Document），就是一条条的数据，类似数据库中的行（Row），文档都是JSON格式
Column	Field	字段（Field），就是JSON文档中的字段，类似数据库中的列（Column）
Schema	Mapping	Mapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema）
SQL	DSL	DSL是elasticsearch提供的JSON风格的请求语句，用来操作elasticsearch，实现CRUD

是不是说，我们学习了elasticsearch就不再需要mysql了呢？

并不是如此，两者各自有自己的擅长支出：

• Mysql：擅长事务类型操作，可以确保数据的安全和一致性

• Elasticsearch：擅长海量数据的搜索、分析、计算

因此在企业中，往往是两者结合使用：

• 对安全性要求较高的写操作，使用mysql实现
• 对查询性能要求较高的搜索需求，使用elasticsearch实现
• 两者再基于某种方式，实现数据的同步，保证一致性

2.Elasticsearch的索引库操作

2.1.mapping映射属性

mapping是对索引库中文档的约束，常见的mapping属性包括：

• type：字段数据类型，常见的简单类型有：
  • 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）
  • 数值：long、integer、short、byte、double、float、
  • 布尔：boolean
  • 日期：date
  • 对象：object
• index：是否创建索引，默认为true
• analyzer：使用哪种分词器
• properties：该字段的子字段

例如下面的json文档：

{
    "age": 21,
    "weight": 52.1,
    "isMarried": false,
    "info": "黑马程序员Java讲师",
    "email": "zy@itcast.cn",
    "score": [99.1, 99.5, 98.9],
    "name": {
        "firstName": "云",
        "lastName": "赵"
    }
}

对应的每个字段映射（mapping）：

• age：类型为 integer；参与搜索，因此需要index为true；无需分词器
• weight：类型为float；参与搜索，因此需要index为true；无需分词器
• isMarried：类型为boolean；参与搜索，因此需要index为true；无需分词器
• info：类型为字符串，需要分词，因此是text；参与搜索，因此需要index为true；分词器可以用ik_smart
• email：类型为字符串，但是不需要分词，因此是keyword；不参与搜索，因此需要index为false；无需分词器
• score：虽然是数组，但是我们只看元素的类型，类型为float；参与搜索，因此需要index为true；无需分词器
• name：类型为object，需要定义多个子属性
  • name.firstName；类型为字符串，但是不需要分词，因此是keyword；参与搜索，因此需要index为true；无需分词器
  • name.lastName；类型为字符串，但是不需要分词，因此是keyword；参与搜索，因此需要index为true；无需分词器

2.2.索引库的CRUD

• 创建索引库：PUT /索引库名
• 查询索引库：GET /索引库名
• 删除索引库：DELETE /索引库名
• 添加字段：PUT /索引库名/_mapping

这里我们统一使用Kibana编写DSL的方式来演示。
就是如下图这里：

2.2.1.创建索引库和映射

基本语法：

• 请求方式：PUT
• 请求路径：/索引库名，可以自定义
• 请求参数：mapping映射

格式：

PUT /索引库名称
{
  "mappings": {
    "properties": {
      "字段名":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2":{
        "type": "keyword",
        "index": "false"
      },
      "字段名3":{
        "type":"object",
        "properties": {
          "子字段": {
            "type": "keyword"
          }
        }
      },
     // ...略
    }
  }
}

示例：

#创建索引库
PUT /laohuang
{
  "mappings": {
    "properties": {
        "info":{
            "type": "text",
            "analyzer": "ik_smart"
        },
        "email":{
          "type": "keyword",
          "index": false
        },
        "name":{
          "type": "object", 
          "properties": {
              "firstName":{
                  "type":"keyword"
              },
              "lastName":{
                   "type":"keyword"
              }
          }
        }
    }
  }
}

结果截图

2.2.2.查询索引库

基本语法：

• 请求方式：GET

• 请求路径：/索引库名

• 请求参数：无

格式：

GET /索引库名

示例：

2.2.3.修改索引库

倒排索引结构虽然不复杂，但是一旦数据结构改变（比如改变了分词器），就需要重新创建倒排索引，这简直是灾难。因此索引库一旦创建，无法修改mapping。

虽然无法修改mapping中已有的字段，但是却允许添加新的字段到mapping中，因为不会对倒排索引产生影响。

语法说明：

PUT /索引库名/_mapping
{
  "properties": {
    "新字段名":{
      "type": "integer"
    }
  }
}

示例：

2.2.4.删除索引库

语法：

• 请求方式：DELETE

• 请求路径：/索引库名

• 请求参数：无

格式：

DELETE /索引库名

在kibana中测试：

3.文档操作

文档操作有哪些？

• 创建文档：POST /{索引库名}/_doc/文档id { json文档 }
• 查询文档：GET /{索引库名}/_doc/文档id
• 删除文档：DELETE /{索引库名}/_doc/文档id
• 修改文档：
  • 全量修改：PUT /{索引库名}/_doc/文档id { json文档 }
  • 增量修改：POST /{索引库名}/_update/文档id { “doc”: {字段}}

3.1.新增文档

语法：

POST /索引库名/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    "字段3": {
        "子属性1": "值3",
        "子属性2": "值4"
    },
    // ...
}

示例：

POST /laohuang/_doc/1
{
  "email": "123@123.com",
  "info": "老黄秃头发",
  "name": {
    "firstName": "老",
    "lastName": "黄"
  }
}

响应：

3.2.查询文档

根据rest风格，新增是post，查询应该是get，不过查询一般都需要条件，这里我们把文档id带上。

语法：

GET /{索引库名称}/_doc/{id}

通过kibana查看数据：

GET /laohuang/_doc/1

查看结果：

3.3.删除文档

删除使用DELETE请求，同样，需要根据id进行删除：

语法：

DELETE /{索引库名}/_doc/id值

示例：

# 根据id删除数据
DELETE /laohuang/_doc/1

结果：

3.4.修改文档

修改有两种方式：

• 全量修改：直接覆盖原来的文档
• 增量修改：修改文档中的部分字段

3.4.1.全量修改

全量修改是覆盖原来的文档，其本质是：

• 根据指定的id删除文档
• 新增一个相同id的文档

注意：如果根据id删除时，id不存在，第二步的新增也会执行，也就从修改变成了新增操作了。

语法：

PUT /{索引库名}/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    // ... 略
}

示例：

PUT /laohuang/_doc/1
{
  "email":"123@321.com",
  "info":"老黄头发少",
  "name":{
    "firstName": "耄",
    "lastName":"黄"
  }
}

3.4.2.增量修改

增量修改是只修改指定id匹配的文档中的部分字段。

语法：

POST /{索引库名}/_update/文档id
{
    "doc": {
         "字段名": "新的值",
    }
}

示例：

PUT /laohuang/_doc/1
{
  "doc":{
    "info":"老黄没头发"
  }
}

3.5 查询全部文档

查看当前索引库中所有的文档，查询用GET请求

语法：

GET /{索引库名称}/_search

示例：

GET /laohuang/_search

4.RestClient 操作索引库

JavaRestClient操作elasticsearch的流程基本类似。核心是client.indices()方法来获取索引库的操作对象。 索引库操作的基本步骤：

• 创建索引库
• 初始化RestHighLevelClient
• 准备DSL（ Create时需要，其它是无参）
• 创建XxxIndexRequest。XXX是Create、Get、Delete
• 发送请求。调用RestHighLevelClient#indices().xxx()方法，xxx是create、exists、delete

4.1.创建索引库

引入依赖

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

因为SpringBoot默认的ES版本是7.6.2，所以我们需要覆盖默认的ES版本：

<properties>
    <java.version>1.8</java.version>
    <elasticsearch.version>7.12.1</elasticsearch.version>
</properties>

导入案例数据库结构

CREATE TABLE `tb_hotel` (
  `id` bigint(20) NOT NULL COMMENT '酒店id',
  `name` varchar(255) NOT NULL COMMENT '酒店名称；例：7天酒店',
  `address` varchar(255) NOT NULL COMMENT '酒店地址；例：航头路',
  `price` int(10) NOT NULL COMMENT '酒店价格；例：329',
  `score` int(2) NOT NULL COMMENT '酒店评分；例：45，就是4.5分',
  `brand` varchar(32) NOT NULL COMMENT '酒店品牌；例：如家',
  `city` varchar(32) NOT NULL COMMENT '所在城市；例：上海',
  `star_name` varchar(16) DEFAULT NULL COMMENT '酒店星级，从低到高分别是：1星到5星，1钻到5钻',
  `business` varchar(255) DEFAULT NULL COMMENT '商圈；例：虹桥',
  `latitude` varchar(32) NOT NULL COMMENT '纬度；例：31.2497',
  `longitude` varchar(32) NOT NULL COMMENT '经度；例：120.3925',
  `pic` varchar(255) DEFAULT NULL COMMENT '酒店图片；例:/img/1.jpg',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

mapping映射分析生成索引库结构

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",
        "copy_to": "all"
      },
      "starName":{
        "type": "keyword"
      },
      "business":{
        "type": "keyword"
      },
      "location":{
        "type": "geo_point"
      },
      "pic":{
        "type": "keyword",
        "index": false
      },
      "all":{
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}

几个特殊字段说明：

• location：地理坐标，里面包含精度、纬度
• all：一个组合字段，其目的是将多字段的值 利用copy_to合并，提供给用户搜索

4.2.初始化RestHighLevelClient

@Configuration
public class RestHighLevelConfig {
    @Bean
    RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                //地址是虚拟机ip地址:9200
                RestClient.builder(HttpHost.create("http://192.168.80.128:9200"))
        );
        return restHighLevelClient;
    }
}

4.3准备DSL

public class HotelConstants {
    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" +
            "        \"copy_to\": \"all\"\n" +
            "      },\n" +
            "      \"starName\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"business\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"location\":{\n" +
            "        \"type\": \"geo_point\"\n" +
            "      },\n" +
            "      \"pic\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"index\": false\n" +
            "      },\n" +
            "      \"all\":{\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}";
}

4.3.创建XxxIndexRequest。XXX是Create、Get、Delete，并发送请求

@SpringBootTest
class HotelDemoApplicationTests {

    @Autowired
    private RestHighLevelClient client;

    @Test
    void createIndex() throws IOException {
        CreateIndexRequest request = new CreateIndexRequest("hotel");
        request.source(HotelConstants.MAPPING_TEMPLATE, XContentType.JSON);
        client.indices().create(request, RequestOptions.DEFAULT);
    }

    @Test
    void deleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("hotel");
        client.indices().delete(request,RequestOptions.DEFAULT);
    }

    @Test
    void getIndex() throws IOException{
        GetIndexRequest request = new GetIndexRequest("hotel");
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        System.err.println(exists==true?"已经存在":"索引库没存在");
    }
}

5.RestClient操作文档

5.1.新增文档

我们要将数据库的酒店数据查询出来，写入elasticsearch中。

5.1.1.索引库实体类

数据库查询后的结果是一个Hotel类型的对象。结构如下：

@Data
@TableName("tb_hotel")
public class Hotel {
    @TableId(type = IdType.INPUT)
    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 longitude;
    private String latitude;
    private String pic;
}

与我们的索引库结构存在差异：

• longitude和latitude需要合并为location

因此，我们需要定义一个新的类型，与索引库结构吻合：

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

5.1.2.语法说明

新增文档的DSL语句如下：

POST /{索引库名}/_doc/1
{
    "name": "Jack",
    "age": 21
}

对应的java代码如图：

可以看到与创建索引库类似，同样是三步走：

• 1）创建Request对象
• 2）准备请求参数，也就是DSL中的JSON文档
• 3）发送请求

变化的地方在于，这里直接使用client.xxx()的API，不再需要client.indices()了。

5.1.3.完整代码

我们导入酒店数据，基本流程一致，但是需要考虑几点变化：

• 酒店数据来自于数据库，我们需要先查询出来，得到hotel对象
• hotel对象需要转为HotelDoc对象
• HotelDoc需要序列化为json格式

因此，代码整体步骤如下：

• 1）根据id查询酒店数据Hotel
• 2）将Hotel封装为HotelDoc
• 3）将HotelDoc序列化为JSON
• 4）创建IndexRequest，指定索引库名和id
• 5）准备请求参数，也就是JSON文档
• 6）发送请求

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

@Test
    @Test
    void createDoc() throws IOException{
        //根据id查询酒店数据
        Hotel hotel = hotelService.getById(61083L);
        //转换为文档模型
        HotelDoc hotelDoc = new HotelDoc(hotel);
        //将文档模型转为JSON
        String hotelDocJson = JSONObject.toJSONString(hotelDoc);
        //准备request对象
        IndexRequest request = new IndexRequest("hotel").id(hotel.getId().toString());
        //将json文档放入请求中
        request.source(hotelDocJson,XContentType.JSON);
        //发送请求
        client.index(request,RequestOptions.DEFAULT);
    }

发送完、在kibana的doc检查

5.2.查询文档

5.2.1.语法说明

查询的DSL语句如下：

GET /hotel/_doc/{id}

非常简单，因此代码大概分两步：

• 准备Request对象
• 发送请求

不过查询的目的是得到结果，解析为HotelDoc，因此难点是结果的解析。完整代码如下：

可以看到，结果是一个JSON，其中文档放在一个_source属性中，因此解析就是拿到_source，反序列化为Java对象即可。

与之前类似，也是三步走：

• 1）准备Request对象。这次是查询，所以是GetRequest
• 2）发送请求，得到结果。因为是查询，这里调用client.get()方法
• 3）解析结果，就是对JSON做反序列化

5.2.2.完整代码

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

    @Test
    void getDoc() throws  IOException{
        //准备request请求
        GetRequest request = new GetRequest("hotel","61083");
        //发送请求
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        //解析response
        String json = response.getSourceAsString();
        HotelDoc hotelDoc = JSONObject.parseObject(json, HotelDoc.class);
        System.out.println(hotelDoc);
    }

运行结果

5.3.删除文档

删除的DSL为是这样的：

DELETE /hotel/_doc/{id}

与查询相比，仅仅是请求方式从DELETE变成GET，可以想象Java代码应该依然是三步走：

• 1）准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id
• 2）准备参数，无参
• 3）发送请求。因为是删除，所以是client.delete()方法

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

    @Test
    void deleteDoc() throws IOException{
        //获取请求
        DeleteRequest deleteRequest = new DeleteRequest("hotel","61083");
        //发送请求
        client.delete(deleteRequest,RequestOptions.DEFAULT);
    }

测试运行结果：

5.4.修改文档

5.4.1.语法说明

修改我们讲过两种方式：

• 全量修改：本质是先根据id删除，再新增
• 增量修改：修改文档中的指定字段值

这里不再赘述，我们主要关注增量修改。

代码示例如图：

与之前类似，也是三步走：

• 1）准备Request对象。这次是修改，所以是UpdateRequest
• 2）准备参数。也就是JSON文档，里面包含要修改的字段
• 3）更新文档。这里调用client.update()方法

5.4.2.完整代码

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

    void OneUpdateDoc() throws IOException{
        //准备request对象
        UpdateRequest request = new UpdateRequest("hotel","61083");
        //准备修改的参数
        request.doc(
                "starName","老黄钻"
        );
        //发送请求
        client.update(request,RequestOptions.DEFAULT);
    }

测试结果：

5.5.批量导入文档

案例需求：利用BulkRequest批量将数据库数据导入到索引库中。

步骤如下：

• 利用mybatis-plus查询酒店数据

• 将查询到的酒店数据（Hotel）转换为文档类型数据（HotelDoc）

• 利用JavaRestClient中的BulkRequest批处理，实现批量新增文档

5.5.1.语法说明

批量处理BulkRequest，其本质就是将多个普通的CRUD请求组合在一起发送。

其中提供了一个add方法，用来添加其他请求：

能添加的请求包括：

• IndexRequest，也就是新增
• UpdateRequest，也就是修改
• DeleteRequest，也就是删除

因此Bulk中添加了多个IndexRequest，就是批量新增功能了。

其实还是三步走：

• 1）创建Request对象。这里是BulkRequest
• 2）准备参数。批处理的参数，就是其它Request对象，这里就是多个IndexRequest
• 3）发起请求。这里是批处理，调用的方法为client.bulk()方法

我们在导入酒店数据时，将上述代码改造成for循环处理即可。

5.5.2.完整代码

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

    @Test
    void bulkDoc() throws IOException{
        List<Hotel> allHotel = hotelService.list();
        //创建BulkRequest
        BulkRequest request = new BulkRequest();
        for (Hotel hotel : allHotel) {
            //将hotel转成hoteldoc
            HotelDoc hotelDoc = new HotelDoc(hotel);
            //创建新增文档的新增对象
            request.add(new IndexRequest("hotel").id(hotel.getId().toString())
            .source(JSONObject.toJSONString(hotelDoc),XContentType.JSON));
        }
        //发送请求
        client.bulk(request,RequestOptions.DEFAULT);
    }

测试结果：

5.6总结

	请求	发送
删除索引库	DeleteIndexRequest	client.indices().delete(…)
创建索引库	CreateIndexRequest	client.indices().create(…)
判断索引库是否存在	GetIndexRequest	client.indices().exists(…)

	步骤
删除索引库	1）创建Request对象。 2）添加请求参数，其实就是DSL的JSON参数部分。 3）发送请求，
创建索引库	1）创建Request对象。 2）准备参数。这里是无参 3）发送请求。改用delete方法
判断索引库是否存在	1）创建Request对象。2）准备参数。这里是无参 3）发送请求。改用exists方法

	请求	发送
新增文档数据	IndexRequest(…)	client.index(…)
查询文档数据	GetRequest(…)	client.get(…)
删除文档数据	DeleteRequest(…)	client.delete(…)
修改文档数据（全量）	DeleteRequest(…) AND IndexRequest(…)	client.delete(…) AND client.index(…)
修改文档数据（增量）	UpdateRequest(…)	client.update(…)
批量新增文档数据	BulkRequest(…)	client.bulk(…)

	步骤
新增文档数据	1）创建Request对象 2）准备请求参数，也就是DSL中的JSON文档 3）发送请求
查询文档数据	1）准备Request对象 2）发送请求
删除文档数据	1）准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id 2）准备参数，无参 3）发送请求。因为是删除，所以是client.delete()方法
修改文档数据（全量）	1）先根据id删除文档数据，2）新增文档数据
修改文档数据（增量）	1）准备Request对象。这次是修改，所以是UpdateRequest 2）准备参数。也就是JSON文档，里面包含要修改的字段 3）更新文档。这里调用client.update()方法
批量新增文档数据	1）创建Request对象。这里是BulkRequest 2）准备参数。批处理的参数，就是其它Request对象，这里就是多个IndexRequest 3）发起请求。这里是批处理，调用的方法为client.bulk()方法