SpringCloud保姆级搭建教程六---ElasticSearch

es下载地址：https://www.elastic.co/cn/downloads/elasticsearch 最新版本

或者 https://github.com/elastic/elasticsearch 7.17.9

kibana下载地址：https://github.com/elastic/kibana 各个版本

jdk8 对应的es应该是7.*版本，最新的es应该对应的至少得17及以上了

===========================================

es7.17.3版本下载：https://www.elastic.co/cn/downloads/past-releases/elasticsearch-7-17-3

kibana最好和es版本相同。

https://www.elastic.co/cn/downloads/past-releases/kibana-7-17-3

版本对应关系参考官网：https://www.elastic.co/cn/support/matrix#matrix_compatibility

因为我电脑上装的还是8,所以下载的还是7.17.3这个版本。

===============================================

1、下载好之后，解压压缩包放到你指定的文件夹下，打开这个路径，双击elasticsearch.bat

双击之后就出现一个黑窗口，等它运行完之后，在浏览器输入localhost:9200,

出现这个界面，就是成功启动了。

2、下载好kibana之后，同样的，解压，然后打开文件夹的这个路径，双击kibana.bat

同样的，等他运行完，在浏览器输入localhost:5601,出现界面之后就是启动成功了。

3、此时此刻，kibana就默认连接上了localhost:9200的ElasticSearch（下面用es代替

除此之外，es之后的使用可能还需要安装分词器，这个windows上安装分词器也是相当的坎坷，客官继续往下看。

这里就不演示坑了，直接说怎么正确的配置

首先第一步，下载与es版本相同的ik分词器这里下载的是 7.17.3

https://gitcode.net/mirrors/medcl/elasticsearch-analysis-ik/-/releases?after=eyJpZCI6IjU4NDAwNSIsInJlbGVhc2VkX2F0IjoiMjAyMi0wNi0zMCAyMDo0Njo1Ny4wMDAwMDAwMDAgQ1NUIn0

下载完之后解压是这个样子的：

此时此刻，它是不能直接用的，需要编译打包才可以，我这里是用idea打开的，因为我用mvn命令失败了，应该是我没配置的原因。

打开idea,open这个ik分词器的项目，这里要注意一个坑，先打开pom.xml文件，修改一个版本号，这里虽然下载的7.17.3版本的ik分词器，但是在pom.xml中有一个es的版本号并不是这个，如果这里不改，后面仍旧会报错。

将这里的7.16.0修改成7.17.3。

然后依次执行这三个命令：

然后我们就得到了一个target文件夹

进入target文件夹下的releases文件夹，有一个zip后缀的压缩包，将其解压，得到一些文件。

这些才是我们要用的。

然后要做的就是，在es的这个目录下创建的一个名叫ik的空文件夹

然后，将刚才咱们得到的那一堆文件复制过来。

这样就算是大功告成了。

然后重启es，重启kibana ,然后测试一下。

创建这个索引，并指定了ik分词器，提示成功。

然后就可以写DSL语句进行对es进行操作了。

4、DSL语法属于单独一节课了哈，大家可以自行百度学习一下，或者看我的这篇文章，里面也说了DSL的语法。https://blog.csdn.net/weixin_65549694/article/details/125686075

5、下面就是怎么在java中使用了，本文章用Spingboot进行演示。

第一步：引入依赖：.

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

第二步：写配置文件，便于使用，在application.yml中写es的ip和端口号

第三步：写配置类，这里用了application.yml中的配置，所以会有一个警告，可以引入一个依赖，去除掉这个警告：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <version>2.4.5</version>
            <!--不传递依赖-->
            <optional>true</optional>
</dependency>


package com.brave.config;

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

@Configuration
@ConfigurationProperties(prefix="elasticsearch")
public class ElasticSearchConfig {

    private String host;

    private int port;


    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestClientBuilder builder = RestClient.builder(new HttpHost(host, port, "http"));
        builder.setRequestConfigCallback(requestConfigBuilder ->{
            requestConfigBuilder.setConnectionRequestTimeout(500000);
            requestConfigBuilder.setSocketTimeout(500000);
            requestConfigBuilder.setConnectTimeout(500000);
            return requestConfigBuilder;
        });
        return new RestHighLevelClient(builder);
    }
}

第四步：可以开始写代码测试了。

我在测试类中进行一系列测试：

package com.brave.test;

//import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.bouncycastle.cert.ocsp.Req;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
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.client.indices.CreateIndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
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.junit4.SpringJUnit4ClassRunner;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
* @author 泛筱荻
* @version 1.0
* @date 2023/2/16 13:47
*/
@SpringBootTest
    @RunWith(SpringJUnit4ClassRunner.class)
    public class EsTest {

        @Autowired
        private RestHighLevelClient restHighLevelClient;

        /**
* 创建索引
* @throws IOException
*/
        @Test
        public void test1() throws IOException {
            CreateIndexRequest request = new CreateIndexRequest("bravejava1");
            //可以直接做表结构的创建，这里就在kibana中写好语句直接复制mapping后面的语句就好了 || 也可以只创建一个索引
            String info= "{\n" +
                "      \"properties\": {\n" +
                "        \"content\": {\n" +
                "          \"type\": \"text\",\n" +
                "          \"analyzer\": \"ik_max_word\",\n" +
                "          \"search_analyzer\": \"ik_max_word\"\n" +
                "        }\n" +
                "      }\n" +
                "  }";
            request.mapping(info,XContentType.JSON);
            CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
            System.out.println(createIndexResponse.isAcknowledged());
        }

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

                /**
                * 判断索引是否存在
                * @throws IOException
                */
                @Test
                public void test3() throws IOException {
                GetIndexRequest request = new GetIndexRequest("bravejava");
                boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
                System.out.println(exists);
                }

                /**
                * 新增文档    指定索引，如果索引不存在会自动创建索引
                * @throws IOException
                */
                @Test
                public void test4() throws IOException {
                IndexRequest request = new IndexRequest("bravejava");
                //用map做数据源
                Map<String, Object> map=new HashMap<>();
                map.put("name","李四");
                map.put("age",20);
                map.put("address","北京昌平");
                //        如果想用对象做数据源，可以这样
                //        person.setId("2");
                //        person.setName("李四");
                //        person.setAge(30);
                //        person.setAddress("北京北五环");
                //        String source = JSON.toJSONString(person);
                //        request.id("2").source(source,XContentType.JSON);
                request.id("2").source(map);
                IndexResponse index = restHighLevelClient.index(request, RequestOptions.DEFAULT);
                System.out.println(index.status());
                }

                /**
                * 根据id查询文档
                * @throws IOException
                */
                @Test
                public void test5() throws IOException {
                GetRequest request = new GetRequest("bravejava","1");
                GetResponse getResponse = restHighLevelClient.get(request, RequestOptions.DEFAULT);
                Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();
                System.out.println(sourceAsMap.get("name"));
                System.out.println(sourceAsMap.get("age"));
                System.out.println(sourceAsMap.get("address"));
                //        如果想把map结果传承对应的对象可以这样
                //        Person person = JSONObject.parseObject(JSONObject.toJSONString(source), Person.class);
                }


                /**
                * 根据id删除文档
                * @throws IOException
                */
                @Test
                public void test6() throws IOException {
                DeleteRequest request = new DeleteRequest("bravejava","2");
                DeleteResponse delete = restHighLevelClient.delete(request, RequestOptions.DEFAULT);
                System.out.println(delete.status());
                }


                /**
                * 查询操作  查询操作是最复杂的，其中包括布尔查询，聚合查询，范围查询等等等等。就不一一列举了，具体情况具体再查吧
                * @throws IOException
                */
                @Test
                public void test7() throws IOException {
                SearchRequest request = new SearchRequest("bravejava");
                SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
                //这里分页是从0开始的，如果不写，es也会默认分页，也是十条
                searchSourceBuilder.from(0);
                searchSourceBuilder.size(10);
                request.source(searchSourceBuilder);
                SearchResponse search = restHighLevelClient.search(request, RequestOptions.DEFAULT);
                SearchHits hits = search.getHits();
                SearchHit[] hits1 = hits.getHits();
                for (SearchHit documentFields : hits1) {
                Map<String, Object> sourceAsMap = documentFields.getSourceAsMap();
                //然后做之后的操作，比如转成对象啊，或者做什么别的操作
                System.out.println(sourceAsMap.get("name"));
                System.out.println(sourceAsMap.get("age"));
                System.out.println(sourceAsMap.get("address"));
                }
                System.out.println(search.status());
                }
                }