初次使用elasticsearch整合springboot

初学elasticsearch

1.首先引入所需的依赖

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

2.配置类的编写

我们可以自己编写一个工具类，但是我一般是习惯写在springboot的启动类里面代码如下

@SpringBootApplication
public class EsStudyApplication {

    public static void main(String[] args) {
        SpringApplication.run(EsStudyApplication.class, args);
    }
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")));
        return client;
    }
}

把其中的地址和端口号改成自己的就可以了。

3.方法的使用

当依赖和配置类都写好后就可以开始使用elasticsearch了，我们可以先写一个简单的方法试试水。
首先自动注入一个RestHighLevelClient对象

    @Autowired
    private RestHighLevelClient restHighLevelClient;

然后我们写一个简单的方法

//测试索引的创建
@Test
void testcreate() throws IOException {
    //创建索引
    CreateIndexRequest request = new CreateIndexRequest("fanwenhui");
    //客户端执行请求,请求后获得响应
    CreateIndexResponse createIndexResponse =
            restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
    System.out.println(createIndexResponse);
}

我们可以很清晰的看到这个方法的关键部分CreateIndexRequest是你创建的的请求类，Create显然是创建的请求，才外还有修改更新删除等的请求类。
写好请求后需要将请求执行，就可以了。
还有一些请求我也贴出来了，大家可以看看。

//测试获取索引
    @Test
    void testExistIndex() throws IOException {
        GetIndexRequest request  = new GetIndexRequest("fanwenhui");
        //判断索引是否存在
        boolean exists = restHighLevelClient.indices().exists(request,RequestOptions.DEFAULT);
        System.out.println(exists);
    }

//测试删除索引
    @Test
    void testDeleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("fanwenhui");
        //删除索引
        AcknowledgedResponse delete = restHighLevelClient.indices().delete(request,RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());
    }

以上的都是索引的操作，下面是对文档的操作。

@Test
    void testAddDocument() throws IOException {
        //创建对象
        User user = new User("杨树林", 23);
        //创建请求
        IndexRequest request = new IndexRequest("fanwenhui");
        //规则 put/fanwenhui/_doc/1
        request.id("1");
        //设置超时
        request.timeout(TimeValue.timeValueSeconds(1));
        request.timeout("1s");
        //将我们的数据放入请求
        request.source(JSON.toJSONString(user), XContentType.JSON);
        //客户端发送请求，获取响应的结果
        IndexResponse index = restHighLevelClient.index(request, RequestOptions.DEFAULT);
    }

我们可以看到，其实操作文档和操作索引的方式很相似，都是创建一个请求，然后将请求放入到RestHighLevelClient中执行。

//获取文档,判断是否存在 get /fanwenhui/_doc/1
    @Test
    void findDoucment() throws IOException {
        GetRequest request = new GetRequest("fanwenhui", "1");
        //不获取返回后的 _source的上下文
        request.fetchSourceContext(new FetchSourceContext(false));
        request.storedFields("_none_");

        boolean exists = restHighLevelClient.exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

//获取文档的信息
    @Test
    void getDocument() throws IOException {
        GetRequest request = new GetRequest("fanwenhui","1");
        GetResponse response = restHighLevelClient.get(request, RequestOptions.DEFAULT);
        System.out.println(response);//打印文档的内容
        System.out.println(response.getSource());//返回的全部内容和命令是一样的
    }

//更新文档信息
    @Test
    void updateDocument() throws IOException {
        UpdateRequest request = new UpdateRequest("fanwenhui", "1");
        request.timeout("1s");
        User user = new User("朽木逢春",99);
        request.doc(JSON.toJSONString(user),XContentType.JSON);
        UpdateResponse response = restHighLevelClient.update(request, RequestOptions.DEFAULT);
        System.out.println(response);
    }

//删除文档信息
    @Test
    void deleteDocument() throws IOException {
        DeleteRequest request = new DeleteRequest("fanwenhui","1");
        request.timeout("1s");
        DeleteResponse response = restHighLevelClient.delete(request, RequestOptions.DEFAULT);
        System.out.println(response.status());
    }

还有我们常用的批量操作

//特殊的，批量添加数据
    @Test
    void allsaveDocument() throws IOException {
        BulkRequest request = new BulkRequest();
        //设置超时时间
        request.timeout("10s");

        ArrayList<User> list = new ArrayList<>();
        list.add(new User("杨树林",23));
        list.add(new User("枯木逢春",23));
        list.add(new User("梅开二度",23));
        list.add(new User("紫气东来",23));
        //批处理请求
        for(int i = 0; i<list.size(); i++){
            request.add(new IndexRequest("fanwenhui").id(""+(i+1)).source(JSON.toJSONString(list.get(i)),XContentType.JSON));
        }
        BulkResponse bulkResponse = restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
        System.out.println(bulkResponse.hasFailures());//是否失败,返回flase代表成功
    }

其实批量操作就是将我们的添加请求给循环放到BulkRequest请求中，然后再统一用restHighLevelClient执行。此外还有批量删除也是一样的，只是将添加请求换成删除请求，这里就不做赘述。

接下来就是elaticsearch中最重要的功能了，就是查询

    //查询
    @Test
    void search() throws IOException {
        SearchRequest request = new SearchRequest("fanwenhui");
        //构建搜索的条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //构建高亮
        builder.highlighter();
        //查询条件，我们可以使用QueryBuilder工具类来实现
        //QueryBuilders.termQuery精确匹配
        //QueryBuilders.matchAllQuery()查询匹配所有
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name.keyword","枯木逢春长木耳");
        //查询全部
//        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        builder.query(termQueryBuilder);
        builder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        request.source(builder);
        SearchResponse search = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        System.out.println(JSON.toJSONString(search.getHits()));
        System.out.println("===========================");
        for(SearchHit documentFields : search.getHits().getHits()){
            System.out.println(documentFields.getSourceAsMap());
        }
    }

几乎所有的的查询方法我们都可以通过QueryBuilders来创建，查询的主要的过程其实就是先创建一个SearchRequest请求，创建完之后我们还需要创建一个SearchSourceBuilder用来将所有的搜索条件放入其中。然后再将SearchSourceBuilder对象放入到SearchRequest请求中，最后通过restHighLevelClient来将请求执行。

以上就是我个人对于elasticsearch的一些总结，第一次写博客，有什么不对的地方欢迎各位大佬指出，谢谢。