ES搜索引擎的使用完整代码

已于 2022-02-27 17:46:40 修改
阅读量652 收藏 1
点赞数
分类专栏： 晋升板块 文章标签： 搜索引擎 elasticsearch 大数据
于 2022-02-26 20:43:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43978695/article/details/123155505
版权

ES依赖pom配置

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

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

        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.10.1</version>
        </dependency>

ElasticSearchConfig 文件配置

package com.xx.xx.webservices.config;

import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

/**
 * @Author : 骑士李四 
 * @Date : Created in 10:29 2021/11/10
 * @Description :
 * @since 3.0
 */
@Configuration
public class ElasticSearchConfig {
    /** 协议 */
    @Value("${elasticsearch.schema:http2}")
    private String schema;

    /** 集群地址，如果有多个用“,”隔开 */
    @Value("${elasticsearch.address}")
    private String address;

    /** 连接超时时间 */
    @Value("${elasticsearch.connectTimeout}")
    private int connectTimeout;

    /** Socket 连接超时时间 */
    @Value("${elasticsearch.socketTimeout}")
    private int socketTimeout;

    /** 获取连接的超时时间 */
    @Value("${elasticsearch.connectionRequestTimeout}")
    private int connectionRequestTimeout;

    /** 最大连接数 */
    @Value("${elasticsearch.maxConnectNum}")
    private int maxConnectNum;

    /** 最大路由连接数 */
    @Value("${elasticsearch.maxConnectPerRoute}")
    private int maxConnectPerRoute;

    @Value("${elasticsearch.userName}")
    private String userName;
    @Value("${elasticsearch.password}")
    private String password;

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        // 拆分地址
        List<HttpHost> hostLists = new ArrayList<>();
        String[] hostList = address.split(",");
        for (String addr : hostList) {
            String host = addr.split(":")[0];
            String port = addr.split(":")[1];
            hostLists.add(new HttpHost(host, Integer.parseInt(port), schema));
        }
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        /*设置账号密码*/
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userName,password));
        // 转换成 HttpHost 数组
        HttpHost[] httpHost = hostLists.toArray(new HttpHost[]{});
        // 构建连接对象
        RestClientBuilder builder = RestClient.builder(httpHost);

        // 异步连接延时配置
        builder.setRequestConfigCallback(requestConfigBuilder -> {
            requestConfigBuilder.setConnectTimeout(connectTimeout);
            requestConfigBuilder.setSocketTimeout(socketTimeout);
            requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeout);
            return requestConfigBuilder;
        });
        // 异步连接数配置
        builder.setHttpClientConfigCallback(httpClientBuilder -> {
            httpClientBuilder.setMaxConnTotal(maxConnectNum);
            httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
            httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
            return httpClientBuilder;
        });
        return new RestHighLevelClient(builder);
    }

}

propertity文件配置


# es相关
elasticsearch.schema=http
elasticsearch.address=xxxxx:9200
elasticsearch.connectTimeout=20000
elasticsearch.socketTimeout=20000
elasticsearch.connectionRequestTimeout=20000
elasticsearch.maxConnectNum=100
elasticsearch.maxConnectPerRoute=100
elasticsearch.userName=xxx
elasticsearch.password=xxx

在这里插入代码片

ESUtils

package com.hundsun.lightdata.webservices.utils;

import com.alibaba.fastjson.JSON;
import com.hundsun.jrescloud.common.exception.BaseBizException;
import com.hundsun.lightdata.common.entity.common.EsUdataDoc;
import com.hundsun.lightdata.common.enumpackage.ResponseEnum;
import com.lightdata.provide.repsonse.QuantizationFactorToEsResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.action.update.UpdateRequest;
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.common.settings.Settings;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.annotation.PostConstruct;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author : 骑士李四
 * @Date : Created in 15:53 2021/11/10
 * @Description : es工具类
 */
@Slf4j
@Component
public class EsUtils {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    private static RestHighLevelClient staticRestHighLevelClient;

    @PostConstruct
    public void init() {
        staticRestHighLevelClient = this.restHighLevelClient;
    }


    /**
     * 创建索引
     * @author lipeng39232
     * @param index
     * @throws Exception
     */
    public static void  createIndex(String index) throws Exception {

        CreateIndexRequest createIndexRequest = new CreateIndexRequest(index)
                .settings(
                        Settings.builder()
                                .put("number_of_shards", 6)
                                .put("number_of_replicas", 1)
                                .build()
                );
        XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.startObject("properties");
            {
                //设置属性
                builder.startObject("factorName");
                {
                    builder.field("type", "text")
                            .field("analyzer", "ik_max_word")
                            .field("search_analyzer", "ik_smart");
                }
                builder.endObject();

                builder.startObject("factorType");
                {
                    builder.field("type", "text");
                }
                builder.endObject();

                builder.startObject("factorSecondType");
                {
                    builder.field("type", "text");
                }
                builder.endObject();

                builder.startObject("stockCode");
                {
                    builder.field("type", "text")
                            .field("analyzer", "ik_max_word")
                            .field("search_analyzer", "ik_smart");
                }
                builder.endObject();

                builder.startObject("factorValue");
                {
                    builder.field("type", "text");
                }
                builder.endObject();

                builder.startObject("date");
                {
                    builder.field("type", "date");
                }
                builder.endObject();
            }
            builder.endObject();
        }

        builder.endObject();

        createIndexRequest.mapping(builder);
        CreateIndexResponse response = staticRestHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
        log.info(response.toString());
    }


    /**
     * 保存文档
     * <p>
     * 如果文档存在，则更新文档；如果文档不存在，则保存文档,保存时会全字段更新
     *
     * @param esUdataDoc 文档数据
     */
    public static void save(String index, EsUdataDoc esUdataDoc) throws IOException {
        IndexRequest indexRequest = new IndexRequest(index);
        Long esId = esUdataDoc.getDocumentId();
        indexRequest.id(Long.toString(esId));
        indexRequest.source(JSON.toJSONString(esUdataDoc), XContentType.JSON);
        // 保存文档数据
        staticRestHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);

    }

    /**
     * 更新文档 仅更新修改字段,其它字段保持原值
     *
     * @param index
     * @param esUdataDoc
     * @throws IOException
     */
    public static void update(String index, EsUdataDoc esUdataDoc) throws IOException {
        Long esId = esUdataDoc.getDocumentId();
        UpdateRequest updateRequest = new UpdateRequest(index, Long.toString(esId));
        updateRequest.doc(JSON.toJSONString(esUdataDoc), XContentType.JSON);
        log.info("更新es数据,rq:{}", JSON.toJSONString(esUdataDoc));
        staticRestHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
    }

    /**
     * 批量更新 仅更新修改字段,其它字段保持原值
     *
     * @param index
     * @param contentList
     */
    public static void updateAll(String index, List<EsUdataDoc> contentList) throws IOException {
        if (CollectionUtils.isEmpty(contentList)) {
            return;
        }

        //批量请求
        BulkRequest bulkRequest = new BulkRequest();
        contentList.forEach(esUdataDoc -> {
            Long esId =esUdataDoc.getDocumentId();
            UpdateRequest updateRequest = new UpdateRequest(index, Long.toString(esId));
            updateRequest.doc(JSON.toJSONString(esUdataDoc), XContentType.JSON);
            bulkRequest.add(updateRequest);
        });

        staticRestHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);

    }

    /**
     * 批量保存文档
     * <p>
     * 如果集合中有些文档已经存在，则更新文档；不存在，则保存文档。
     *
     * @param index        索引
     * @param contentList 文档集合
     */
    public static void saveAll(String index, List<QuantizationFactorToEsResponse> contentList) throws IOException {
        if (CollectionUtils.isEmpty(contentList)) {
            return;
        }
        // 批量请求
        BulkRequest bulkRequest = new BulkRequest();
        contentList.forEach(esUdataDoc -> {
            bulkRequest.add(new IndexRequest(index)
                    .id(esUdataDoc.getId())
                    .source(JSON.toJSONString(esUdataDoc), XContentType.JSON));
        });

        staticRestHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);

    }

    /**
     * 根据文档 ID 删除文档
     *
     * @param index 索引
     * @param id    文档 ID
     */
    public static void delete(String index, String id) throws IOException {
        DeleteRequest deleteRequest = new DeleteRequest(index, id);

        staticRestHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
    }

    /**
     * description
     * @author liZheng   @Date 14:18 2021/7/29
     * @param index
     * @return void
     */
    public static void deleteByIndex(String index) throws IOException{
        if (StringUtils.isBlank(index)){
            return;
        }
        DeleteRequest deleteRequest = new DeleteRequest();
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(index);
        //若无索引 不报错
        deleteIndexRequest.indicesOptions(IndicesOptions.LENIENT_EXPAND_OPEN);
        staticRestHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);

    }

    /**
     * 根据查询条件删除文档
     *
     * @param index        索引
     * @param queryBuilder 查询条件构建器
     */
    public static void deleteByQuery(String index, QueryBuilder queryBuilder) throws IOException {
        DeleteByQueryRequest deleteRequest = new DeleteByQueryRequest(index).setQuery(queryBuilder);
        deleteRequest.setConflicts("proceed");

        staticRestHighLevelClient.deleteByQuery(deleteRequest, RequestOptions.DEFAULT);

    }

    /**
     * 根据文档 ID 批量删除文档
     *
     * @param index  索引
     * @param idList 文档 ID 集合
     */
    public static void deleteAll(String index, List<String> idList) throws IOException {
        if (CollectionUtils.isEmpty(idList)) {
            return;
        }
        BulkRequest bulkRequest = new BulkRequest();
        idList.forEach(id -> bulkRequest.add(new DeleteRequest(index, id)));

        staticRestHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
    }

    /**
     * 根据索引和文档 ID 获取数据
     *
     * @param index 索引
     * @param id    文档 ID
     * @param <T>   数据类型
     * @return T    返回 T 类型的数据
     */
    public static <T> T get(String index, String id, Class<T> resultType) throws IOException {
        GetRequest getRequest = new GetRequest(index, id);
        GetResponse response = staticRestHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
        String resultAsString = response.getSourceAsString();

        return JSON.parseObject(resultAsString, resultType);
    }

    /**
     * 条件查询
     *
     * @param index         索引
     * @param sourceBuilder 条件查询构建起
     * @param <T>           数据类型
     * @return T 类型的集合
     */
    public static <T> List<Map<String,Object>> searchByQuery(String index, SearchSourceBuilder sourceBuilder, Class<T> resultType) throws IOException {
        // 构建查询请求
        SearchRequest searchRequest = new SearchRequest(index).source(sourceBuilder);
        log.info("es条件查询**********"+searchRequest.source().toString());
        // 获取返回值searchRequest = {SearchRequest@11775} "SearchRequest{searchType=QUERY_THEN_FETCH, indices=[kiplatform_library], indicesOptions=IndicesOptions[ignore_unavailable=false, allow_no_indices=true, expand_wildcards_open=true, expand_wildcards_closed=false, expand_wildcards_hidden=false, allow_aliases_to_multiple_indices=true, forbid_closed_indices=true, ignore_aliases=false, ignore_throttled=true], types=[], routing='null', preference='null', requestCache=null, scroll=null, maxConcurrentShardRequests=0, batchedReduceSize=512, preFilterShardSize=null, allowPartialSearchResults=null, localClusterAlias=null, getOrCreateAbsoluteStartMillis=-1, ccsMinimizeRoundtrips=true, source={"from":0,"size":10,"sort":[{"_score":{"order":"desc"}}],"highlight":{"fields":{"title":{"type":"unified"},"content":{}}}}}"
        SearchResponse response = staticRestHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHit[] hits = response.getHits().getHits();
        // 创建空的查询结果集合
        List<Map<String,Object>> results = new ArrayList<>(hits.length);
        for (SearchHit hit : hits) {
            Map<String, Object> source = hit.getSourceAsMap();
            //处理高亮片段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            for (Map.Entry<String, HighlightField> entry : highlightFields.entrySet()){
                StringBuilder valueString = new StringBuilder();
                Text[] fragments = entry.getValue().fragments();
                for (Text text:fragments){
                    valueString.append(text);
                }
                source.put(entry.getKey(),valueString);
            }
            results.add(source);
        }
        return results;

    }

    public static SearchHits doSearch(String index, SearchSourceBuilder builder) {
        SearchRequest searchRequest = new SearchRequest(index).source(builder);
        try {
            SearchResponse response = staticRestHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            return response.getHits();
        } catch (IOException e) {
            log.error(e.getMessage());
            throw new BaseBizException(ResponseEnum.ERROR_ELASTICSEARCH.getErrorCode(), ResponseEnum.ERROR_ELASTICSEARCH.getErrorInfo());
        }
    }

    /**
     * 一个分组查询
     *
     * @param indexs       索引
     * @param queryBuilder 条件查询构建起
     * @param field        分组字段
     * @return Map<String, Long> 返回的map
     */
    public static Map<String, Long> getTermsAgg(QueryBuilder queryBuilder, String field, String... indexs) {
        Map<String, Long> groupMap = new HashMap<>();
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(queryBuilder);
        searchSourceBuilder.size(0);

        AggregationBuilder aggregationBuilder = AggregationBuilders.terms("agg").field(field);
        searchSourceBuilder.aggregation(aggregationBuilder);

        SearchRequest searchRequest = new SearchRequest(indexs);
        searchRequest.source(searchSourceBuilder);

        SearchResponse searchResponse = null;
        try {
            searchResponse = staticRestHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            log.error(e.getMessage());
            throw new BaseBizException(ResponseEnum.ERROR_ELASTICSEARCH.getErrorCode(), ResponseEnum.ERROR_ELASTICSEARCH.getErrorInfo());
        }
        Terms terms = searchResponse.getAggregations().get("agg");
        for (Terms.Bucket entry : terms.getBuckets()) {
            groupMap.put(entry.getKey().toString(), entry.getDocCount());
        }
        return groupMap;
    }


    /***
     * 判断当前索引是否存在
     * @author lipeng
     * @param indexName
     * @return
     * @throws IOException
     */
    public static boolean isExistsIndex(String indexName) throws IOException {
//
//        GetRequest getRequest = new GetRequest(indexName);
//
//        boolean exists = staticRestHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);
//        return exists;

        GetIndexRequest getRequest = new GetIndexRequest();
        getRequest.indices(indexName);
        boolean exists = staticRestHighLevelClient.indices().exists(getRequest, RequestOptions.DEFAULT);
        return exists;
    }
}
骑士李四
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
search-engine-parser：轻巧的软件包，用于查询流行的搜索引擎并抓取结果标题，链接和描述
02-21
搜索引擎解析器 “如果它是一个搜索引擎，那么它就可以被解析” -一个随机的家伙 search-engine-parser是一个软件包，可让您查询流行的搜索引擎并抓取结果标题，链接，说明等。 它旨在抓取最广泛的搜索引擎。 查看所有受支持的引擎 受欢迎的受支持引擎 支持的流行搜索引擎包括： 谷歌 鸭鸭去 的GitHub 堆栈溢出 百度 YouTube 查看所有受支持的引擎 安装 从PyPi安装： # install only package dependencies pip install search-engine-parser # Installs `pysearch` cli tool pip install " search-engine-parser[cli] " 或来自大师： pip install git+https://githu
使用 Elasticsearch 搭建自己的搜索系统，真心强大！
Java技术栈，分享最主流的Java技术
06-13 510
点击关注公众号，Java干货及时送达作者：Hai Xiang 来源：www.cnblogs.com/haixiang/p/12867160.html什么是elasticsearchElasticsearch 是一个开源的高度可扩展的全文搜索和分析引擎，拥有查询近实时的超强性能。大名鼎鼎的Lucene 搜索引擎被广泛用于搜索领域，但是操作复杂繁琐，总是让开发者敬而远之。而 ...
ElasticSearch全文搜索引擎
最新发布
Casual_Lei的博客
06-13 1859
​ Lucene是apache下的一个开源的全文检索引擎工具包(一堆jar包)。它为软件开发人员提供一个简单易用的工具包（类库），以方便的在小型目标系统中实现全文检索的功能。Lucene适用于中小型项目 ，ES适用于中大型项目（它底层是基于lucene实现的）​ 虽然全文搜索领域，Lucene可以被认为是迄今为止最先进、性能最好的、功能最全的搜索引擎库。但是，Lucene只是一个库。
博客检索系统（ES+springboot+vue）代码+解析
qerwtrt4t的博客
12-30 758
springboot+vue+ES
ElasticSearch 全文搜索引擎；ES 搜索引擎
lhorse003的博客
03-02 4432
默认情况下，每个节点都会被安排加入到一个叫做 “elasticsearch” 的集群中，这意味着，如果你在你的网络中启动了若干个节点，并假定它们能够相互发现彼此，它们将会自动地形成并加入到一个叫做 “elasticsearch” 的集群中。当然我们下载的 ElasticSearch 中包含了一个 jdk ，如果你的 jdk 版本不兼容，可以直接将你 JAVA_HOME 变量改为 ElasticSearch 中的 jdk 目录即可（建议备份原理的 JAVA_HOME，因为你之前的项目都是用的原来的）
ElasticSearch搜索引擎使用说明书.docx
03-25
ElasticSearch 搜索引擎使用说明书 ElasticSearch 是一个基于 Lucene 的搜索服务器，提供了一个分布式多用户能力的全文搜索引擎，基于 RESTful web 接口。Elasticsearch 是用 Java 语言开发的，并作为 Apache 许可...
基于Java的Elasticsearch搜索引擎ORM框架设计源码
04-05
这些文件详细展示了如何使用JavaScript、Java、HTML和CSS构建一个Elasticsearch搜索引擎ORM框架，该框架提供索引全自动智能托管，与Mybatis-plus一致的API，屏蔽语言差异，开发者只需要会MySQL语法即可完成对Es的...
ElasticSearch分布式搜索引擎源代码
03-18
ElasticSearch 是一个基于Lucene构建的开源，分布式，RESTful搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。支持通过HTTP使用JSON进行数据索引。
ElasticSearch+Django+Scrapy搜索引擎
02-22
ElasticSearch+Django+Scrapy搜索引擎 项目功能 scrapy爬虫获取数据存储至es，ElasticSearch+Django实现搜索页面。 快速开始 # 下拉项目代码 git clone https://github.com/downdawn/eswork.git # 安装...
Java使用强大的Elastisearch搜索引擎实例代码
08-30
在本文中，我们将深入探讨如何使用Java与Elasticsearch进行集成，这是一个强大的全文搜索引擎，广泛应用于数据检索、分析和实时数据分析。Elasticsearch以其高效、可扩展和易于使用的特性受到开发者的青睐。以下是对...
搜索引擎研究
热门推荐
suilam的专栏
09-22 5万+
http://www.wespoke.com/archives/cat_search_engine.php搜索引擎研究"Search Engine" archive搜索引擎的几则消息1:54 on Tuesday January 25, 2005 | 0 Trackbacks | 1 Comments 1。 google TV 和录像搜索 Google Video search Beta 版暗中发
解决JAR包冲突的终极方法-如何找出冲突jar包依赖关系？
luo_hai_fei的博客
05-15 2618
JAR包冲突是JAR开发过程中常遇到的问题，近期一个项目过程中，出现了如下的冲突： org/slf4j/slf4j-log4j12/1.7.25/slf4j-log4j12-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]与 ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar!/org/slf4j/impl/StaticLoggerBinder.class]冲突。 网上方法
【ES】代码例子
weixin_34060741的博客
06-05 259
#!/usr/bin/env python #coding=utf-8 from elasticsearch import Elasticsearch from elasticsearch_dsl import Search class ES(object): def __init__(self): self.es = Elasticsearch(hosts="loc...
Elasticsearch入门
LF991的博客
06-25 840
Elasticsearch
ElasticSearch——全文搜索引擎
hl404的博客
05-28 9160
一、为什么需要全文搜索引擎？ 首先先来了解一个概念，在我们生活中一般来说有两种数据：结构化数据、非结构化数据 结构化数据：指具有固定格式或有限长度的数据，如数据库，元数据等。 非结构化数据： 非结构化数据又可称为全文数据，指不定长或无固定格式的数据，如邮件，word文档等。 对于结构化数据我们可以直接从数据库查询，而对于非结构化的数据此时就要用到全文检索的方式查询，比如对一个文档或者网页中的内容文本每个词建立一个索引，把这些非结构化的变成结构化的方式然后来查询。 全文搜索引擎百度百科定义：全文搜索引擎是目前
搜索引擎——Elasticsearch
qq_52030824的博客
01-20 3700
Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎，**它可以快速地储存、搜索和分析海量数据。**作为 Elastic Stack 的核心，Elasticsearch 会集中存储您的数据，让您飞快完成搜索，微调相关性，进行强大的分析，并轻松缩放规模。Elasticsearch：官方分布式搜索和分析引擎 | Elastic**Mapping 是用来定义一个文档（document），以及它所包含的属性（field）是如何存储和索引的。**当添加数据时，他会自动处理属性类型。
ES搜索引擎入门+最佳实践(一)
柳老师的博客
08-03 2786
本篇文章计划给大家介绍什么ES,ES的架构,以及ES搜索入门.我尽量用简单不拖沓的语言给大家介绍,水平有限,时间也有限,各位读者如发现文中有不当之处,请留言指正.ES的全称是Elasticsearch,翻译过来就是弹性搜索,知道就可以,不用纠结这个词的含义,我觉得这个词并不能表述ES的含义.ES并不是传统意义上的数据库,所以不需要用传到的数据库例如Oracle,mysql等数据库与ES进行类比.ES是建立在Lucene(全文搜索)基础上的分布式准实时搜索引擎.
es搜索引擎
m0_73858774的博客
10-25 2134
es
Elasticsearch搜索引擎
qq_55648724的博客
12-29 2416
笔记

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值