Elasticsearch基础总结与Spring Boot整合

最新推荐文章于 2024-10-10 11:17:27 发布
最新推荐文章于 2024-10-10 11:17:27 发布
阅读量4.9k 收藏 8
点赞数
分类专栏： Spring Boot 文章标签： ElasticSearch SpringBoot 基础操作 整合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huxiutao/article/details/88040765
版权

一、概述

Elasticsearch，基于lucene，隐藏复杂性，提供简单易用的restful api接口、java api接口（还有其他语言的api接口）。

Elasticsearch是一个实时分布式搜索和分析引擎。它用于全文搜索、结构化搜索、分析。
全文检索：将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的目的。

结构化检索：我想搜索商品分类为电子商品都有哪些，select * from products where category_id=‘电子’

数据分析：电商网站，最近一周电子类商品销量排名前10的商家有哪些；新闻网站，最近1个月访问量排名前3的新闻版块是哪些等等。
使用场景：
1）维基百科，类似百度百科，全文检索，高亮，搜索推荐。
2）The Guardian（国外新闻网站），类似搜狐新闻，用户行为日志（点击，浏览，收藏，评论）+ 社交网络数据（对某某新闻的相关看法），数据分析。
3）Stack Overflow（国外的程序异常讨论论坛），IT问题，程序的报错，提交上去，有人会跟你讨论和回答
4）GitHub（开源代码管理），搜索上千亿行代码。
5）国内：站内搜索（电商，招聘，门户，等等），IT系统搜索（OA，CRM，ERP，等等），数据分析（ES热门的一个使用场景）

核心概念：
Index（索引-数据库）
Type（类型-表）
Document（文档-行）
Field（字段-列）
mapping（映射-约束）

ES是如何存取数据的，又是如何检索数据的呢？
1）存放数据时：
类型分为索引区和数据区。
a、索引对象（blog）：存储数据的表结构 ，任何搜索数据，存放在索引对象上 。
b、映射（mapping）：数据如何存放到索引对象上，需要有一个映射配置， 包括：数据类型、是否存储、是否分词等。
c、文档（document）：一条数据记录，存在索引对象上
d、文档类型（type）：一个索引对象，存放多种类型数据，数据用文档类型进行标识
2）搜索
由于不是由记录来确定属性值，而是由属性值来确定记录的位置，因而称为倒排索引(inverted index)，ES就是利用倒排索引，先搜索索引区域，查找到对应的docID，通过docID去数据区域查找数据。

二、安装配置

1、下载：

https://www.elastic.co/cn/products/elasticsearch
官网：快速入门，开箱即用，底层需要进行大量操作，例如分片、副本、集群发现，但是您无需考虑这些操作即可开始使用。由于 Elasticsearch 定义了合理的默认值，并且无需前期的模式定义，因此能够让您在开始时一切从简，并随着您的发展进一步微调。

推荐下载图形化插件：

elasticsearch-head-master.zip
2、Elasticsearch提供了各个操纵系统下的安装版本，并且提供了Docker安装的方式。

2.1 Docker
拉取镜像：

docker pull docker.elastic.co/elasticsearch/elasticsearch:6.6.1

启动：

docker run -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" docker.elastic.co/elasticsearch/elasticsearch:6.6.1

例如我的启动：

docker run -e ES_JAVA_OPTS="-Xms256m -Xmx256m" -d -p 9200:9200 -p 9300:9300 --name ES01 5acf0e8da90b

2.2 安装Elasticsearch（单节点Linux环境）
最好安装图形界面化插件：elasticsearch-head-master.zip，因为这是node.js编写的，所以需要Nodejs的环境（node-v6.9.2-linux-x64.tar.gz）

1）解压elasticsearch-5.2.2.tar.gz到/opt/module目录下

[xxx@hadoop102 software]$ tar -zxvf elasticsearch-5.2.2.tar.gz -C /opt/module/

2）在/opt/module/elasticsearch-5.2.2路径下创建data和logs文件夹

[xxx@hadoop102 elasticsearch-5.2.2]$ mkdir data
[xxx@hadoop102 elasticsearch-5.2.2]$ mkdir logs

3）修改配置文件/opt/module/elasticsearch-5.2.2/config/elasticsearch.yml

[xxx@hadoop102 config]$ pwd
/opt/module/elasticsearch-5.2.2/config
[xxx@hadoop102 config]$ vi elasticsearch.yml

# ---------------------------------- Cluster -----------------------------------
# 只要和其他服务器上的名字相同，就默认为集群，java操作时也会用此名字
cluster.name: my-application
# ------------------------------------ Node ------------------------------------
node.name: node-102
# ----------------------------------- Paths ------------------------------------
path.data: /opt/module/elasticsearch-5.2.2/data
path.logs: /opt/module/elasticsearch-5.2.2/logs
# ----------------------------------- Memory -----------------------------------
# 这两个必须要设置，否则启动报错
bootstrap.memory_lock: false
bootstrap.system_call_filter: false
# ---------------------------------- Network -----------------------------------
network.host: 192.168.1.102 
# --------------------------------- Discovery ----------------------------------
discovery.zen.ping.unicast.hosts: ["hadoop102"]

（1）cluster.name
如果要配置集群需要两个节点上的elasticsearch配置的cluster.name相同，都启动可以自动组成集群，这里如果不改cluster.name则默认是cluster.name=my-application，
（2）nodename随意取但是集群内的各节点不能相同
（3）修改后的每行前面不能有空格，修改后的“：”后面必须有一个空格

4）配置linux系统环境（参考：http://blog.csdn.net/satiling/article/details/59697916）
（1）切换到root用户，编辑limits.conf 添加类似如下内容
[root@hadoop102 elasticsearch-5.2.2]# vi /etc/security/limits.conf
添加如下内容:

  • soft nofile 65536
  • hard nofile 131072
  • soft nproc 2048
  • hard nproc 4096
    （2）切换到root用户，进入limits.d目录下修改配置文件。
    [root@hadoop102 elasticsearch-5.2.2]# vi /etc/security/limits.d/90-nproc.conf
    修改如下内容：
  • soft nproc 1024
    #修改为
  • soft nproc 2048
    （3）切换到root用户修改配置sysctl.conf
    [root@hadoop102 elasticsearch-5.2.2]# vi /etc/sysctl.conf
    添加下面配置：
    vm.max_map_count=655360
    并执行命令：
    [root@hadoop102 elasticsearch-5.2.2]# sysctl -p
    然后，重新启动elasticsearch，即可启动成功。

2.3 Elasticsearch head插件安装（许多坑，需要注意的点很多）

1）下载插件
https://github.com/mobz/elasticsearch-head
elasticsearch-head-master.zip

2）nodejs官网下载安装包
https://nodejs.org/dist/
node-v6.9.2-linux-x64.tar.xz

3）将elasticsearch-head-master.zip和node-v6.9.2-linux-x64.tar.xz都导入到linux的/opt/software目录。

4）安装nodejs
[xxx@hadoop102 software]$ tar -zxvf node-v6.9.2-linux-x64.tar.gz -C /opt/module/
5）配置nodejs环境变量
[root@hadoop102 software]# vi /etc/profile
export NODE_HOME=/opt/module/node-v6.9.2-linux-x64
export PATH= P A T H : PATH: PATH:NODE_HOME/bin
[root@hadoop102 software]# source /etc/profile
6）查看node和npm版本
[root@hadoop102 software]# node -v
v6.9.2
[root@hadoop102 software]# npm -v
3.10.9
7）解压head插件到/opt/module目录下
[xxx@hadoop102 software]$ unzip elasticsearch-head-master.zip -d /opt/module/
8）查看当前head插件目录下有无node_modules/grunt目录：
没有：执行命令创建：
[xxx@hadoop102 elasticsearch-head-master]$ npm install grunt --save
9）安装head插件：
[xxx@hadoop102 elasticsearch-head-master]$ npm install -g cnpm --registry=https://registry.npm.taobao.org
10）安装grunt：
[xxx@hadoop102 elasticsearch-head-master]$ npm install -g grunt-cli
11）编辑Gruntfile.js
[xxx@hadoop102 elasticsearch-head-master]$ vim Gruntfile.js
文件93行添加hostname:‘0.0.0.0’
options: {
hostname:‘0.0.0.0’,
port: 9100,
base: ‘.’,
keepalive: true
}
12）检查head根目录下是否存在base文件夹
没有：将 _site下的base文件夹及其内容复制到head根目录下
[xxx@hadoop102 elasticsearch-head-master]$ mkdir base
[xxx@hadoop102 _site]$ cp base/* …/base/
13）启动grunt server：
[xxx@hadoop102 elasticsearch-head-master]$ grunt server -d
Running “connect:server” (connect) task
[D] Task source: /opt/module/elasticsearch-head-master/node_modules/grunt-contrib-connect/tasks/connect.js
Waiting forever…
Started connect web server on http://localhost:9100

如果提示grunt的模块没有安装：
Local Npm module “grunt-contrib-clean” not found. Is it installed?
Local Npm module “grunt-contrib-concat” not found. Is it installed?
Local Npm module “grunt-contrib-watch” not found. Is it installed?
Local Npm module “grunt-contrib-connect” not found. Is it installed?
Local Npm module “grunt-contrib-copy” not found. Is it installed?
Local Npm module “grunt-contrib-jasmine” not found. Is it installed?
Warning: Task “connect:server” not found. Use –force to continue.
执行以下命令：
npm install grunt-contrib-clean -registry=https://registry.npm.taobao.org
npm install grunt-contrib-concat -registry=https://registry.npm.taobao.org
npm install grunt-contrib-watch -registry=https://registry.npm.taobao.org
npm install grunt-contrib-connect -registry=https://registry.npm.taobao.org
npm install grunt-contrib-copy -registry=https://registry.npm.taobao.org
npm install grunt-contrib-jasmine -registry=https://registry.npm.taobao.org
最后一个模块可能安装不成功，但是不影响使用。
14）浏览器访问head插件：
http://ES-01:9100

15）启动集群插件后发现集群未连接
在/opt/module/elasticsearch-5.2.2/config路径下修改配置文件elasticsearch.yml，在文件末尾增加
[XXX@hadoop102 config]$ pwd
/opt/module/elasticsearch-5.2.2/config
[XXX@hadoop102 config]$ vi elasticsearch.yml

http.cors.enabled: true
http.cors.allow-origin: “*”
再重新启动elasticsearch。

16）关闭插件服务
ctrl+c
[XXX@hadoop102 elasticsearch-head-master]$ netstat -lntp | grep 9100
tcp 0 0 192.168.1.102:9100 0.0.0.0:* LISTEN 6070/grunt

三、Java API调用

Elasticsearch的Java客户端非常强大；它可以建立一个嵌入式实例并在必要时运行管理任务。
运行一个Java应用程序和Elasticsearch时，有两种操作模式可供使用。该应用程序可在Elasticsearch集群中扮演更加主动或更加被动的角色。在更加主动的情况下（称为Node Client），应用程序实例将从集群接收请求，确定哪个节点应处理该请求，就像正常节点所做的一样。（应用程序甚至可以托管索引和处理请求。）另一种模式称为Transport Client，它将所有请求都转发到另一个Elasticsearch节点，由后者来确定最终目标。

3.1 API基本操作（Eclipse）

新建Maven工程：

<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.elasticsearch</groupId>
			<artifactId>elasticsearch</artifactId>
			<version>5.2.2</version>
		</dependency>

		<dependency>
			<groupId>org.elasticsearch.client</groupId>
			<artifactId>transport</artifactId>
			<version>5.2.2</version>
		</dependency>

		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-core</artifactId>
			<version>2.9.0</version>
		</dependency>
	</dependencies>

一定要注意导入的版本与实际连接的ElasticSearch是否匹配，否则会报错！

3.2 获取Transport Client

ElasticSearch服务默认端口9300。Web管理平台端口9200

获取连接客户端：

private TransportClient client;

	@Before
	public void getClient() throws Exception {

		// 1 设置连接的集群名称
		Settings settings = Settings.builder().put("cluster.name", "my-application").build();

		// 2 连接集群
		client = new PreBuiltTransportClient(settings);
		client.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("ES01"), 9300));

		// 3 打印集群名称
		System.out.println(client.toString());
	}
3.3 操作索引

创建索引：

	@Test
	public void createIndex_blog(){
		// 1 创建索引
		client.admin().indices().prepareCreate("news").get();
		
		// 2 关闭连接
		client.close();
	}

删除索引：

	@Test
	public void deleteIndex(){
		// 1 删除索引
		client.admin().indices().prepareDelete("blog2").get();
		
		// 2 关闭连接
		client.close();
	}
3.4 新建文档：有三种常用的方式——Json String 、Map方式、ES构建器。

注意：当直接在ElasticSearch建立文档对象时，如果索引不存在的，默认会自动创建，映射采用默认方式。

Json String方式：

	@Test
	public void createIndexByJson() throws UnknownHostException {

		// 1 文档数据准备
		String json = "{" + "\"id\":\"1\"," + "\"title\":\"你好！\","
				+ "\"content\":\"进入ES的世界了！\"" + "}";

		// 2 创建文档
		IndexResponse indexResponse = client.prepareIndex("blog", "article", "1").setSource(json).execute().actionGet();

		// 3 打印返回的结果
		System.out.println("index:" + indexResponse.getIndex());
		System.out.println("type:" + indexResponse.getType());
		System.out.println("id:" + indexResponse.getId());
		System.out.println("version:" + indexResponse.getVersion());
		System.out.println("result:" + indexResponse.getResult());

		// 4 关闭连接
		client.close();
	}

Map方式：

@Test
	public void createIndexByMap() {

		// 1 文档数据准备
		Map<String, Object> json = new HashMap<String, Object>();
		json.put("id", "2");
		json.put("title", "底层调用了Lucene");
		json.put("content", "这是一个基于RESTful web接口的框架");

		// 2 创建文档
		IndexResponse indexResponse = client.prepareIndex("blog", "article", "2").setSource(json).execute().actionGet();

		// 3 打印返回的结果
		System.out.println("index:" + indexResponse.getIndex());
		System.out.println("type:" + indexResponse.getType());
		System.out.println("id:" + indexResponse.getId());
		System.out.println("version:" + indexResponse.getVersion());
		System.out.println("result:" + indexResponse.getResult());

		// 4 关闭连接
		client.close();
	}

ES构建器：

@Test
	public void createIndex() throws Exception {

		// 1 通过es自带的帮助类，构建json数据
		XContentBuilder builder = XContentFactory.jsonBuilder().startObject().field("id", 3)
				.field("title", "基于Lucene的搜索服务器").field("content", "它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。")
				.endObject();

		// 2 创建文档
		IndexResponse indexResponse = client.prepareIndex("blog", "article", "3").setSource(builder).get();

		// 3 打印返回的结果
		System.out.println("index:" + indexResponse.getIndex());
		System.out.println("type:" + indexResponse.getType());
		System.out.println("id:" + indexResponse.getId());
		System.out.println("version:" + indexResponse.getVersion());
		System.out.println("result:" + indexResponse.getResult());

		// 4 关闭连接
		client.close();
	}
3.5 搜索文档
	@Test	// 单个索引
	public void getData() throws Exception {
		
		// 1 查询文档
		GetResponse response = client.prepareGet("blog", "article", "1").get();
		
		// 2 打印搜索的结果
		System.out.println(response.getSourceAsString());
		
		// 3 关闭连接
		client.close();
	}


@Test	// 多个索引
	public void getMultiData() {
		
		// 1 查询多个文档
		MultiGetResponse response = client.prepareMultiGet().add("blog", "article", "1").add("blog", "article", "2", "3")
				.add("blog", "article", "2").get();
		
		// 2 遍历返回的结果
		for(MultiGetItemResponse itemResponse:response){
			GetResponse getResponse = itemResponse.getResponse();
			
			// 如果获取到查询结果
			if (getResponse.isExists()) {
				String sourceAsString = getResponse.getSourceAsString();
				System.out.println(sourceAsString);
			}
		}
		
		// 3 关闭资源
		client.close();
	}
3.6 更新文档数据——update、upsert

update

@Test
	public void updateData() throws Throwable {

		// 1 创建更新数据的请求对象
		UpdateRequest updateRequest = new UpdateRequest();
		updateRequest.index("blog");
		updateRequest.type("article");
		updateRequest.id("3");

		updateRequest.doc(XContentFactory.jsonBuilder().startObject()
				// 对没有的字段添加, 对已有的字段替换
				.field("title", "基于Lucene的搜索服务器")
				.field("content",
						"它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。大数据前景无限")
				.field("createDate", "2017-8-22").endObject());

		// 2 获取更新后的值
		UpdateResponse indexResponse = client.update(updateRequest).get();
		
		// 3 打印返回的结果
		System.out.println("index:" + indexResponse.getIndex());
		System.out.println("type:" + indexResponse.getType());
		System.out.println("id:" + indexResponse.getId());
		System.out.println("version:" + indexResponse.getVersion());
		System.out.println("create:" + indexResponse.getResult());

		// 4 关闭连接
		client.close();
	}

upsert

@Test
	public void testUpsert() throws Exception {

		// 设置查询条件, 查找不到则添加
		IndexRequest indexRequest = new IndexRequest("blog", "article", "5")
				.source(XContentFactory.jsonBuilder().startObject().field("title", "搜索服务器").field("content","它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。").endObject());
		
		// 设置更新, 查找到更新下面的设置
		UpdateRequest upsert = new UpdateRequest("blog", "article", "5")
				.doc(XContentFactory.jsonBuilder().startObject().field("user", "李四").endObject()).upsert(indexRequest);

		client.update(upsert).get();
		client.close();
	}
3.7 删除文档数据（prepareDelete）
	@Test
	public void deleteData() {
		
		// 1 删除文档数据
		DeleteResponse indexResponse = client.prepareDelete("blog", "article", "5").get();

		// 2 打印返回的结果
		System.out.println("index:" + indexResponse.getIndex());
		System.out.println("type:" + indexResponse.getType());
		System.out.println("id:" + indexResponse.getId());
		System.out.println("version:" + indexResponse.getVersion());
		System.out.println("found:" + indexResponse.getResult());

		// 3 关闭连接
		client.close();
	}
3.8 条件查询：查询所有、对所有字段分词查询、通配符查询、词条查询、模糊查询。

查询所有

@Test
	public void matchAllQuery() {
		
		// 1 执行查询
		SearchResponse searchResponse = client.prepareSearch("blog").setTypes("article")
				.setQuery(QueryBuilders.matchAllQuery()).get();

		// 2 打印查询结果
		SearchHits hits = searchResponse.getHits(); // 获取命中次数，查询结果有多少对象
		System.out.println("查询结果有：" + hits.getTotalHits() + "条");

		Iterator<SearchHit> iterator = hits.iterator();

		while (iterator.hasNext()) {
			SearchHit searchHit = iterator.next(); // 每个查询对象

			System.out.println(searchHit.getSourceAsString()); // 获取字符串格式打印
		}

		// 3 关闭连接
		client.close();
	}

对所有字段分词查询

@Test
	public void query() {
		// 1 条件查询
		SearchResponse searchResponse = client.prepareSearch("blog").setTypes("article")
				.setQuery(QueryBuilders.queryStringQuery("全文")).get();

		// 2 打印查询结果
		SearchHits hits = searchResponse.getHits(); // 获取命中次数，查询结果有多少对象
		System.out.println("查询结果有：" + hits.getTotalHits() + "条");
		
		Iterator<SearchHit> iterator = hits.iterator();
		
		while (iterator.hasNext()) {
			SearchHit searchHit = iterator.next(); // 每个查询对象
			
			System.out.println(searchHit.getSourceAsString()); // 获取字符串格式打印
		}
		
		// 3 关闭连接
		client.close();
	}

通配符查询（wildcardQuery）
*：表示多个字符（任意的字符）
？：表示单个字符

@Test
	public void wildcardQuery() {

		// 1 通配符查询
		SearchResponse searchResponse = client.prepareSearch("blog").setTypes("article")
				.setQuery(QueryBuilders.wildcardQuery("content", "*全*")).get();

		// 2 打印查询结果
		SearchHits hits = searchResponse.getHits(); // 获取命中次数，查询结果有多少对象
		System.out.println("查询结果有：" + hits.getTotalHits() + "条");

		Iterator<SearchHit> iterator = hits.iterator();

		while (iterator.hasNext()) {
			SearchHit searchHit = iterator.next(); // 每个查询对象

			System.out.println(searchHit.getSourceAsString()); // 获取字符串格式打印
		}

		// 3 关闭连接
		client.close();
	}

词条查询（TermQuery）

@Test
	public void termQuery() {
		
		// 1 第一field查询
		SearchResponse searchResponse = client.prepareSearch("blog").setTypes("article")
				.setQuery(QueryBuilders.termQuery("content", "全")).get();
		
		// 2 打印查询结果
		SearchHits hits = searchResponse.getHits(); // 获取命中次数，查询结果有多少对象
		System.out.println("查询结果有：" + hits.getTotalHits() + "条");

		Iterator<SearchHit> iterator = hits.iterator();

		while (iterator.hasNext()) {
			SearchHit searchHit = iterator.next(); // 每个查询对象

			System.out.println(searchHit.getSourceAsString()); // 获取字符串格式打印
		}

		// 3 关闭连接
		client.close();
	}

模糊查询（fuzzy）

@Test
	public void fuzzy() {
		
		// 1 模糊查询
		SearchResponse searchResponse = client.prepareSearch("blog").setTypes("article")
				.setQuery(QueryBuilders.fuzzyQuery("title", "lucene")).get();
		
		// 2 打印查询结果
		SearchHits hits = searchResponse.getHits(); // 获取命中次数，查询结果有多少对象
		System.out.println("查询结果有：" + hits.getTotalHits() + "条");

		Iterator<SearchHit> iterator = hits.iterator();

		while (iterator.hasNext()) {
			SearchHit searchHit = iterator.next(); // 每个查询对象

			System.out.println(searchHit.getSourceAsString()); // 获取字符串格式打印
		}

		// 3 关闭连接
		client.close();
	}
3.9 映射相关操作
@Test
	public void createMapping() throws Exception {
		
		// 1设置mapping
		XContentBuilder builder = XContentFactory.jsonBuilder()
				.startObject()
					.startObject("article")
						.startObject("properties")
							.startObject("id1")
								.field("type", "string")
								.field("store", "yes")
							.endObject()
							.startObject("title2")
								.field("type", "string")
								.field("store", "no")
							.endObject()
							.startObject("content")
								.field("type", "string")
								.field("store", "yes")
							.endObject()
						.endObject()
					.endObject()
				.endObject();

		// 2 添加mapping
		PutMappingRequest mapping = Requests.putMappingRequest("blog4").type("article").source(builder);
		
		client.admin().indices().putMapping(mapping).get();
		
		// 3 关闭资源
		client.close();
	}

四、ElasticSearch与Spring Boot整合

SpringBoot默认支持两种技术来和ES交互：

1）Jest(默认是不生效的，如果想让其生效，必须导入jest的工具包：import io.searchbox.client.JestClient;)

2）SpringData ElasticSearch

  • 类ElasticsearchAutoConfiguration，自动帮我们配置了客户端类Client，在这里面需要配置节点信息clusterNodes和clusterName。
  • 类ElasticsearchDataAutoConfiguration，自动帮我们配置了让我们来操作ES的ElasticsearchTemplate。
  • 编写一个ElasticsearchRepository的子接口来操作ES

在这里插入图片描述

4.1 利用Jest操作ElasticSearch

在pom中移除spring-boot-starter-data-elasticsearch

在pom中导入jest的依赖

访问http://172.22.34.28:9200/时的返回信息中有响应的版本信息，如下：
后来我又搭建了一台ElasticSearch Server，用的版本比较新：5.6.12.

{
  "name" : "725ijsI",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "IwPHG-JtT6Wd7SXCE1L96g",
  "version" : {
    "number" : "5.6.12",
    "build_hash" : "cfe3d9f",
    "build_date" : "2018-09-10T20:12:43.732Z",
    "build_snapshot" : false,
    "lucene_version" : "6.6.1"
  },
  "tagline" : "You Know, for Search"
}

我们看到是5.6.12版本，所以，在引入依赖时也要用相应大版本号的：

<!-- https://mvnrepository.com/artifact/io.searchbox/jest -->
<dependency>
   <groupId>io.searchbox</groupId>
   <artifactId>jest</artifactId>
   <version>5.3.4</version>
</dependency>

我的测试程序：

@Autowired
JestClient jestClient;

// 给ES中索引(保存)一个文档
@Test
public void testSaveToES() throws IOException {
   Article article = new Article(001, "胡秀韬","Good News","今天看了一部好电影。");
   // 新建构建器
   Index.Builder builder = new Index.Builder(article);
   // 指定索引（保存）到的地方
   builder.index("mytest");
   // 指定保存的类型
   builder.type("news");
   // 指定保存的id，因为article对象中有ID，此处可以省略
   builder.id(String.valueOf(article.getId()));
   // 将信息设置好之后，进行构建
   Index index = builder.build();
   // 上面的index就构建了一个索引功能
   // 利用jestClient开始执行
   jestClient.execute(index);
}

执行后可在页面上查看是否成功：
在这里插入图片描述
测试搜索：

// 测试搜索
@Test
public void searchES() {
   // Elasticsearch提供丰富且灵活的查询语言叫做DSL查询(Query DSL),
   // 它允许你构建更加复杂、强大的查询。
   // DSL(Domain Specific Language特定领域语言)以JSON请求体的形式出现
   // 定义查询表达式
   String json = "{\n" +
         "\"query\" : {\n" +
         "\"match\" : {\n" +
         "\"content\" : \"电影\"\n" +
         "}\n" +
         "}\n" +
         "}";
   // 创建构建器
   Search.Builder builder = new Search.Builder(json);
   // 指定在哪个索引下搜索
   builder.addIndex("mytest");
   // 指定在哪个类型下搜索
   builder.addType("news");
   // 构建搜索操作功能
   Search search = builder.build();
   // 利用jestClient执行
   try {
      SearchResult result = jestClient.execute(search);
      // result中可以拿到许多信息
      System.out.println(result.getJsonString());
   } catch (IOException e) {
      e.printStackTrace();
   }
}

控制台输出：

{
	"took": 165,
	"timed_out": false,
	"_shards": {
		"total": 5,
		"successful": 5,
		"skipped": 0,
		"failed": 0
	},
	"hits": {
		"total": 1,
		"max_score": 0.5446649,
		"hits": [{
			"_index": "mytest",
			"_type": "news",
			"_id": "1",
			"_score": 0.5446649,
			"_source": {
				"id": 1,
				"author": "胡秀韬",
				"title": "Good News",
				"content": "今天看了一部好电影。"
			}
		}]
	}
}
2、引入spring-boot-starter-data-elasticsearch
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

关于版本问题：

https://spring.io/projects/spring-data官网中查看：Community modules模块下的Spring Data Elasticsearch - Spring Data module for Elasticsearch.打开Spring Data Elasticsearch连接后，打开"Learn"后，再打开最新版本的Reference Doc，从中找到Project Metadata:

Version Control - https://github.com/spring-projects/spring-data-elasticsearch

在这里插入图片描述
一般更换ES的版本。（本例使用2.4.6）
在这里插入图片描述
在application.properties中配置：

spring.data.elasticsearch.cluster-name=elasticsearch
spring.data.elasticsearch.cluster-nodes=172.22.34.28:9301

https://github.com/spring-projects/spring-data-elasticsearch该页面中也有相应的使用方法：有两种：编写一个ElasticsearchRepository和使用ElasticsearchTemplate。

第一种方法：ElasticsearchRepository

定义Book实体：

// 一定要注明索引和type
@Document(indexName = "mytest", type = "book")
public class Book {
    private Integer id;
    private String bookName;
    private String author;
  	// constructor
  	// Getter Setter方法
}

自定义repository接口，并继承ElasticsearchRepository

public interface BookRepository extends ElasticsearchRepository<Book, Integer> {
    // 支持自定义方法
    // 具体使用和更多的使用方法参照：https://docs.spring.io/spring-data/elasticsearch/docs/3.1.3.RELEASE/api/
    public List<Book> findByBookNameLike(String bookName);
}

在这里插入图片描述

@Test
public void testElasticsearchRepository() {
   Book book = new Book(001, "《红楼梦》", "曹雪芹");
   // 保存
   bookRepository.index(book);
   // 模糊查询
   List<Book> result = bookRepository.findByBookNameLike("红");
   for (Book book1 : result) {
      System.out.println(book1);
   }
}
Spring Boot整合Elasticsearch，最新最全教程
Cloud-Future的博客
12-21 9万+
要想快速入门新技术，英文文档的阅读能力必不可少。本篇文章主要参考《Spring Data Elasticsearch》Spring Boot整合Elasticsearch的官方文档。 Elasticsearch官网参考文档：https://www.elastic.co/guide/index.html Elasticsearch官方下载地址：https://www.elastic.co/cn/downloads/elasticsearch Elasticsearch目前最近版本为:7.10.1 最近系统.
Spring整合ElasticSearch
码农的在线笔记
03-22 1506
ES集群： ES为Java内置了两套客户端（通过9300端口通信） ps：其他语言使用9200端口与ES通信 集群状态 结构化语句： 项目 结构化查询（Query DSL） 结构化过滤（Filter DSL） 目的 询问每个文档目标字段的值与目标值的匹配程度如何 检查是否包含特定值 适用范围 全文本搜索，相关性评分 剩下的所有 性能 因为需要计算相关性，耗时，且不可缓...
ElasticSearch与spring boot的集成使用
weixin_33861800的博客
05-07 334
2019独角兽企业重金招聘Python工程师标准>>> ...
Elasticsearch(看这一篇就够了)
最新发布
m0_74436895的博客
10-10 1498
Elasticsearch是一个全文检索服务器全文检索是一种非结构化数据的搜索方式结构化数据：指具有固定格式固定长度的数据，如数据库中的字段。非结构化数据：指格式和长度不固定的数据，如电商网站的商品详情。结构化数据一般存入数据库，使用sql语句即可快速查询。但由于非结构化数据的数据量大且格式不固定，我们需要采用全文检索的方式进行搜索。全文检索通过建立倒排索引加快搜索效率。真实开发中我们往往需要对一段内容既进行文字分词，又进行拼音分词，此时我们需要自定义ik+pinyin分词器。创建自定义分词器。
SpringBoot 2.6.3 + ElasticSearch7.12.1 - SpringData 开发指南
CYK_byte的博客
04-02 1929
这个东西就跟 JPA 的使用方式一样，只不过高版本的 SpringData Elasticsearch 没有给 ElasticsearchRepository 接口提供复杂搜索查询，建议还是使用 ElasticsearchTemplate。
Elasticsearch结合spring的使用
IT夜幕的博客
01-23 2025
spring中使用ES
7 SpringBoot与Elasticsearch
m0_62520968的博客
09-09 778
Elaticsearch简称为es,是⼀个开源的可扩展的分布式全⽂检索引擎服务器，它可以近乎实时的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据。es使⽤Java开发并使⽤Lucene作为其核⼼来实现索引和搜索的功能，它通过简单的RestfulAPI和javaAPI来隐藏Lucene的复杂性，从⽽让全⽂搜索变得简单。Elasticsearch官⽹：https://www.elastic.co/cn/products/elasticsearch。
Spring Boot整合ElasticSearch实现多版本兼容的方法详解
08-27
总之，Spring Boot整合Elasticsearch是一个相对简单的过程，主要涉及添加依赖、配置属性以及定义实体和仓库接口。理解版本兼容性是关键，以确保你的应用能够顺利运行在不同版本的Elasticsearch之上。在实际开发中，...
Spring Boot整合Elasticsearch实现全文搜索引擎案例解析
08-28
在本案例中，我们将探讨如何使用Spring Boot与Elasticsearch进行整合，构建一个全文搜索引擎。首先，理解Elasticsearch的基本概念至关重要。Elasticsearch是一个基于Lucene的开源、分布式、实时的搜索和分析引擎，...
SpringBoot整合Spring Data Elasticsearch的过程详解
08-25
SpringBoot整合Spring Data Elasticsearch是将SpringBoot框架与Elasticsearch搜索引擎进行整合，以实现数据的搜索和索引功能。下面将详细介绍SpringBoot整合Spring Data Elasticsearch的过程详解。 1. 添加依赖项 ...
es(elasticsearch)整合SpringCloud（SpringBoot）搭建教程详解
08-19
在本教程中，我们将探讨如何将Elasticsearch与SpringBoot和SpringCloud进行集成，以便在微服务架构中利用Elasticsearch强大的搜索和分析能力。Elasticsearch是一个分布式、RESTful风格的搜索和数据分析引擎，而...
elasticsearch spring 集成
12-14
elasticsearch spring 集成,用到maven elasticsearch服务下载包括其中插件和分词，可以简单参考下
elasticsearch基于java(springboot)
m0_68907326的博客
08-14 601
在kibana中操作elaticsearch
Springboot--ElasticSearch入门及整合
sout
11-27 260
一、ElasticSearch简介 我们的应用经常需要添加检索功能，开源的 ElasticSearch 是目前全文搜索引擎的首选。他可以快速的存储、搜索和分析海量数据。Spring Boot通过整合Spring Data ElasticSearch为我们提供了非常便捷的检索功能支持； Elasticsearch是一个分布式搜索服务，提供Restful API，底层基于Lucene，采用多sha...
Elasticsearch-SpringBoot整合Elasticsearch
XiangYida
05-06 804
SpringBoot整合Elasticsearch Elasticsearch的Java客户端有好几个。具体可以看 这篇博客: Elasticsearch的Java客户端 先说整合流程，注意，我这里使用的es是6.1.4版本SpringBoot是2.1.4.RELEASE 版本不一致可能导致出错！！！。 这里是个大坑 这里我采用的是启动器整合 1 添加启动器 <dependency>...
elasticsearch - java - elasticsearch对接spring boot
我的博客
01-17 1403
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程 文章目录elasticsearch对接spring boot本栏目使用的版本信息MVN依赖application.yml配置配置代码测试代码测试 elasticsearch对接spring boot spring boot与elasticsearch版本之间的对应关系 本栏目使用的版本信息 版本信息如下 条目 版本 elasticsearch 7.16.2 spring boot 2.6.2 .
springboot与elasticsearch
chuanyuan8669的博客
07-27 156
最近看了下elasticsearch相关的知识，对其使用有了个大概的了解，于是准备试着与springboot整合看下，在网上搜索了很多文章，但是真的按着坐下来发现成功的没几个，最后发现主要的问题还是出在版本上，由于现在es版本和springboot版本都有很多，但是很多人都只写了示例，而没有介...
基于SpringBoot的ElasticSearch操作（超详细教程）
Coder
10-05 5731
基于SpringBoot+Elasticsearch的操作项目， 从零到一，囊括了es本身的API操作、java代码的请求 （索引操作、doc操作插入、精准搜索、模糊搜索、聚合搜索等）
ElasticSearch 在 Spring 项目中的实践
JavaShark的博客
06-21 507
ElasticSearch简称es，是一个开源的高扩展的分布式全文检索引擎。它可以近乎实时的存储、检索数据，其扩展性很好，ElasticSearch是企业级应用中较为常见的技术。下面和大家分享 ElasticSearch 集成在Spring Boot 项目的一些学习心得。1.1基本认识ElasticSearch 是基于 Lucene 实现的开源、分布式、RESTful接口的全文搜索引擎。Elasticsearch 还是一个分布式文档数据库，其中每个字段均是被索引的数据且可被搜索，它能够扩展至数以百计的服务器
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值