Spring Data操作 ES

最新推荐文章于 2024-03-28 23:48:43 发布
最新推荐文章于 2024-03-28 23:48:43 发布
阅读量4.2k 收藏 17
点赞数 6
分类专栏： ElasticSearch 文章标签： Spring Data操作ES 高亮显示
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32108357/article/details/99183757
版权

写在前面：

Spring Data 是持久层通用解决方案，支持关系型数据库 Oracle、MySQL、非关系型数据库NoSQL、Map-Reduce 框架、云基础数据服务 、搜索服务。Spring Data JPA 框架，主要针对的就是 Spring 唯一没有简化到的业务逻辑代码，至此，开发者连仅剩的实现持久层业务逻辑的工作都省了，唯一要做的，就只是声明持久层的接口，其他都交给 Spring Data JPA 来帮你完成！

环境搭建：

1.创建一个新的maven的web的moudle
项目结构如下：在这里插入图片描述
2.引入springboot和操作es的的相关依赖

 <!--注意:升级原有项目中springboot版本-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.6.RELEASE</version>
  </parent>
  <dependencies>
    <!--springboot web -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!--通过spring data 操作Es-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    </dependency>

    <!--springboot 继承test-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
    <!--引入lombook-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
    </dependency>
  </dependencies>

3.配置yml文件

spring:
  redis:
    port: 8989
  data:
    elasticsearch:
      cluster-nodes: 192.168.94.160:9300

编程测试一（实现基本的增删改查）：

1.编写实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
/*  索引 、 类型 、映射 、 文档
* 声明当前文档对应的索引和类型
* */
@Document(indexName = "ems",type = "emp")
public class Emp {
    @Id
    private String id;
    @Field(type = FieldType.Keyword,analyzer = "ik_max_word")
    private String name;
    @Field(type = FieldType.Text,analyzer = "ik_max_word")
    private String intr;
    private String age;
    @Field(type = FieldType.Text,analyzer = "ik_max_word")
    private String content;
    @Field(type = FieldType.Boolean)
    private Boolean sex;
}

@Document: 代表一个文档记录

indexName:  用来指定索引名称

type:		用来指定索引类型

@Id: 用来将对象中id和ES中_id映射

@Field: 用来指定ES中的字段对应Mapping

type: 用来指定ES中存储类型

analyzer: 用来指定使用哪种分词器

2.编写EmpRepository

public interface EmpRepository extends ElasticsearchRepository<Emp,String> {
}

自定义的接口只需要继承ElasticsearchRepository<Emp,String>接口即可，不需要进行实现，其实现部分已经由SpringData框架为我们做了底层的封装，供我们完基本的增删改查功能。

3.编写测试类

索引or更新一条记录：

@SpringBootTest(classes = Application.class)
@RunWith(SpringRunner.class)
public class TestFunction {

    @Autowired
    private EmpRepository empRepository;
    /*
    * 这种方式会根据实体类中的配置自动在ES中创建索引以及映射
    * */
    @Test
    public void testIndex(){
        Emp emp = new Emp("1", "毕鑫蕊", "全世界独一无二的姑娘", "18", "全是姐独一无二的姑娘", true);
        empRepository.save(emp);
    }
}

删除一条记录：

@Test
    public void testDelete(){
        Emp emp = new Emp();
        emp.setId("3");
        //delete方法的参数参数要求是一个对象
        empRepository.delete(emp);
    }

查询一个：

 @Test
    public void testFindOne(){
        Optional<Emp> byId = empRepository.findById("2");
        System.out.println(byId);
    }

查询所有：

@Test
    public void testFindAll(){
        Iterable<Emp> all = empRepository.findAll();
        for (Emp emp : all) {
            System.out.println(emp);
        }
    }

查询功能中的查询结果返回的内容是对象的形式，一下是查询结果：

Emp(id=2, name=bxr2, intr=全世界独一无二的姑娘2, age=182, content=全是姐独一无二的姑娘, sex=true)
Emp(id=1, name=bxr, intr=全世界独一无二的姑娘, age=18, content=全是姐独一无二的姑娘, sex=true)

排序查询：

@Test
    public void testFindAllOrder(){
        Iterable<Emp> age = empRepository.findAll(Sort.by(Sort.Order.desc("age")));
        age.forEach(emp -> System.out.println(emp));
    }

编程测试二（实现自定的查询）

1.自定义关键字一览表：

KeywordSampleElasticsearch Query String
AndfindByNameAndPrice{"bool" : {"must" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}
OrfindByNameOrPrice{"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}
IsfindByName{"bool" : {"must" : {"field" : {"name" : "?"}}}}
NotfindByNameNot{"bool" : {"must_not" : {"field" : {"name" : "?"}}}}
BetweenfindByPriceBetween{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}
LessThanEqualfindByPriceLessThan{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}
GreaterThanEqualfindByPriceGreaterThan{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}
BeforefindByPriceBefore{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}
AfterfindByPriceAfter{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}
LikefindByNameLike{"bool" : {"must" : {"field" : {"name" : {"query" : "*","analyze_wildcard" : true}}}}}
StartingWithfindByNameStartingWith{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}
EndingWithfindByNameEndingWith{"bool" : {"must" : {"field" : {"name" : {"query" : "*?","analyze_wildcard" : true}}}}}
Contains/ContainingfindByNameContaining{"bool" : {"must" : {"field" : {"name" : {"query" : "**?**","analyze_wildcard" : true}}}}}
InfindByNameIn
(Collection<String>names)		{"bool" : {"must" : {"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"name" : "?"}} ]}}}}
NotInfindByNameNotIn
(Collection<String>names)		{"bool" : {"must_not" : {"bool" : {"should" : {"field" : {"name" : "?"}}}}}}
NearfindByStoreNearNot Supported Yet !
TruefindByAvailableTrue{"bool" : {"must" : {"field" : {"available" : true}}}}
FalsefindByAvailableFalse{"bool" : {"must" : {"field" : {"available" : false}}}}
OrderByfindByAvailable
TrueOrderByNameDesc		{"sort" : [{ "name" : {"order" : "desc"} }],"bool" : {"must" : {"field" : {"available" : true}}}}

2.自定义的基本查询

public interface EmpRepository extends ElasticsearchRepository<Emp,String> {
    /*
    * 扩展方法 自定方法  根据方法名可以直观的得知方法的作用
    */
    List<Emp> findByContent(String content);  //等值查询

    List<Emp> findByIntrNot(String intr);  //必须不

    List<Emp> findByIntrAndContent(String intr,String content); //并且

    List<Emp> findByIntrOrContent(String intr,String content);  //或者

    List<Emp> findByAgeBetween(Integer start,Integer end);

    List<Emp> findByContentLike(String string);

    List<Emp> findByNameNotIn(List<String> strs);

    List<Emp> findBySexTrueOrderByNameDesc();
}

自定义的基本查询不需要自己去实现，但要求其命名时严格按照springData提供的关键字规范进行命名，

3.自定义复杂查询
（
自定义的复杂实现区别于简单查询有两点：
1.接口无需进行任何继承
2.实现类需要加上@Com
）
首先自定义Repository接口，在接口中去定义需要实现的复杂方法

package com.baizhi.esrepository;


import com.baizhi.esentity.Emp;
import java.util.List;
public interface CustomRepository  {
    //关键词查询
    public List<Emp> termQuery();
    //关键词查询 并且分页
    public List<Emp> termQueryPage();

    //关键词查询 并且分页 并且排序
    public List<Emp> termQueryPageSort();

    //关键词查询 并且分页 并且排序  指定字段展示
    public List<Emp> termQueryPageSortSource();

    //关键词查询 并且分页 并且排序  指定字段展示  过滤查询
    public List<Emp> termQueryPageSortSourceFilter();

    //关键词查询 并且分页 并且排序  指定字段展示  过滤查询 高亮查询
    public List<Emp> termQueryPageSortSourceFilterHighLighter();
}

其次是书写实现类自己实现相关的方法，这里有一个需要用到一个关键的对象
ElasticsearchTemplate elasticsearchTemplate：

package com.baizhi.esrepository;

import com.baizhi.esentity.Emp;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
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.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.SearchResultMapper;
import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
import org.springframework.data.elasticsearch.core.query.CriteriaQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.SearchQuery;
import org.springframework.stereotype.Component;

import java.awt.print.Book;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Component
public class CustomRepositoryImpl implements CustomRepository {
/*
* 构建复杂查询

*
* */
    @Autowired
    ElasticsearchTemplate elasticsearchTemplate;
    @Override
    public List<Emp> termQuery() {

        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("content", "橘子");
        SearchQuery searchQuery=new NativeSearchQuery(termQueryBuilder);
        //第一个参数为查询条件
        //第二个参数  是当前操作的类型的类对象
        List<Emp> emps = elasticsearchTemplate.queryForList(searchQuery, Emp.class);
        return emps;
    }

    @Override
    public List<Emp> termQueryPage() {
        /*
        * dsl
        *
        * */
        NativeSearchQuery build = new NativeSearchQueryBuilder()
                .withIndices("ems")
                .withTypes("emp")
                .withQuery(QueryBuilders.matchAllQuery())
                .withPageable(PageRequest.of(1,5))
                .build();

        List<Emp> emps = elasticsearchTemplate.queryForList(build, Emp.class);

        return emps;
    }

    @Override
    public List<Emp> termQueryPageSort() {

        FieldSortBuilder sortBuilder = SortBuilders.fieldSort("age").order(SortOrder.DESC);


        NativeSearchQuery build = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchAllQuery())
                .withIndices("ems")
                .withTypes("emp")
                .withPageable(PageRequest.of(0,10))
                .withSort(sortBuilder)
                .build();
        List<Emp> emps = elasticsearchTemplate.queryForList(build, Emp.class);

        return emps;
    }

    @Override
    public List<Emp> termQueryPageSortSource() {
        FieldSortBuilder sortBuilder = SortBuilders.fieldSort("age").order(SortOrder.DESC);


        NativeSearchQuery build = new NativeSearchQueryBuilder()
                .withIndices("ems")
                .withTypes("emp")
                .withQuery(QueryBuilders.matchAllQuery())
                .withSort(sortBuilder)
                .withFields("name", "content", "age","intr")
                .build();

        List<Emp> emps = elasticsearchTemplate.queryForList(build, Emp.class);

        return emps;
    }

    @Override
    public List<Emp> termQueryPageSortSourceFilter() {

        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.rangeQuery("age").lte(200).gte(10));


        NativeSearchQuery build = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchAllQuery())
                .withSort(SortBuilders.fieldSort("age").order(SortOrder.ASC))
                .withPageable(PageRequest.of(0,10))
                .withFields("name","content","age")
                .withFilter(boolQueryBuilder)
                .build();

        List<Emp> emps = elasticsearchTemplate.queryForList(build, Emp.class);


        return emps;
    }

    @Override
    public List<Emp> termQueryPageSortSourceFilterHighLighter() {

        HighlightBuilder.Field field = new HighlightBuilder
                .Field("*")
                .requireFieldMatch(false)
                .preTags("<font color='red'>")
                .postTags("</font>");

        NativeSearchQuery build = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.termQuery("intr","好人"))
                .withHighlightFields(field)
                .build();



//        List<Emp> emps = elasticsearchTemplate.queryForList(build, Emp.class);


        AggregatedPage<Emp> emps=elasticsearchTemplate.queryForPage(build, Emp.class, new SearchResultMapper() {
            @Override
            public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
                SearchHit[] hits = searchResponse.getHits().getHits();
                List<Emp> list=new ArrayList<>();
                for (SearchHit hit : hits) {
                    Emp emp = new Emp();
                    //原始数据的对象
                    Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                    if (sourceAsMap.get("sex")!=null){
                        emp.setSex(Boolean.valueOf(sourceAsMap.get("sex").toString()));
                    }
                    emp.setAge(Integer.valueOf(sourceAsMap.get("age").toString()));
                    emp.setName(sourceAsMap.get("name").toString());
                    emp.setContent(sourceAsMap.get("content").toString());
                    emp.setId(sourceAsMap.get("id").toString());
                    emp.setIntr(sourceAsMap.get("intr").toString());


                    /*
                    * 首先拿到高亮数据 判断高亮数据中的每个字段是否高亮 如果高亮则返回高亮值 否则返回原始值
                    * */
//
                    Map<String, HighlightField> highlightFields = hit.getHighlightFields();
//                    HighlightField id = highlightFields.get("id");
//                    if (id!=null){
//                        emp.setId(highlightFields.get("id").getFragments()[0].toString());
//                    }
//                    HighlightField name = highlightFields.get("name");
//                    if (name!=null){
//                        emp.setName(highlightFields.get("name").getFragments()[0].toString());
//                    }
//
//                    HighlightField content = highlightFields.get("content");
//                    if (content!=null){
//                        emp.setContent(highlightFields.get("content").getFragments()[0].toString());
//                    }
//
//                    HighlightField intr = highlightFields.get("intr");
//                    if (intr!=null){
//                        emp.setIntr(highlightFields.get("intr").getFragments()[0].toString());
//                    }
                    for (String key : sourceAsMap.keySet()) {
                        if (highlightFields.get(key)!=null){
                            //高亮后的数据
                            String fragment = highlightFields.get(key).getFragments()[0].toString();
                           //获取方法名
                            String method="set"+key.substring(0,1).toUpperCase()+key.substring(1);
                           //获取类对象
                            Class<? extends Emp> aClass1 = emp.getClass();
                            //set方法
                            Method declaredMethod = null;
                            try {
                                declaredMethod = aClass1.getDeclaredMethod(method, fragment.getClass());
                            } catch (NoSuchMethodException e) {
                                e.printStackTrace();
                            }
                            try {
                              //调用set方法
                                declaredMethod.invoke(emp,fragment);
                            } catch (IllegalAccessException e) {
                                e.printStackTrace();
                            } catch (InvocationTargetException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                    list.add(emp);
                }
                return new AggregatedPageImpl<T>((List<T>)list);
            }
        });


        return emps.getContent();
    }
}
北漂的意义是啥啊
关注
专栏目录
SpringBoot整合Spring Data Elasticsearch的过程详解
08-25
"SpringBoot整合Spring Data Elasticsearch的过程详解" SpringBoot整合Spring Data Elasticsearch是将SpringBoot框架与Elasticsearch搜索引擎进行整合，以实现数据的搜索和索引功能。下面将详细介绍SpringBoot整合...
Elastic实战：spring-data-elasticsearch聚合查询指南｜spring-data-elasticsearch实现各类聚合
55555的博客
05-31 5614
0.引言 elasticsearch支持各种类型的聚合查询，给我们做数据统计、数据分析时提供了强大的处理能力，但是作为java开发者，如何在java client中实现这些聚合呢？ 我们知道spring-data-elasticsearch提供了针对整合spring的es java client，但是在elastic、spring-data官方文档中都没有详细说明聚合查询在java client中如何实现。 所以本期，我们的目标就是一篇将这些聚合操作一网打尽！ 为了更好的将这些聚合讲解清楚，我们结合es官方
SpringDataES
qq_42480555的博客
08-17 1412
SpringDataElasticsearch（以后简称SDE）是Spring Data项目下的一个子模块。 Spring Data的使命是给各种数据访问提供统一的编程接口，比如Mysql、Redis、ES等等，目的是简化开发人员的代码。 SDE提供对象即支持ES的原生API操作，也提供了ElasticsearchTemplate对象来操作ES。 创建索引库和映射 创建springboot工程，导入依赖 <parent> <groupId>org.sp.
spring-data-es 基本操作使用
wujiumengxing的博客
05-25 1628
索引创建过程,以及前置的Dao等等实现和配置略过…. 背景: 本地创建了一个名为User的索引 结构如下 /** * 单条插入数据 */ @Test public void save() { User user = new User(); user.setId(1L); user.setImage("wwwwwwww.111111"); user.setName("zhuxueyu"); user.setPrice(999.99); use
Spring Data Elasticsearch--使用/教程/实例
热门推荐
IT利刃出鞘的博客
10-10 1万+
原文网址： 简介
spring-data-elasticsearch
weixin_33854644的博客
03-15 231
为什么80%的码农都做不了架构师？>>> ...
Spring data elasticsearch使用方法详解
08-25
本文将深入讲解如何利用 Spring Data Elasticsearch 进行索引创建、配置映射、文档操作等基本功能。 ### **一、设置依赖** 在开始使用 Spring Data Elasticsearch 之前，你需要在项目中添加相应的依赖。在 Maven ...
Springboot集成spring data elasticsearch过程详解
08-19
Spring Boot 集成 Spring Data Elasticsearch 过程详解 Spring Boot 是一个基于 Java 的框架，用于快速构建独立的、生产级别的基于 Spring 的应用程序，而 Spring Data Elasticsearch 是 Spring Data 家族中的一员...
Spring Data Elasticsearch API（Spring Data Elasticsearch 开发文档）.CHM
08-31
Spring Data Elasticsearch API（Spring Data Elasticsearch 开发文档）.CHM。 官网 Spring Data Elasticsearch API
基于Spring Data Jest的Elasticsearch数据统计示例
08-27
"基于Spring Data Jest的Elasticsearch数据统计示例" 本文主要介绍了基于Spring Data Jest的Elasticsearch数据统计示例，通过使用Spring Data Jest链接Elasticsearch，实现数据统计示例。同时，本文也介绍了命令...
ES中FieldType讲解
weixin_52293201的博客
04-13 1860
Field(type=FieldType.Text, analyzer="ik_max_word") 表示该字段是一个文本，并作最大程度拆分，默认建立索引。@Field(type=FieldType.Keyword) 表示该字段内容是一个文本并作为一个整体不可分，默认建立索引。@Field(type=FieldType.Float) 表示该字段内容是一个浮点类型并作为一个整体不可分，默认建立索引。@Field(type=FieldType.Date) 表示该字段是一个文本，日期类型，默认不建立索引。
ES小记录
Dzooooone_的博客
02-10 1863
3.1、文档（Document） 我们知道Java是面向对象的，而Elasticsearch是面向文档的，也就是说文档是所有可搜索数据的最小单元。ES的文档就像MySql中的一条记录，只是ES的文档会被序列化成json格式，保存在Elasticsearch中； 这个json对象是由字段组成，字段就相当于Mysql的列，每个字段都有自己的类型（字符串、数值、布尔、二进制、日期范围类型）； 当我们创建文档时，如果不指定字段的类型，Elasticsearch会帮我们自动匹配类型； 每个文档都...
spring data操作ES简直不能再香
lucasma的博客
06-27 1万+
引言 Elasticsearch（以下简称ES）并不像mysql这么容易上手，很多java程序员会觉得ES的java客户端比较难以掌握，尽管ES 7.x官方推荐的high level client已经相对于早期的TransportClient好用很多了。 Spring Boot通过整合Spring Data ElasticSearch为我们提供了非常便捷的检索功能支持，我们几乎可以像操作数据库一样操作ES了。本篇文章是我肝了4个小时写出的文章，希望能对大家有所帮助。 看这篇文章的小伙伴，我假设是对ES有基本
ES集成SpringData
root_zhb的博客
06-09 1279
ES集成SpringData，搭建流程及操作代码
springdata操作es
诗琪芮的博客
03-30 1497
1、创建一个maven项目 项目结构： 2、导入依赖 <dependencies> <!-- 测试用 --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test&l
springboot通过springdata整合es7.x
qq_38639813的博客
08-02 4565
Data@Id// //指定字段的索引方式，index是否索引、store是否存储、字段的分词方式、搜索时关键字分词的方式、type指定该字段的值以什么样的数据类型来存储// @Field(index = true,store = true,analyzer = "ik_max_word" ,searchAnalyzer = "ik_max_word" ,type = FieldType.Text) /* ik_smart:粗粒度分词 */
springboot-ES多数据源链接\Spring-Data-ES 连接多个ES集群
一个BUG的博客
02-27 2407
springboot 链接ES 多数据源 spring-data || elasticsearch
通过Spring Data Elasticsearch操作ES
m0_67393039的博客
08-31 574
Elasticsearch (ES)是一个基于Lucene构建的开源、分布式、RESTful 接口全文搜索引擎。Elasticsearch 还是一个分布式文档数据库，其中每个字段均是被索引的数据且可被搜索，它能够扩展至数以百计的服务器存储以及处理PB级的数据。它可以在很短的时间内在存储、搜索和分析大量的数据。它通常作为具有复杂搜索场景情况下的核心发动机。。Elasticsearch就是为高可用和可扩展而生的。可以通过购置性能更强的服务器来完成。...
springdata框架对es集成
最新发布
m0_71017987的博客
03-28 1565
Spring Data是一个用于简化数据库、非关系型数据库、索引库访问，并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷，并支持 map-reduce框架和云计算数据服务。Spring Data可以极大的简化JPA(Elasticsearch…)的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了CRUD 外，还包括如分页、排序等一些常用的功能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值