带你了解如何使用ElasticSearch下

置顶 ‏猿究院Sublate

已于 2023-09-06 17:06:09 修改

阅读量91

点赞数

文章标签： elasticsearch 大数据搜索引擎

于 2023-09-06 17:03:25 首次发布

本文链接：https://blog.csdn.net/2301_77852117/article/details/132718231

版权

3.multiMatchQuery()：多字段查询

4.termQuery():词条精确值查询

5.rangeQuery():范围查询

6.bool复合查询

7.分页查询

RestAPI ES

官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。官方文档地址：https://www.elastic.co/guide/en/elasticsearch/client/index.html

其中的Java Rest Client又包括两种：

Java Low Level Rest Client

Java High Level Rest Client

我们学习的是Java HighLevel Rest Client客户端API

数据结构如下

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,
"copy_to": "all"
},
"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合并，提供给用户搜索

初始化RestClient

在elasticsearch提供的API中，与elasticsearch一切交互都封装在一个名为RestHighLevelClient的类中，必须先完成这个对象的初始化，建立与elasticsearch的连接。分为三步：

1）引入es的RestHighLevelClient依赖：

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

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

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

3）初始化RestHighLevelClient：初始化的代码如下：

RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://localhost:9200")
));

这里为了单元测试方便，我们创建一个测试类HotelIndexTest，然后将初始化的代码编写在 @BeforeEach方法中：

public class HotelIndexTest {
private RestHighLevelClient client;
@BeforeEach
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://localhost:9200")
));
}
@AfterEach
void tearDown() throws IOException {
this.client.close();
}
}

创建索引库

创建索引库的API如下：创建一个类，定义mapping映射的JSON字符串常量：

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" +
"}";

在hotel-demo中的HotelIndexTest测试类中，编写单元测试，实现创建索引：

@Test
void createHotelIndex() throws IOException {
// 1.创建Request对象
CreateIndexRequest request = new CreateIndexRequest("hotel");
// 2.准备请求的参数：DSL语句
request.source(MAPPING_TEMPLATE, XContentType.JSON);
// 3.发送请求
client.indices().create(request, RequestOptions.DEFAULT);
}

删除索引库

在hotel-demo中的HotelIndexTest测试类中，编写单元测试，实现删除索引：

@Test
void testDeleteHotelIndex() throws IOException {
// 1.创建Request对象
DeleteIndexRequest request = new DeleteIndexRequest("hotel");
// 2.发送请求
client.indices().delete(request, RequestOptions.DEFAULT);
}

判断索引库是否存在

@Test
void testExistsHotelIndex() throws IOException {
// 1.创建Request对象
GetIndexRequest request = new GetIndexRequest("hotel");
// 2.发送请求
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
// 3.输出
System.err.println(exists ? "索引库已经存在！" : "索引库不存在！");
}

总结

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

索引库操作的基本步骤：初始化RestHighLevelClient

创建XxxIndexRequest。XXX是Create、Get、Delete

准备DSL（ Create时需要，其它是无参）

发送请求。调用RestHighLevelClient#indices().xxx()方法，xxx是create、exists、delete

RestClient操作文档

新增文档与数据库相关的实体类

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

我们需要定义一个新的类型，与索引库结构吻合：为ES索引库设计实体类

longitude和latitude需要合并为location

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

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

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

查询文档

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

@Test
void testGetDocumentById() throws IOException {
// 1.准备Request
GetRequest request = new GetRequest("hotel", "61082");
// 2.发送请求，得到响应
GetResponse response = client.get(request, RequestOptions.DEFAULT);
// 3.解析响应结果
String json = response.getSourceAsString();
HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
System.out.println(hotelDoc);
}

删除文档

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

@Test
void testDeleteDocument() throws IOException {
// 1.准备Request
DeleteRequest request = new DeleteRequest("hotel", "61083");
// 2.发送请求
client.delete(request, RequestOptions.DEFAULT);
}

修改文档

修改我们讲过两种方式：

全量修改：本质是先根据id删除，再新增

增量修改：修改文档中的指定字段值

在RestClient的API中，全量修改与新增的API完全一致

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

@Test
void testUpdateDocument() throws IOException {
// 1.准备Request
UpdateRequest request = new UpdateRequest("hotel", "61083");
// 2.准备请求参数
request.doc(
"price", "952",
"starName", "四钻"
);
// 3.发送请求
client.update(request, RequestOptions.DEFAULT);
}

批量导入文档

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

@Test
void testBulkRequest() throws IOException {
// 批量查询酒店数据
List<Hotel> hotels = hotelService.list();
// 1.创建Request
BulkRequest request = new BulkRequest();
// 2.准备参数，添加多个新增的Request
for (Hotel hotel : hotels) {
// 2.1.转换为文档类型HotelDoc
HotelDoc hotelDoc = new HotelDoc(hotel);
// 2.2.创建新增文档的Request对象
request.add(new IndexRequest("hotel")
.id(hotelDoc.getId().toString())
.source(JSON.toJSONString(hotelDoc), XContentType.JSON));
}
// 3.发送请求
client.bulk(request, RequestOptions.DEFAULT);
}

自定义响应解析方法

void show(SearchResponse response){
        //解析响应
        SearchHits searchHits =response.getHits();
        //获取总条数
        Long total = searchHits.getTotalHits().value;
        System.out.println("共搜到"+total+"条数据");
        //文档数组
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String json = hit.getSourceAsString();
            System.err.println(json);
            HotelDoc hotelDoc = JSON.parseObject(json,HotelDoc.class);
            System.out.println(hotelDoc);
        }
    }

小结

文档操作的基本步骤：

初始化RestHighLevelClient

创建XxxRequest。XXX是Index、Get、Update、Delete、Bulk

准备参数（Index、Update、Bulk时需要）

发送请求。调用RestHighLevelClient#.xxx()方法，xxx是index、get、update、delete、bulk

解析结果（Get时需要）

ElasticSearch查询

DSL查询文档

elasticsearch的查询依然是基于JSON风格的DSL来实现的。

DSL查询分类

Elasticsearch提供了基于JSON的DSL（Domain Specific Language）来定义查询。常见的查询类型包括：

查询所有：查询出所有数据，一般测试用(不会显示出所有，自带分页功能)。例如：match_all

全文检索（full text）查询：利用分词器对用户输入内容分词，然后去倒排索引库中匹配。例如： match_query：单字段查询

multi_match_query：多字段查询，任意一个字段符合条件就算符合查询条件

精确查询：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：

ids range根据值的范围查询

term根据词条精确值查询

地理（geo）查询：根据经纬度查询。例如：

geo_distance

geo_bounding_box

复合（compound）查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如： bool

function_score

RestClient查询文档

文档的查询同样适用昨天学习的 RestHighLevelClient对象，基本步骤包括：

1）准备Request对象

2）准备请求参数

3）发起请求

4）解析响应

快速入门

1.MatchAll():查询所有

@Test
void testMatchAll() throws IOException {
// 1.准备Request
SearchRequest request = new SearchRequest("hotel");
// 2.准备DSL，QueryBuilders构造查询条件
request.source()
.query(QueryBuilders.matchAllQuery());
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}
private void handleResponse(SearchResponse response) {
// 4.解析响应
SearchHits searchHits = response.getHits();
// 4.1.获取总条数
long total = searchHits.getTotalHits().value;
System.out.println("共搜索到" + total + "条数据");
// 4.2.文档数组
SearchHit[] hits = searchHits.getHits();
// 4.3.遍历
for (SearchHit hit : hits) {
// 获取文档source
String json = hit.getSourceAsString();
// 反序列化
HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
System.out.println("hotelDoc = " + hotelDoc);
}
}

2.matchQuery():单字段查询

	@Test
    void testMatch() throws IOException {
        //1.准备request
        SearchRequest request = new SearchRequest("hotels");
        // 2.准备DSL 参数1：字段  参数2：数据
        request.source().query(QueryBuilders.matchQuery("all","如家"));
        //3.执行查询，返回响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应
        show(response);
    }

3.multiMatchQuery()：多字段查询

	@Test
    void testMultiMatch() throws IOException {
        //1.准备request
        SearchRequest request = new SearchRequest("hotels");
        // 2.准备DSL
        request.source().query(QueryBuilders.multiMatchQuery("如家","name","business"));
        //3.执行查询，返回响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应
        show(response);
    }

4.termQuery():词条精确值查询

@Test
    void testTermQuery() throws IOException {
        //1.准备request
        SearchRequest request = new SearchRequest("hotels");
        // 2.准备DSL
        request.source().query(QueryBuilders.termQuery("city","上海"));
        //3.执行查询，返回响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应
        show(response);
    }

5.rangeQuery():范围查询

	@Test
    void testRangeQuery() throws IOException {
        //1.准备request
        SearchRequest request = new SearchRequest("hotels");
        // 2.准备DSL
        request.source().query(QueryBuilders.rangeQuery("pirce").gte(100).lte(200));
        //3.执行查询，返回响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应
        show(response);
    }

6.bool复合查询

布尔查询是一个或多个查询子句的组合,子查询的组合方式有:
must:必须匹配每个子查询，类似“与”;
should:选择性匹配子查询，类似“或”;
must_not:必须不匹配，不参与算分，类似“非”;
filter:必须匹配，类似“与”，不参与算分一般搜索框用must，选择条件使用filter;

@Test
    void testBool() throws IOException {
        SearchRequest request = new SearchRequest("hotels");
        //方式1
//        BoolQueryBuilder boolQuery = new BoolQueryBuilder();
//        boolQuery.must(QueryBuilders.termQuery("city","上海"));
//        boolQuery.filter(QueryBuilders.rangeQuery("price").gte(100).lte(200));
//        request.source().query(boolQuery);
        //方式2
        request.source().query(new BoolQueryBuilder()
                .must(QueryBuilders.termQuery("city","上海"))
                .filter(QueryBuilders.rangeQuery("price").gte(100).lte(200)));
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        show(response);
    }

7.分页查询

	 @Test
    void testPageAndSort() throws IOException {
        int page = 1, size = 5;
        String searchName = "如家";
        SearchRequest request = new SearchRequest("hotels");
        // 2.1.query
        if(searchName == null){
            request.source().query(QueryBuilders.matchAllQuery());
        }else{
            request.source().query(QueryBuilders.matchQuery("name", searchName));
        }
        // 2.2.分页 from、size
        request.source().from((page - 1) * size).size(size);
        //2.3.排序
        request.source().sort("price", SortOrder.DESC);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        show(response);
    }