SpringBoot 整合 ElasticSearch-7.15.2

最新推荐文章于 2023-03-17 17:43:27 发布
最新推荐文章于 2023-03-17 17:43:27 发布
阅读量4.9k 收藏 15
点赞数 5
分类专栏： Spring Boot ElasticSearch 文章标签： java elasticsearch spring boot 后端 搜索引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vihem/article/details/121428258
版权

SpringBoot 整合 ElasticSearch-7.15.2

一、Linux 安装 ElasticSearch-7.15.2

ElasticSearch 之 Linux 安装 ElasticSearch-7.15.2(ELK、IK)

 

二、SpringBoot 整合 ElasticSearch

项目GitHub地址： springboot-elasticsearch-demo

1. 新建一个springboot项目，添加maven依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<!--swagger-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.75</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

2. 添加配置文件 application.yml

spring:
  elasticsearch:
    rest:
      uris: 192.168.25.137:9200
      connection-timeout: 600s
      read-timeout: 600s
server:
  port: 8888

或者使用java类：

import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//@Configuration
public class ElasticSearchConfig {
    
    @Bean
    public RestHighLevelClient getRestHighLevelClient(){
        return new RestHighLevelClient(
                RestClient.builder(new HttpHost("192.168.25.137", 9200, "http"))
                        .setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
                            @Override
                            public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder builder) {
                                return builder.setConnectTimeout(5000 * 1000) // 连接超时（默认为1秒）
                                        .setSocketTimeout(6000 * 1000);// 套接字超时（默认为30秒）//更改客户端的超时限制默认30秒现在改为100*1000分钟
                            }
                        })
        );
    }
}

3. 配置swagger

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
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 {

    @Bean
    public Docket api(){
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("cn.ea.sbes.controller"))//Controller 包名
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("springboot-elasticsearch")
                .build();
    }
}

4. Pojo

重点在于pojo加一个@Document，指定索引，表明了要连接到 ElasticSearch 的哪个索引

@Data
@ToString
@Document(indexName = "sb_es_product")
public class Product {
    int id;
    String name;
    String category;
    float price;
    String place;
    String code;

    public Map<String, Object> toMap() {
        HashMap<String,Object> map = new HashMap<>();
        map.put("name", name);
        map.put("category", category);
        map.put("code", code);
        map.put("place", place);
        map.put("price", price);
        return map;
    }
}

5. Dao

使用 ElasticsearchRepository ，简单的增删改查就不用另外实现了

@Repository
public interface ProductDao extends ElasticsearchRepository<Product, String> {}

6. Service

对于导包，这里只写了部分包名。

6.1 索引管理

public interface IEsService {
    String createIndex(String indexName) throws IOException;
    <T> String createIndex2(Class<T> tClass) throws IOException;
    boolean isIndexExist(String indexName) throws IOException;
    boolean checkExistIndex(String indexName) throws IOException;
    boolean deleteIndex(String indexName) throws IOException;
    String getDocument(String indexName, String id) throws IOException;
}

import org.elasticsearch.ElasticsearchStatusException;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.stereotype.Service;

import java.io.IOException;

@Service
public class EsServiceImpl implements IEsService {
    
//    @Qualifier("getRestHighLevelClient")
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    @Autowired
    ElasticsearchOperations elasticsearchOperations;

    @Override
    public String createIndex(String indexName) {
        if (isIndexExist(indexName)){
            return " 索引 "+ indexName + " 已经存在";
        }
        try {
            CreateIndexRequest request = new CreateIndexRequest(indexName);
            CreateIndexResponse response = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
            System.out.println(" 创建索引 "+response.index() + " 成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
        return " 创建索引 "+ indexName + " 成功";
    }

    /**
     * 这种方式创建索引很奇葩，会报错，但是创建索引能成功，不建议使用，只用于对比: 
     * Elasticsearch exception [type=resource_already_exists_exception, reason=index [sb_es_product/iHwe11k9T0yNFrI_R9oipw] already exists]
     */
    @Override
    public <T> String createIndex2(Class<T> tClass) throws IOException {
        IndexOperations ops = elasticsearchOperations.indexOps(tClass);
        boolean b = ops.create();
        return b ? "创建索引成功":"创建索引失败";
    }

    @Override
    public boolean isIndexExist(String indexName) {
        GetIndexRequest getIndexRequest = new GetIndexRequest(indexName);
        boolean exists = false;
        try {
            exists = restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return exists;
    }

    @Override
    public boolean checkExistIndex(String indexName) throws IOException {
        boolean result = true;
        try {
            OpenIndexRequest openIndexRequest = new OpenIndexRequest(indexName);
            restHighLevelClient.indices().open(openIndexRequest, RequestOptions.DEFAULT).isAcknowledged();
        } catch (ElasticsearchStatusException ex) {
            String m = "Elasticsearch exception [type=index_not_found_exception, reason=no such index ["+ indexName +"]]";
            if (m.equals(ex.getMessage())) {
                result = false;
            }
        }
        return result;
    }

    @Override
    public boolean deleteIndex(String indexName) throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest(indexName);
        AcknowledgedResponse response = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
        return response.isAcknowledged();
    }

    @Override
    public String getDocument(String indexName, String id) throws IOException {
        GetRequest request = new GetRequest(indexName, id);

        GetResponse response = restHighLevelClient.get(request, RequestOptions.DEFAULT);
        if(!response.isExists()){
            System.out.println("检查到服务器上 id="+id+ " 的文档不存在");
            return "检查到服务器上 id="+id+ " 的文档不存在";
        } else {
            String source = response.getSourceAsString();
            System.out.print("获取到服务器上 id="+id+ " 的文档内容是：");
            System.out.println(source);
            return source;
        }
    }
}

6.2 Product管理

public interface IProductService {
    String batchInsert(List<Product> products) throws IOException;
    List<Product> searchProducts(String keyword, int start, int count) throws IOException;
    List<Product> searchProducts2(String keyword, int page, int rows) throws IOException;
    Product addProduct(Product product) throws Exception;
    void deleteProduct(Product product) throws Exception;
    Product updateProduct(Product product) throws Exception;
    Optional<Product> findById(String id) throws Exception;
}

import org.apache.commons.codec.binary.StringUtils;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.ScoreSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class ProductServiceImpl implements IProductService {
    private final static String indexName = "sb_es_product";
    
    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;
/
/    @Qualifier("getRestHighLevelClient")
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    @Autowired
    private IEsService esService;

    @Autowired
    private ProductDao productDao;
    
    @Override
    public String batchInsert(List<Product> products) throws IOException {
        if (!esService.isIndexExist(indexName)){
            esService.createIndex(indexName);
        }
        
        BulkRequest bulkRequest = new BulkRequest();
        for (Product product : products) {
            // 封装除了id的其他信息，id做为索引的id
            Map<String,Object> m  = product.toMap();
            IndexRequest indexRequest= new IndexRequest(indexName).id(String.valueOf(product.getId())).source(m);
            bulkRequest.add(indexRequest);
        }
        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        return bulkResponse.hasFailures() ? "Failed": "Successful" ;
    }

    @Override
    public List<Product> searchProducts(String keyword, int start, int count) throws IOException {
        // 1. 创建 匹配查询构建器
        MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("name", keyword);//关键字匹配
        matchQueryBuilder.fuzziness(Fuzziness.AUTO);//模糊匹配

        // 2. 创建 搜索资源构建器，设置搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(matchQueryBuilder) // 为 SearchSourceBuilder 指定 MatchQueryBuilder
                .from(start)    //第几页
                .size(count)    //第几条
                .sort(new ScoreSortBuilder().order(SortOrder.DESC));    //设置搜索排序为降序，即匹配度从高到低

        // 3. 创建 搜索请求
        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(sourceBuilder);
        
        // 4. 执行查询，并使用 搜索响应-SearchResponse 接收查询结果
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        
        // 5. 获取 搜索结果-SearchHits
        SearchHits searchHits = searchResponse.getHits();
        // 6. 处理搜索结果，并返回结果 //推荐直接返回SearchHits结果
        List<Product> products = new ArrayList<>();
        for (SearchHit hit : searchHits) {
//            System.out.println(hit.getSourceAsString());
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            Product product = new Product();
            product.setId(Integer.parseInt(hit.getId()));
            product.setCode(String.valueOf(sourceAsMap.get("code")));
            product.setPrice(Float.parseFloat(sourceAsMap.get("price").toString()));
            product.setName((String) sourceAsMap.get("name"));
            product.setPlace((String) sourceAsMap.get("place"));
            product.setCategory((String) sourceAsMap.get("category"));
            
            products.add(product);
        }
        return products;
    }
    
    @Override
    public List<Product> searchProducts2(String keyword, int page, int rows) throws IOException{
        List<Product> arrayList = new ArrayList<>();
        Pageable pageable = PageRequest.of(page, rows); // 设置分页参数
        NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchQuery("name", keyword).operator(Operator.AND)) // match查询
                .withPageable(pageable) //分页
                .withHighlightBuilder(getHighlightBuilder("name")) //高亮
                .withSort(new ScoreSortBuilder().order(SortOrder.DESC))
                .build();
        org.springframework.data.elasticsearch.core.SearchHits<Product> searchHits = elasticsearchRestTemplate.search(nativeSearchQuery, Product.class);
        for (org.springframework.data.elasticsearch.core.SearchHit<Product> searchHit : searchHits) { // 获取搜索到的数据
            Product content = searchHit.getContent();
            Product product = new Product();
            BeanUtils.copyProperties(content, product);

            //处理高亮
            Map<String, List<String>> highlightFields = searchHit.getHighlightFields();
            for (Map.Entry<String, List<String>> highlightFieldsStr : highlightFields.entrySet()){
                String key = highlightFieldsStr.getKey();
                System.out.println(" key = "+key);
                if (StringUtils.equals(key, "name")){
                    List<String> fragments = highlightFieldsStr.getValue();
                    StringBuilder sb = new StringBuilder();
                    for (String fragment : fragments){
                        System.out.println(" -- "+fragment);
                        sb.append(fragment);
                    }
                    product.setName(sb.toString());
                }
            }
            arrayList.add(product);
        }
        return arrayList;
    }
    @Override
    public Product addProduct(Product product) throws Exception {
        product.setId(currentTime());
        return productDao.save(product);
    }

    @Override
    public void deleteProduct(Product product) throws Exception {
        productDao.delete(product);
    }

    @Override
    public Product updateProduct(Product product) throws Exception {
        return productDao.save(product);
    }

    @Override
    public Optional<Product> findById(String id) throws Exception {
        return productDao.findById(id);
    }

    private int currentTime() {
        SimpleDateFormat sdf = new SimpleDateFormat("MMddHHmmss");
        String time= sdf.format(new Date());
        return Integer.parseInt(time);
    }
    // 设置高亮字段
    public static HighlightBuilder getHighlightBuilder(String... fields) {
        // 高亮条件
        HighlightBuilder highlightBuilder = new HighlightBuilder(); // 生成高亮查询器
        for (String field : fields) {
            highlightBuilder.field(field);// 高亮查询字段
        }
        highlightBuilder.requireFieldMatch(false); // 如果要多个字段高亮,这项要为false
        highlightBuilder.preTags("<span style=\"color:red\">"); // 高亮设置
        highlightBuilder.postTags("</span>");
        // 下面这两项,如果你要高亮如文字内容等有很多字的字段,必须配置,不然会导致高亮不全,文章内容缺失等
        highlightBuilder.fragmentSize(800000); // 最大高亮分片数
        highlightBuilder.numOfFragments(0); // 从第一个分片获取高亮片段

        return highlightBuilder;
    }
}

关于SearchProducts和SearchProducts2函数：

SearchProducts的jar包如下：
import org.elasticsearch.search.SearchHit; import org.elasticsearch.search.SearchHits;

SearchProducts2：使用了ElasticsearchRestTemplate，而且其中有两个jar包不同：
import org.springframework.data.elasticsearch.core.SearchHit; import org.springframework.data.elasticsearch.core.SearchHits;

详细可以查看代码。

7. Controller

7.1 索引管理

@RestController
@RequestMapping("/es")
@Api("EsController")
public class EsController {

    @Autowired
    private IEsService esService;

    @PutMapping("/create/{indexName}")
    @ApiOperation("createIndex")
    public String createIndex(@PathVariable String indexName) throws IOException {
        return esService.createIndex(indexName);
    }
    
    @PutMapping("/create2")
    @ApiOperation("createIndex2")
    public String createIndex2() throws IOException {
        return esService.createIndex2(Product.class);
    }


    @DeleteMapping("/delete/{indexName}")
    @ApiOperation("deleteIndex")
    public String deleteIndex(@PathVariable String indexName) throws IOException{
        boolean b = esService.deleteIndex(indexName);
        return b ? (indexName + " 索引删除成功"):(indexName + " 索引删除失败");
    }
    
    @GetMapping("/getDocById/{indexName}/{id}")
    @ApiOperation("getDocById")
    public String getDocById(@PathVariable String indexName, @PathVariable String id) throws IOException {
        return esService.getDocument(indexName, id);
    }
}

7.2 Product管理

@RestController
@RequestMapping("/product")
@Api("product")
public class ProductController {
    
    @Autowired
    private IProductService productService;
    
    @ApiOperation("search")
    @GetMapping("/search/{keyword}/{start}/{count}")
    public List<Product> searchProducts(@PathVariable String keyword,
                                        @PathVariable int start,
                                        @PathVariable int count) throws IOException {
        return productService.searchProducts(keyword,start,count);
    }

    @ApiOperation("add")
    @RequestMapping("/add")
    public Product addProduct(@RequestBody Product product) throws Exception{
        return productService.addProduct(product);
    }

    @ApiOperation("delete")
    @RequestMapping("/delete")
    public void deleteProduct(@RequestBody Product product) throws Exception{
        productService.deleteProduct(product);
    }

    @ApiOperation("update")
    @RequestMapping("/update")
    public Product updateProduct(@RequestBody Product product) throws Exception{
        return productService.updateProduct(product);
    }

    @ApiOperation("findById")
    @GetMapping("/findById/{id}")
    public Optional<Product> findById(@PathVariable String id) throws Exception{
        return productService.findById(id);
    }
}

三、启动测试

  1. 启动ElasticSearch

  2. 启动SpringBoot 的 Application

    @SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

  3. 访问 http://localhost:8888/swagger-ui.html/
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

项目GitHub地址： springboot-elasticsearch-demo

若有不正之处，请谅解和批评指正，谢谢~
转载请标明：
https://blog.csdn.net/vihem/article/details/121428258

vihem
关注
专栏目录
Spring Boot集成Elasticsearch 8.12.2客户端
iOS逆向与安全
03-29 568
Java REST 客户端已被弃用，取而代之的是 Java API client 客户端，ES 8.x 新版本中，Type 概念被弃用，所以新版 JavaAPI 也相应做出了改变，支持lambda，使用更加简便。ElasticSearch 5.0以后，string类型有重大变更，移除了string类型，string字段被拆分成两种新的数据类型: text用于全文搜索的，而keyword用于关键词搜索。如果按照年进行索引存储，判断查询年份，如果没有对应的索引，则提示查询年份超出范围。
ElasticSearch7.16通过Java API Client与SpringBoot整合
prelude1201的博客
03-08 2447
ElasticSearch7.16通过Java API Client与SpringBoot整合。 目前，最新版本为4.3.2的Spring Data Elasticsearch (SpringBoot2.6.2通过spring-data 9300端口TCP方式操作Elasticsearch)只支持到Elasticsearch7.15.2版本为止，elasticsearch-rest-high-level-client也已经在7.15.0弃用，因此7.16及以上版本可以改为使用Java API Client。
SpringBoot 集成 Elasticsearch7.15.2
Lyndon的专栏
06-26 880
elasticsearch基本使用
ElasticSearch 7.15.2详解（五）：SpringBoot 2.6.11整合
weixin_45181611的博客
03-17 862
SpringBoot 2.6.11 整合 ES 7.15.2
SpringBoot(2.2.4.RELEASE)整合ElasticSearch7.15.2
publicluo的博客
08-17 1097
SpringBoot整合ElasticSearch7.15.2
springboot2集成elasticsearch7.15.0（RestHighLevelClient）纯代码
zhaoqiangbo的博客
12-16 2034
maven坐标 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> </dependency> <properties> <!--需要指定es的版本，与服务的一致--> <elastic
springboot2.6.4整合elasticsearch7.15.2
jinqingjianghai的博客
08-30 1715
springboot2.6.4整合elasticsearch7.15.2
elasticsearch-7.15.2安装
Lyndon的专栏
06-06 538
elasticsearch 单节点部署
springboot整合elasticsearch7实现es数据同步，查询、相关度排序、高亮显示、自动补全搜索等功能。
03-31
springboot整合elasticsearch7，进行数据同步。elasticsearch相关度查询、排序。高亮显示；自动补全等功能。代码仅供参考，代码中有具体的注释，可以根据代码及注释内容，对自己项目架构及业务进行修改、整合。
【ElasticSearch8】SpringBoot集成ElasticSearch8.x 基本应用 CRUD操作 环境安装
m0_67401270的博客
07-31 1204
最近在研究es的时候发现官方已经在7.15.0放弃对旧版本中的JavaRESTClient（HighLevelRestClient(HLRC)）的支持，从而替换为推荐使用的JavaAPIClient8.x查看SpringBoot2.6.4的依赖，其中es的版本仅为7.15.2因此这里我就按照官方文档使用了推荐的鉴于es8.x的资料文档目前并不是很齐全，本文中如有错误，欢迎各位指出。本文将记录一些es8.xapi下的简单CRUD操作。...
SpringBoot集成Elasticsearch
weixin_51296247的博客
03-09 1226
集成SpringBoot 参考文档:Elastic Stack and Product Documentation | Elastic 1.maven依赖 //这个依赖可以直接在创建springboot项目时进行选择 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch...
springboot7==ElasticSearch7.15.2在windows上安装，可视化界面kibana连接es实现CRUD，IK7.15.2分词插件安装，通过javaAPI连接es实现CRUD
hebian1994的博客
11-20 1311
感谢这篇文章，让我一下就看懂了，牛皮： 搜索引擎技术系列教材 （十七）- elasticsearch - elastic search 教程;什么是,ElasticSearch,和,,Solr,一样的，,ElasticSearch,也是基于,Lucene进行了封装，提供了更为便利的访问和调用;关于JDK版本,至少使用JDK8版本，请下载JDK8或者更高版本：,下载以及配置JDK环境;下载,教程使用的ElasticSerach是截至目前,...https://how2j.cn/k/search-engine
SpringBoot+Elasticsearch实战
yh_124的博客
10-27 1428
title: SpringBoot+Elasticsearch实战 categories: 实战 tags: Java elasticsearch date: 2021-10-26 一、引入依赖 本文使用的SpringBoot版本为2.5.4，elasticsearch版本为7.15.0 1. pom文件如下 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.
ElasticSearch搭建集群及调优配置和springboot集成
qq_44784918的博客
08-12 1683
环境准备 jdk版本 [root@iz2zefc352jeey9szh60wlz ~]# java -version openjdk version "1.8.0_292" OpenJDK Runtime Environment (build 1.8.0_292-b10) OpenJDK 64-Bit Server VM (build 25.292-b10, mixed mode) Linux操作系统 [root@iz2zefc352jeey9szh60wlz ~]# cat /etc/redhat-r
SpringBoot整合ElasticSearch
qq_55946115的博客
06-01 1388
Elasticsearch是一个分布式搜索服务，提供Restful API，底层基于Lucene，采用多shard（分片）的方式保证数据安全，并且提供自动resharding的功能，github等大型的站点也是采用了ElasticSearch作为其搜索服务。 开源的 ElasticSearch 是目前全文搜索引擎的首选。他可以快速的存储、搜索和分析海量数据。Spring Boot通过整合SpringData ElasticSearch为我们提供了非常便捷的检索功能支持。
ElasticSearch7.x 之 elasticsearch.yml详细配置
热门推荐
lukabruce的博客
03-12 1万+
配置项 一下子看到这么多配置项，可能就吓坏了，不要怕，用到的并不多。 cluster.name: elasticsearch # 配置的集群名称，默认是elasticsearch，es服务会通过广播方式自动连接在同一网段下的es服务，通过多播方式进行通信，同一网段下可以有多个集群，通过集群名称这个属性来区分不同的集群。 node.name: "Franz Kafka" # 当前配置所在机器...
Linux安装elasticsearch7.15.2集群
weixin_40701186的博客
11-25 497
ELK安装部署
Elasticsearch - Java API 操作 ES7.15.0、ES7.x 索引，文档；高级搜索（六）
MinggeQingchun的博客
09-11 3181
Elasticsearch - Elasticsearch详解；安装部署（一）_MinggeQingchun的博客-CSDN博客
SpringBoot 整合 Elasticsearch （超详细）
个人学习使用
11-09 3532
😊SpringBoot 整合 Elasticsearch （超详细）
Elasticsearch-7.15.2和laravel版本
最新发布
05-15
Elasticsearch-7.15.2是一个基于Apache Lucene(TM)的开源搜索引擎。它提供了分布式、多租户的全文搜索功能，并支持实时数据分析。Elasticsearch-7.15.2可以用于各种场景，例如企业搜索、网站搜索、日志分析、安全分析等。 Laravel是一款基于PHP语言的开源Web应用程序框架，它遵循MVC模式，具有优雅简洁的语法和强大的功能。Laravel框架提供了各种工具和组件，可以帮助开发人员快速构建高质量的Web应用程序。Laravel框架支持各种数据库系统，例如MySQL、PostgreSQL等。 在Laravel中，可以使用Elasticsearch-7.15.2作为搜索引擎，来提供更高效、更准确的搜索功能。Laravel框架提供了Elasticsearch-7.15.2的官方扩展包——Scout，它可以方便地集成Elasticsearch-7.15.2和Laravel框架。通过Scout扩展包，可以轻松地将Laravel模型与Elasticsearch-7.15.2索引进行关联，并使用Eloquent模型语法来执行搜索操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值