微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

【Elasticsearch使用教程一篇就够了】

分类：Elasticsearch作者：浪打白龙原文地址

1.Elasticsearch 是什么？

一句话概述：Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎，同时也是 Elastic Stack 的核心。

其应用于比如说全文搜索、购物推荐、附近定位推荐等。

2.Elasticsearch安装

官网下载链接：https://www.elastic.co/cn/downloads/elasticsearch

Elasticsearch 是免安装的，只需要把 zip 包解压就可以了。

elasticsearch图片


1）bin 目录下是一些脚本文件，包括 Elasticsearch 的启动执行文件。
2）config 目录下是一些配置文件。
3）jdk 目录下是内置的 Java 运行环境。
4）lib 目录下是一些 Java 类库文件。
5）logs 目录下会生成一些日志文件。
6）modules 目录下是一些 Elasticsearch 的模块。
7）plugins 目录下可以放一些 Elasticsearch 的插件。

直接双击 bin 目录下的 elasticsearch.bat 文件就可以启动 Elasticsearch 服务了。

在这里插入图片描述


启动后输出了很多信息，只需要看启动日志中是否有started字眼，就表示启动成功了。
确认是否真正启动成功，可以在浏览器的地址栏里输入 http://localhost:9200 进行查看（9200 是 Elasticsearch 的默认端口号）。

在这里插入图片描述

3.安装可视化界面 Kibana

官网下载链接：https://www.elastic.co/cn/downloads/kibana
下载后解压如下图（不同版本可能不一样）

在这里插入图片描述


各级目录不一一解释什么意思，大家可以自行去问度娘。
启动同样跟elasticsearch的启动一样，直接点击bin目录下的kibana.bat即可启动，启动速度相对较慢一点。
当看到 [Kibana][http] http server running 的信息后，说明服务启动成功了。
验证：在浏览器地址栏输入 http://localhost:5601 查看 Kibana 的图形化界面。

在这里插入图片描述

4.可视化界面操作ES

  • 检查集群的健康状态

GET _cluster/health

在这里插入图片描述

  • 快速检查集群的健康状态

GET _cat/health?v

在这里插入图片描述

集群的状态：Green: 所有的primary shard和所有的replica shard 都是active的Yellow：所有的primary shard都是active的但是部分replica shard不是activeRed: 不是所有的primary shard都是active的，可能会造成数据丢失
Es规定primary shard和与他对应的replica shard 不能再同一台机器上，所以当前的状态是yellow的

  • 检查集群中有哪些索引

GET _cat/indices?v

在这里插入图片描述

  • 在集中创建索引

PUT /index

在这里插入图片描述

  • 在某个索引下创建document数据
PUT /ecommerce/product/1
{
  "name": "gaolujie yagao","price": 20,"desc": "gaolujie yaga desc","tags": "meibai jieya"
}

GET /ecommerce/product/1

在这里插入图片描述

  • 更新document文档

i. 全量更新 (更新后可能部分列丢失)

PUT /ecommerce/product/1
{
“name” : “heimei”
}

ii. portial update(需要更新什么 就写什么)

POST /ecommerce/product/1/_update
{
“doc”:{
“name” : “heimei”
  }
}

#创建索引结构
PUT sku
{
  "mappings": {
    "doc":{
      "properties":{
        "name":{
          "type":"text","analyzer":"ik_smart"
        },"price":{
          "type":"integer"
        },"image":{
          "type":"text"
        },"createTime":{
          "type":"date"
        },"spuId":{
          "type":"text"
        },"categoryName":{
          "type":"keyword"
        },"brandName":{
          "type":"keyword"
        },"spec":{
          "type":"object"
        },"saleNum":{
          "type":"integer"
        },"commentNum":{
          "type":"integer"
        }
      }
    }
  }
}

#增加文档
POST sku/doc
{
  "name":"华为手机","price":4500,"spuId":"106","createTime":"2019-06-25","categoryName":"手机","brandName":"华为","saleNum":54532,"commentNum":32543,"spec":{
    "网络制式":"全网通","屏幕尺寸":"6.5"
  }
}


#新增指定ID文档
PUT sku/doc/1
{
 "name":"小米电视","price":3500,"spuId":"117","categoryName":"电视","brandName":"小米","saleNum":2332,"commentNum":4123,"spec":{
    "网络制式":"联通4G","屏幕尺寸":"6.5"
  } 
}

#查询所有文档
GET /sku/_search
{
  "query": {
    "match_all": {}
  }
}

#匹配查询(单字段查询 分词查询默认为or)
GET /sku/doc/_search
{
  "query": {
    "match": {
      "name": "小米手机"
    }
  }
}

#匹配查询(精准查找)
GET /sku/doc/_search
{
  "query": {
    "match": {
      "name": {
        "query": "小米电视","operator": "and"
      }
    }
  }
}

#多字段查询(multi_match)
GET /sku/_search
{
  "query": {
    "multi_match": {
      "query": "小米","fields": ["name","brandName","categoryName"]
    }
  }
}

#词条匹配(term)
GET /sku/_search
{
  "query": {
    "term": {
      "price": "1000"
    }
  }
}

#多词条匹配(terms)
GET /sku/_search
{
  "query": {
    "terms": {
      "price": [
        "1000","3500"
      ]
    }
  }
}


#布尔查询(bool)
#查询名称包含手机的，并且品牌为小米的。
GET /sku/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"name": "手机"}},{"term": {"brandName": "小米"}}
      ]
    }
  }
}

#布尔查询(bool)
#查询名称包含手机的，或者品牌为小米的。
GET /sku/_search
{
  "query": {
    "bool": {
      "should": [
        {"match": {"name": "手机"}},{"term": {"brandName": "小米"}}
      ]
    }
  }
}

#过滤查询
GET /sku/_search
{
  "query": {
    "bool": {
      "filter":[
          {"match":{"brandName":"小米"}}
        ]
    }
  }
}

#分组查询
#按分组名称聚合查询，统计每个分组的数量
GET /sku/_search
{
  "size": 0,"aggs": {
    "sku_category": {
      "terms": {
        "field": "categoryName"
      }
    }
  }
}

5.Java 中使用 Elasticsearch

虽然有图形化界面可供我们操作，但是对于程序员来说更多的是在程序中如何使用，当然ES也提供了API供我们使用。

第一步，在项目中添加 Elasticsearch 客户端依赖：
版本号根据使用者喜好设置

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

第二步，在SpringBoot的application.yml中添加 Elasticsearch配置：

 # Spring配置
spring:
  elasticsearch:
	 ip: 192.168.xx.xx
	 port: 9200
	 pool: 5
	 cluster:
	   name: my-application

第三步，编写ES读取配置类：

@Configuration
public class ElasticSearchConfig {
    // 获取yml中es的配置
    @Value("${spring.elasticsearch.ip}")
    String esIp;

    @Value("${spring.elasticsearch.port}")
    int esPort;

    @Value("${spring.elasticsearch.pool}")
    String esClusterPool;
    // 注册 rest高级客户端
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost(esIp,esPort,"http")
                )
        );
        return client;
    }
}

第四步，编写ES工具类：代码不免有细小错误请理解

@Slf4j
@Component
public class EsUtileService {

    @Autowired
    RestHighLevelClient restHighLevelClient;

    /**
     * 创建索引
     * 
     */
    public boolean createIndex(String indexName) {
        try {
            CreateIndexRequest createIndexRequest = new CreateIndexRequest(indexName);
            CreateIndexResponse response = restHighLevelClient.indices().create(createIndexRequest,RequestOptions.DEFAULT);
            log.info("创建索引 response 值为： {}",response.toString());
            return true;
        }catch (Exception e) {
            e.printstacktrace();
        }
        return false;
    }

    /**
     * 判断索引是否存在
     * 
     */
    public boolean existIndex(String indexName) {
        try {
            GetIndexRequest getIndexRequest = new GetIndexRequest(indexName);
            return restHighLevelClient.indices().exists(getIndexRequest,RequestOptions.DEFAULT);
        }catch (Exception e) {
            e.printstacktrace();
        }
        return false;
    }

    /**
     * 删除索引
     * 
     */
    public boolean deleteIndex(String indexName) {
        try {
            DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(indexName);
            AckNowledgedResponse delete = restHighLevelClient.indices().delete(deleteIndexRequest,RequestOptions.DEFAULT);
            log.info("删除索引{}，返回结果为{}",indexName,delete.isAckNowledged());
            return delete.isAckNowledged();
        }catch (Exception e) {
            e.printstacktrace();
        }
        return false;
    }

    /**
     * 根据id删除文档
     *
     */
    public boolean deleteDocById(String indexName,String id) {
        try {
            DeleteRequest deleteRequest = new DeleteRequest(indexName,id);
            DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest,RequestOptions.DEFAULT);
            log.info("删除索引{}中id为{}的文档，返回结果为{}",id,deleteResponse.status().toString());
            return true;
        }catch (Exception e) {
            e.printstacktrace();
        }
        return false;
    }

    /**
     * 批量插入数据
     *
     */
    public boolean multiAddDoc(String indexName,List<JSONObject> list) {
        try {
            BulkRequest bulkRequest = new BulkRequest();
            list.forEach(doc -> {
                String source = JSON.toJSONString(doc);
                IndexRequest indexRequest = new IndexRequest(indexName);
                indexRequest.source(source,XContentType.JSON);
                bulkRequest.add(indexRequest);
            });
            BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest,RequestOptions.DEFAULT);
            log.info("向索引{}中批量插入数据的结果为{}",!bulkResponse.hasFailures());
            return !bulkResponse.hasFailures();
        }catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return false;
    }

    /**
     * 更新文档
     *
     */
    public boolean updateDoc(String indexName,String docId,JSONObject jsonObject) {
        try {
            UpdateRequest updateRequest = new UpdateRequest(indexName,docId).doc(JSON.toJSONString(jsonObject),XContentType.JSON);
            UpdateResponse updateResponse = restHighLevelClient.update(updateRequest,RequestOptions.DEFAULT);
            int total = updateResponse.getShardInfo().getTotal();
            log.info("更新文档的影响数量为{}",total);
            return total > 0;
        }catch (Exception e) {
            e.printstacktrace();
        }
        return false;
    }

    /**
     * 根据id查询文档
     */
    public JSONObject queryDocById(String indexName,String docId) {
        JSONObject jsonObject = new JSONObject();
        try {
            GetRequest getRequest = new GetRequest(indexName,docId);
            GetResponse getResponse = restHighLevelClient.get(getRequest,RequestOptions.DEFAULT);
            jsonObject = (JSONObject) JSONObject.toJSON(getResponse.getSource());
        }catch (Exception e) {
            e.printstacktrace();
        }
        return jsonObject;
    }

    /**
     * 通用条件查询，map类型的参数都为空时，默认查询全部
     * 
     */
    public PageResult<List<JSONObject>> conditionSearch(String indexName,Integer pageNum,Integer pageSize,String highName,Map<String,Object> andMap,Object> orMap,Object> dimAndMap,Object> dimOrMap) throws IOException {
        SearchRequest searchRequest = new SearchRequest(indexName);
        // 索引不存在时不报错
        searchRequest.indicesOptions(IndicesOptions.lenientExpandopen());
        //构造搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = buildMultiQuery(andMap,orMap,dimAndMap,dimOrMap);
        sourceBuilder.query(boolQueryBuilder);
        //高亮处理
        if (!StringUtils.isEmpty(highName)) {
            buildHighlight(sourceBuilder,highName);
        }
        //分页处理
        buildPageLimit(sourceBuilder,pageNum,pageSize);
        //超时设置
        sourceBuilder.timeout(TimeValue.timeValueSeconds(60));
        searchRequest.source(sourceBuilder);

        //执行搜索
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest,RequestOptions.DEFAULT);
        SearchHits searchHits = searchResponse.getHits();
        List<JSONObject> resultList = new ArrayList<>();
        for (SearchHit hit : searchHits) {
            //原始查询结果数据
            Map<String,Object> sourceAsMap = hit.getSourceAsMap();
            //高亮处理
            if (!StringUtils.isEmpty(highName)) {
                Map<String,HighlightField> highlightFields = hit.getHighlightFields();
                HighlightField highlightField = highlightFields.get(highName);
                if (highlightField != null) {
                    Text[] fragments = highlightField.fragments();
                    StringBuilder value = new StringBuilder();
                    for (Text text : fragments) {
                        value.append(text);
                    }
                    sourceAsMap.put(highName,value.toString());
                }
            }
            JSONObject jsonObject =  JSONObject.parSEObject(JSONObject.toJSONString(sourceAsMap));
            resultList.add(jsonObject);
        }

        long total = searchHits.getTotalHits().value;
        PageResult<List<JSONObject>> pageResult = new PageResult<>();
        pageResult.setPageNum(pageNum);
        pageResult.setPageSize(pageSize);
        pageResult.setTotal(total);
        pageResult.setList(resultList);
        pageResult.setTotalPage(total==0?0: (int) (total % pageSize == 0 ? total / pageSize : (total / pageSize) + 1));

        return pageResult;
    }

    /**
     * 构造多条件查询
     *
     */
    public BoolQueryBuilder buildMultiQuery(Map<String,Object> dimOrMap) {
        BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
        //该值为true时搜索全部
        boolean searchAllFlag = true;
        //精确查询，and
        if (!CollectionUtils.isEmpty(andMap)) {
            for (Map.Entry<String,Object> entry : andMap.entrySet()) {
                MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery(entry.getKey(),entry.getValue());
                boolQueryBuilder.must(matchQueryBuilder);
            }
            searchAllFlag = false;
        }
        //精确查询，or
        if (!CollectionUtils.isEmpty(orMap)) {
            for (Map.Entry<String,Object> entry : orMap.entrySet()) {
                MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery(entry.getKey(),entry.getValue());
                boolQueryBuilder.should(matchQueryBuilder);
            }
            searchAllFlag = false;
        }
        //模糊查询，and
        if (!CollectionUtils.isEmpty(dimAndMap)) {
            for (Map.Entry<String,Object> entry : dimAndMap.entrySet()) {
                WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery(entry.getKey(),"*" + entry.getValue() + "*");
                boolQueryBuilder.must(wildcardQueryBuilder);
            }
            searchAllFlag = false;
        }
        //模糊查询，or
        if (!CollectionUtils.isEmpty(dimOrMap)) {
            for (Map.Entry<String,Object> entry : dimOrMap.entrySet()) {
                WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery(entry.getKey(),"*" + entry.getValue() + "*");
                boolQueryBuilder.should(wildcardQueryBuilder);
            }
            searchAllFlag = false;
        }
        if (searchAllFlag) {
            MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
            boolQueryBuilder.must(matchAllQueryBuilder);
        }

        return boolQueryBuilder;
    }

    /**
     * 构建高亮字段
     * 
     */
    public void buildHighlight(SearchSourceBuilder sourceBuilder,String highName) {
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        //设置高亮字段
        highlightBuilder.field(highName);
        //多个高亮显示
        highlightBuilder.requireFieldMatch(false);
        //高亮标签前缀
        highlightBuilder.preTags("<span style='color:red'>");
        //高亮标签后缀
        highlightBuilder.postTags("</span>");

        sourceBuilder.Highlighter(highlightBuilder);
    }

    /**
     * 构造分页
     */
    public void buildPageLimit(SearchSourceBuilder sourceBuilder,Integer pageSize) {
        if (sourceBuilder!=null && !StringUtils.isEmpty(pageNum) && !StringUtils.isEmpty(pageSize)) {
            sourceBuilder.from(pageSize * (pageNum-1) );
            sourceBuilder.size(pageSize);
        }
    }

}

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

完美掌握MySQL登录方法]MySQL登录教程
TCP/IP套接字登录方法是MySQL在一切服务平台都提供的一种登录方法，也是互联网中应用数最多的一种方法。这种方法在TCP/IP登录上创建一个根据互联网的登录申请，一般手机客户端在一台服务器上，而MySQL实例在另外一台网络服务器上，这两台设备根据TCP/IP协议登录。一般对于刚安裝好的mysql，在配置的时候勾选启用mysql lineclient的话，就可以直接通过“开始—mysql—mysql command lineclient”，点击进入以后，会提醒输入root登陆密码。...
easy-rules规则引擎最佳落地实践
easy-rule规则引擎最佳落地
windows 安装 Elasticsearch
Elasticsearch 是一个分布式、高扩展、高实时的搜索与数据分析引擎, 本文主要介绍了在 windows 10上 安装 Elasticsearch,Elasticsearch-head,kibana等软件, 方便自己学习使用,
关于ElasticSearch日期格式不一致的异常，可以这么解决
最近壹哥的一个学生，在利用spring-data-elasticsearch访问ElasticSearch(ES)时，遇到了一个关于日期类型的BUG，困扰了很久。然后他就找壹哥给他解决，接下来壹哥就把解决的过程给大家复现一下，希望本文可以给遇到同样问题的同学一点启发。我们先来看看他的POM.xml文件配置，如下所示：实体类的代码如下：创建索引的单元测试类代码如下：以下是ES中创建的索引 Mapping结构，其中日期类型的format为date_time。看了以上代码，你能猜出来哪里有问题吗
java 操作elasticsearch详细总结
java 操作elasticsearch详细总结
全文搜索引擎 Elasticsearch 入门教程
原文链接：http://www.ruanyifeng.com/blog/2017/08/elasticsearch.html全文搜索属于最常见的需求，开源的 Elasticsearch （以下简称 Elastic）是目前全文搜索引擎的首选。它可以快速地储存、搜索和分析海量数据。维基百科、Stack Overflow、Github 都采用它。Elastic 的底层是开源库 Lucene。但是，你没法...
elasticsearch启动常见错误
原文链接：https://www.cnblogs.com/zhi-leaf/p/8484337.html 问题出现环境，OS版本：CentOS-7-x86_64-Minimal-1708；ES版本：elasticsearch-6.2.2。1、max file descriptors [4096] for elasticsearch process is too low, increas...
【ES】Elasticsearch分词器使用和简单查询
文章目录Elasticsearch一. analysis与analyzer1.1 内置的分词器1.2 内置分词器示例1.3 中文分词1.3.1 IK分词器1.3.2 HanLP1.3.3 pinyin分词器1.4 中文分词演示1.5 分词的实际应用1.5.1 设置mapping1.5.2 插入数据1.5.3 查询1.6 拼音分词器1.6.1 设置settings1.6.2 设置mapping1.6.3 数据的插入1.6.4 查询1.7 中文、拼音混合查找1.7.1 设
Elasticsearch06：Elasticsearch分词详解：ES分词介绍、倒排索引介绍、分词器的作用、停用词
一、ES分词介绍ES中在添加数据，也就是创建索引的时候，会先对数据进行分词。在查询索引数据的时候，也会先根据查询的关键字进行分词。所以在ES中分词这个过程是非常重要的，涉及到查询的效率和准确度。假设有一条数据，数据中有一个字段是titile，这个字段的值为LexCorp BFG-9000。我们想要把这条数据在ES中创建索引，方便后期检索。创建索引和查询索引的大致流程是这样的：图中左侧是创建索引的过程：首先对数据进行空白字符分割，将LexCorp BFG-9000切分为LexCorp和BFG-90
ES和Kibana设置账号密码
命令执行后，会出现几句英文，大概的意思是：你如果确定开启密码的话，需要设置以下六种账户的密码elastic、apm_system、kibana、logstash_system、beats_system、remote_monitoring_user。第四步：重启后，输入kibana的访问地址：http://192.168.1.10:5601,这时已经提示让你输入账号密码了。第六步：重启后，输入ES的访问地址：http://192.168.1.10:9200，这时已经提示让你输入账号密码了。
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native