sprongboot学习（4）--springboot中使用elasticsearch

最新推荐文章于 2024-04-29 23:25:26 发布

hnwolfs

最新推荐文章于 2024-04-29 23:25:26 发布

阅读量534

点赞数 1

分类专栏： Springboot es 文章标签： elasticsearch java es springboot

本文链接：https://blog.csdn.net/hnwolfs/article/details/106564959

版权

Springboot 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

1 篇文章 0 订阅

订阅专栏

本文主要是使用springboot结合es使用RestHighLevelClient风格实现查询数据，对es安装和使用的简单操作过程。
1、安装完后是不是想尝试一下springboot如何使用es？
在springboot中使用es需要具备es环境，未安装elasticsearch和kibana可以参考下面这篇文章进行安装。
sprongboot学习（3）–window10中安装使用elasticsearch和ik以及Kibana
2、ES数据准备
使用kibaba造数据

# 创建索引 index
PUT shuji

GET shuji/_mapping

PUT shuji/book/1
{
   "id":{
       "type":1
    },
    "bookName":{
        "type":"西游记"
    },
    "author":{
       "type":"吴承恩"
    }
}

PUT shuji/book/2
{
  "id":{
       "type":2
    },
    "bookName":{
        "type":"水浒传"
    },
    "author":{
       "type":"施耐庵"
    }
}

PUT shuji/book/3
{
  "id":{
       "type":3
    },
    "bookName":{
        "type":"三国演义"
    },
    "author":{
       "type":"罗贯中"
    }
}

PUT shuji/book/4
{
  "id":{
       "type":4
    },
    "bookName":{
        "type":"红楼梦"
    },
    "author":{
       "type":"曹雪芹"
    }
}
# 查询shuji的信息
GET shuji/book/_search

部分截图
3、相关配置
（1）pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hxk.estest</groupId>
    <artifactId>es-last-test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>es-last-test</name>
    <description>Demo project for Spring Boot</description>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.70</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

（2）application.properties

server.port=8080

elasticSearch.host=127.0.0.1
elasticSearch.port=9200
elasticSearch.client.connectNum=10
elasticSearch.client.connectPerRoute=50

4、springboot实现
目录结构
在这里插入图片描述
es配置及简单查询实现
（1）ESConfig.java

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;


@Configuration
@ComponentScan(basePackageClasses= ESClientSpringFactory.class)
public class ESConfig {
        @Value("${elasticSearch.host}")
        private String host;

        @Value("${elasticSearch.port}")
        private int port;

        @Value("${elasticSearch.client.connectNum}")
        private Integer connectNum;

        @Value("${elasticSearch.client.connectPerRoute}")
        private Integer connectPerRoute;

        @Bean
        public HttpHost httpHost(){

                return new HttpHost(host,port,"http");
        }

        @Bean(initMethod="init",destroyMethod="close")
        public ESClientSpringFactory getFactory(){
            return ESClientSpringFactory.
                    build(httpHost(), connectNum, connectPerRoute);
        }

        @Bean
        @Scope("singleton")
        public RestClient getRestClient(){

                return getFactory().getClient();
        }

        @Bean
        @Scope("singleton")
        public RestHighLevelClient getRHLClient(){

                return getFactory().getRhlClient();
        }

}

（2）ESClientSpringFactory .java

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;

import java.io.IOException;

public class ESClientSpringFactory {

    public static int CONNECT_TIMEOUT_MILLIS = 1000;
    public static int SOCKET_TIMEOUT_MILLIS = 30000;
    public static int CONNECTION_REQUEST_TIMEOUT_MILLIS = 500;
    public static int MAX_CONN_PER_ROUTE = 10;
    public static int MAX_CONN_TOTAL = 30;

    private static HttpHost HTTP_HOST;
    private RestClientBuilder builder;
    private RestClient restClient;
    private RestHighLevelClient restHighLevelClient;

    private static ESClientSpringFactory esClientSpringFactory = new ESClientSpringFactory();

    private ESClientSpringFactory(){}

    public static ESClientSpringFactory build(HttpHost httpHost,
                                              Integer maxConnectNum, Integer maxConnectPerRoute){
        HTTP_HOST = httpHost;
        MAX_CONN_TOTAL = maxConnectNum;
        MAX_CONN_PER_ROUTE = maxConnectPerRoute;
        return  esClientSpringFactory;
    }

    public static ESClientSpringFactory build(HttpHost httpHost,Integer connectTimeOut, Integer socketTimeOut,
                                              Integer connectionRequestTime,Integer maxConnectNum, Integer maxConnectPerRoute){
        HTTP_HOST = httpHost;
        CONNECT_TIMEOUT_MILLIS = connectTimeOut;
        SOCKET_TIMEOUT_MILLIS = socketTimeOut;
        CONNECTION_REQUEST_TIMEOUT_MILLIS = connectionRequestTime;
        MAX_CONN_TOTAL = maxConnectNum;
        MAX_CONN_PER_ROUTE = maxConnectPerRoute;
        return  esClientSpringFactory;
    }


    public void init(){
        builder = RestClient.builder(HTTP_HOST);
        setConnectTimeOutConfig();
        setMutiConnectConfig();
        restClient = builder.build();
        restHighLevelClient = new RestHighLevelClient(builder);
        System.out.println("init factory");
    }
    // 配置连接时间延时
    public void setConnectTimeOutConfig(){
        builder.setRequestConfigCallback(requestConfigBuilder -> {
            requestConfigBuilder.setConnectTimeout(CONNECT_TIMEOUT_MILLIS);
            requestConfigBuilder.setSocketTimeout(SOCKET_TIMEOUT_MILLIS);
            requestConfigBuilder.setConnectionRequestTimeout(CONNECTION_REQUEST_TIMEOUT_MILLIS);
            return requestConfigBuilder;
        });
    }
    // 使用异步httpclient时设置并发连接数
    public void setMutiConnectConfig(){
        builder.setHttpClientConfigCallback(httpClientBuilder -> {
            httpClientBuilder.setMaxConnTotal(MAX_CONN_TOTAL);
            httpClientBuilder.setMaxConnPerRoute(MAX_CONN_PER_ROUTE);
            return httpClientBuilder;
        });
    }

    public RestClient getClient(){
        return restClient;
    }

    public RestHighLevelClient getRhlClient(){
        return restHighLevelClient;
    }

    public void close() {
        if (restClient != null) {
            try {
                restClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("close client");
    }
}

(3)bean

package com.hxk.estest.eslasttest.bean;
public class Book {
    private int id;
    private String bookName;
    private String author;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

(4)ResponseBean

package com.hxk.estest.eslasttest.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
@Data
@AllArgsConstructor
public class ResponseBean {
    //状态码
    private Integer code;
    //返回信息
    private String message;
    //返回的数据
    private Object data;

}

(5)TestController.java

package com.hxk.estest.eslasttest.controller;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.hxk.estest.eslasttest.vo.ResponseBean;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
@RestController
public class TestController {
    @Autowired
    private RestHighLevelClient rhlClient;

    //@Autowired
    Client client;

    private BoolQueryBuilder boolQueryBuilder = null;

    @RequestMapping("search")
    public ResponseBean searchInfoByCursor1(){
        SearchRequest searchRequest = new SearchRequest("shuji");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        System.out.println("heello ");
        //如果用name直接查询，其实是匹配name分词过后的索引查到的记录(倒排索引)；如果用
        sourceBuilder.query();
        try {
            SearchResponse response = rhlClient.search(searchRequest, RequestOptions.DEFAULT);
            SearchHits hits = response.getHits();
            JSONArray jsonArray = new JSONArray();
            for (SearchHit hit : hits) {
                String sourceAsString = hit.getSourceAsString();
                JSONObject jsonObject = JSON.parseObject(sourceAsString);
                jsonArray.add(jsonObject);
                System.out.println("输出"+jsonObject.toString());
            }
            return new ResponseBean(200,"查询成功",jsonArray);
        } catch (IOException e) {
            e.printStackTrace();
            return new ResponseBean(10001, "查询失败", null);
        }
    }
}

5、测试验证
需要开启本地的：elasticsearch服务
输入：http://localhost:8080/search
在这里插入图片描述

github项目链接：https://github.com/hnwolfs220/es-last-testcase

hnwolfs

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
sprongboot学习（4）--springboot中使用elasticsearch

1、安装完后是不是想尝试一下springboot如何使用es？在springboot中使用es需要具备es环境，未安装elasticsearch和kibana可以参考下面这篇文章进行安装。sprongboot学习（3）–window10中安装使用elasticsearch和ik以及Kibana2、ES数据准备3、相关配置4、springboot编程5、测试验证...
复制链接

扫一扫