Elastaticsearch 与 SpringBoot的实战集成（十一）

不念不忘少年蓝@ 2022-12-13 14:10 159阅读 0赞

这篇分析es和springBoot的集成：

**1、maven相关jar配置：**

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

为方便我们的使用，我们还会引入一些其他的组件，比如 fastjson 和 Swagger2

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.54</version>
    </dependency>
    
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>2.7.0</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>2.7.0</version>
    </dependency>
    2、创建启动类：

package cn.enjoyedu.springboot.es.highlevel;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class DemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    
    }

3、配置es相关：
    application.yml  中配置：

server:
      port: 8833
    elasticsearch:
      host: 127.0.0.1
      port: 9200

代码里设置：

import org.apache.http.HttpHost;
    import org.elasticsearch.client.RestClient;
    import org.elasticsearch.client.RestClientBuilder;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class ESConfig {
    
        @Value("${elasticsearch.host}")
        private String host;
    
        @Value("${elasticsearch.port}")
        private int port;
    
    
        @Bean
        public RestClientBuilder restClientBuilder() {
            HttpHost httpHost = new HttpHost(host, port, "http");
            RestClientBuilder restClientBuilder = RestClient.builder(httpHost);
            return restClientBuilder;
        }
    
        @Bean
        public RestHighLevelClient highLevelClient(@Autowired RestClientBuilder restClientBuilder) {
            return new RestHighLevelClient(restClientBuilder);
        }
    
    }

4、Swagger 配置：

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.context.request.async.DeferredResult;
    import springfox.documentation.builders.ApiInfoBuilder;
    import springfox.documentation.builders.PathSelectors;
    import springfox.documentation.service.ApiInfo;
    import springfox.documentation.spi.DocumentationType;
    import springfox.documentation.spring.web.plugins.Docket;
    import springfox.documentation.swagger2.annotations.EnableSwagger2;
    
    @Configuration // 启动时就要加载
    @EnableSwagger2
    public class SwaggerConfig {
        private String version;
    
        @Bean
        public Docket createRestApi() {
    
            return new Docket(DocumentationType.SWAGGER_2)
                    .genericModelSubstitutes(DeferredResult.class).select()
                    .paths(PathSelectors.any())
                    .build().apiInfo(apiInfo());
    
        }
    
        private ApiInfo apiInfo() {
    
            return new ApiInfoBuilder().title("Enjoyedu es server")
                    .description("****")
                    .termsOfServiceUrl("http://www.xiangxueketang.cn/")
                    .version("1.0").build();
        }
    
    }

5、controller 部分代码：

import cn.enjoyedu.springboot.es.highlevel.config.ESConfig;
    import cn.enjoyedu.springboot.es.highlevel.service.AggsSearch;
    import cn.enjoyedu.springboot.es.highlevel.service.NormalSearch;
    import cn.enjoyedu.springboot.es.highlevel.service.OperateDoc;
    import cn.enjoyedu.springboot.es.highlevel.service.OperateIndex;
    import cn.enjoyedu.springboot.es.highlevel.vo.ResponseBean;
    import cn.enjoyedu.springboot.es.highlevel.vo.User;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.bind.annotation.*;
    
    import javax.annotation.Resource;
    import java.io.IOException;
    
    @Api(value = "ES测试接口", tags = {"ES测试接口"})
    @RestController
    @RequestMapping("/es")
    @CrossOrigin(origins = "*", methods = {RequestMethod.GET,
            RequestMethod.POST, RequestMethod.DELETE, RequestMethod.PUT})
    public class ESController {
    
        @Resource
        private OperateIndex operateIndex;
    
        @Resource
        private OperateDoc operateDoc;
    
        @Resource
        private NormalSearch normalSearch;
    
        @Resource
        private AggsSearch aggsSearch;
    
        private  final Logger log = LoggerFactory.getLogger(ESConfig.class);
        private final static String KIBANA_SAMPLE_DATA_FLIGHTS
                = "kibana_sample_data_flights";
        private final static String KIBANA_SAMPLE_DATA_LOGS
                = "kibana_sample_data_logs";
    
    
        @ApiOperation(value = "es测试创建索引接口", notes = "es测试创建索引接口")
        @RequestMapping(value = "/index/creation", method = RequestMethod.POST)
        public ResponseBean createIndex(@RequestParam String indexName) {
            try {
                if (operateIndex.createIndex(indexName)) {
                    log.info("开始创建索引{}",indexName);
                    return new ResponseBean(200, "创建成功", null);
                } else {
                    return new ResponseBean(1002, "创建失败", null);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        @ApiOperation(value = "es测试是否存在索引接口", notes = "es测试是否存在索引接口")
        @RequestMapping(value = "/index/existence", method = RequestMethod.POST)
        public ResponseBean indexExists(@RequestParam String indexName) {
            boolean isExists = operateIndex.isIndexExists(indexName);
            String msg = isExists? "索引存在："+indexName : "索引不存在："+indexName ;
            return new ResponseBean(200, msg, isExists);
        }
    
        @ApiOperation(value = "es测试删除索引接口", notes = "es测试删除索引接口")
        @RequestMapping(value = "/index/erasure", method = RequestMethod.POST)
        public ResponseBean deleteIndex(@RequestParam String indexName) {
            boolean isDelete = operateIndex.deleteIndex(indexName);
            if (isDelete) {
                return new ResponseBean(200, "删除成功", null);
            } else {
                return new ResponseBean(10002, "删除失败", null);
            }
        }
    
        @ApiOperation(value = "es测试插入文档接口", notes = "es测试插入文档接口")
        @RequestMapping(value = "/doc/insertion", method = RequestMethod.POST)
        public ResponseBean insertDoc(@RequestBody User user,
                                      @RequestParam String indexName,
                                      @RequestParam  String docId) {
            return operateDoc.insertDoc(user,indexName,docId);
        }
    
        @ApiOperation(value = "es测试获取文档接口", notes = "es测试插入文档接口")
        @RequestMapping(value = "/doc/query", method = RequestMethod.GET)
        public ResponseBean getDoc(@RequestParam String indexName,
                                   @RequestParam String docId) {
            return operateDoc.getDoc(indexName,docId);
        }
    
        @ApiOperation(value = "es测试更新文档接口", notes = "es测试插入文档接口")
        @RequestMapping(value = "/doc/update", method = RequestMethod.POST)
        public ResponseBean updateDoc(@RequestParam String indexName,
                                      @RequestParam String docId,
                                      @RequestParam String fieldName,
                                      @RequestParam String fieldValue) {
            return operateDoc.updateDoc(indexName,docId,fieldName,fieldValue);
        }
    
        @ApiOperation(value = "es测试删除文档接口", notes = "es测试插入文档接口")
        @RequestMapping(value = "/doc/erasure", method = RequestMethod.POST)
        public ResponseBean deleteDoc(@RequestParam String indexName,
                                      @RequestParam String docId) {
            return operateDoc.deleteDoc(indexName,docId);
        }
    
        @ApiOperation(value = "_search接口基本用法", notes = "search接口基本用法")
        @RequestMapping(value = "/search/example", method = RequestMethod.POST)
        public ResponseBean searchExample() {
            return normalSearch.searchExample(KIBANA_SAMPLE_DATA_FLIGHTS);
        }
    
        @ApiOperation(value = "基于词项的查询", notes = "基于词项的term查询")
        @RequestMapping(value = "/search/term", method = RequestMethod.POST)
        public ResponseBean termsBasedSearch() {
            return normalSearch.termsBasedSearch(KIBANA_SAMPLE_DATA_FLIGHTS,
                    "dayOfWeek");
        }
    
        @ApiOperation(value = "基于全文的查询", notes = "基于全文的multi_match查询")
        @RequestMapping(value = "/search/match", method = RequestMethod.POST)
        public ResponseBean matchBasedSearch() {
            return normalSearch.matchBasedSearch(KIBANA_SAMPLE_DATA_FLIGHTS,
                    "AT","DestCountry", "OriginCountry");
        }
    
        @ApiOperation(value = "基于全文的模糊查询", notes = "基于全文的模糊查询")
        @RequestMapping(value = "/search/fuzzy", method = RequestMethod.POST)
        public ResponseBean fuzzySearch() {
            return normalSearch.fuzzySearch(KIBANA_SAMPLE_DATA_LOGS,
                    "message","firefix");
        }
    
        @ApiOperation(value = "组合查询范例", notes = "组合查询之bool查询")
        @RequestMapping(value = "/search/combination-bool",
                method = RequestMethod.POST)
        public ResponseBean combinationSearch() {
            return normalSearch.boolSearch(KIBANA_SAMPLE_DATA_LOGS);
        }
    
        @ApiOperation(value = "聚集查询范例", notes = "聚集查询范例")
        @RequestMapping(value = "/search/aggsExample", method = RequestMethod.POST)
        public ResponseBean aggsExampleSearch() {
            return aggsSearch.aggsExampleSearch(KIBANA_SAMPLE_DATA_FLIGHTS);
        }
    
    }

6、service层部分代码：

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
    import org.elasticsearch.action.support.IndicesOptions;
    import org.elasticsearch.action.support.master.AcknowledgedResponse;
    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.xcontent.XContentBuilder;
    import org.elasticsearch.common.xcontent.XContentFactory;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    import java.io.IOException;
    
    @Service
    public class OperateIndex {
    
        @Resource
        private RestHighLevelClient restHighLevelClient;
    
        public boolean createIndex(String indexName) throws IOException {
            XContentBuilder xContentBuilder = XContentFactory.jsonBuilder()
                    .startObject()
                        .field("properties").startObject()
                            .field("firstName").startObject()
                                .field("type","keyword")
                            .endObject()
                            .field("secondName").startObject()
                                .field("type","keyword")
                            .endObject()
                            .field("age").startObject()
                                .field("type","integer")
                            .endObject()
                            .field("content").startObject()
                                .field("type","text")
                            .endObject()
                        .endObject()
                    .endObject();
    
            CreateIndexRequest createIndexRequest = new CreateIndexRequest(indexName);
            createIndexRequest.mapping(xContentBuilder);
            CreateIndexResponse createIndexResponse
                    = restHighLevelClient.indices().create(createIndexRequest,
                    RequestOptions.DEFAULT);
            boolean acknowledeg = createIndexResponse.isAcknowledged();
            return acknowledeg;
    
        }
    
        public boolean isIndexExists(String indexName) {
            GetIndexRequest getIndexRequest = new GetIndexRequest(indexName);
            getIndexRequest.humanReadable(true);
            boolean exists =   false;
            try {
                exists = restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return exists;
        }
    
        public boolean deleteIndex(String indexName) {
            DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(indexName);
            deleteIndexRequest.indicesOptions(IndicesOptions.LENIENT_EXPAND_OPEN);
            boolean acknowledged = false;
            try {
                AcknowledgedResponse delete =
                        restHighLevelClient.indices().delete(deleteIndexRequest,
                                RequestOptions.DEFAULT);
                acknowledged = delete.isAcknowledged();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return acknowledged;
        }
    
    }

7、 代码目录结构如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70][]

比较关键的类是：

AggsSearch ：聚集搜索服务类

NormalSearch ：一般搜索服务类 OperateDoc ：操作文档的服务

OperateIndex ：操作索引的服务

SendSearchRequest ：通用的发送  Search  请求，并处理响应结果的服务其中主要包括了索引的管理、文档的管理、\_search  接口基本用法、基于词 项的查询、基于全文的查询、基于全文的模糊查询、组合查询、聚集查询的相关 范例，详情参阅相关代码。

8、启动该服务，启动后访问： [http://127.0.0.1:8833/swagger-ui.html][http_127.0.0.1_8833_swagger-ui.html]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 1][]

9、点击  [POST][]  [/es/index/creation][POST]  创建索引：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 2][]

10、kibana 中查询：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 3][]

es和springboot集成到此演示完成，不明白的地方可以留言，下篇分析es的集群实战，敬请期待！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70]: /images/20221123/d00ada2f00034f459d98454e2dac8d84.png
[http_127.0.0.1_8833_swagger-ui.html]: http://127.0.0.1:8833/swagger-ui.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 1]: /images/20221123/947c25dace0e49b5a9d342173cbe6f27.png
[POST]: http://127.0.0.1:8833/swagger-ui.html#!/ES27979357972550921475/createIndexUsingPOST
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 2]: /images/20221123/b0cf4a874cff411e812809443fe033d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 3]: /images/20221123/299bc8ce6501492b8bc77b0980b1a32f.png