Springboot项目搭建

添加maven依赖

根据集群版本来选配SpringBoot的依赖版本

这里我的集群是6.8.8，版本6的最后稳定版 所以在项目中依赖也要更换味相同的版本，避免报错

<!--修改对应的版本号-->
<properties>
    <java.version>1.8</java.version>
    <elasticsearch.version>6.8.8</elasticsearch.version>
</properties>

<!--添加elasticSearch的依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

代码配置

新增ElasticSearch的配置文件注入Bean交给Spring来管理

新建config文件夹，新建ElasticSearchClientConfig.java

package com.sun.elasticsearchtest.config;

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;

/**
 * 1. 找对象
 * 2. 放入sprig中待用
 * @author sungang
 */
@Configuration
public class ElasticSearchClientConfig {

    @Bean
    public RestHighLevelClient restHighLevelClient() {
    //这里配置的是集群信息
        return new RestHighLevelClient(RestClient.builder(
                new HttpHost("111.230.226.16", 9200, "http"),
                new HttpHost("134.175.54.236", 9201, "http"),
                new HttpHost("134.175.54.236", 9202, "http")));
    }
}

==小知识点== 在使用autoWired的时候有以下两种方式

/**
 * 对应到我们配置好的文件上
 * 按住control跳转
 */
@Autowired
@Qualifier("restHighLevelClient")
private RestHighLevelClient client;

@Autowired
RestHighLevelClient restHighLevelClient;

新建实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;


/**
 * @author sungang
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserDao {

    private Integer id;
    private String name;
    private String desc;
}

引入依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.62</version>
</dependency>

新建测试类UserDao

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializeFilter;
import com.sun.elasticsearchtest.config.ElasticSearchClientConfig;
import com.sun.elasticsearchtest.pojo.UserDao;
import jdk.nashorn.internal.ir.CallNode;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
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.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;

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

@SpringBootTest
class ElasticsearchtestApplicationTests {

//	@Autowired
//	RestHighLevelClient restHighLevelClient;

    /**
     * 对应到我们配置好的文件上
     * 按住control跳转
     * 连接ES集群
     */
    @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;

    @Test
    void contextLoads() {
    }

    //测试索引的创建
    @Test
    void testCreateIndex() throws IOException {
        CreateIndexRequest request = new CreateIndexRequest("zykj");
        CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse);
    }

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

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

    //测试创建文档
    @Test
    void testCreateDocument() throws IOException {
        //创建对象
        UserDao userDao = new UserDao();
        userDao.setId(1);
        userDao.setName("sunbt");
        userDao.setDesc("术业有专攻");
        //创建请求
        IndexRequest request = new IndexRequest("zykj");
        //规则 PUT/zykj/_doc/1
        request.id("1");
        request.type("test");
        request.timeout(TimeValue.timeValueSeconds(1));
        request.timeout("1s");
        //将数据放入json
        IndexRequest source = request.source(JSON.toJSONString(userDao), XContentType.JSON);
        System.out.println(source);
        //客户端发送请求 json格式的
        IndexResponse index = client.index(request, RequestOptions.DEFAULT);
        System.out.println(index.toString());
        System.out.println(index.status());
    }

    //测试获取文档，判断是否存在 get /zykj/test/1
    @Test
    void testisExist() throws IOException {
        GetRequest request = new GetRequest("zykj").id("1");
        //不获取返回的_source的上下文
        request.fetchSourceContext(new FetchSourceContext(false));
        request.storedFields("_none_");
        boolean exists = client.exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    //测试获得文档信息
    @Test
    void testGetDocument() throws IOException {
        GetRequest getRequest = new GetRequest("zykj").id("1");
        GetResponse response = client.get(getRequest, RequestOptions.DEFAULT);
        System.out.println(response.getSourceAsString());
        System.out.println(response);
    }

    //测试更新文档信息
    //只更新修改的部分
    @Test
    void testUpdateDocument() throws IOException {
        UpdateRequest updateRequest = new UpdateRequest().index("zykj").type("test").id("1");
        updateRequest.timeout("1s");
        UserDao userDao = new UserDao();
        userDao.setName("捷克");
        updateRequest.doc(JSON.toJSONString(userDao), XContentType.JSON);
        UpdateResponse update = client.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println(update.status());
    }

    //测试删除文档记录
    @Test
    void testDeleteDocument() throws IOException {
        DeleteRequest deleteRequest = new DeleteRequest().index("zykj").type("test").id("1");
        deleteRequest.timeout("1s");
        DeleteResponse delete = client.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(delete.status());
    }

    //测试批量插入数据
    @Test
    void TestInsertDocuments() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");
        ArrayList<UserDao> list = new ArrayList<>();
        list.add(new UserDao(2, "张三", "法外狂徒，罪恶的犯罪者"));
        list.add(new UserDao(3, "里斯", "法外狂徒，罪恶的犯罪者"));
        list.add(new UserDao(4, "李四", "法外狂徒，罪恶的犯罪者"));
        list.add(new UserDao(5, "王五", "法外狂徒，罪恶的犯罪者"));
        list.add(new UserDao(6, "sunBT", "法外狂徒，罪恶的犯罪者"));
        list.add(new UserDao(7, "王一博", "法外狂徒，罪恶的犯罪者"));
        list.add(new UserDao(8, "罗志祥", "法外狂徒，罪恶的犯罪者"));
        list.add(new UserDao(9, "欧弟", "法外狂徒，罪恶的犯罪者"));
        list.add(new UserDao(10, "杨永信", "法外狂徒，罪恶的犯罪者"));
        //批量处理
        for (int i = 0; i < list.size(); i++) {
            bulkRequest.add(new IndexRequest("zykj").type("test").id("" + (i + 1)).source(JSON.toJSONString(list.get(i)), XContentType.JSON));
        }
        BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        //是否失败，返回false代表成功！
        System.out.println(bulk.hasFailures());
    }

    /**
     * 查询
     * SearchRequest 搜索请求
     * SearchSourceBuilder 条件构造
     * HighLightBuilder 构建高亮
     * TermQueryBuilder 精确查询
     * MatchAllQueryBuilder
     * xxx QueryBuilder
     */

    //测试查询
    @Test
    void testSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("zykj");
        //构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("name", "张");
        //精准匹配有问题？查不到
       // TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "张三");
        sourceBuilder.query(matchQueryBuilder);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        searchRequest.source(sourceBuilder);
        SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(JSON.toJSONString(search));
        System.out.println(JSON.toJSONString(search.getHits()));
        System.out.println("+++++++++++++++++++++++++++++++");
        for (SearchHit documentFields :
                search.getHits().getHits()) {
            System.out.println(documentFields.getSourceAsMap());
        }
    }

}