官方文档

首先我们查看官方文档

https://www.elastic.co/guide/index.html

image-20201118140000249

image-20201118140058995

这里我们选择其他版本。选择7.6

image-20201118140136445

image-20201118140221804

我们一般使用高级的客户端

image-20201118140339392

image-20201118140550864

image-20201118140759717

image-20201118140840923

1
2
3
4
5
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.6.2</version>
</dependency>

image-20201118141356147

环境搭建

创建一个SpringBoot项目

image-20201118141655917

image-20201118142243997

image-20201118142353620

所以我们要修改版本与我们的对应

image-20201118142521569

编写配置类

image-20201118142820589

1
2
3
4
5
6
7
8
9
10
11
@Configuration
public class ElasticSearchClientConfig {

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")));
        return client;
    }
}

索引API

创建索引

CreateIndexRequest request = new CreateIndexRequest("索引名");

client.indices().create(request, RequestOptions.DEFAULT);

create()创建

image-20201118144438096

1
2
3
4
5
6
7
8
9
10
//测试索引的创建 Request PUT kylin_index
@Test
void testCreateIndex() throws IOException {
    //1.创建索引请求 put
    CreateIndexRequest request = new CreateIndexRequest("kylin_index");
    //2.客户端执行请求 IndicesClient,请求后获得响应
    CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
    System.out.println(createIndexResponse);

}

image-20201118144527300

image-20201118144558236

获取索引

new GetIndexRequest("索引名");

client.indices().exists(request, RequestOptions.DEFAULT);

exists()判断是否存在返回boolean

image-20201118144923078

1
2
3
4
5
6
7
//测试获取索引
@Test
void testExistIndex() throws IOException {
    GetIndexRequest request = new GetIndexRequest("kylin_index");
    boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
    System.out.println(exists);
}

image-20201118145208398

删除索引

new DeleteIndexRequest("索引名");

client.indices().delete(request, RequestOptions.DEFAULT);

delete()删除索引方法返回一个AcknowledgedResponse对象通过isAcknowledged()判断是否被删除。

image-20201118145412541

image-20201118145440468

1
2
3
4
5
6
7
//删除索引
@Test
void testDeleteIndex() throws IOException {
    DeleteIndexRequest request = new DeleteIndexRequest("kylin_index");
    AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
    System.out.println(delete.isAcknowledged());
}

文档API

当前所有的索引全都被删除。

image-20201118145703005

创建一个User对象

image-20201118145848073

1
2
3
4
5
6
7
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
}

导入fastjson

1
2
3
4
5
<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>fastjson</artifactId>
   <version>1.2.62</version>
</dependency>

添加文档

image-20201118150912241

XContentType.JSON表示传送的是Json数据

image-20201118150938402

image-20201118151052838

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//测试添加文档
@Test
void testAddDocument() throws IOException {
    //创建对象
    User user = new User("kylin", 3);
    //创建请求
    IndexRequest request = new IndexRequest("kylin_index");

    //规则 put/kylin_index/_doc/1{user(json)}
    request.id("1");
    request.timeout("1s");//过期时间
    //将我们的数据放入请求 json
    request.source(JSON.toJSONString(user), XContentType.JSON);

    //客户端发送请求获取响应结果
    IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);

    System.out.println(indexResponse.toString());
    System.out.println(indexResponse.status());
}

获取文档

判断该文档是否存在

image-20201118151802029

_source就是下面这个数据，不获取。

image-20201118151428766

image-20201118151909053

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//获取文档，判断是否存在 get /kylin_index/_doc/1
@Test
void testIsExists() throws IOException {

    GetRequest getRequest = new GetRequest("kylin_index", "1");

    //不获取返回的_source的上下文 2个可以不用配
    getRequest.fetchSourceContext(new FetchSourceContext(false));
    //将某字段单独存放在GetResponse对象
    getRequest.storedFields("_none");

    boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
    System.out.println(exists);
}

获取文档信息

image-20201118152254103

getSourceAsString()获取_source中的内容以String类型

更新文档

image-20201118153004904

image-20201118153332978

image-20201118153458524

1
2
3
4
5
6
7
8
9
10
11
12
13
//更新文档信息 PUT /kylin_index/1/_update{"doc":{}}
@Test
void testUpdateRequest() throws IOException {
    UpdateRequest updateRequest = new UpdateRequest("kylin_index", "1");
    updateRequest.timeout("1s");

    User user = new User("Kylin", 18);
    updateRequest.doc(JSON.toJSONString(user), XContentType.JSON);//表明传的是json数据类型

    UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);

    System.out.println(updateResponse.status());
}

删除文档

image-20201118153734925

image-20201118153803077

image-20201118153817273

1
2
3
4
5
6
7
8
9
10
//测试删除文档信息 DELETE /kylin_index/1
@Test
void testDeleteRequest() throws IOException {
    DeleteRequest deleteRequest = new DeleteRequest("kylin_index", "1");
    deleteRequest.timeout("1s");

    DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);

    System.out.println(deleteResponse.status());
}

批量操作

创建 BulkRequest对象BulkRequest bulkRequest = new BulkRequest();

client.bulk(bulkRequest, RequestOptions.DEFAULT);

bulkResponse.hasFailures()判断是否失败

image-20201118154220020

image-20201118154353117

image-20201118154415225

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//批量插入数据
@Test
void testBulkRequest() throws IOException {
    BulkRequest bulkRequest = new BulkRequest();
    bulkRequest.timeout("10s");

    ArrayList<User> userList = new ArrayList<>();
    userList.add(new User("kylin1", 3));
    userList.add(new User("kylin2", 3));
    userList.add(new User("kylin3", 3));
    userList.add(new User("kylin4", 3));
    userList.add(new User("kylin5", 3));
    userList.add(new User("kylin6", 3));
    userList.add(new User("kylin7", 3));

    //批处理请求
    for (int i = 0; i < userList.size(); i++) {
        bulkRequest.add(new IndexRequest("kylin_index").id("" + (i + 1)).source(JSON.toJSONString(userList.get(i)), XContentType.JSON));
    }

    BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);

    System.out.println(bulkResponse.hasFailures());//false 是否失败，没有失败代表成功
}

其他的获取更新也类似该操作。

查询文档

创建搜索请求new SearchRequest("索引名");

构建搜索条件SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

  • 查询条件，我们可以使用QueryBuilders工具来实现
  • QueryBuilders.termQuery 精确查询
  • QueryBuilders.matchAllQuery()匹配所有
  • sourceBuilder.query(termQueryBuilder);添加查询条件
  • sourceBuilder.highlighter();构建高亮

搜索请求添加搜索条件searchRequest.source(sourceBuilder);

客户端执行搜索client.search(searchRequest, RequestOptions.DEFAULT);

searchResponse.getHits().getHits()获取hits

image-20201118160520701

image-20201118160543883

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 查询
// SearchRequest 搜索请求
// SearchSourceBuilder 条件构造
// HighlightBuilder 构建高亮
// TermQueryBuilder 精确查询
// MatchAllQueryBuilder
// xxx QueryBuilder 对应我们刚才看到的命令！
@Test
void testSearch() throws IOException {
    SearchRequest searchRequest = new SearchRequest("kylin_index");
    // 构建搜索条件
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

    sourceBuilder.highlighter();//高亮
    // 查询条件，我们可以使用 QueryBuilders 工具来实现
    // QueryBuilders.termQuery 精确
    // QueryBuilders.matchAllQuery() 匹配所有
    TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name",
            "kylin1");
    // MatchAllQueryBuilder matchAllQueryBuilder =
    QueryBuilders.matchAllQuery();
    sourceBuilder.query(termQueryBuilder);
    sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));//超时时间
    searchRequest.source(sourceBuilder);

    SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
    //hits
    System.out.println(JSON.toJSONString(searchResponse.getHits()));

    System.out.println("=================================");
    for (SearchHit documentFields : searchResponse.getHits().getHits()) {
        System.out.println(documentFields.getSourceAsMap());
    }
}