ElasticSearch 入门总结

最新推荐文章于 2024-09-13 15:04:04 发布
最新推荐文章于 2024-09-13 15:04:04 发布
阅读量3.2k 收藏 29
点赞数 8
分类专栏： ElasticSearch 文章标签： ElasticSearch Springboot整合ElasticSearch ElasticSearch入门 ElasticSearch总结 ElasticSearch笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010648555/article/details/81841188
版权

ElasticSearch 入门

本篇为 ElasticSearch 入门学习总结笔记，课程视频地址：ElasticSearch 入门

一、ElasticSearch 简介

1.1、什么是ElasticSearch

简称 ES
  • 基于Apache Lucene 构建的 开源搜索引擎，提供一个分布式多用户能力的全文搜索引擎
  • 采用 JAVA 编写的 ，提供简单易用的 RESTFul API（RESTFul web接口），当前流行的企业级搜索引擎
  • 轻松的 横向扩展，可支持PB级 的结构化或非结构化数据处理
  • 可以准实时地快速存储、搜索、分析海量的数据。（用于云计算中，能够达到实时搜索）

1.2、应用场景

  • 海量数据分析引擎（聚合搜索）
  • 站内搜索引擎
  • 数据仓库

1.3、谁在用ES呢?

英国卫报— 实时分析公众对文章的回应

维基百科、GitHub - 站内实时搜索

百度—实时日志监控平台

阿里、Google、小米、京东…

1.4、环境要求

工具版本
IDEIDEA或Eclipse
JAVAJDK8
Maven3.x 以上
NodeJS6.0以上

二、ElasticSearch 安装

2.1、ES版本问题

  • 版本历史 ： 1.x-》2.x-》5.x -》最新6.0
  • 版本选择 ： 选择6.0进行演练！

2.2、ES安装-单实例

下载地址：ES Downloads，windows环境下载 ZIP sha ，Linux或者Mac环境下，下载TAR sha。

windows 下安装elasticsearch（有访问页面）

ElasticSearch安装部署（Windows）（添加到windows）

2.2.1 单实例的安装(Windows)

1、下载ES zip包

2、安装Jdk8,并查看环境变量配置

3、解压ES包

  • 目录说明：
目录名说明
config配置文件
modules模块存放目录
bin脚本
lib第三方库
plugins第三方插件

4、启动验证服务

windows环境在/bin 下载双击 `elasticsearch.bat` 。启动成功，看到starting....最后是started！

[2018-08-18T22:18:41,578][INFO ][o.e.n.Node               ] [-Jy0w6-] starting ...
[2018-08-18T22:18:44,044][INFO ][o.e.t.TransportService   ] [-Jy0w6-] publish_address {127.0.0.1:9300}, bound_addresses {127.0.0.1:9300}, {[::1]:9300}
{ml.machine_memory=8441524224, xpack.installed=true, ml.max_open_jobs=20, ml.enabled=true}, reason: apply cluster state (from master [master {-Jy0w6-}{-Jy0w6-QTKquaudbtTAQMQ}
[2018-08-18T22:18:48,923][INFO ][o.e.x.s.t.n.SecurityNetty4HttpServerTransport] [-Jy0w6-] publish_address {127.0.0.1:9200}, bound_addresses {127.0.0.1:9200}, {[::1]:9200}
[2018-08-18T22:18:48,924][INFO ][o.e.n.Node               ] [-Jy0w6-] started

然后访问  http://localhost:9200/ ,页面响应json格式数据，服务启动正常！

访问ElasticSeach

2.2.2 实用插件Head安装（Windows）

ES 默认返回的信息在页面上是Json格式显示!不太友好！

Head插件的优点：

  • 提供了友好的web界面，解决数据在界面显示问题
  • 实现基本信息的查看和Restful 请求的模拟以及数据的基本检索

1、安装Head的步骤

【ElasticSearch-5.0安装head插件】

【ES6.0版本安装head插件】

1）、安装Node 6.x以上J环境，安装  执行指令` npm install -g grunt  -cli `进行安装grunt。 

2）、 下载elasticsearch-head包，在Github【[elasticsearch-head](https://github.com/mobz/elasticsearch-head)】上面,直接选择下载的DownLoad zip到本地！

3）、保存在 F:\elasticsearch_learn\ 文件夹下面并对 elasticsearch-head 进行解压！

4）、在  F:\elasticsearch_learn\elasticsearch-head-master文件夹目录下面，使用 `npm install` ! 

F:\elasticsearch_learn\elasticsearch-head-master>npm install

注意：第一次==执行失败了！==报了下面的错误（可能是网络不好的原因，网络好的时候在尝试执行一次），但是服务启动没有问题！

npm WARN optional SKIPPING OPTIONAL DEPENDENCY: fsevents@^1.0.0 
npm ERR! node v6.10.3
npm ERR! npm  v3.10.10
npm ERR! code ELIFECYCLE
npm ERR! phantomjs-prebuilt@2.1.16 install: `node install.js`
npm ERR! Exit status 1
....
npm ERR! Please include the following file with any support request:
npm ERR!     F:\elasticsearch_learn\elasticsearch-head-master\npm-debug.log

5）、doc窗口 在 F:\elasticsearch_learn\elasticsearch-head-master文件夹目录下面执行

 # npm run start  或者  grunt server 
 F:\elasticsearch_learn\elasticsearch-head-master>npm run start

6）、验证服务，默认访问地址http://localhost:9100，如下图显示：

启动elasticsearch-head并验证

2、修改相应的配置

ElasticSearch和 elasticsearch-head 本质上是两个服务进程，访问存在跨域问题，需要进行一些设置。

在 elasticsearch安装目录 /config/elasticsearch.yml ,在这个配置文件的末尾追加下面两行配置信息并保存！

http.cors.enabled: true
http.cors.allow-origin: "*"
属性缺省值描述
http.cors.enabledtrue如果启用了 HTTP 端口，那么此属性会指定是否允许跨源 REST 请求。
http.cors.allowed.originlocalhost如果 http.cors.enabled 的值为 true，那么该属性会指定允许 REST 请求来自何处。

更多属性配置，请查看 【Elasticsearch 服务配置属性】

3、验证elasticsearch和 elasticsearch-head

  • 启动 elasticsearch服务
  • 启动elasticsearch-head 服务

访问 http://localhost:9100 地址！查看elasticsearch 集群健康值是否正常！正常如下图：

注： 集群健康值

red（差）：集群 健康状况很差，虽然可以查询，但是已经出现了丢失数据的现象 ；

yellow（中）：集群健康状况不是很好，但是集群可以正常使用 ；

green（优）：集群健康状况良好，集群正常使用。

验证elasticsearch和 elasticsearch-head组合

2.3、ES安装-分布式安装

1）、安装说明，安装三个节点，一个master ，两个slave。

集群名称ip-端口
myEsCluster （master）127.0.0.1:9500
myEsCluster（slave）127.0.0.1:9600
myEsCluster（slave）127.0.0.1:9700

2）、Es安装包解压出三份ES，修改每个 elasticsearch安装目录 /config/elasticsearch.yml 这个配置文件

master配置说明:

# 设置支持elasticsearch-head
http.cors.enabled: true
http.cors.allow-origin: "*"

# 设置集群master配置信息
# 首先要指定 集群的名字 ,名字随便起，符合常规命名规则
cluster.name: myEsCluster
# 节点的名字，一般为master 或者 slave
node.name: master
# 节点是否为master，设置为true的话，说明此节点为master节点
node.master: true
# 设置网络,如果是本机的话就是127.0.0.1，其他服务器配置对应的IP地址即可
network.host: 127.0.0.1
# 默认端口为 9200,可以修改默认设置
http.port: 9500

slave配置说明:

# 设置集群slave配置信息
# 首先要指定 集群的名字 ,名字随便起，符合常规命名规则
cluster.name: myEsCluster
# 节点的名字，一般为master 或者 slave
node.name: slave1
# 节点是否为master，设置为true的话，说明此节点为master节点
node.master: false
# 默认端口为 9200,可以修改默认设置
http.port: 9600
# 设置网络,如果是本机的话就是127.0.0.1，其他服务器配置对应的IP地址即可
network.host: 127.0.0.1
# 设置集群中master节点的初始列表，可以通过这些节点来自动发现新加入集群的节点。可以是一个数组。
# #discovery.zen.ping.unicast.hosts: ["host1", "host2"]
discovery.zen.ping.unicast.hosts: ["127.0.0.1"]

两个slave配置只需要改相应的端口号即可！一个slave1：9600 ，一个slave2：9700。

更多配置参考：

3）、配置后完成后，启动master的，然后启动Slave，也启动elasticsearch-head服务，此时页面可以查看Es集群的状态！如下图所示:

Es集群

2.4、 总结

从上面的安装来看，Es的安装相对还是比较简单，并且在安装分布式的时候，通过简单的配置就可以快速扩展多个ES节点，能够快速的进行扩容，非常灵活，方便！

三、ElasticSearch 基础概念

3.1、基本概念

集群和节点

集群：是由一个或者多个ES节点组成的集合。 每一个集群都有一个唯一的名字，默认是ElasticSearch。每个节点也都有唯一名字。

集群和节点

索引

索引： 含有相同属性的文档集合，比如产品的索引，用户的索引等

类型：索引可以定义一个或多个类型，文档必须属于一个类型（一般会定义有相同字段的文档为一个类型）

文档：文档是可以被所有的基本数据单位，是整个ES中最小的存储单位

索引在Es中是通过一个名字来识别的，而且它的名字必须是 英文字母小写，且不能有中划线。

都是通过这个名字来进行增删查改。

ES数据库
索引实例database
类型表-table
文档(字段)一行记录

举例：图书索引 —> 文学类型、技能类型…---->每一本书可以看成一个文档

分片和备份

分片： 每个索引都有多个分片，每个分片是一个Lucene索引

分片的好处：假如数据量很大的话，就会造成硬盘的压力很大，同时搜索速度也会出现瓶颈，将索引分成多个分片，从而分摊压力提供效率。

备份：拷贝一份分片就完成了分片的备份，提供可用性

ES默认在创建索引的时候，会创建5个分片，1个备份。这个默认的数量是可以修改的。

  number_of_shards： 每个索引的主分片数，默认值是 5 。这个配置在索引创建后不能修改。

  number_of_replicas：每个主分片的副本数，默认值是 1 。对于活动的索引库，这个配置可以随时修改。

注意：索引的分片只能在创建索引的时候指定，而不能再后期进行修改。备份是可以动态修改的。

四、ElasticSearch 基本用法

ES是以Restful API的风格来命名的。

  • API 的基本格式

    http://:/<索引>/<类型>/<文档id>

  • 常用HTTP动词

    GET/PUT/POST/DELETE

4.1、索引的创建

问题：如何确定一个索引是非结构化还是结构的化的呢？

结合Head插件，索引–>索引信息，查看JSON数据中mappings，如果数据为空，则说明是非结构化索引。

非结构化创建

使用Head插件进行索引的创建，在tab标签上，选择索引，点 新建索引，输入索引的名称，注意名称的命名规则。（我自己验证，中文、有中划线的索引名字都可以创建成功！但是字母必须是小写！）

创建成功每个框框，都是Es索引的分片，粗线框是主分片 和 细线框 是分片的备份。

索引的创建-1

结构化创建

1）、使用Head插件进行索引的创建，在tab标签上，选择复合查询，进行如下配置：

创建结构化索引

2）、或者使用PostMan工具进行索引的创建

说明：

在Elasticsearch 6.0.0或更高版本中创建的索引只包含一个mapping type。 在5.x中使用multiple mapping types创建的索引将继续像以前一样在Elasticsearch 6.x中运行。 Mapping types将在Elasticsearch 7.0.0中完全删除。

Indices created in Elasticsearch 6.0.0 or later may only contain a single mapping type. Indices created in 5.x with multiple mapping types will continue to function as before in Elasticsearch 6.x. Mapping types will be completely removed in Elasticsearch 7.0.0.

PUT 127.0.0.1:9500/people

请求参数：

{
	"settings":{
		"number_of_shards":3,
		"number_of_replicas":1
	},
	"mappings":{
		"man":{
			"properties":{
				"name":{
					"type":"text"
				},
				"age":{
					"type":"integer"
				},
				"birth":{
					"type":"date",
					"format":"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
				},
				"country":{
					"type":"keyword"
				}
			}
		},
		"woman":{}
	
	}
}

结果：

{
    "acknowledged": true,
    "shards_acknowledged": true,
    "index": "people"
}

如果一个mappings中有两个type的话，在提交的时候会报如下错误：

PUT 127.0.0.1:9500/people2

参数：

{
	"settings":{
		"number_of_shards":3,
		"number_of_replicas":1
	},
	"mappings":{
		"man":{
			"properties":{
				"name":{
					"type":"text"
				},
				"age":{
					"type":"integer"
				},
				"birth":{
					"type":"date",
					"format":"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
				},
				"country":{
					"type":"keyword"
				}
			}
		},
		"woman":{}
	
	}
}

结果：

{
    "error": {
        "root_cause": [
            {
                "type": "illegal_argument_exception",
                "reason": "Rejecting mapping update to [people2] as the final mapping would have more than 1 type: [woman, man]"
            }
        ],
        "type": "illegal_argument_exception",
        "reason": "Rejecting mapping update to [people2] as the final mapping would have more than 1 type: [woman, man]"
    },
    "status": 400
}

4.2、插入

文档ID是一个唯一索引值，指向我们的文档数据。

指定文档ID插入

PUT 127.0.0.1:9500/people/man/1

指定插入文档的ID为 1.

参数：

{
	"name":"dufy",
	"age":27,
	"birth":"1992-09-28",
	"country":"China"
}

请求结果：

{
    "_index": "people",
    "_type": "man",
    "_id": "1", # id 为1 
    "_version": 1,
    "result": "created", # 标识创建一个文档
    "_shards": {
        "total": 2,
        "successful": 2,
        "failed": 0
    },
    "_seq_no": 0,
    "_primary_term": 1
}

使用Head插件查看数据：

使用ID插入文档

自动产生文档ID插入

自动产生ID和上面指定ID插入不同的两个地方是:

（1）、在请求地址上不需要指定 ID，让ES自动帮我们创建ID!

（2）、请求方式为POST方式

POST 127.0.0.1:9500/people/man

请求参数：

{
	"name":"dufy_auto_id",
	"age":37,
	"birth":"1982-09-28",
	"country":"China"
}

请求结果：

{
    "_index": "people",
    "_type": "man",
    "_id": "zmLSUGUBWifqa4luPRp5", # 自动创建ID
    "_version": 1,
    "result": "created", # 标识创建一个文档
    "_shards": {
        "total": 2,
        "successful": 2,
        "failed": 0
    },
    "_seq_no": 1,
    "_primary_term": 1
}

使用Head插件查看数据：

自动生成文档ID

4.3 、修改

直接修改文档

POST 127.0.0.1:9500/people/man/1/_update

注意：需要在请求的地址后面加上 _update,标识是一个修改操作。

请求参数：

{
    "doc":{
        "name":"dufy_update" 
    }
}

请求响应结果：

{
    "_index": "people",
    "_type": "man",
    "_id": "1", # 标识文档的ID为1
    "_version": 2,
    "result": "updated", # 标识修改一个文档
    "_shards": {
        "total": 2,
        "successful": 2,
        "failed": 0
    },
    "_seq_no": 2,
    "_primary_term": 1
}

通过Head插件查看，发现文档ID为1 name已经修改了。

脚本修改文档

脚本修改和直接修改的API是一样的，只是参数有些区别。

POST 127.0.0.1:9500/people/man/1/_update

第一种方式请求参数：

{
    "script":{
        "lang":"painless" , # ES 脚本语言
        "inline":"ctx._source.age += 10" #ctx：es上下文，_source:代表es当前的文档，age：字段
    }
}

第二种方式请求参数：

{
    "script":{
        "lang":"painless" ,
        "inline":"ctx._source.age = params.age",
        "params":{  #使用params 指定数据值
        	"age":80
        }
    }
}

4.4、删除

删除文档

DELETE 127.0.0.1:9500/people/man/1

使用delete请求，通过文档的ID进行删除操作。

{
    "_index": "people",
    "_type": "man",
    "_id": "1",
    "_version": 5,
    "result": "deleted", # 标识删除一个文档
    "_shards": {
        "total": 2,
        "successful": 2,
        "failed": 0
    },
    "_seq_no": 5,
    "_primary_term": 1
}
删除索引

删除操作是一个比较危险的操作，因为索引一旦删除，对应的所有数据全部被删除了。

  • 可以通过Head插件删除。确认输入删除，索引就删除了。

  • 使用 PostMan进行删除，使用 请求，只输入请求的索引

    127.0.0.1:9500/people

4.5、查询-重点

查询功能是使用过操作比较频繁的。

首先进行数据初始化，创建一个book 的索引，然后插入一些数据。具体的创建索引和插入数据，查看之前内容。

PUT　127.0.0.1:9500/book

结构化创建：

{
	"mappings":{
		"novel":{
			"properties":{
				"author":{
					"type":"text"
				},
				"word_count":{
					"type":"integer"
				},
				"publish_date":{
					"type":"date",
					"format":"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
				},
				"title":{
					"type":"keyword"
				}
			}
		}
	}
}

插入文档数据：

POST 127.0.0.1:9500/book/novel/1

{
	"title":"Nginx",
	"word_count":5000,
	"publish_date":"2992-09-28",
	"author":"zhangyc"
}

book索引初始化数据

简单查询

GET 127.0.0.1:9500/book/novel/4

{
    "_index": "book",
    "_type": "novel",
    "_id": "4",
    "_version": 1,
    "found": true,
    "_source": {  # 查询出来索引为book，类型是novel的ID=4 的文档数据
        "title": "Dubbo",
        "word_count": 8000,
        "publish_date": "1992-09-28",
        "author": "alibb"
    }
}
条件查询

POST 127.0.0.1:9500/book/_search

  • 查询全部数据
{
	"query":{ # 查询是以query为关键词的
		"match_all":{} # 查询全部的数据
	}
}

返回结果：

{
    "took": 8, # 接口响应花费的时间/ms
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": { 
        "total": 5,  # 总共数据5条
        "max_score": 1,
        "hits": [ # 击中，也就是响应的全部数据，hits默认返回的数据为10条，可以修改！
            {
                "_index": "book",
                "_type": "novel",
                "_id": "5",
                "_score": 1,
                "_source": {
                    "title": "Nginx",
                    "word_count": 5000,
                    "publish_date": "2992-09-28",
                    "author": "zhangyc"
                }
            },
            {....} #其他的数据信息 
            }
        ]
    }
}

修改 hits默认返回数据的总数。

{
	"query":{ # 查询是以query为关键词的
		"match_all":{} # 查询全部的数据
	},
	"size":2 # 返回数据的总数
}

  • 关键词查询

    POST 127.0.0.1:9500/book/_search

{
	"query":{ 
        "match":{
            "title": "Redis实战"
        },
        # 默认 排序 使用 _score 
        "sort":[ # 如何查询数据较多，可以进行排序操作
            {"publish_date":{"order":"desc"}}
        ]
	}
}

{
    "took": 7,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": 1,
        "max_score": 0.2876821,
        "hits": [
            {
                "_index": "book",
                "_type": "novel",
                "_id": "3",
                "_score": 0.2876821,
                "_source": {
                    "title": "Redis实战",
                    "word_count": 2000,
                    "publish_date": "1582-09-28",
                    "author": "marry"
                }
            }
        ]
    }
}
聚合查询

POST 127.0.0.1:9500/book/_search

  • 对书籍的字数进行聚合

查询参数：

{
	"aggs":{
		"groud_word_count":{ # 自定义聚合名称
			"terms":{
				"field":"word_count"
			}
		}
	}
}

返回结果：

{
    # 其他数据省略
    "aggregations": {
        "groud_word_count": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": 5000,
                    "doc_count": 2 # 文档总数
                },
                {
                    "key": 2000,
                    "doc_count": 1
                },
                {
                    "key": 8000,
                    "doc_count": 1
                },
                {
                    "key": 10000,
                    "doc_count": 1
                }
            ]
        }
    }
}

上面这个是单个聚合，多个聚合同理：

{
	"aggs":{
		"groud_word_count":{ # 自定义聚合名称
			"terms":{
				"field":"word_count"
			}
		},
    	"groud_title":{ # 自定义聚合名称
			"terms":{
				"field":"title"
			}
		}
	}
}
  • 进行函数计算
{
	"aggs":{
		"grades_word_count":{
			"stats":{  #统计数据 min 、max、avg、avg
				"field":"word_count"
			}
		}
	}
}

返回结果：

"aggregations": { # 聚合
        "grades_word_count": {
            "count": 5,
            "min": 2000,
            "max": 10000,
            "avg": 6000,
            "sum": 30000
        }
    }

五、ElasticSearch 高级查询

Elasticsearch Reference 6

子条件查询

特定字段查询 所指特定值

1、Query Context

在查询过程中，除了判断文档是否满足查询条件外，ES还会计算一个**_score来标识匹配的程度，旨在判断目标文档和查询条件匹配的有多好**（匹配度）！

  • 全文本查询 —— 针对文本类型数据
  • 字段级别查询——针对结构化数据，如数字、日期等
{
	"query":{
		"multi_match":{ # 多条件查询
			"query":"Redis",
			"fields":["title","author"]
		}
	}
	
}

语法查询：

{
	"query":{
		"query_string":{
			"query":"入门 OR Redis",
			"fields":["title","author"]
		}
	}
	
}

字段级别的查询：

{
	"query":{
		"term":{
			"word_count":5000
		}
	}
	
}

字数或者日期范围：

{
	"query":{
		"range":{
            "word_count":{
                "gte":1000,
                "lte":5000
            }
		}
	}
	
}
2、Filter Context
{
	"query":{
		"bool":{
            "filter":{
                "term":{
                	"word_count":5000
                }
            }
		}
	}
	
}
复合条件查询

以一定的逻辑组合子条件查询,结合了Query和Filter Context

  • 固定分数查询

  • 布尔查询

六、ElasticSearch 实战演练

1、配置Spring boot ElasticSearch开发环境

1、创建Spring boot web项目，spring boot 使用2.0.4版本, elasticsearch为5.6.10

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

 <!--引入ELasticSearch的依赖包，默认使用elasticsearch5.6.10版本-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
 <!--需要引入transport-netty3-client，否则会启动报错-->
        <dependency>
            <groupId>org.elasticsearch.plugin</groupId>
            <artifactId>transport-netty3-client</artifactId>
            <version>5.6.10</version>
        </dependency>

2、配置代码

/**
 * ES 配置类
 * @author:dufyun
 * @version:1.0.0
 * @date 2018/8/19
 * @update:[日期YYYY-MM-DD] [更改人姓名][变更描述]
 */
@Configuration
public class ElasticSearchConfig {

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

	@Bean
	public TransportClient transportClient() {
		logger.info("初始化开始。。。。。");
		TransportClient client = null;
		try {
			TransportAddress transportAddress = new InetSocketTransportAddress(InetAddress.getByName("localhost"),
					Integer.valueOf(9300));

			// 配置信息
			Settings esSetting = Settings.builder()
					.put("cluster.name","myEsCluster")
					.build();

			//配置信息Settings自定义,下面设置为EMPTY
			client = new PreBuiltTransportClient(esSetting);

			client.addTransportAddresses(transportAddress);


		} catch (Exception e) {
			logger.error("elasticsearch TransportClient create error!!!", e);
		}

		return client;
	}
}

也可以使用配置文件！

es.hostName=localhost
es.transport=9300
es.cluster.name=myEsCluster

@Configuration
@PropertySource(value={"classpath:elasticsearch.properties"}) // 加载 指定的配置，只支持properti
public class ElasticSearchConfig {

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

	@Value("${es.hostName}")
	private String hostName;

	@Value("${es.transport}")
	private Integer transport;

	@Value("${es.cluster.name}")
	private String clusterName;

	@Bean
	public TransportClient transportClient() {
		LOGGER.info("初始化开始。。。。。");
		TransportClient client = null;
		try {
			TransportAddress transportAddress = new InetSocketTransportAddress(InetAddress.getByName(hostName),
					Integer.valueOf(transport));

			// 配置信息
			Settings esSetting = Settings.builder()
					.put("cluster.name",clusterName)
					.build();

			//配置信息Settings自定义,下面设置为EMPTY
			client = new PreBuiltTransportClient(esSetting);

			client.addTransportAddresses(transportAddress);


		} catch (Exception e) {
			logger.error("elasticsearch TransportClient create error!!!", e);
		}

		return client;
	}
}

3、使用单元测试进行验证

@Autowired
	private TransportClient client;

	@Test
	public void contextLoads() {

		System.out.println(client);
       //org.elasticsearch.transport.client.PreBuiltTransportClient@6c9b44bf
	}

2、接口开发

1、新增图书信息功能开发

2、修改图书信息功能开发

3、删除功能开发

4、综合查询接口开发

代码如下：

/**
 * ES book索引 控制器
 * @author:dufyun
 * @version:1.0.0
 * @date 2018/8/19
 * @update:[日期YYYY-MM-DD] [更改人姓名][变更描述]
 */
@Controller
public class BookController {

	@Autowired
	private TransportClient client;

	/**
	 * http://localhost:8080/get/book/novel?id=2
	 * 获取Es中数据
	 * @param id
	 * @return
	 */
	@GetMapping(value = "/get/book/novel")
	@ResponseBody
	public ResponseEntity getBook(@RequestParam("id") String id) {
		if (StringUtils.isEmpty(id)) {
			return new ResponseEntity("ID不能为空！", HttpStatus.NOT_FOUND);
		}
		GetResponse result = client.prepareGet("book", "novel", id).get();

		if (!result.isExists()) {
			return new ResponseEntity("资源没有找到！", HttpStatus.NOT_FOUND);
		}

		return new ResponseEntity(result.getSource(), HttpStatus.OK);

	}

	/**
	 * 添加文档数据
	 *  http://localhost:8080/add/book/novel
	 *  form-data
	 * @param title
	 * @param author
	 * @param word_count
	 * @param publish_date
	 * @return
	 */
	@PostMapping(value = "/add/book/novel")
	@ResponseBody
	public ResponseEntity addBook(@RequestParam("title") String title, @RequestParam("author") String author,
			@RequestParam("word_count") Integer word_count,
			@RequestParam("publish_date") String publish_date) {

		try {
			/**
			 * 要加 startObject，否则出现 Can not write a field name, expecting a value 错误！
			 */
			XContentBuilder builder = XContentFactory.jsonBuilder().startObject().field("title", title)
					.field("author", author).field("word_count", word_count)
					.field("publish_date", publish_date).endObject();

			IndexResponse indexResponse = client.prepareIndex("book", "novel").setSource(builder).get();

			return new ResponseEntity(indexResponse.getId(), HttpStatus.INTERNAL_SERVER_ERROR);
		} catch (IOException e) {
			e.printStackTrace();
			new ResponseEntity("内部服务错误！", HttpStatus.INTERNAL_SERVER_ERROR);
		}
		return new ResponseEntity("插入出错！", HttpStatus.INTERNAL_SERVER_ERROR);

	}


	/**
	 * 删除Es中数据
	 * localhost:8080/del/book/novel?id=sdfhUWUB1-6vN1-K8u5f
	 * @param id
	 * @return
	 */
	@DeleteMapping(value = "/del/book/novel")
	@ResponseBody
	public ResponseEntity delBook(@RequestParam("id") String id) {
		if (StringUtils.isEmpty(id)) {
			return new ResponseEntity("ID不能为空！", HttpStatus.NOT_FOUND);
		}
		DeleteResponse result = client.prepareDelete("book", "novel", id).get();

		return new ResponseEntity(result.toString(), HttpStatus.OK);

	}

	/**
	 * 更新文档
	 *
	 * @param id
	 * @param title
	 * @param author
	 * @param word_count
	 * @param publish_date
	 * @return
	 */
	@PutMapping(value = "/update/book/novel")
	@ResponseBody
	public ResponseEntity updateBook(@RequestParam("id") String id,
			@RequestParam(value = "title",required = false) String title,
			@RequestParam(value = "author",required = false) String author,
			@RequestParam(value = "word_count",required = false) Integer word_count,
			@RequestParam(value = "publish_date",required = false) String publish_date) {
		if (StringUtils.isEmpty(id)) {
			return new ResponseEntity("ID不能为空！", HttpStatus.NOT_FOUND);
		}
		UpdateRequest updateRequest = new UpdateRequest("book","novel",id);

		try {
			XContentBuilder builder = XContentFactory.jsonBuilder().startObject();
			if (!StringUtils.isEmpty(title)){
				builder.field("title", title);
			}
			if (!StringUtils.isEmpty(author)){
				builder.field("author", author);
			}
			if (!StringUtils.isEmpty(word_count)){
				builder.field("word_count", word_count);
			}
			if (!StringUtils.isEmpty(publish_date)){
				builder.field("publish_date", publish_date);
			}

			builder.endObject();

			updateRequest.doc(builder);

			UpdateResponse updateResponse = client.update(updateRequest).get();

			return new ResponseEntity(updateResponse.getId(), HttpStatus.OK);
		} catch (Exception e) {
			e.printStackTrace();
			return new ResponseEntity("内部错误！", HttpStatus.INTERNAL_SERVER_ERROR);
		}

	}

	/**
	 * localhost:8080/query/book/novel
	 * 复合查询接口
	 * @param title
	 * @param author
	 * @param gt_word_conut
	 * @param lt_word_conut
	 * @return
	 */
	@PostMapping(value = "/query/book/novel")
	@ResponseBody
	public ResponseEntity queryBook(
			@RequestParam(value = "title",required = false) String title,
			@RequestParam(value = "author",required = false) String author,
			@RequestParam(value = "gt_word_conut",defaultValue = "0") int gt_word_conut,
			@RequestParam(value = "lt_word_conut",required = false) Integer lt_word_conut) {


		BoolQueryBuilder boolQuy = QueryBuilders.boolQuery();

		if(!StringUtils.isEmpty(title)){
			boolQuy.must(QueryBuilders.matchQuery("title", title));
		}
		if(!StringUtils.isEmpty(author)){
			boolQuy.must(QueryBuilders.matchQuery("author", author));
		}

		RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("word_count").from(gt_word_conut);

		if(lt_word_conut != null && gt_word_conut >0){
			rangeQueryBuilder.to(lt_word_conut);
		}
		boolQuy.filter(rangeQueryBuilder);

		SearchRequestBuilder searchRequestBuilder = client.prepareSearch("book")
				.setTypes("novel")
				.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
				.setQuery(boolQuy)
				.setFrom(0)
				.setSize(10);
		SearchResponse searchResponse = searchRequestBuilder.get();
		List<Map<String, Object>> lists = new ArrayList<>();
		for (SearchHit hit:searchResponse.getHits().getHits()) {
			lists.add(hit.getSource());
		}

		return new ResponseEntity(lists,HttpStatus.OK);
	}

}

七、ElasticSearch 总结

  • ES简介——使用场景（重要性），提高竞争力
  • 安装ES-单机-分布式
  • 核心基础概念
  • 基本使用方法 ——增删查改
  • 高级查询语法——重点和难点
  • 实战演练

ES课程总结

实战演练源码

springboot-elasticsearch

如果您觉得这篇博文对你有帮助，请点赞或者喜欢，让更多的人看到，谢谢！

如果帅气（美丽）、睿智（聪颖），和我一样简单善良的你看到本篇博文中存在问题，请指出，我虚心接受你让我成长的批评，谢谢阅读！
祝你今天开心愉快！

欢迎访问我的csdn博客，我们一同成长！

不管做什么，只要坚持下去就会看到不一样！在路上，不卑不亢!

博客首页 : http://blog.csdn.net/u010648555

© 每天都在变得更好的阿飞

阿飞云漫步
关注
专栏目录
Elasticsearch基础知识整理
昔日的博客
02-28 3105
Elasticsearch基础知识 ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。能够达到实时搜索，稳定，可靠，快速，安装使用方便。 我们建立一个网站或应用程序，并要添加搜索功能，令我们受打击
Elasticsearch基础知识
m0_46093203的博客
07-29 240
1、我们都知道Elasticsearch是一个实时分布式搜索和分析引擎，是面向文档类型的。 首先我们先看一下关系型数据库和Elasticsearch的关系对比图 此时的可以认为的关系是关系型数据库的数据库（database）名相当于Elasticsearch的索引（indices）,数据库表（table）相当于Elasticsearch的的type，以此类推。（暂时这样可以理解方便）。 在关系型数据库中我们找数据库都是“找到数据库名->找到表名->找到所需要的行->找到列->最后找
ElasticSearch基础知识整理
weixin_34306676的博客
03-01 199
分片、副本 分片shards：数据量特大，没有足够大的硬盘空间来一次性存储，且一次性搜索那么多的数据，响应跟不上es提供把数据进行分片存储，这样方便进行拓展和提高吞吐。 副本replicas：分片的拷贝，当主分片不可用的时候，副本就充当主分片进行使用 Es中的每个索引默认分配5个主分片和1份副本：如果你的集群中至少有两个节点，你的索引将...
5分钟熟练上手ES的具体使用
最新发布
qq_63728673的博客
09-13 1786
类似于关系型数据库中的“表结构”或“schema”，它告诉 Elasticsearch 每个字段是什么类型，应该如何处理和索引这些字段的数据。于是这一篇博客应运而生。的子级，它定义了文档中每个字段的名称和类型。每个字段的类型决定了 Elasticsearch 如何存储、索引和查询该字段的数据。(X的意思是指定HTTP请求的方法)如GET，POST，PUT，DELETE等。类型适合存储并查询复杂的嵌套数组数据，如订单中的商品列表或评论的回复。：类似于关系型数据库中的“行”，是 JSON 格式的数据单位。
ElasticSearch基础知识
arne's Blog
06-21 320
### 1.基本概念 ElasticSearch是一个开源的分布式搜索引擎，具备高可靠性，设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。基于RESTful接口。像Solr4一样，是基于Lucene构建的。支持时间时间索引和全文检索。官网：http://www.elasticsearch.org ElasticSearch对比Solr的优点在于： 轻量级：安装启动方便，下载文...
ElasticSearch从入门到精通，史上最全（持续更新，未完待续，每天一点点）
热门推荐
Null的博客
07-30 13万+
目录 1.ElasticSearch的简介 2.用数据库实现搜素的功能 3.ES的核心概念 3.1 NRT(Near Realtime)近实时 3.2 cluster集群，ES是一个分布式的系统 3.3 Node节点，就是集群中的一台服务器 3.4 index 索引（索引库） 3.5 type类型 3.6 document：文档 3.7 Field 字段 3.8 sha...
ElasticSearch入门篇.docx
03-12
### ElasticSearch 入门知识点详解 #### 一、ElasticSearch 概览 **1.1 ElasticSearch 的使用案例** ElasticSearch 在多个领域有着广泛的应用案例，这充分证明了其在大规模数据处理和搜索方面的强大能力。 - **...
Elasticsearch入门讲解
03-28
Elasticsearch 入门讲解 1. ELASTICSEARCH 初识 Elasticsearch（简称ES）是一款基于Lucene的开源分布式搜索引擎，以其强大的全文检索、实时分析和高可扩展性而闻名。它不仅用于传统的搜索功能，还广泛应用于日志...
elasticsearch入门教程&应用场景.zip
02-01
**Elasticsearch 入门教程与应用场景** Elasticsearch 是一个开源的全文搜索引擎，基于 Lucene 库构建，设计用于分布式、实时的数据存储和搜索。它不仅提供了强大的全文搜索功能，还支持聚合分析，广泛应用于日志...
第13单元 ElasticSearch入门1
08-08
总结：Elasticsearch 是一个强大且灵活的搜索引擎，它的核心在于倒排索引，支持分布式部署，适用于大数据量、实时搜索的场景。了解其基本原理和安装步骤是入门的关键，进一步掌握插件使用和分布式配置将有助于提升...
（三） ElasticSearch基础知识
chenyl
10-13 699
结合ElasticSearch的api： { "name" : "master", "cluster_name" : "chenyulin", "cluster_uuid" : "mICgsP3OTKC-oNpcJTQiAQ", "version" : { "number" : "5.6.3", "build
Elasticsearch（一）基础知识点
asd804171023的博客
09-25 382
Elasticsearch 是一个分布式的 RESTful 风格的搜索和数据分析引擎。 1. cluster（集群） 一个集群就是由一个或多个节点组织在一起，它们共同持有整个的数据，并一起提供索引和搜索功能，一个集群由一个唯一的名字标识，这个名字默认就是“elasticsearch”,多个节点使用这个名字加入集群 2. node（节点） 一个节点是集群中的一个es实例，作为集群的一部分，它...
Elasticsearch基础知识分享
WOLF
02-13 219
Elasticsearch背景介绍 Elasticsearch 是一个基于 Lucene 的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于 RESTful web 接口。Elasticsearch 是用 Java 开发的，并作为 Apache 许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。 备注： Luc...
ElasticSearch —— 基础知识汇总
看了就会暴富的博客！
08-10 827
一、ElasticSearch介绍 一个主要应用于大数据场景下的近实时的全文搜索引擎。 近实时：从添加一个文档到能搜索到这个文档，有一个微小的延迟（通常是1s）。 二、ES核心 —— 倒排索引 倒排索引是类似于哈希表一样的数据结构，完成由词条到文档id的映射。可以根据搜索词条快速找到该词条对应的所有文档id，然后根据id直接获取文档。 三、基础概念 （一）集群 一个集群就是由一个或多个节点组织在一起，它们共同持有你整个的数据，并一...
ElasticSearch基础知识汇总
HSQdePYZ的博客
08-28 1611
Elasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。Elasticsearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在Java、.NET（C#）、PHP、Python、Apache Groovy、Ruby和许多其他语言中都是可用的。
Elasticsearch入门：理解基础概念
"这篇博客是关于Elasticsearch入门的基础概念，包括近实时搜索、集群、节点和索引的介绍。内容基于Elasticsearch 6.2版本的官方文档。" 在深入探讨Elasticsearch之前，我们需要理解一些核心概念。首先，Elastic...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值