Elasticsearch完整案例(设置索引,删除索引,查询)

最新推荐文章于 2024-08-06 11:43:58 发布
最新推荐文章于 2024-08-06 11:43:58 发布
阅读量388 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44145478/article/details/103992676
版权

项目配置见上一篇

https://blog.csdn.net/weixin_44145478/article/details/103972887

HouseInfoController

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;

/**
 * @program: es
 * @create: 2020-01-14 16:11
 **/
@Api(value = "house", description = "租房数据")
@RestController
@RequestMapping("/houseInfo")
public class HouseInfoController {

    @Autowired
    private HouseInfoService houseInfoService;

    @RequestMapping(value = "/searchWarehouseInfo", method = RequestMethod.POST)
    @ApiOperation(value = "搜索租房基本信息", httpMethod = "POST")
    public Result<PagedResult<HouseInfoResp>> searchWarehouseInfo(@RequestBody @Valid SearchReqVo searchReqVo) {

        return Result.success(houseInfoService.searchWarehouseInfoList(searchReqVo));
    }


    @RequestMapping(value = "/updateAllIndex", method = RequestMethod.GET)
    @ApiOperation(value = "更新所有租房信息索引", httpMethod = "GET")
    public Result<String> updateAllIndex() {
        return Result.success(houseInfoService.updateAllIndex());
    }

    @RequestMapping(value = "/deleteAllIndex", method = RequestMethod.GET)
    @ApiOperation(value = "删除所有租房信息索引", httpMethod = "GET")
    public Result<String> deleteAllIndex() {
        return Result.success(houseInfoService.deleteAllIndex());
    }

}

HouseInfoService

public interface HouseInfoService {

    PagedResult<HouseInfoResp> searchWarehouseInfoList(SearchReqVo searchReqVo);

    String updateAllIndex();

    String deleteAllIndex();
}


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * @program: es
 * @create: 2020-01-14 16:10
 **/
@Service
public class HouseInfoServiceImpl implements HouseInfoService {


    private static final Logger logger = LoggerFactory.getLogger(HouseInfoServiceImpl.class);

    @Autowired
    HouseInfoIndexService houseInfoIndexService;

    @Autowired
    HouseInfoMapperExt houseInfoMapperExt;

    @Override
    public PagedResult<HouseInfoResp> searchWarehouseInfoList(SearchReqVo searchReqVo) {
        return houseInfoIndexService.search(searchReqVo);
    }

    @Override
    public String updateAllIndex() {
        int successCount = 0;
        int failCount = 0;
        //查询所有 houseInfo数据 
        //List<HouseInfo> warehouseInfos = houseInfoMapperExt.selectAll();
        List<HouseInfo> warehouseInfos;
        if (!CollectionUtils.isEmpty(warehouseInfos)) {
            for (int i = 0; i < warehouseInfos.size(); i++) {
                HouseInfo warehouseInfo = warehouseInfos.get(i);
                HouseInfoDto houseInfoDto = new HouseInfoDto();
                BeanUtils.copyProperties(warehouseInfo, houseInfoDto);
                boolean isSuccess = houseInfoIndexService.index(houseInfoDto);
                if (isSuccess) {
                    ++successCount;
                } else {
                    ++failCount;
                }
            }

        }
        logger.info("全量更新索引完成, 成功:" + successCount + ", fail:" + failCount);
        return "成功:" + successCount + ", fail:" + failCount;
    }

    @Override
    public String deleteAllIndex() {
        boolean success = houseInfoIndexService.deleteAll();
        if (success) {
            return "成功";
        } else {
            return "失败";
        }
    }
}

ElasticSearchService (共用创建索引,索引,关键词使用分词等)

import com.sf.es.enums.ElasticSearchEnum;
import org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest;
import org.elasticsearch.action.admin.indices.analyze.AnalyzeResponse;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.rest.RestStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;


@Service
public class ElasticSearchService {
    private static final Logger logger = LoggerFactory.getLogger(ElasticSearchService.class);

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    public boolean index(ElasticSearchEnum elasticSearchEnum, String id, String jsonString) {

        String methodName = "创建索引,index:" + elasticSearchEnum.getIndex() + ",id:" + id;

        try {
            IndexRequest request = new IndexRequest()
                    .index(elasticSearchEnum.getIndex())
                    .id(id)
                    .source(jsonString, XContentType.JSON);

            IndexResponse indexResponse = restHighLevelClient.index(request, RequestOptions.DEFAULT);

            logger.info(methodName + "-response:{}", indexResponse);

            if (indexResponse != null && indexResponse.status() != null && (RestStatus.CREATED == indexResponse.status() || RestStatus.OK == indexResponse.status())) {
                return true;
            } else {
                return false;
            }
        } catch (IOException e) {
            logger.error(methodName + "-异常", e);
            return false;
        }
    }


    public boolean deleteAll(ElasticSearchEnum elasticSearchEnum) {

        String methodName = "删除全部索引, index:" + elasticSearchEnum.getIndex();

        try {
            DeleteIndexRequest request = new DeleteIndexRequest(elasticSearchEnum.getIndex());
            restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
            return true;

        } catch (Exception e) {
            logger.error(methodName + "-异常", e);
            return false;
        }
    }


    public boolean delete(ElasticSearchEnum elasticSearchEnum, String id) {

        String methodName = "删除索引, index:" + elasticSearchEnum.getIndex() + ", id:" + id;

        try {

            DeleteRequest request = new DeleteRequest()
                    .index(elasticSearchEnum.getIndex())
                    .id(id);

            DeleteResponse response = restHighLevelClient.delete(request, RequestOptions.DEFAULT);

            logger.info(methodName + "-response:{}", response);

            if (response != null && response.status() != null && RestStatus.OK == response.status()) {
                return true;
            } else {
                return false;
            }

        } catch (Exception e) {
            logger.error(methodName + "-异常", e);
            return false;
        }
    }

    public List<String> analyze(ElasticSearchEnum elasticSearchEnum, String keyword, String tokenizer) {

        List<String> analyzeKeywords = new ArrayList<>();

        try {
            AnalyzeRequest analyzeRequest = new AnalyzeRequest(elasticSearchEnum.getIndex()).tokenizer(tokenizer).text(keyword);
            AnalyzeResponse response = restHighLevelClient.indices().analyze(analyzeRequest, RequestOptions.DEFAULT);
            List<AnalyzeResponse.AnalyzeToken> tokens = response.getTokens();
            for (AnalyzeResponse.AnalyzeToken token : tokens) {
                analyzeKeywords.add(token.getTerm());
            }
        } catch (IOException e) {
            logger.error("关键字分词异常, keyword:{}", keyword, e);
        }
        return analyzeKeywords;
    }
}

HouseInfoIndexService (租房索引方法,更新索引,查询,删除等方法)

import org.apache.commons.lang3.StringUtils;
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.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * describe:
 * @date 2019/12/30 20:32
 */
@Service
public class HouseInfoIndexService {

    private static final Logger logger = LoggerFactory.getLogger(HouseInfoIndexService.class);

    @Autowired
    private ElasticSearchService elasticSearchService;

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * @param houseInfoDto
     * @return
     */
    public boolean index(HouseInfoDto houseInfoDto) {

        if (houseInfoDto == null || houseInfoDto.getId() == null) {
            return false;
        }
        String methodName = "创建租房信息索引, id:" + houseInfoDto.getId();

        try {
            return elasticSearchService.index(ElasticSearchEnum.STORAGE_SERVICE, String.valueOf(houseInfoDto.getId()), JSON.toJSONString(houseInfoDto));
        } catch (Exception e) {
            logger.error(methodName + "-异常", e);
            return false;
        }
    }

    /**
     * 搜索租房信息
     *
     * @param searchReqVo
     * @return
     */
    public PagedResult<HouseInfoResp> search(SearchReqVo searchReqVo) {

        PagedResult<HouseInfoResp> houseInfoRespPagedResult= new PagedResult<>();
        String methodName = "搜索租房信息, keyword:" + searchReqVo.getKeyword() + ", pageNo:" + searchReqVo.getPageNo() + ", pageSize:" + searchReqVo.getPageSize() + ", sort:" + searchReqVo.getSort();

        try {
           SearchRequest searchRequest = new SearchRequest();
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();


            //最低面积
            if (null != searchReqVo.getUsableAreaFrom() && 1 == searchReqVo.getUsableAreaFrom().compareTo(BigDecimal.ZERO)) {
                boolQueryBuilder.must(QueryBuilders.rangeQuery(WarehouseIndexKeyEnum.USABLEAREA.getKey()).gte(searchReqVo.getUsableAreaFrom()));
            }

            //最高面积
            if (null != searchReqVo.getUsableAreaTo() && 1 == searchReqVo.getUsableAreaTo().compareTo(BigDecimal.ZERO)) {
                boolQueryBuilder.must(QueryBuilders.rangeQuery(WarehouseIndexKeyEnum.USABLEAREA.getKey()).lte(searchReqVo.getUsableAreaTo()));
            }

            //最低价格
            if (null != searchReqVo.getPriceFrom() && 1 == searchReqVo.getPriceFrom().compareTo(BigDecimal.ZERO)) {
                boolQueryBuilder.must(QueryBuilders.rangeQuery(WarehouseIndexKeyEnum.PRICE.getKey()).gte(searchReqVo.getPriceFrom()));
            }

            //最高价格
            if (null != searchReqVo.getPriceTo() && 1 == searchReqVo.getPriceTo().compareTo(BigDecimal.ZERO)) {
                boolQueryBuilder.must(QueryBuilders.rangeQuery(WarehouseIndexKeyEnum.PRICE.getKey()).lte(searchReqVo.getPriceTo()));
            }


//            //关键词搜索
//            if (StringUtils.isNotEmpty(searchReqVo.getKeyword())) {
//                boolQueryBuilder.must(QueryBuilders.multiMatchQuery(searchReqVo.getKeyword(),
//                        WarehouseIndexKeyEnum.WAREHOUSE_NAME.getKey(),
//                        WarehouseIndexKeyEnum.ADDRESS.getKey()).minimumShouldMatch("100%"));
//            }
            // 关键字搜索
            if (StringUtils.isNotEmpty(searchReqVo.getKeyword())) {
                Map<String, Float> fieldsBoosts = new HashMap<>(2);
                fieldsBoosts.put( WarehouseIndexKeyEnum.WAREHOUSE_NAME.getKey(), 9f);
                fieldsBoosts.put( WarehouseIndexKeyEnum.ADDRESS.getKey(), 5f);
                boolQueryBuilder.must(QueryBuilders.multiMatchQuery(searchReqVo.getKeyword()).fields(fieldsBoosts).minimumShouldMatch(getMiniMumShouldMatch(searchReqVo.getKeyword())));
            }

            searchSourceBuilder.query(boolQueryBuilder);

            //排序
            Integer sort = searchReqVo.getSort();
            if (0 == sort || 1 == sort) {
                //searchSourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
                searchSourceBuilder.sort(new FieldSortBuilder(WarehouseIndexKeyEnum.USABLEAREA.getKey()).order(SortOrder.DESC));
            } else if (2 == sort) {
                //searchSourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
                searchSourceBuilder.sort(new FieldSortBuilder(WarehouseIndexKeyEnum.USABLEAREA.getKey()).order(SortOrder.ASC));
            } else if (3 == sort) {
                //searchSourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
                searchSourceBuilder.sort(new FieldSortBuilder(WarehouseIndexKeyEnum.PRICE.getKey()).order(SortOrder.DESC));
            } else if (4 == sort) {
                //searchSourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
                searchSourceBuilder.sort(new FieldSortBuilder(WarehouseIndexKeyEnum.PRICE.getKey()).order(SortOrder.ASC));
            }

            // 分页设置
            Integer pageSize = searchReqVo.getPageSize();
            Integer pageNo = searchReqVo.getPageNo();
            if (pageSize != null && pageSize > 0) {
                searchSourceBuilder.size(pageSize);
                if (pageNo != null && pageNo > 0) {
                    searchSourceBuilder.from(pageSize * (pageNo - 1));
                }
            }

            // 设置查询索引范围
            searchRequest.indices(ElasticSearchEnum.STORAGE_SERVICE.getIndex());
            // 向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            // 执行搜索,向ES发起http请求
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            if (RestStatus.OK.equals(searchResponse.status())) {
                // 搜索结果
                SearchHits hits = searchResponse.getHits();

                // 搜索总数量
                long total = hits.getTotalHits().value;

                // 得到匹配度文档
                SearchHit[] searchHits = hits.getHits();

                List<HouseInfoResp> houseInfoResps = new ArrayList<>();
                // 日期格式化对象
                for (SearchHit hit : searchHits) {
                    HouseInfoDto houseInfoDto = JSON.parseObject(hit.getSourceAsString(), HouseInfoDto.class);
                    HouseInfoResp respVo = new HouseInfoResp();
                    respVo.setId(houseInfoDto.getId());
                    respVo.setName(houseInfoDto.getName());
                    respVo.setUsableArea(houseInfoDto.getUsableArea());
                    respVo.setPrice(houseInfoDto.getPrice());
                    respVo.setAddress(houseInfoDto.getAddress());
                    houseInfoResps.add(respVo);
                }

                houseInfoRespPagedResult.setDataList(houseInfoResps);

                houseInfoRespPagedResult.setPageNo(pageNo);
                houseInfoRespPagedResult.setPageSize(pageSize);
                houseInfoRespPagedResult.setTotal(total);
                houseInfoRespPagedResult.setPages((total + pageSize - 1) / pageSize);
            }
        } catch (Exception e) {
            logger.error(methodName + "-异常", e);
        }

        return houseInfoRespPagedResult;
    }

    /**
     * 删除所有索引，包括mapping(慎用)
     * @return
     */
    public boolean deleteAll() {
        return elasticSearchService.deleteAll(ElasticSearchEnum.STORAGE_SERVICE);
    }

    /**
     * 通过索引主键ID删除索引
     * @param id
     * @return
     */
    public boolean delete(Long id) {
        return elasticSearchService.delete(ElasticSearchEnum.STORAGE_SERVICE, String.valueOf(id));
    }

    public String getMiniMumShouldMatch (String keyword) {
        List<String> keywords = elasticSearchService.analyze(ElasticSearchEnum.STORAGE_SERVICE, keyword, "ik_smart");
        if (!CollectionUtils.isEmpty(keywords) && keywords.size() > 2) {
            return "75%";
        }
        return "100%";
    }
}

实体类等


public class HouseInfo {
    private Long id;

    private String name;

    private Long usableArea;

    private BigDecimal price;

    private String picture;

    private String address;

    private String currentFloor;
	//set get....


public class HouseInfoDto {
    private Long id;

    private String name;

    private Long usableArea;

    private BigDecimal price;

    private String picture;

    private String address;

    private String currentFloor;
// set get
}


@ApiModel("搜索参数请求VO")
public class SearchReqVo extends PageBaseReqVo {

    @ApiModelProperty(value = "排序方式，1：面积从高到底 2：面积从低到高 3：价格从高到低 4：价格从低到高")
    private Integer sort = 0;

    @ApiModelProperty(value = "最低面积")
    private BigDecimal usableAreaFrom;

    @ApiModelProperty(value = "最高面积")
    private BigDecimal usableAreaTo;

    @ApiModelProperty(value = "最低价格")
    private BigDecimal priceFrom;

    @ApiModelProperty(value = "最高价格")
    private BigDecimal priceTo;

    @ApiModelProperty(value = "关键词")
    private String keyword;
// set get ....
}


public enum WarehouseIndexKeyEnum {

    WAREHOUSE_ID("id", "房屋ID"),
    WAREHOUSE_NAME("name", "房屋名称"),
    USABLEAREA("usableArea", "可用面积"),
    PRICE("price", "价格"),
    ADDRESS("address", "房屋详细地址"),
    ICON("icon", "房屋图片路径");
    
    private String key;
    private String desc;

    WarehouseIndexKeyEnum(String key, String desc) {
        this.key = key;
        this.desc = desc;
    }
    public String getKey() {
        return key;
    }
    public String getDesc() {
        return desc;
    }
}

public enum ElasticSearchEnum {

    STORAGE_SERVICE("storage","租房");
    private String index;
    private String desc;

    ElasticSearchEnum(String index, String desc) {
        this.index = index;
        this.desc = desc;
    }
    //set get ...
}
yaoyaomei
关注
ElasticSearch删除索引【真实案例】
甘蓝的专栏
05-17 2463
删除ElasticSearch索引的真实案例，以及介绍当时遇到的删除超时问题的解决方案。
es修改索引java_Elasticsearch添加修改删除索引文档案例分享
weixin_42365266的博客
03-04 600
本文介绍如何采用bboss es添加/修改/删除/批量删除elasticsearch索引文档，直接看代码。添加/修改文档TAgentInfo agentInfo = new TAgentInfo() ;//设置地理位置坐标agentInfo.setLocation("28.292781,117.238963");//设置其他属性。。。。ClientInterface clientUtil = El...
Elasticsearch 实战案例（索引切分、模板、别名、数据迁移）
高广超的博客
01-15 888
背景 基于ELK搭建的日志平台，前期匆忙建设过程中一些参数和设计未做过多的考虑，上线后就需要不断根据实际情况做调整，而一些调整限于ELK的一些特性，一旦操作不当就会出现丢数据、数据写入异常、数据查不到等情况。 因此如何在这种背景下，做到对使用方无感知的动态调整是我们所要实现的目标。所以本文更加注重实践而非深层次的理论讲解，有兴趣深入了解的可以自行研习。 总...
Elasticsearch 索引设计
陈家老二的博客
09-10 962
随着 Elastic 的上市，ELK Stack 不仅在 BAT 的大公司得到长足的发展，而且在各个中小公司都得到非常广泛的应用，甚至连“婚庆网站”都开始使用 Elasticsearch 了。随之而来的是 Elasticsearch 相关部署、框架、性能优化的文章早已铺天盖地。 初学者甚至会进入幻觉——“一键部署、导入数据、检索&聚合、动态扩展， So Easy，妈妈再也不用担心我的 Elastic 学习”！ 但，实际上呢？仅就 Elasticsearch 索引设计，请回答如下几个问题： 每天几百
Elasticsearch：用例、架构和 6 个最佳实践
最新发布
欢迎拜读我的作品，喜欢的领域请给我留言
08-06 1514
它建立在 Apache Lucene 之上，并由Elastic 支持。Elasticsearch 用于近乎实时地存储、搜索和分析结构化和非结构化数据。Elasticsearch 的一个主要特性是其，这使得它能够处理集群中多个节点的大型数据集。这使得它成为企业搜索、日志分析和监控应用程序的热门选择。Elasticsearch 提供了用于与搜索引擎交互的，并支持多种查询类型，包括全文搜索、短语搜索和聚合。它还包括各种搜索和分析功能，例如分面、过滤、排序和突出显示。除了搜索和分析之外，。
Elasticsearch实战---------设计索引
weixin_43918863的博客
08-02 248
大索引的缺陷 索引是es存储数据的地方，如果一个索引很大，数据写入和查询性能都会变差，而高效检索体现在：基于日期的检索可以直接检索对应日期的索引，无形中缩减了很大的数据规模。 比如检索：“2019-02-01”号的数据，之前的检索会是在一个月甚至更大体量的索引中进行 好处： 1.查询效率快， 2.一旦一个大索引出现故障，相关的数据都会受到影响。而分成滚动索引的话，相当于做了物理隔离。 PB 级索引设计实现 综上，结合实践经验，大索引设计建议：使用模板+Rollover+Curator动态创建索引。 使用模板
基于ElasticSearch全文搜索引擎的旅游景点搜索网设计-计算机毕业源码设计
计算机源码设计案例的博客
02-09 1628
开发环境： Idea + Mysql + ubuntu + Docker + RabbitMQ + ElasticSearch + kibana 本项目主要是学习利用全文检索引擎框架ElasticSearch实现一个中文旅游网站搜索设计，通过建立一个hotel的索引库关联对应的mysql表数据，实现高效率的查询，解决了传统关系型数据因为数据量大导致的查询瓶颈问题。查询业务是crud中最复杂的业务，涉及到多种条件的组合，查询结果的分页和排序，搜索引擎查询结果的解析；根据查询条件的设置对结果某些信息字段进.
Elasticsearch学习-索引操作及Mapping映射_es建索引建mapping
2401_84181403的博客
04-21 930
一个索引包含一个多个分片，7.0之前默认五个主分片，每个主分片一个副本，在7.0之后默认一个主分片，副本可以在索引创建之后修改数量，但是主分片的数量一旦确定不可修改。设置text类型以后，字段内容会被分析，在生成倒排索引（默认）以前，字符串会被分析器分成一个一个词项，text类型的字段不用于排序，很少用于聚合。index： 是否对当前字段创建倒排索引，默认为true，若为false，该字段不会通过索引被搜索到，但是仍会在source元数据中展示。
mysql索引 和 es索引_ElasticSearch 索引 VS MySQL 索引
weixin_36243739的博客
01-19 394
前言这段时间在维护产品的搜索功能，每次在管理台看到elasticsearch这么高效的查询效率我都很好奇他是如何做到的。这甚至比在我本地使用MySQL通过主键的查询速度还快。为此我搜索了相关资料：这类问题网上很多答案，大概意思呢如下：ES 是基于Lucene的全文检索引擎，它会对数据进行分词后保存索引，擅长管理大量的索引数据，相对于MySQL来说不擅长经常更新数据及关联查询。说的不是很透彻...
ElasticSearch重建/创建/删除索引操作 - 第501篇
悟纤学院
01-29 1788
ES的索引的基本操作 – 增删改查。
ElasticSearch索引（index）当中的增删改查操作
qq_39939541的博客
07-16 1105
当使用Kibana时，可以通过控制台来执行 Elasticsearch 索引的增删改查操作。
ElasticSearch 索引 剖析
weixin_34194087的博客
10-21 302
ElasticSearch index 剖析 在看ElasticSearch权威指南基础入门中关于：分片内部原理这一小节内容后，大致对ElasticSearch的索引、搜索底层实现有了一个初步的认识。记录一下在看文档的过程中碰到的问题以及我的理解。此外，在文章的末尾，还讨论分布式系统中的主从复制原理，以及采用这种副本复制方案带来的数据一致性问题。 ElasticSearch index 操作背后发...
全文检索服务 ElasticSearch---------整合Spring Boot
没有简介
08-26 1223
ES提供多种不同的客户端：ES提供的传统客户端，官方计划8.0版本删除此客户端。​   RestClient是官方推荐使用的，它包括两种：REST Low Level Client和 REST High Level Client。ES在6.0之后提供REST High Level Client， 两种客户端官方更推荐使用 REST High Level Client，不过当前它还处于完善中，有些功能还没有。.........
ElasticSearch Java Api(四) -删除索引
AndyLizh的专栏
08-09 3412
删除可以是删除整个索引库，也可以根据文档id删除索引库下的文档，还可以通过query查询条件删除所有符合条件的数据。 一、删除整个索引库 下面的例子会删除indexName索引： DeleteIndexResponse dResponse = client.admin().indices().prepareDelete(indexName) ...
Elasticsearch Java API之清空索引
云守护的专栏
08-05 8660
package com.nerve.core.test; import java.io.IOException; import java.io.InputStream; import java.net.URL; import java.util.Properties; import org.elasticsearch.action.admin.cluster.state.ClusterStat
ElasticSearch6.6.x从入门到企业开发
05-10
本课程深入浅出剖析了Elasticsearch的核心基础知识，带着大家一步一步，从快速入门，到理解Elasticsearch的工作原理、内核级原理，再到动手实战操作Elasticsearch的各种核心功能，到最后可以基于Java语言开发基本的搜索和集群搭建。
Es中索引的删除操作
荣山的博客
08-28 9951
Es中索引的删除操作
ElasticSearch7.3学习(十六)----RestHighLevelClient Java api实现索引的创建、删除、是否存在、关闭、开启
09-08 2803
注意：导入的包区别，不同的包创建索引的方式不同。博主亲身实践，具体体现在createIndexRequest.mapping()里面。读者可自行试验。可以看到上述两种方式导入的包的子类名是相同的，但是具体对索引的操作方式可能是不同的。具体的区别博主暂时还不清楚，后续若有进展再在此处更新。
elasticsearch索引生命周期案例
05-30
一个常见的 Elasticsearch 索引生命周期案例如下： 1. 创建一个索引，设置参数，并定义索引的映射。 2. 在索引中添加文档，并设置文档的过期时间。 3. 定期执行一个基于时间的索引升级策略，例如将每个月的数据分配到新的索引中。 4. 在索引中执行搜索，根据需要对结果进行聚合和过滤。 5. 当索引不再需要时，删除该索引。 6. 对于需要长期保留的数据，将其移动到冷存储中。 7. 对于需要快速访问的数据，将其移动到热存储中。 这个案例中，我们使用 Elasticsearch 的索引生命周期管理功能，自动管理数据的生命周期。这样可以有效地减少数据管理的工作量，并确保数据始终保持最新和可用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值