JZTXT

ES在java中的使用之springboot集成RestHighLevelClient相关

发布时间 2023-06-29 15:48:27作者: 一剑一叶一花

官方下载es并安装；

RestHighLevelClient官网使用文档：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.8/java-rest-high-getting-started-initialization.html

里面包含了所有操作es的相关接口功能以及介绍；

第一步：导入依赖

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

第二步：创建相关配置类（配置es连接地址）

package com.demo;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author sun
 * @Date 2021/6/20 15:40
 */
@Configuration
public class ElasticSearchClientConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient client = new RestHighLevelClient(RestClient
                .builder(new HttpHost("127.0.0.1", 9200, "http")));
        return client;
    }
}

第三步：增、删、改、查相关操作

/**
 * @Author sun
 * @Date 2021/6/20 15:41
 */
@Slf4j
@RestController
@RequestMapping("/demo")
public class EsTest {
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    @Autowired
    private ProductService productService;

    //索引的创建
    @RequestMapping("/esCreate")
    public void testCreateIndex() throws IOException {
        //创建索引对象，并设置索引名
        CreateIndexRequest request = new CreateIndexRequest("java_test");
        //根据索引对象信息创建索引
        CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
        //判断索引是否创建成功---输出为true则创建成功
        System.out.println(createIndexResponse.isAcknowledged());
    }

    //获取索引,只能判断存不存在
    @RequestMapping("/es2")
    public void testExistIndex() throws IOException {
        //创建查询索引对象，并指定查询的索引
        GetIndexRequest request = new GetIndexRequest("java_test");
        //通过对象信息查询索引是否存在
        boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    //删除索引
    @RequestMapping("/esDelete")
    public void testDeleteIndex() throws IOException {
        //创建索引删除对象，并设置索引名
        DeleteIndexRequest request = new DeleteIndexRequest("java_test");
        //根据相关对象信息删除索引
        AcknowledgedResponse response = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(response.isAcknowledged());
    }

    //添加文档 该方法同时拥有修改功能---该id不存在则添加，存在则修改
    //索引：java_test；类型：User；文档：加id的具体的user对象（以后的修改删除会根据此id操作）
    @RequestMapping("/esAdd")
    public void testAddDocument() throws IOException {
        //创建对象
        User user = new User("张三", 18);
        //创建文档信息对象---指定文档所在的索引
        IndexRequest request = new IndexRequest("java_test");
        //指定文档id    规则 put /java_test/_doc/1
        request.id("2");
        request.timeout(TimeValue.timeValueSeconds(1));
        //指定文档数据  将数据放入请求 json
        request.source(JSON.toJSONString(user), XContentType.JSON);
        //根据相关信息创建文档  客户端发送请求,获取响应结果
        IndexResponse indexResponse = restHighLevelClient.index(request, RequestOptions.DEFAULT);

        //获取文档创建的结果---首次创建该文档则返回CREATED,若存在该文档则返回UPDATE
        System.out.println(indexResponse.getResult());
        System.out.println(indexResponse.status());
    }

    //获取文档,判断是否存在
    @RequestMapping("/es5")
    public void testExistDocument() throws IOException {
        GetRequest request = new GetRequest("java_test", "1");
        //不获取返回的_source的上下文
        request.fetchSourceContext(new FetchSourceContext(false));
        request.storedFields("_none_");

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

    //获取文档的信息
    @RequestMapping("/esGet")
    public void testGetDocument() throws IOException {
        //创建查询对象，并指定索引和文档id
        GetRequest request = new GetRequest("java_test", "1");
        //根据相关信息查询文档是否存在
        GetResponse response = restHighLevelClient.get(request, RequestOptions.DEFAULT);
        String sourceAsString = response.getSourceAsString();
        System.out.println(response);//返回全部内容和命令是一样的
        System.out.println(sourceAsString);//打印文档内容
    }

    //更新文档的信息
    @RequestMapping("/esUpdate")
    public void testUpdateDocument() throws IOException {
        //创建修改信息对象，并指定索引和文档id
        UpdateRequest request = new UpdateRequest("java_test", "1");
        User user = new User("李四", 22);
        request.doc(JSON.toJSONString(user), XContentType.JSON);
        UpdateResponse response = restHighLevelClient.update(request, RequestOptions.DEFAULT);
        System.out.println(response.status());
    }

    //删除文档记录
    @RequestMapping("/esDeleteRecord")
    public void testDeleteDocument() throws IOException {
        //创建删除对象---指定索引
        DeleteRequest request = new DeleteRequest("java_test", "1");
        //调用删除方法
        DeleteResponse deleteResponse = restHighLevelClient.delete(request, RequestOptions.DEFAULT);
        System.out.println(deleteResponse.status());
    }

    //真实项目一般都会批量插入数据
    @RequestMapping("/esInsert")
    public void testBulkRequest() throws IOException {
        //定义容器并指定索引
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");

        List<User> userList = new ArrayList<User>();
        userList.add(new User("张三", 18));
        userList.add(new User("李四", 18));
        userList.add(new User("王五", 18));
        userList.add(new User("赵六", 18));
        userList.add(new User("王朝", 18));
        userList.add(new User("马汉", 18));

        //批处理请求
        for (int i = 0; i < userList.size(); i++) {
            //批量更新和批量删除,就在这里修改对应的请求就可以了
            bulkRequest.add(
                    new IndexRequest("java_test")
                            .id("" + (i + 1)) //可写，可不写（不写的话会自动生成相关的文档id）
                            .source(JSON.toJSONString(userList.get(i)), XContentType.JSON)
            );
        }
        //将封装好的信息放入该方法中进行批量添加---将会自动生成id
        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulkResponse.hasFailures());//是否失败,返回false 代表成功
    }

    //查询
    @RequestMapping("/esSelete")
    public void testSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("java_test");
        //构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //查询条件,我们可以使用QueryBuilds工具类来实现
        //QueryBuilders.termQuery() 精确
        //QueryBuilders.matchAllQuery() 匹配所有
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "lisi1");

        sourceBuilder.query(termQueryBuilder);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

        searchRequest.source(sourceBuilder);

        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(JSON.toJSONString(searchResponse.getHits()));
        System.out.println("===============================================");
        for (SearchHit searchHit : searchResponse.getHits().getHits()) {
            System.out.println(searchHit.getSourceAsString());
        }

    }

//复杂查询
@RequestMapping("/testSearchReq")
public void testSearchReq() throws Exception {
    //创建复杂查询对象
    SearchRequest searchRequest = new SearchRequest("java_test");
    //创建一个条件对象用来封装各种条件
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

    //创建一个对象来封装查询条件query
    MatchQueryBuilder queryBuilder = new MatchQueryBuilder("name", "王");
    //使用条件对象来封装查询条件---条件
    sourceBuilder.query(queryBuilder);

    //指定查询的列------条件
    String[] arr = {"name", "age"};
    String[] att = {};
    sourceBuilder.fetchSource(arr, att); //指定查询列和不查询列

    //分页查询---条件
    sourceBuilder.from(0);
    sourceBuilder.size(5);
    //排序----条件
    // SortOrder sortOrder = SortOrder.ASC;------定义排序方式
    sourceBuilder.sort("age", SortOrder.DESC);

    //创建一个高亮对象，封装高亮条件
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    //指定高亮列----也可以用fields，全局定义高亮
    highlightBuilder.field("name");
    highlightBuilder.preTags("<font color='red'>");
    highlightBuilder.postTags("</font>");

    sourceBuilder.highlighter(highlightBuilder);
    //将封装好的条件对象给searchRequest
    searchRequest.source(sourceBuilder);
    //将封装好所有条件的对象给查询方法
    SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    //输出根据条件查出的总条数
    System.out.println("命中条数/查询总数:" + search.getHits().getTotalHits().value);

    //将查出的数据封住为一个数组
    SearchHit[] hits = search.getHits().getHits();
    //遍历数组
    for (SearchHit item : hits) {
        //输出遍历对象
        System.out.println(item.getSourceAsString());
        //遍历输出高亮的字段
        System.out.println(item.getHighlightFields());
    }

 }
}