springboot Elasticsearch

最新推荐文章于 2024-07-20 23:36:59 发布
最新推荐文章于 2024-07-20 23:36:59 发布
阅读量140 收藏
点赞数
分类专栏： ELK 文章标签： elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32078397/article/details/118481530
版权

springboot web项目调用elasticsearch API 进行索引、文档操作

pom.xml新增文件

 <dependency>
            <groupId>net.logstash.logback</groupId>
            <artifactId>logstash-logback-encoder</artifactId>
            <version>4.9</version>
        </dependency>

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

        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-client</artifactId>
            <version>7.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.2.0</version>
        </dependency>

Controller层  接收异常并进行处理

@Slf4j
@Controller
@RequestMapping(value = "/water-api")
@CrossOrigin(origins = "*", maxAge = 3600, allowCredentials = "true", allowedHeaders = "*")
public class ElasticsearchController {
    @Resource
    private RestHighLevelClient restHighLevelClient;
    @Resource
    private ElasticsearchUtil elasticsearchUtil;
   /**
     * 备注    CreateIndexRequest创建索引   GetIndexRequest获取索引   deleteIndexRequest删除索引
     * 查询索引是否存在
     *
     * @param indexName
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/index/exists", method = RequestMethod.POST)
    public Result indexExists(@RequestBody String indexName) {
        boolean exists = elasticsearchUtil.isIndexExists(indexName);
        return Result.ok(exists);
    }

    /**
     * 删除索引
     *
     * @param map
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/delete/exists", method = RequestMethod.POST)
    public Result deleteIndex(@RequestBody HashMap<String, Object> map) {
        boolean isDelete = elasticsearchUtil.deleteIndex((String) map.get("indexName"));
        if (isDelete) {
            return Result.ok("删除成功");
        } else {
            return Result.ok("删除失败");
        }

    }
    /**
     * 测试创建索引
     *
     * @param map
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/create/exists", method = RequestMethod.POST)
    public Result createIndex(@RequestBody HashMap<String, Object> map) {
        String indexName = String.valueOf(map.get("indexName"));

        try {
            XContentBuilder builder = XContentFactory.jsonBuilder()
                    .startObject()
                    .field("properties")
                    .startObject()
                    .field("name").startObject().field("index", "true").field("type", "keyword").endObject()
                    .field("age").startObject().field("index", "true").field("type", "integer").endObject()
                    .field("money").startObject().field("index", "true").field("type", "double").endObject()
                    .field("address").startObject().field("index", "true").field("type", "text").endObject()
//                    .field("address").startObject().field("index", "true").field("type", "text").field("analyzer", "ik_max_word").endObject()
                    .field("birthday").startObject().field("index", "true").field("type", "date").field("format", "strict_date_optional_time||epoch_millis").endObject()
                    .endObject()
                    .endObject();
            //创建索引的请求
            CreateIndexRequest createIndexRequest = new CreateIndexRequest(indexName);
            createIndexRequest.mapping(builder);
            //客户端执行请求IndicesClient ,请求后获取响应
            CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);

//            IndexRequest indexRequest = new IndexRequest(indexName);
//            indexRequest.source(builder);
//            IndexResponse index = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);

            boolean acknowledged = createIndexResponse.isAcknowledged();
            if (acknowledged) {
                return Result.ok("创建成功");
            }
        } catch (IOException e) {
            log.error("创建失败:{}", e.getCause());

        }
        return Result.error("创建失败");

    }

  /**
     * 测试获取索引
     *
     * @param map
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/get/index", method = RequestMethod.POST)
    public Result getIndex(@RequestBody HashMap<String, Object> map) {
        GetIndexRequest getIndexRequest = new GetIndexRequest((String) map.get("indexName"));
        try {
            boolean exists = restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
            if (exists) {
                GetIndexResponse getIndexResponse = restHighLevelClient.indices().get(getIndexRequest, RequestOptions.DEFAULT);
                return Result.ok("获取索引成功");
            } else {
                return Result.ok("索引不存在");
            }
        } catch (IOException e) {
            log.error("/get/index:{}", e.getStackTrace());
            return Result.ok("获取索引失败");
        }
    }


    public Result testIndexforJson(String indexName) throws IOException {

        IndexRequest indexRequest = new IndexRequest(indexName);
        String jsonString = "{" +
                "\"user\":\"niujun\"," +
                "\"postDate\":\"2019-06-10\"," +
                "\"message\":\"trying out Elasticsearch\"" +
                "}";
        //文档源以字符串形式提供
        indexRequest.source(jsonString, XContentType.JSON);
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        log.info("id:{}", indexResponse.getId());
        return Result.ok("插入成功");
    }

    public Result testIndexforMap(String indexName) throws IOException {
        Map<String, Object> jsonMap = new HashMap<>();
        jsonMap.put("user", "kimchy");
        jsonMap.put("postDate", new Date());
        jsonMap.put("message", "trying out Elasticsearch");
        IndexRequest indexRequest = new IndexRequest(indexName);
        //文档源以字符串形式提供
        indexRequest.source(jsonMap);
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        log.info("id:{}", indexResponse.getId());
        return Result.ok("插入成功");
    }



    /**
     * 文档创建
     *
     * @param map
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/add/document", method = RequestMethod.POST)
    public Result addDocument(@RequestBody HashMap<String, Object> map) throws IOException {
        //创建请求
        IndexRequest indexRequest = new IndexRequest((String) map.get("indexName"));
        //规则 put /indexName/_doc/1
        indexRequest.timeout(TimeValue.timeValueSeconds(1));
        ClientExceptionDto dto = new ClientExceptionDto();
        dto.setName("niujun");
        dto.setAge(33);
        //将数据放入请求中
        indexRequest.source(JSONObject.toJSONString(dto), XContentType.JSON);
        //客户端发送请求，获取
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        return Result.ok(indexResponse);
    }


    /**
     * 获取文档
     * web_water_2021.06.30/_doc/GhmeW3oBYRN5B60OiWub
     * @param map
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/get/document", method = RequestMethod.POST)
    public Result getDocument(@RequestBody HashMap<String, Object> map) throws IOException {
        String indexName = String.valueOf(map.get("indexName"));
        String docId = String.valueOf(map.get("docId"));
        //判断文档是否存在
        GetRequest getRequest = new GetRequest(indexName, docId);
        boolean exists = restHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);
        if (exists) {
            GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
            return Result.ok(getResponse);
        } else {
            return Result.ok("文档不存在");
        }
    }

    /**
     * 更新文档
     *
     * @param map
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/update/document", method = RequestMethod.POST)
    public Result updateDocument(@RequestBody HashMap<String, Object> map) throws IOException {
        String indexName = String.valueOf(map.get("indexName"));
        String docId = String.valueOf(map.get("docId"));
        UpdateRequest updateRequest = new UpdateRequest(indexName, docId);
        updateRequest.timeout(TimeValue.timeValueSeconds(1));
        ClientExceptionDto dto = new ClientExceptionDto();
        dto.setName("niujun1");
        dto.setAge(331);
        updateRequest.doc(JSONObject.toJSONString(dto), XContentType.JSON);
        UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        return Result.ok(updateResponse);
    }


    /**
     * 删除文档
     *
     * @param map
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/delete/document", method = RequestMethod.POST)
    public Result deleteDocument(@RequestBody HashMap<String, Object> map) throws IOException {
        String indexName = String.valueOf(map.get("indexName"));
        String docId = String.valueOf(map.get("docId"));
        DeleteRequest deleteRequest = new DeleteRequest(indexName, docId);
        deleteRequest.timeout(TimeValue.timeValueSeconds(1));
        DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
        return Result.ok(deleteResponse);
    }

    /**
     * 特殊 ，真实项目一般都是批量插入数据
     *
     * @param map
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/bulkRequest/document", method = RequestMethod.POST)
    public Result bulkRequest(@RequestBody HashMap<String, Object> map) throws IOException {
        String indexName = String.valueOf(map.get("indexName"));
        String docId = String.valueOf(map.get("docId"));
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout(TimeValue.timeValueSeconds(1));
        List<ClientExceptionDto> list = Lists.newArrayListWithExpectedSize(8);
        for (int i = 0; i < list.size(); i++) {
            bulkRequest.add(new IndexRequest(indexName).source(JSONObject.toJSONString(list.get(0)), XContentType.JSON));
        }
        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        return Result.ok(bulkResponse);
    }




}

EsConfiguration  Java文件
@Configuration
public class EsConfiguration {
    private static String hosts = "192.168.60.233"; // 集群地址，多个用,隔开
    private static int port = 9200; // 使用的端口号
    private static String schema = "http"; // 使用的协议
    private static ArrayList<HttpHost> hostList = null;

    private static int connectTimeOut = 1000; // 连接超时时间
    private static int socketTimeOut = 30000; // 连接超时时间
    private static int connectionRequestTimeOut = 500; // 获取连接的超时时间


    private static int maxConnectNum = 100; // 最大连接数
    private static int maxConnectPerRoute = 100; // 最大路由连接数

    static {
        hostList = new ArrayList<>();
        String[] hostStrs = hosts.split(",");
        for (String host : hostStrs) {
            hostList.add(new HttpHost(host, port, schema));
        }
    }

    @Bean
    public RestHighLevelClient client() {
        RestClientBuilder builder = RestClient.builder(hostList.toArray(new HttpHost[0]));
        // 异步httpclient连接延时配置
        builder.setRequestConfigCallback(new RequestConfigCallback() {
            @Override
            public Builder customizeRequestConfig(Builder requestConfigBuilder) {
                requestConfigBuilder.setConnectTimeout(connectTimeOut);
                requestConfigBuilder.setSocketTimeout(socketTimeOut);
                requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeOut);
                return requestConfigBuilder;
            }
        });
        // 异步httpclient连接数配置
        builder.setHttpClientConfigCallback(new HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                httpClientBuilder.setMaxConnTotal(maxConnectNum);
                httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
                return httpClientBuilder;
            }
        });
        RestHighLevelClient client = new RestHighLevelClient(builder);
        return client;
    }


}

ElasticsearchUtil  Java文件
@Component
public class ElasticsearchUtil {
    @Resource
    private RestHighLevelClient restHighLevelClient;

    /**
     * 判断索引是否存在
     *
     * @param indexName
     * @return
     */
    public boolean isIndexExists(String indexName) {
        boolean exists = false;
        GetIndexRequest getIndexRequest = new GetIndexRequest(indexName);
        getIndexRequest.humanReadable(true);
        try {
            exists = restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return exists;
    }

    public boolean deleteIndex(String indexName) {
        boolean acknowledged = false;
        try {
            DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(indexName);
            deleteIndexRequest.indicesOptions(IndicesOptions.LENIENT_EXPAND_OPEN);
            AcknowledgedResponse delete = restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
            acknowledged = delete.isAcknowledged();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return acknowledged;
    }
}

dream_alen
关注
专栏目录
Spring Boot数据——ElasticSearch
Alex_LiuC的博客
02-17 1020
一、为什么需要ES？ 1. 思考：大规模数据如何检索？ 如：当系统数据量上了10亿、100亿条的时候，我们在做系统架构的时候通常会从以下角度去考虑问题： 1）用什么数据库好？(mysql、sybase、oracle、达梦、神通、mongodb、hbase…) 2）如何解决单点故障；(lvs、F5、A10、Zookeep、MQ) 3）如何保证数据安全性；(热备、冷备、异地多活) 4）如何解决检索难题...
springBoot Elasticsearch 配置 demo
03-10
在测试环境中，可以使用`@LocalServerPort`和`@SpringBootTest`注解来启动一个临时的Elasticsearch实例，进行集成测试。 8. **性能优化**： 考虑到性能，可以配置Elasticsearch的刷新间隔、分片数和副本数等参数...
SpringBoot+Elasticsearch
weixin_34199405的博客
10-09 152
前言 1.1. 集成方式 Spring Boot中集成Elasticsearch有4种方式： 本文用后面两种方式来分别连接并操作Elasticsearch 1.2. 环境与配置 服务端：elasticsearch-6.3.2 1台 客户端：elasticsearch 6.4.1 服务端配置文件：elasticsearch.yml /etc/security/limits.conf /etc/sy...
SpringBoot整合ElasticSearch
最新发布
JackMa的博客
07-20 849
本系统使用的spring boot版本为2.6.13，ElasticSearch版本是7.16.2。
Spring Boot Elasticsearch
从零开始的教程世界
07-14 304
Spring Boot Elasticsearch 6 (Spring Boot Elasticsearch 6) In this post, we will setup up a sample Spring boot Elasticsearch application. We will use latest version of Elasticsearch i.e. 6.1.x. To int...
springboot elasticsearch
大鸡腿的博客
12-13 394
elasticsearch首先人家是一个搜索引擎，性能很好。 springboot集成elasticsearch,maven引入pom.xml &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starte...
springboot——elasticsearch
大白的博客
09-18 829
一、安装 （1）elasticsearch：https://blog.csdn.net/zebra_916/article/details/78020630 （2）ik分词器：https://blog.csdn.net/shiyaru1314/article/details/54425828 注意： 1、不同版本服务器对应不同分词器，对照表：https://blog.csdn.net/sh...
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用
11-12
本实例为博主原创，属于简单易上手并且能够拿来就用的SpringBoot ES 项目，全文使用的是ElasticsearchTemplate进行开发。 本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、...
springboot整合elasticsearch7实现es数据同步，查询、相关度排序、高亮显示、自动补全搜索等功能。
03-31
springboot整合elasticsearch7，进行数据同步。elasticsearch相关度查询、排序。高亮显示；自动补全等功能。代码仅供参考，代码中有具体的注释，可以根据代码及注释内容，对自己项目架构及业务进行修改、整合。
Springboot es包版本异常解决方案
08-19
在项目的 pom.xml 文件中，我们添加了依赖项 `<dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>7.6.1</version></dependency>`...
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用）
04-18
本实例属于简单易上手并且能够拿来就用的SpringBoot ES 项目，全文使用的是ElasticsearchTemplate进行开发。 本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、关键字查询、...
Spring boot中使用Elasticsearch（一）
m0_64344940的博客
12-07 1396
Spring boot中使用Elasticsearch（一）
SpringBoot集成 ElasticSearch
阿水的博客
04-14 6189
Spring Boot 集成 ElasticSearch Elasticsearch 是位于 Elastic Stack 核心的分布式搜索和分析引擎。Logstash 和 Beats 有助于收集、聚合和丰富您的数据并将其存储在 Elasticsearch 中。Kibana 使您能够以交互方式探索、可视化和分享对数据的见解，并管理和监控堆栈。
Springboot--ElasticSearch入门及整合
sout
11-27 252
一、ElasticSearch简介 我们的应用经常需要添加检索功能，开源的 ElasticSearch 是目前全文搜索引擎的首选。他可以快速的存储、搜索和分析海量数据。Spring Boot通过整合Spring Data ElasticSearch为我们提供了非常便捷的检索功能支持； Elasticsearch是一个分布式搜索服务，提供Restful API，底层基于Lucene，采用多sha...
SpringBoot集成ElasticSearch
qq_42828901的博客
07-26 178
ElasticSearch https://www.elastic.co/guide/index.html 选择 ElasticSearch的客户端Elasticsearch Clients 选择[Java REST Client 7.13] 使用高级的客户端Java High Level REST Client 高级客户端封装了低级的客户端,里面包含常见的API 1.原生的依赖(对基本的依赖进行的封装) <dependency> <groupId>...
SpringBoot 操作 Elasticsearch
2201_75382167的博客
03-15 519
SpringBoot 操作 Elasticsearch 单条件查询 多条件查询 排序查询 分页查询
[ ElasticSearch ] SpringBoot整合ElasticSearch
削尖螺丝刀的钉文
06-02 218
此文演示在IDEA下，SpringBoot整合ElasticSearch的整体流程，供大伙儿学习测试 1.IDEA下选择新建Module 2.选择版本 3.选择版本 + 自定义名称 4.选择需要的依赖（这里打钩的都选上即可） 5. 自定义名称、路径 6.Pom.xml中把ES版本改为和当前要操作的ES一致（比如我的是7.13.0） 代码在此： <elasticsearch.version>7.13.0</elasticsearch.version> 7.在prop.
SpringBoot集成Elasticsearch
wengeaiyuanyuan的博客
07-20 113
新建SpringBoot项目啥的我就不说了，都是基础，不会的自己就要学习一下了 一、添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> </dependency> 二、配置applicati
springboot elasticsearch
05-31
Spring Data Elasticsearch是Spring框架提供的一个模块，它提供了与Elasticsearch集成的API，可以帮助我们更轻松地在Spring Boot应用中使用Elasticsearch。 在Spring Boot中使用Elasticsearch需要完成以下几个步骤...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值