当先锋百科网

首页 1 2 3 4 5 6 7

在SpringBoot集成ElasticSearch


在上一章我们已经学习了ElasticSearch基本使用,现在我们来看看如何在java中使用ElasticSearch。使用前先启动ElasticSearch和ElasticSearch-Head(为了方便我们查看数据),不知道怎么做的可以参考上一章(注意:本次测试环境使用的是JDK1.8+SpringBoot2.2.5.RELEASE+ElasticSearch7.6.1)

1.导入maven依赖

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

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

2.将我们的ElasticSearch注入到SpringBoot中

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

3.测试ElasticSearch在java中的使用

  1. 对索引的相关操作

    创建ES索引

    @Resource
    private RestHighLevelClient client;
    
    @Test
    void testCreateIndex() throws IOException {
        //1.创建索引的请求,如果该索引已存在则会报错
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("aaron_index");
        //2.执行请求返回一个地址值
        CreateIndexResponse createIndexResponse = client.indices()
                .create(createIndexRequest, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse);
    }
    

    获取ES索引,判断是否存在

    @Test
    void testGetIndex() throws IOException {
        //1.获取索引的请求
        GetIndexRequest getIndexRequest = new GetIndexRequest("aaron_index");
        //2.执行请求返回boolean
        boolean exists = client.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
        if (exists) {
            System.out.println("该索引已存在");
        } else {
            System.out.println("该索引还未创建");
        }
    }
    

    删除ES索引

    @Test
    void testDeleteIndex() throws IOException {
        //1.删除索引的请求
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("aaron_index");
        //2.执行请求后返回删除的状态
        AcknowledgedResponse delete = client.indices()
                    .delete(deleteIndexRequest, RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());
    }
    
  2. 对文档的相关操作

    添加一条文档信息

    @Test
    void testAddDocument() throws IOException {
        //1.创建对象
        User user = new User("Aaron", 20);
        //2.创建请求
        IndexRequest request = new IndexRequest("aaron_index");
        //3.设置一些规则(PUT /aaron_index/_doc/1)
        request.id("1");
        request.timeout(TimeValue.timeValueSeconds(1));
        //4.将我们的数据放入请求
        request.source(JSON.toJSONString(user), XContentType.JSON);
        //5.客户端发送请求,获取响应的结果
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
        System.out.println(indexResponse.toString());
        System.out.println(indexResponse.status());
    }
    

    添加多条文档信息

    @Test
    void testInsertDataInBulk() throws IOException {
        //1.创建BulkRequest对象,并设置超时时间
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");
        //2.创建多个对象
        List<User> userList = new ArrayList<>();
        userList.add(new User("aaron1",18));
        userList.add(new User("aaron2",19));
        userList.add(new User("aaron3",20));
        userList.add(new User("aaron4",21));
        //3.批处理请求(PUT /aaron_index/_doc/1)
        for (int i = 0; i <userList.size() ; i++) {
            bulkRequest.add(
                    //3.1.要插入的索引
                    new IndexRequest("aaron_index")
                    //3.2.设置id为(i+1)
                    .id(""+(i+1))
                    //3.3.放入我们要插入的数据
                    .source(JSON.toJSONString(userList.get(i)),XContentType.JSON)
            );
        }
        //4.执行批量插入的请求
        BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        //5.输出是否失败,返回false代表成功
        System.out.println(bulkResponse.hasFailures());
    }
    

    判断文档是否存在

    @Test
        void testIsDocument() throws IOException {
            //1.获取文档,判断是否存在(GET /aaron_index/1)
            GetRequest getRequest = new GetRequest("aaron_index","1");
            //2.不获取返回的_source上下文
            getRequest.fetchSourceContext(new FetchSourceContext(false));
            boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
            if (exists) {
                System.out.println("该文档已存在");
            } else {
                System.out.println("该文档不存在");
            }
        }
    
    
    

    获取文档信息

    @Test
    void testGetDocument() throws IOException {
        //1.获取文档(GET /aaron_index/1)
        GetRequest getRequest = new GetRequest("aaron_index","1");
        //2.发送请求打印返回结果
        GetResponse documentFields = client.get(getRequest, RequestOptions.DEFAULT);
        System.out.println(documentFields.getSourceAsString());
        System.out.println(documentFields);
    }
    

    根据条件获取文档信息

    @Test
    void testSearch() throws IOException {
        //1.创建搜索请求
        SearchRequest searchRequest = new SearchRequest("aaron_index");
        //2.构建搜索条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //3.查询条件,我们可以使用QueryBuilders工具来实现
            //QueryBuilders.termQuery("name", "aaron1"):精确查找
            //QueryBuilders.matchAllQuery():匹配所有
        //TermQueryBuilder queryBuilder = QueryBuilders.termQuery("name", "aaron1");
        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        searchSourceBuilder.query(matchAllQueryBuilder);
        //4.设置超时时间
        searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        //5.将我们的搜索条件放入到请求当中
        searchRequest.source(searchSourceBuilder);
        //6.客户端执行搜索请求,返回搜索结果
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        //7.循环打印搜索结果
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }
    

    更新文档信息

    @Test
    void testUpdateDocument() throws IOException {
        //1.创建一个更新文档的请求
        UpdateRequest updateRequest = new UpdateRequest("aaron_index", "1");
        //2.设置超时时间(可以不写)
        updateRequest.timeout("1s");
        //3.创建一个新的对象,将对象放到请求当中
        User user = new User("Aaron", 18);
        updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
        //4.执行修改操作
        UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println(updateResponse);
    }
    

    删除文档信息

    @Test
    void testDeleteDocument() throws IOException {
        //1.创建一个删除文档的请求
        DeleteRequest deleteRequest = new DeleteRequest("aaron_index", "1");
        //2.设置超时时间(可以不写)
        deleteRequest.timeout("1s");
        //3.执行删除操作
        DeleteResponse deleteResponse = client.delete(deleteRequest,RequestOptions.DEFAULT);
        System.out.println(deleteResponse);
    }