SpringBoot整合ElasticSearch实现模糊查询，排序，分页，高亮

已于 2023-03-07 19:11:09 修改
阅读量1.3w 收藏 91
点赞数 25
分类专栏： elasticsearch 文章标签： elasticsearch spring boot java
于 2023-03-07 19:10:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51438138/article/details/129388324
版权

目录

前言

1.框架集成-SpringData-整体介绍

1.1Spring Data Elasticsearch 介绍

2.框架集成Spring Data Elasticsearch

2.1版本说明

2.2.idea创建一个springboot项目

2.3.导入依懒

2.3.增加配置文件

2.4Spring Boot 主程序。

2.5.数据实体类

2.6.配置类

2.7.DAO 数据访问对象

3.框架集成-SpringData-集成测试-索引操作

4.框架集成-SpringData-集成测试-文档操作

5.框架集成-SpringData-集成测试-文档搜索

6.demo地址

前言

推荐首先查看spring boot对应elasticsearch版本，选择合适的版本整合，推荐以spring boot版本为主，因为项目中集成的框不止是es，根据spring boot去安装对应版本的es。
Spring Data Elasticsearch - 参考文档，这是官方文档，建议一定参照文档，这个文档真的很详细。

springboot操作elasticsearch有两种常用方式：

  • Spring Data Elasticsearch

这是Spring官方最推荐的，就像JPA，Mybatisplus一样，在DAO层继承ElasticsearchRepository接口，就可以使用封装好的一些常见的操作了，用起来简单方便。

 

 文档： Spring 数据弹性搜索 - 参考文档 

  •  ElasticsearchRestTemplate

封装的就是High Level REST Client，这是基于HTTP协议的客户端，是ES官方推荐使用的，也是可以使用的，但是要求对ES的DSL语句熟悉，方便自己做复杂的增删改查。

映射标注概述

使用元数据来驱动对象到文档的映射。 元数据取自可以注释的实体属性。MappingElasticsearchConverter

以下注释可用：

  • @Document：在类级别应用，以指示此类是映射到数据库的候选项。 最重要的属性是（查看 API 文档以获取完整的属性列表）：

    • indexName：要在其中存储此实体的索引的名称。 这可以包含一个 SpEL 模板表达式，例如"log-#{T(java.time.LocalDate).now().toString()}"

    • createIndex：标记是否在存储库引导时创建索引。 默认值为 true。 请参阅使用相应映射自动创建索引

  • @Id：在字段级别应用，以标记用于标识目的的字段。

  • @Transient， ， ： 有关详细信息，请参阅以下控制写入和读取哪些属性一节。@ReadOnlyProperty@WriteOnlyProperty

  • @PersistenceConstructor：标记给定的构造函数 - 甚至是受包保护的构造函数 - 以便在从数据库中实例化对象时使用。 构造函数参数按名称映射到检索到的文档中的键值。

  • @Field：应用于字段级别并定义字段的属性，大多数属性映射到相应的 Elasticsearch 映射定义（以下列表不完整，请查看注释 Javadoc 以获取完整参考）：

    • name：将在 Elasticsearch 文档中表示的字段名称，如果未设置，则使用 Java 字段名称。

    • type：字段类型可以是文本、关键字、长整型、整数、短整型、字节、双精度、浮点型、Half_Float型、Scaled_Float、日期、Date_Nanos、布尔值、二进制、Integer_Range、Float_Range、Long_Range、Double_Range、Date_Range、Ip_Range、对象、嵌套、IP、令牌计数、渗滤器、扁平化、Search_As_You_Type之一。 请参阅 Elasticsearch 映射类型。 如果未指定字段类型，则默认为 。 这意味着，不会为该属性写入映射条目，并且 Elasticsearch 将在存储此属性的第一个数据时动态添加映射条目（查看 Elasticsearch 文档以了解动态映射规则）。FieldType.Auto

    • format：一种或多种内置日期格式，请参阅下一节日期格式映射。

    • pattern：一种或多种自定义日期格式，请参阅下一节日期格式映射。

    • store：标记原始字段值是否应存储在 Elasticsearch 中，默认值为 false。

    • analyzer， ， ，用于指定自定义分析器和规范化器。searchAnalyzernormalizer

  • @GeoPoint：将字段标记为geo_point数据类型。 如果字段是类的实例，则可以省略。GeoPoint

  • @ValueConverter定义用于转换给定属性的类。 与注册的 Spring 不同，这只转换带注释的属性，而不是给定类型的每个属性。Converter

映射元数据基础设施在一个单独的 spring-data-commons 项目中定义，该项目与技术无关。

文档： Spring 数据弹性搜索 - 参考文档

1.框架集成-SpringData-整体介绍

Spring Data是一个用于简化数据库、非关系型数据库、索引库访问，并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷，并支持 map-reduce框架和云计算数据服务Spring Data可以极大的简化JPA(Elasticsearch)的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了CRUD 外，还包括如分页、排序等一些常用的功能。

Spring Data 的官网

Spring Data 常用的功能模块如下：

  • Spring Data JDBC
  • Spring Data JPA
  • Spring Data LDAP
  • Spring Data MongoDB
  • Spring Data Redis
  • Spring Data R2DBC
  • Spring Data REST
  • Spring Data for Apache Cassandra
  • Spring Data for Apache Geode
  • Spring Data for Apache Solr
  • Spring Data for Pivotal GemFire
  • Spring Data Couchbase
  • Spring Data Elasticsearch
  • Spring Data Envers
  • Spring Data Neo4j
  • Spring Data JDBC Extensions
  • Spring for Apache Hadoop

1.1Spring Data Elasticsearch 介绍

Spring Data Elasticsearch基于Spring Data API简化 Elasticsearch 操作，将原始操作Elasticsearch 的客户端API进行封装。Spring Data为Elasticsearch 项目提供集成搜索引擎。Spring Data Elasticsearch POJO的关键功能区域为中心的模型与Elastichsearch交互文档和轻松地编写一个存储索引库数据访问层。

Spring Data Elasticsearch 官网

注意点：

  • ElasticsearchRestTemplate是spring-data-elasticsearch项目中的一个类,和其他spring项目中的 template类似。
  • 在新版的spring-data-elasticsearch 中，ElasticsearchRestTemplate 代替了原来的ElasticsearchTemplate。
  • 原因是ElasticsearchTemplate基于TransportClient，TransportClient即将在8.x 以后的版本中移除。所以，我们推荐使用ElasticsearchRestTemplate。ElasticsearchRestTemplate基于RestHighLevelClient客户端的。
  • 需要自定义配置类，继承AbstractElasticsearchConfiguration，并实现elasticsearchClient()抽象方法，创建RestHighLevelClient对象。
     

2.框架集成Spring Data Elasticsearch

2.1版本说明

内容版本
elasticsearchelasticsearch-7.8.0
springboot 
2.3.6.RELEASE

2.2.idea创建一个springboot项目

2.3.导入依懒

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
    </dependencies>

2.3.增加配置文件

在 resources 目录中增加application.properties文件

# es 服务地址
elasticsearch.host=127.0.0.1
# es 服务端口
elasticsearch.port=9200
# 配置日志级别,开启 debug 日志
logging.level.com.es=debug

2.4Spring Boot 主程序。

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;


/**
 * @author 24412
 */
@SpringBootApplication
public class SpringBootElasticSearchApplication {

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

}

2.5.数据实体类

package com.example.es;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

/**
 * @author 24412
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
@Document(indexName = "shopping", shards = 3, replicas = 1)
public class Product {
    /**
     * type : 字段数据类型
     * analyzer : 分词器类型
     * index : 是否索引(默认:true)
     * Keyword : 短语,不进行分词
     */

    /**
     *     商品唯一标识 必须有 id,这里的 id 是全局唯一的标识，等同于 es 中的"_id"
     */
    @Id
    private Long id;

    @Field(type = FieldType.Text, analyzer = "ik_max_word")
    private String title;//商品名称

    @Field(type = FieldType.Keyword)
    private String category;//分类名称

    @Field(type = FieldType.Double)
    private Double price;//商品价格

    @Field(type = FieldType.Keyword, index = false)
    private String images;//图片地址
}

2.6.配置类

package com.example.config;

import lombok.Data;
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.Configuration;
import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;

/** ElasticsearchRestTemplate基于RestHighLevelClient客户端的。
 * 需要自定义配置类，继承AbstractElasticsearchConfiguration，
 * 并实现elasticsearchClient()抽象方法，创建RestHighLevelClient对象。
 * @author 24412
 */
@ConfigurationProperties(prefix = "elasticsearch")
@Configuration
@Data
public class ElasticsearchConfig extends AbstractElasticsearchConfiguration{
     /**
     * 设置为static方便后面调用
     */
    public static RestHighLevelClient restHighLevelClient;
    private String host ;
    private Integer port ;
    /**
     * 重写父类方法
     */
    @Override
    public RestHighLevelClient elasticsearchClient() {
        RestClientBuilder builder = RestClient.builder(new HttpHost(host, port));
        restHighLevelClient = new RestHighLevelClient(builder);
        return restHighLevelClient;
    }
}

2.7.DAO 数据访问对象

import com.lun.model.Product;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Repository;

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

}

3.框架集成-SpringData-集成测试-索引操作

package com.example;

import com.example.es.Product;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringDataESIndexTest {
    //注入 ElasticsearchRestTemplate
    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;
    //创建索引并增加映射配置
    @Test
    public void createIndex(){
        //创建索引，系统初始化会自动创建索引
        System.out.println("创建索引");
    }

    @Test
    public void deleteIndex(){
        //创建索引，系统初始化会自动创建索引
        boolean flg = elasticsearchRestTemplate.deleteIndex(Product.class);
        System.out.println("删除索引 = " + flg);
    }
}

4.框架集成-SpringData-集成测试-文档操作

package com.example;

import com.example.dao.ProductDao;
import com.example.es.Product;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.List;

/**
 * 文档操作
 */
@RunWith(SpringRunner.class)
@SpringBootTest
class SpringBootElasticSearchApplicationTests {
    @Autowired
    private ProductDao productDao;

    /**
     * 新增
     */
    @Test
    public void testAdd() {
        Product product = new Product();
        product.setId(1L);
        product.setTitle("小米手机");
        product.setCategory("手机");
        product.setPrice(1999.00);
        product.setImages("http://image.baidu.com/13123.jpg");
        productDao.save(product);
    }

    /**
     * 修改
     */
    @Test
    public void testUpdate() {
        Product product = new Product();
        product.setId(1L);
        product.setTitle("华为手机");
        product.setCategory("手机");
        product.setPrice(2999.00);
        product.setImages("http://image.baidu.com/13123.jpg");
        productDao.save(product);
    }

    /**
     * 根据id查询
     */
    @Test
    public void testFindById() {
        Product product = productDao.findById(1L).get();
        System.out.println(product);
    }

    /**
     * 查询全部
     */
    @Test
    public void testFindAll() {
        productDao.findAll().forEach(System.out::println);
    }

    /**
     * 删除
     */
    @Test
    public void testDelete() {
        productDao.deleteById(1L);

    }

    /**
     * 批量插入
     */
    @Test
    public void testBatchAdd() {
        List<Product> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            Product product = new Product();
            product.setId(Long.valueOf(i));
            product.setTitle("华为手机" + i);
            product.setCategory("手机");
            product.setPrice(2999.00);
            product.setImages("http://image.baidu.com/13123.jpg");
            list.add(product);
        }
        productDao.saveAll(list);
    }

    /**
     * 分页查询
     */
    @Test
    public void testPageQuery() {
        //设置排序(排序方式，正序还是倒序，排序的 id)
        Sort sort = Sort.by(Sort.Direction.DESC, "id");
        //设置分页(页码，每页显示的条数)
        //当前页码0开始
        int currentPage = 0;
        //每页显示的条数
        int pageSize = 10;
        //设置分页
        PageRequest pageRequest = PageRequest.of(currentPage, pageSize, sort);
        //分页查询
        productDao.findAll(pageRequest).forEach(System.out::println);
    }



}

5.框架集成-SpringData-集成测试-文档搜索

package com.example;

import com.example.config.ElasticsearchConfig;
import com.example.dao.ProductDao;
import com.example.es.Product;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.FuzzyQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.*;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringDataESSearchTest {
    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;

    @Autowired
    private ProductDao productDao;

    /**
     * term 查询
     * search(termQueryBuilder) 调用搜索方法，参数查询构建器对象
     */
    @Test
    public void termQuery() {
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", "华为手机99");
        QueryBuilders.boolQuery().must(termQueryBuilder);
        Iterable<Product> products = productDao.search(termQueryBuilder);
        for (Product product : products) {
            System.out.println(product);
        }
    }

    /**
     * term 查询加分页
     */
    @Test
    public void termQueryByPage() {
        int currentPage = 0;
        int pageSize = 5;
        //设置查询分页
        PageRequest pageRequest = PageRequest.of(currentPage, pageSize);
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", "华为手机");
        Iterable<Product> products =
                productDao.search(termQueryBuilder, pageRequest);
        for (Product product : products) {
            System.out.println(product);
        }
    }

    /**
     * 高亮查询
     */
    @Test
    public void testHighlight() {
        //构建查询条件
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.should(QueryBuilders.matchQuery("title", "华为手机"));
        //设置高亮字段
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        //设置标签前缀
        highlightBuilder.preTags("<font color='red'>");
        //设置标签后缀
        highlightBuilder.postTags("</font>");
        //设置高亮字段
        highlightBuilder.field("title");
        // 构建查询
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(boolQuery)
                .withHighlightBuilder(highlightBuilder)
                .build();
        //执行查询
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
        //获取查询结果
        searchHits.forEach(searchHit -> {
            System.out.println(searchHit.toString());
        });
    }

    /**
     * 高亮查询加分页
     */
    @Test
    public void testHighlightByPage() {
        //当前页
        int currentPage = 0;
        //每页显示条数
        int pageSize = 5;
        //设置查询分页
        PageRequest pageRequest = PageRequest.of(currentPage, pageSize);
        //构建查询条件
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.should(QueryBuilders.matchQuery("title", "华为手机"));
        //设置高亮字段
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        //设置标签前缀
        highlightBuilder.preTags("<font color='red'>");
        //设置标签后缀
        highlightBuilder.postTags("</font>");
        //设置高亮字段
        highlightBuilder.field("title");
        // 构建查询
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(boolQuery)
                .withHighlightBuilder(highlightBuilder)
                .withPageable(pageRequest)
                .build();
        //执行查询
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
        //获取查询结果
        searchHits.forEach(searchHit -> {
            System.out.println(searchHit.toString());
        });
    }

    /**
     * 模糊查询
     */
    @Test
    public void testFuzzyQuery() {
        //构建查询条件
        FuzzyQueryBuilder fuzzyQuery = QueryBuilders.fuzzyQuery("title", "华为").fuzziness(Fuzziness.ONE);
        // 构建查询
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(fuzzyQuery)
                .build();
        //执行查询
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
        //获取查询结果
        searchHits.forEach(searchHit -> {
            System.out.println(searchHit.toString());
        });
    }

    /**
     * 最大查询
     */
    @Test
    public void testMaxQuery() {
        FuzzyQueryBuilder fuzzyQuery = QueryBuilders.fuzzyQuery("title", "华为").fuzziness(Fuzziness.ONE);
        // 构建查询
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(fuzzyQuery)
                .addAggregation(AggregationBuilders.max("maxAge").field("age"))
                .build();
        //执行查询
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
        //获取查询结果
        searchHits.forEach(searchHit -> {
            System.out.println(searchHit.toString());
        });
    }

    /**
     * 分组查询
     */
    @Test
    public void testGroupQuery() {
        // 构建查询
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .addAggregation(AggregationBuilders.terms("title").field("price"))
                .build();
        //执行查询
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
        //获取查询结果
        searchHits.forEach(searchHit -> {
            System.out.println(searchHit.toString());
        });
    }

    /**
     * 范围查询
     */
    @Test
    public void testRangeQuery() {
        //构建条件查询：id为30-50，按价格分组
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.must(QueryBuilders.rangeQuery("id").from(30).to(50));
        // 构建查询
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(boolQuery)
                .addAggregation(AggregationBuilders.terms("title").field("price"))
                .build();
        //执行查询
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
        //获取查询结果
        searchHits.forEach(searchHit -> {
            System.out.println(searchHit.toString());
        });
    }

    /**
     * 组合查询
     */
    @Test
    public void testConditionQuery() {
        //构建条件查询：id为30-50，按价格分组
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.must(QueryBuilders.rangeQuery("id").from(30).to(50));
        // 构建查询
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(boolQuery)
                .addAggregation(AggregationBuilders.terms("title").field("price"))
                .build();
        //执行查询
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
        //获取查询结果
        searchHits.forEach(searchHit -> {
            System.out.println(searchHit.toString());
        });
    }

    /**
     * TODO 查询排序  ElasticsearchConfig.restHighLevelClient
     */
    @Test
    public void testSortQuery() throws IOException {
        //里面可以放多个索引
        SearchRequest request = new SearchRequest("shopping");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //按照id倒序排列（score会失效返回NaN）
        sourceBuilder.sort(SortBuilders.fieldSort("_id").order(SortOrder.DESC));
        //执行查询
        SearchResponse response = ElasticsearchConfig.restHighLevelClient.search(request, RequestOptions.DEFAULT);
        //打印结果信息
        org.elasticsearch.search.SearchHits hits = response.getHits();
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());
        System.out.println("hits========>>");
        hits.forEach(hit -> {
            System.out.println(hit.getSourceAsString());
        });
        System.out.println("<<========");
    }

}

6.demo地址

SpringBoot整合ElasticSearch小demo: SpringBoot整合ElasticSearch小demo

Traveler飞
关注
专栏目录
SpringBoot + Elasticsearch 实现模糊查询，批量CRUD，排序，分页，高亮！
北辰
12-08 669
SpringBoot + Elasticsearch 实现模糊查询，批量CRUD，排序，分页，高亮！
SpringBoot+ElasticSearch 实现模糊查询，批量CRUD，排序，分页，高亮！
m0_71777195的博客
12-02 1716
1.大致流程创建对应的请求 --> 设置请求（添加规则，添加数据等） --> 执行对应的方法（传入请求，默认请求选项）–> 接收响应结果（执行方法返回值）–> 输出响应结果中需要的数据（source，status等）2.注意事项如果不指定id，会自动生成一个随机id正常情况下，不应该这样使用，如果索引发生改变了，那么代码都需要修改，可以定义一个枚举类或者一个专门存放常量的类，将变量用等进行修饰，并指定索引值。其他地方引用该常量即可，需要修改也只需修改该类即可。
SpringBoot集成ElasticSearch，实现模糊查询，批量CRUD，排序，分页，高亮
qq_52355487的博客
04-18 4350
文章目录一、导入elasticsearch依赖二、创建高级客户端三、基本用法1.创建、判断存在、删除索引2.对文档的CRUD3.批量CRUD数据4.查询所有、模糊查询、分页查询、排序、高亮显示四、总结1.大致流程2.注意事项 一、导入elasticsearch依赖 在pom.xml里加入如下依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>sp
springboot3 集成elasticsearch(es)客户端(高亮查询)
最新发布
abments的博客
09-05 576
springboot3 集成elasticsearch(es)客户端(高亮查询)
SpringData+ElasticSearch实现模糊查询、高亮显示
m0_37107281的博客
02-28 1945
原文链接：https://blog.csdn.net/zhang33565417/article/details/99406387 环境搭建 1.1 引入依赖 核心依赖如下（其他依赖自行引入） org.springframework.boot spring-boot-starter-parent 2.0.6.RELEASE org.springfra...
Java实战：SpringBoot+ElasticSearch 实现模糊查询
oandy0的博客
03-08 3051
本文将详细介绍如何使用SpringBoot整合ElasticSearch，实现模糊查询、批量CRUD、排序、分页和高亮功能。我们将深入探讨ElasticSearch的相关概念和技术细节，以及如何使用SpringData Elasticsearch库简化开发过程。
SpringBoot+ElasticSearch 实现模糊查询，批量CRUD，排序，分页，高亮
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
04-24 258
????????关注后回复“进群”，拉你进程序员交流群????????导入elasticsearch依赖创建高级客户端基本用法创建、判断存在、删除索引对文档的CRUD批量CRUD数据查询所有、模糊查询、分页查询、排序、高亮显示总结大致流程注意事项一、导入elasticsearch依赖在pom.xml里加入如下依赖<dependency> <groupId>org.springfra...
springboot整合Elasticsearch复杂查询
weixin_45865428的博客
02-18 1018
参考京东查询商品界面来实现！ 1、导入依赖 <properties> <!--修改默认版本号，默认为6版本--> <elasticsearch.version>7.12.1</elasticsearch.version> </properties> <dependency> <groupId>org.elasticsearch.client</groupId> <artifa
SpringBoot整合es源码
07-18
SpringBoot整合es源码, 包括详细的批量操作 bulk, 批量导入, 查询所有, 分页, termQuery:词条查询, matchQuery:词条分词查询, 模糊查询:WildcardQuery, 模糊查询:regexpQuery, 模糊查询:perfixQuery, 范围查询：...
elasticsearch学习2—springboot整合：查询条件高亮、分页、关键字查询，排序
qq_15058425的博客
01-04 1288
需求：实现关键字查询，关键字查询可以输入多个，且以空格分开，然后查询条件高亮 一、mapping: PUT /cartoonindex/ { "mappings" : { "cartoon" : { "properties" : { "name" : { "type" : "text", "anal...
SpringBoot整合ElasticSearch：模糊查询与数据操作实战
本文档主要介绍了如何在SpringBoot框架下集成并使用Elasticsearch进行数据操作，包括模糊查询、批量创建、读取、更新和删除（CRUD）、排序、分页以及高亮显示等核心功能。 在现代互联网应用中，高效的数据检索和...
SpringBoot 整合ElasticSearch实现模糊查询，批量CRUD，排序，分页，高亮
Tongyao
05-15 1476
创建对应的请求 --> 设置请求（添加规则，添加数据等） --> 执行对应的方法（传入请求，默认请求选项）–> 接收响应结果（执行方法返回值）–> 输出响应结果中需要的数据（source，status等）
Springboot实现ElasticSearch全文模糊搜索（3）
qq_33431394的博客
08-11 1161
Pom文件 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency>
Spring boot 整合 Elasticsearch 实现模糊查询
weixin_44172680的博客
11-15 4889
大家好，今天突发奇想，，学习拉一下Elasticsearch，今天来跟大家分享一下，平时不熬夜得的我，最近熬夜搞这个东西，可能不是那么完美，也会有小bug，所以请大家谅解 1：安装Elasticsearch 去官网下载https://www.elastic.co/cn/downloads/elasticsearch 下面运行Elasticsearch 下载完解压即可：直接双击/bin/Elas...
Spring Boot中的ElasticsearchRepository
程序员徐师兄的博客
06-30 906
ElasticsearchRepository是Spring Data Elasticsearch提供的一个仓库接口，它提供了一些方法来访问Elasticsearch，比如增删改查等操作。通过实现该接口，我们可以轻松地操作Elasticsearch，并且可以充分利用Spring Data的自动化特性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Traveler飞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值