公司经验之----springboot项目集成elasticsearch7.6.1，索引操作，文档操作等

公司项目需求，跟着狂神学习了elasticsearch，这里我把学习成果分享一下

spring-boot集成es 7.6.1

1，创建springboot项目，引入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>

因为springboot自带的es版本是6.x的，所以更新版本，在pom文件中修改

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

当你在maven中看到elastic已经为7.6.1时，就说明已经更新完成了！

2，在配置文件application.yml中添加你的elasticsearch配置

# elasticsearch配置
elasticsearch:
  schema: http
  host: 127.0.0.1
  port: 9200
  userName: elastic
  password: 123456
  indexes: index	

账号密码记得填写正确！！！

3，创建配置类

import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author ylwang
 * @create 2021/7/27 9:16
 */
@Configuration
public class ElasticSearchClientConfig {

    /**
     * 协议
     */
    @Value("${elasticsearch.schema:http}")
    private String schema;

    /**
     * 用户名
     */
    @Value("${elasticsearch.userName}")
    private String userName;

    /**
     * 密码
     */
    @Value("${elasticsearch.password}")
    private String password;

    /**
     * 地址
     */
    @Value("${elasticsearch.host}")
    private String host;

    /**
     * 地址
     */
    @Value("${elasticsearch.port}")
    private String port;

    public static RestHighLevelClient restHighLevelClient;

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        restHighLevelClient = new RestHighLevelClient(RestClient.builder(
                new HttpHost(host, Integer.parseInt(port), schema)));
        //验证用户密码
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userName, password));
        RestClientBuilder restClientBuilder = RestClient
                .builder(new HttpHost(host, Integer.parseInt(port), schema))
                .setHttpClientConfigCallback(httpClientBuilder -> {
httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                    return httpClientBuilder;
                })
                .setRequestConfigCallback(requestConfigBuilder -> {
                    return requestConfigBuilder;
                });

        restHighLevelClient = new RestHighLevelClient(restClientBuilder);
        return restHighLevelClient;
    }

}

4，索引的操作

这里另外需要一些依赖

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

1，创建索引

    @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;


    @Value("${elasticsearch.indexes}")
    private String indexes;

    @Test
    public void contextLoadTest() throws IOException {
    	//创建索引请求
        CreateIndexRequest request = new CreateIndexRequest(indexes);
        //这里是通过客户端，然后传递请求， RequestOptions.DEFAULT（这个是默认的，是es里面的，可以查看源码）
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        log.info(response);
    }

2，测试索引,判断是否存在

    @Test
    void testExistIndex() throws IOException {
        GetIndexRequest request = new GetIndexRequest(indexes);
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        log.info(JSON.toJSONString(exists));
    }

3，删除索引

	@Test
    void deleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest(indexes);
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
        log.info(JSON.toJSONString(delete.isAcknowledged()));
    }

5，文档的操作

1，添加数据到索引中

    @Test
    void testAdd() throws IOException {
        //创建对象
        User user = new User("wang", 25, 36.0);
        //创建请求
        IndexRequest request = new IndexRequest(indexes);
        
        //规则  put /org_jeecg/_doc/1
        //自定义id，不自定义则随机生成
        request.id("1");	
		//请求超时不执行
        request.timeout(TimeValue.timeValueSeconds(1));
        request.timeout("1s");
        
        //将我们的数据放入请求 json，XContentType.JSON（指定信息的类型）
        request.source(JSON.toJSONString(user), XContentType.JSON);
        //客户端发送请求
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        log.info(response.toString());
        log.info(JSON.toJSONString(response.status()));
    }

2，获取文档信息

    //获得文档信息
    @Test
    void testGetDocument() throws IOException {
        GetRequest getRequest = new GetRequest(indexes, "1");
        GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
        //打印文档内容
//        log.info(getResponse.getSourceAsString());
        Object id = getResponse.getSourceAsMap().get("id");
        log.info(JSON.toJSONString(getResponse.getSourceAsMap()));

        //返回的全部内容和命令式一样的
//        log.info(getResponse);
    }

3，更新文档

@Test
    void testUpdate() throws IOException {
        UpdateRequest updateRequest = new UpdateRequest(indexes, "1");
        updateRequest.timeout("1s");
        //创建对象
        User user = new User("long", 35, 36.0);
        updateRequest.doc(JSON.toJSONString(user), XContentType.JSON);
        UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);
        log.info(JSON.toJSONString(updateResponse.status()));
    }

4，删除文档

    @Test
    void testDeteleRequest() throws IOException {
        DeleteRequest request = new DeleteRequest(indexes, "1");
        request.timeout("1s");
        DeleteResponse deleteResponse = client.delete(request, RequestOptions.DEFAULT);
        log.info(deleteResponse.status() + "");
    }

5，查询

    @Test
    public void queryDocument() throws IOException {
    	//查询请求	
    	//wqFN7XMBSotzIjY682h-		这个是索引的ID，通过索引ID查询
        GetRequest request = new GetRequest(indexes,"wqFN7XMBSotzIjY682h-");
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        log.info(response.getSource() + "");
    }

6，批量操作

1，批量添加

    @Test
    void testBlukRequest() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("1s");
        List<User> userList = new ArrayList<>();
        userList.add(new User("long", 35, 36.0));
        userList.add(new User("wang", 23, 36.0));
        userList.add(new User("yao", 22, 36.0));
        userList.add(new User("hu", 31, 36.0));
        userList.add(new User("yang", 24, 36.0));
        userList.add(new User("yang", 33, 36.0));
        userList.add(new User("xiao", 25, 36.0));
        userList.add(new User("yang", 26, 36.0));

        for (int i = 0; i < userList.size(); i++) {
            bulkRequest.add(new IndexRequest(indexes)
//            .id(""+(i+1))
                    .source(JSON.toJSONString(userList.get(i)), XContentType.JSON));
            BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
            //是否失败,返回false代表成功!
            log.info(JSON.toJSONString(bulkResponse.hasFailures()));
        }
    }

2，搜索

    @Test
    void testSearch() throws IOException {
    	//搜索请求
        SearchRequest searchRequest = new SearchRequest(indexes);
        //请求条件构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //查询条件,可以使用QueryBuilders实现
        //QueryBuilders.termQuery 精确查询
        //QueryBuilders.matchAllQuery 匹配所有
//        MatchAllQueryBuilder matchAllQuery = QueryBuilders.matchAllQuery();
		//精准查询
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("username", "yang");
        //把查询添加放入查询构造器中
        sourceBuilder.query(termQueryBuilder);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        sourceBuilder.size(100);	//指定查询结果的数量，这里es默认好像是10条，建议更改一下，比预期查询的数据量大一点，这里我吃过亏的
        //把查询添加放入请求中
        searchRequest.source(sourceBuilder);
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        log.info(JSON.toJSONString(searchResponse.getHits()));
        //打印查询的信息
        for (SearchHit documentFields : searchResponse.getHits().getHits()) {
            log.info(documentFields.getSourceAsMap() + "");
        }
    }

3，高亮查询

@Test
    public void highSearch() throws IOException {
        //创建查询请求
        SearchRequest request = new SearchRequest(indexes);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("username", "wang");
        builder.query(matchQueryBuilder);

        HighlightBuilder highlighter = new HighlightBuilder();
        highlighter.field("username",1);
        highlighter.preTags("<em style='color:red>'");
        highlighter.postTags("</em>");
        builder.highlighter(highlighter);

        request.source(builder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        System.out.println(response.getHits().getCollapseValues());
        System.out.println(response.getAggregations());
        System.out.println(response.getHits().getSortFields());
        System.out.println(response.getHits().getHits().length);
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit:hits) {
            System.out.println(hit.toString());
        }
    }

4，清空数据

这里的需求是数据库要清除部分数据，如果是一条一条数据去对比再删除，就显得格外麻烦，效率也比较低，所以这个我把整个索引删除，再创建索引，最后再把数据添加进来，就可以了

 public void deleteAndSaveSearchAll() throws Exception {
        GetIndexRequest request = new GetIndexRequest(indexes);
        boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
        if (restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT)) {
            DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(indexes);
            restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
            CreateIndexRequest createIndexRequest = new CreateIndexRequest(indexes);
            restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
        }
    }

特别注意：
elasticsearch自带的分词器可能对中文不太友好（个人感觉）
比如：

这里我原没有想那么多，没有安装kibana，用的es自带的分词器的效果，这明显不是我想要的结果，所以如果es自带的不满足你的需求的话，还是要安装kibana分词器。（kibana安装版本与你elasticsearch版本必须一致，不然不能正常启动）

此外，如果你有一些特定的词汇，比如“大马猴”等，就需要在kibana上配置自己的词典！

目前我所做的操作就这么多了，深入学习的还是详细看官网文档，哈哈哈！！！

转发请标明文章出处，谢谢！！！