Elasticsearach 结合springBooot 轻松搞定

1. spirngboot引入ES依赖

<!--  elasticsearch版本和环境使用ES版本号保持一致   -->
<properties>
<elasticsearch.version>7.6.1</elasticsearch.version> 
</properties>

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>
<dependency>
    <groupId>com.sun.jna</groupId>
    <artifactId>jna</artifactId>
    <version>3.0.9</version>
</dependency>

2.创建配置文件 

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 xxx
 * @ className:ElasticSearchClientConfig
 * @ description: 创建 Elasticsearch对象放在spring中使用
 * @ create 2021-02-01 17:38
 **/

@Configuration
public class ElasticSearchClientConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient() {

        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        return client;
    }
}

3.测试调用

import com.alibaba.fastjson.JSON;
import com.gildata.task.platform.common.elasticsearch.MyUser;
import com.gildata.task.platform.common.util.date.DateUtils;
import com.gildata.task.platform.dao.model.TaskJobRecord;
import com.gildata.task.platform.provider.service.RedisService;
import com.gildata.task.platform.provider.service.TaskRecordService;
import com.xxl.job.core.biz.model.ReturnT;
import lombok.SneakyThrows;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.alias.Alias;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author cuitao
 * @ className:
 * @ description:
 * @ create 2021-02-01 19:18
 **/
@SpringBootTest
public class ElasticsearchTest {

    // 创建索引[默认配置]
    @Test
    public void createIndex() throws IOException {
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("task_job_record");
        CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse);
    }

    // 创建索引[自定义配置]
    @Test
    public void createIndexByConfig() throws IOException {
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        String index = "task_job_record";
        // 设置配置
        Map<String, Object> setmapping = new HashMap<>();
        // 分区数、副本数、缓存刷新时间
        setmapping.put("number_of_shards", 6);
        setmapping.put("number_of_replicas", 1);
        setmapping.put("refresh_interval", "5s");
        Map<String, Object> keyword = new HashMap<>();
        //设置类型
        keyword.put("type", "keyword");
        Map<String, Object> text = new HashMap<>();
        //设置类型
        text.put("type", "text");
        Map<String, Object> lon = new HashMap<>();
        //设置类型
        lon.put("type", "long");
        Map<String, Object> inte = new HashMap<>();
        //设置类型
        inte.put("type", "integer");
        Map<String, Object> date = new HashMap<>();
        //设置类型
        date.put("type", "date");
        date.put("format", "yyyy-MM-dd HH:mm:ss");

        Map<String, Object> jsonMap2 = new HashMap<>();
        Map<String, Object> properties = new HashMap<>();
        //设置字段message信息
        properties.put("id", lon);
        properties.put("poolConfigId", lon);
        properties.put("jobUniqueId", lon);
        properties.put("processNodeCode", text);
        properties.put("batchNum", inte);
        properties.put("status", inte);
        properties.put("user", text);
        properties.put("createTime", date);
        properties.put("updateTime", date);

        Map<String, Object> mapping = new HashMap<>();
        mapping.put("properties", properties);
        GetIndexRequest getRequest = new GetIndexRequest(index);
        getRequest.local(false);
        getRequest.humanReadable(true);
        boolean exists2 = restHighLevelClient.indices().exists(getRequest, RequestOptions.DEFAULT);
        //如果存在就不创建了
        if (exists2) {
            System.out.println(index + "索引库已经存在!");
            return;
        }
        // 开始创建库
        CreateIndexRequest request = new CreateIndexRequest(index);
        try {
            // 加载数据类型
            request.settings(setmapping);
            request.mapping(mapping);
            //设置别名
            request.alias(new Alias("job_record"));
            CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
            boolean falg = createIndexResponse.isAcknowledged();
            if (falg) {
                System.out.println("创建索引库:" + index + "成功！");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    // 判断索引是否存在
    @Test
    public void existIndex() throws IOException {
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        GetIndexRequest getIndexRequest = new GetIndexRequest("zgc_index");
        boolean exists = restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    //删除索引
    @Test
    public void delIndex() throws IOException {
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("task_job_record");
        AcknowledgedResponse delete = restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
        System.out.println(delete);
        System.out.println(delete.isAcknowledged());
    }

    @Test
    public void test() {
        System.out.println(DateUtils.getDate());
    }

    // 添加文档(行) put /zgc_index/_doc/1  {xxx}
    @Test
    public void addDocument() throws IOException {
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        TaskJobRecord taskJobRecord=  new TaskJobRecord(1L,100L,100L,"1",1,1,"xw",new Date(),new Date());
        String string = JSON.toJSONString(taskJobRecord);
        //创建请求
        IndexRequest indexRequest = new IndexRequest("zgc_index");
        //将数据放入请求
        indexRequest.source(string, XContentType.JSON);
        //可以设置一些规则
        indexRequest.timeout(TimeValue.timeValueSeconds(1));
        indexRequest.id("1"); // 手动指定id
        //用客户端发送请求，获取响应的结果
        IndexResponse index = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        System.out.println(index.toString());
        System.out.println(index.status());//对应命令返回的状态 created updated 。。。
    }

    // 判断文档是否存在（和判断索引差不多）
    @SneakyThrows
    @Test
    public void existDocument() throws IOException {
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        GetRequest getRequest = new GetRequest("zgc_index", "1");
        boolean exists = restHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    //获取文档
    @Test
    public void getDocument() throws IOException {
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        GetRequest getRequest = new GetRequest("zgc_index", "1");
        GetResponse documentFields = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
        System.out.println("--------------------------");
        System.out.println(documentFields);
        System.out.println(documentFields.getSourceAsString());
    }

    // 更新文档
    @Test
    public void updateDucement() throws IOException {
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        MyUser user = new MyUser("陈大周", 88);
        UpdateRequest updateRequest = new UpdateRequest("zgc_index", "1");

        updateRequest.doc(JSON.toJSONString(user), XContentType.JSON);
        updateRequest.timeout("1s");

        UpdateResponse update = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println("============================================");
        System.out.println(update);
        System.out.println(update.status());
    }

    // 批量插入
    @Test
    public void bulkDocument() throws IOException {
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        ArrayList<MyUser> users = new ArrayList<>();
        users.add(new MyUser("aa", 10));
        users.add(new MyUser("bb", 11));
        users.add(new MyUser("cc", 12));
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");
        //批处理请求
        for (int i = 0; i < users.size(); i++) {
            bulkRequest.add(new IndexRequest("zgc_index").id("" + (i + 1)).source(JSON.toJSONString(users.get(i)), XContentType.JSON));
        }
        BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println("========================================");
        System.out.println(bulk);
        System.out.println(bulk.status());
        System.out.println(bulk.hasFailures()); // 返回false代表成功
    }

    // 查询
    @Test
    public void search() throws IOException {
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")
                )
        );
        // 查询请求[A] 面向查询请求
        SearchRequest searchRequest = new SearchRequest("zgc_index");
        // 查询构造[B]面向请求构建器，是查询命令的最外层封装
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // 查询条件 1和2 [C]具体的查询命令在QueryBuilder里,可以用QueryBuilders工具类调用也可以用具体的查询方式实现
        //比如 QueryBuilders.termQuery() || new TermQueryBuilder("name", "aa")
        //注意查询的这些对象底层都是实现了QueryBuilder，所以都可以指向QueryBuilder

        QueryBuilder termQueryBuilder = new TermQueryBuilder("name", "aa");
        searchSourceBuilder.query(termQueryBuilder);
        searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        //高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("name");
        highlightBuilder.requireFieldMatch(false); //多处高亮
        highlightBuilder.preTags("<span style= 'color:red'>");
        highlightBuilder.postTags("</span>");
        searchSourceBuilder.highlighter(highlightBuilder);

        //构建器放到搜索请求中
        searchRequest.source(searchSourceBuilder);
        //客户端执行请求
        SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(search);

        System.out.println(JSON.toJSONString(search.getHits()));
        System.out.println("----------------------------------");
        for (SearchHit hit : search.getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
        System.out.println("----------------------------------");
        for (SearchHit hit : search.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
        //用高亮字段取代原来的字段
        ArrayList<Map<String, Object>> list = new ArrayList<>();
        for (SearchHit hit : search.getHits()) {
            //解析高亮的字段，将原来的字段换为我们高亮的字段即可
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            HighlightField name1 = highlightFields.get("name");
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();//原来的结果
            //解析高亮的字段，将原来的字段换为我们高亮的字段即可
            if (name1 != null) {
                org.elasticsearch.common.text.Text[] fragments = name1.fragments();
                String n_name = "";
                for (Text text : fragments) {
                    n_name += text;
                }
                sourceAsMap.put("title", n_name);
            }
            list.add(sourceAsMap);
        }
        System.out.println(list.toString());
    }

}

 

4.Elasticsearch查询相关好文

最完整的Elasticsearch 基础教程    ElasticSearch实战系列三: ElasticSearch的JAVA API使用教程   ES QueryBuilder学习