ElasticSearch学习总结(基础篇,可学习,可复习)

最近一周都在学习ElasticSearch,之前也零零散散的学过一点,这次下定决心花一周的时间将之前学的知识总结一下,顺便接着再往下学习,所以写篇博客总结一下最近一周的成果,本篇属于ElasticSearch的基础篇,后面会继续深入学习。也希望这篇拙作可以帮助到诸位大佬,如有不足之处,还望诸佬不吝赐教,倾囊相授。
ElasticSearch学习总结(基础篇,可学习,可复习)_第1张图片

ElasticSearch学习总结

      • ElasticSearch概述
      • ES和Solr的差别
        • ElasticSearch简介
        • Solr简介
      • ElasticSearch安装
      • ES核心概念
        • IK分词器
        • Rest风格说明
        • 关于文档的基本操作(重点)
        • 集成SpringBoot
      • 实战案例

ElasticSearch概述

ElasticSearch、简称ES,ES是一个开源的高扩展分布式全文检索引擎,它可以近乎实时的存储,检索数据;本身扩展性很好,可以扩展到上百台服务器,处理PB级别(大数据时代)的数据,ES也使用Java开发使用Lucene作为其核心来实现所有索引和搜索的功能,但是他的目的是通过简单的RestFul API来隐藏Lucene的复杂性,从而让全文搜索变得简单。

ElasticSearch学习总结(基础篇,可学习,可复习)_第2张图片

ES和Solr的差别


ElasticSearch简介

ElasticSearch是一个实时分布式搜索和分析引擎,它让你以前所未有的速度处理大数据成为可能

它用于全文搜索、结构化、分析以及将这三者混合使用

维基百科使用ElasticSearch提供全文搜索并高亮关键字,以及输入实时搜索(search-asyou-type)和搜索纠错等搜索建议功能……

ElasticSearch是一个基于Apache Lucene的开源搜索引擎,无论在开源还是专有领域,Lucene可以被认为是迄今为止最先进,性能最好的,功能最全的搜索引擎库

但是,Lucene只是一个库,想要使用它,你必须使用java来作为开发语言并将其直接集成到你的应用中,更糟糕的是,Lucene非常复杂,你需要深入了解检索的相关知识来理解它是如何工作的

ElasticSearch也使用java开发并使用Lucene作为其核心来实现所有索引和搜索功能,但是它的目的是通过简单的RESTful API来隐藏Lucene的复杂性,从而让全文搜索变得简单!

Solr简介

Solr是Apache下的一个顶级开源项目,采用Java开发,它是基于Lucene的全文搜索服务器,Solr提供了比Lucene更为丰富的查询语言,同时实现了可配置、可扩展、并对索引、搜索性能进行了优化!

Solr可以独立运行,运行在Jetty、Tomcat等这些Servlet容器中,Solr索引的实现方法很简单,==用POST方法向Solr服务器发送一个描述Field及其内容的XML文档,Solr根据xml文档添加,删除,更新索引,==Solr搜索只需要发送HTTP GET请求,然后对Solr返回xml、json等格式的查询结果进行解析,组织页面布局,Solr不提供构建UI的功能,Solr提供了一个管理界面,通过管理界面可以查询Solr的配置和运行情况。

Solr是基于Lucene开发企业级搜索服务器,实际上就是封装Lucene

Solr是一个独立的企业级搜索应用服务器,它对外提供类似与web-service的API接口,用户可以通过http请求,向搜索引擎服务器提交一定格式的文件,生成索引,也可以通过提交查找请求,并得到返回结果!

ElasticSearch 和 Solr

  • 当单纯的对已有数据进行搜索时,Solr更快!
  • 当实时建立索引时,Solr会产生IO阻塞,查询性能较差,ElasticSearch具有明显的优势
  • 随着数据量的增加,Solr的搜索效率会变得更低,而ElasticSearch却没有明显的的变化

ElasticSearch学习总结(基础篇,可学习,可复习)_第3张图片

ElasticSearch vs Solr

  1. ES基本是开箱即用(解压就可以用),非常简单,Solr安装稍微复杂一点
  2. Solr利用Zookeeper进行分布式管理。而ElasticSearch自身带有分布式协调管理功能
  3. Solr支持更多格式的数据,比如JSON、XML、CSV,而ElasticSearch仅支持json文件格式
  4. Solr官方提供的功能更多,而ElasticSearch本身更注重核心功能,高级功能多有第三方插件提供,例如,图形化界面,Kibana友好支撑
  5. Solr查询快,但更新索引时慢(即插入删除慢),用于电商等查询多的应用;
    • ES建立索引快(即查询慢),即实时性查询快,用于facebook新浪等搜索
    • Solr是传统搜索应用的有利解决方案,但ElasticSearch更适用于新兴的实时搜索应用

​ 6.Solr比较成熟,有一个更大,更成熟的用户,开发和贡献者社区,而ElasticSearch相对开发维护者少,更新太快,学习成本较高

ElasticSearch安装

Java开发,ElasticSearch的版本和我们之后对应的java的核心jar包,版本对应,java环境正常!

ElasticSearch学习总结(基础篇,可学习,可复习)_第4张图片

2、熟悉目录

bin  启动文件
config 配置文件
	log4j2 日志配置文件
	jvm.options java虚拟机相关的配置
	ElasticSearch ElasticSearch配置文件  默认端口9200  !跨域

lib 相关jar包
modules 功能模块
plugins 插件

3、启动 ,访问9200 elasticsearch.bat

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hvjH7edi-1651155173755)(/Users/wumao/Documents/Typora笔记/typora-user-images\image-20210713144003204.png)]

4、访问测试

ElasticSearch学习总结(基础篇,可学习,可复习)_第5张图片

安装可视化界面 es head的插件

1、下载地址https://github.com/mobz/elasticsearch-head

2、启动

npm install 安装依赖
npm run start 启动

3、连接测试发现,存在跨域问题:配置es

http.cors.enabled: true
http.cors.allow-origin: "*"

4、重启es ,再次连接

ElasticSearch学习总结(基础篇,可学习,可复习)_第6张图片

初学,可以把es当做一个数据库!(可以建立索引(库),文档(库中的数据))

这个head我们就把它当做数据展示工具!我们后面所有的查询,Kibana

ElasticSearch学习总结(基础篇,可学习,可复习)_第7张图片

ElasticSearch学习总结(基础篇,可学习,可复习)_第8张图片

安装Kibana

Kibana是一个针对ElasticSearch的开源分析及可视化平台,用来搜索,查看交互存储在ElasticSearch索引中的数据,使用Kibana,可以通过各种图表进行高级数据分析及展示,Kibana让海量数据更容易理解,基于浏览器的用户界面可以快速创建仪表板实时显示ElasticSearch查询动态,设置Kibana非常简单,无序编码或者额外的基础架构,几分钟内就可以完成Kibana安装并启动ElasticSearch索引检测。

官网:https://www.elastic.co/cn/kibana

Kibana版本要和ES版本一致

启动测试

1、目录结构

ElasticSearch学习总结(基础篇,可学习,可复习)_第9张图片

2、启动

ElasticSearch学习总结(基础篇,可学习,可复习)_第10张图片

3、开发工具!(POST、curl、head、谷歌浏览器插件)

ElasticSearch学习总结(基础篇,可学习,可复习)_第11张图片

之后的所有的操作都在这里编写

4、汉化!自己修改Kibana.yml ! zh-CN

ElasticSearch学习总结(基础篇,可学习,可复习)_第12张图片

ElasticSearch学习总结(基础篇,可学习,可复习)_第13张图片

ES核心概念

概述

集群、节点、索引、类型、文档、分片、映射是什么?

elasticSearch是面向文档,关系型数据库 和 ElasticSearch 客观的对比!一切都是JSON

Relational DB ElasticSearch
数据库(database) 索引(indices)
表(tables) types
行(rows) documents
字段(columns) fields

elasticsearch(集群)中可以包含多个索引(数据库),每个索引中可以包含多个类型(表),每个类型下又包含多个文档(行),每个文档重女又包含多个字段(列)

物理设计:

ElasticSearch在后台把每个索引划分为多个分片,每分分片可以在集群中的不同服务器间迁移

逻辑设计:

一个索引类型中,包含多个文档,比如说文档1,文档2,当我们索引一篇文档时,可以通过这样的一个顺序找到它:索引–>类型–>文档ID。通过这个组合我们就能索引到某个具体的文档,注意:ID不必是整数,实际上它是个字符串

文档

之前说ElasticSearch是面向文档的,那么就意味着索引和搜索数据的最小单位是文档,ElasticSearch,文档有几个重要属性:

  • 自我包含,一篇文档同时包含字段和对应的值,也就是同时包含key:value
  • 可以是层次型的,一个文档中包含自文档,复杂的逻辑实体就是这么来的
  • 灵活的结构,文档不依赖预先定义的模式,我们知道关系型数据库中,要提前定义字段才能使用,在ElasticSearch中,对于字段是非常灵活的,有时候,我们可以忽略改字段,或者动态的添加一个新的字段
  • 尽管我们可以随意的新增或者忽略某个字段,但是,每个字段的类型非常重要,比如一个年龄字段类型,可以是字符串也可以是整型,因为ElasticSearch会保存字段和类型之间的映射及其他的设置,这种映射具体到每个映射的每种类型,这也是为什么在ElasticSearch中,类型有时候也称为映射类型。

类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3MDMRSIJ-1651155173758)(/Users/wumao/Documents/Typora笔记/typora-user-images\image-20210713161855351.png)]

索引(就是一个数据库)

ElasticSearch学习总结(基础篇,可学习,可复习)_第14张图片

ElasticSearch学习总结(基础篇,可学习,可复习)_第15张图片

倒排索引

ElasticSearch学习总结(基础篇,可学习,可复习)_第16张图片

ElasticSearch学习总结(基础篇,可学习,可复习)_第17张图片

ElasticSearch学习总结(基础篇,可学习,可复习)_第18张图片

ElasticSearch学习总结(基础篇,可学习,可复习)_第19张图片

IK分词器

什么是IK分词器

分词:即把一段中文或者别的划分成一个个的关键字,我们把搜索时会把自己的信息进行分词,会把数据库中或索引库中的数据进行分词,然后进行一个匹配操作,默认的中文分词是将每个字看成一个词。比如:“我爱狂神”会被分为:”我“,”爱“,”狂“,”神“,这显然是不符合要求的,所以我们需要安装中文分词器IK来解决这个问题

IK提供了两个分词算法:ik_smart和ik_max_word,其中ik_smart为最少切分,ik_max_word为最细粒度划分

下载安装

1、https://github.com/medcl/elasticsearch-analysis-ik

2、下载完毕之后,直接放在ElasticSearch插件中即可!

3、重启ElasticSearch

测试分词器效果

ik__smart

ElasticSearch学习总结(基础篇,可学习,可复习)_第20张图片

ik_max_word

ElasticSearch学习总结(基础篇,可学习,可复习)_第21张图片

ik分词器增加自己的配置!

ElasticSearch学习总结(基础篇,可学习,可复习)_第22张图片

保存后重启ES!

ElasticSearch学习总结(基础篇,可学习,可复习)_第23张图片

Rest风格说明

一种软件架构风格,而不是标准,只是提供了一组设计原则和约束条件,它主要用于客户端和服务端交互类的软件,基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。

基本的Rest命令说明:

method url地址 描述
PUT localhost:9200/索引名称/类型名称/文档id 创建文档(指定文档id)
POST localhost:9200/索引名称/类型名称 创建文档(随机文档id)
POST localhost:9200/索引名称/类型名称/文档id/_update 修改文档
DELETE localhost:9200/索引名称/类型名称/文档id 删除文档
GET localhost:9200/索引名称/类型名称/文档id 查询文档通过文档id
POST localhost:9200/索引名称/类型名称/_search 查询所有数据

基础测试

1、创建一个索引

PUT /索引名/类型名/文档id
{请求体}

2、向索引中PUT值

ElasticSearch学习总结(基础篇,可学习,可复习)_第24张图片

ElasticSearch学习总结(基础篇,可学习,可复习)_第25张图片

3、name这个字段用不用指定类型呢,毕竟我们关系型数据库,是需要指定类型的

  • 字符串类型

    text 、keyword

  • 数值类型

    long、integer、short、byte、double、float、half、float、scaled

  • 日期类型

    date

  • te布尔值类型

    boolean

  • 二进制类型

    binary

  • 等等……

4、指定字段的类型(创建规则)

ElasticSearch学习总结(基础篇,可学习,可复习)_第26张图片

获取规则,可以通过get请求获取具体的信息

GET test2

测试

ElasticSearch学习总结(基础篇,可学习,可复习)_第27张图片

如果自己的文档字段没有自定,那么es会给我们配置默认字段类型!

扩展:通过命令ElasticSearch索引情况! 通过get _cat/ 可以获得ElasticSearch的很多信息

ElasticSearch学习总结(基础篇,可学习,可复习)_第28张图片

修改索引 提交还是使用PUT

曾经的方法:

ElasticSearch学习总结(基础篇,可学习,可复习)_第29张图片

最新办法

ElasticSearch学习总结(基础篇,可学习,可复习)_第30张图片

删除索引 通过DELETE命令实现删除,根据你的请求来判断是删除索引还是删除文档记录!

ElasticSearch学习总结(基础篇,可学习,可复习)_第31张图片

ElasticSearch学习总结(基础篇,可学习,可复习)_第32张图片

关于文档的基本操作(重点)

基本操作

1、添加一条数据

PUT /wumao/user/1
{
  "name":"wumao",
  "age":21,
  "desc":"一顿操作猛如虎,一看工资2500",
  "tags":["技术宅","无聊者"]
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1ocrVBSc-1651155173766)(/Users/wumao/Documents/Typora笔记/typora-user-images\image-20210714113305099.png)]

2、获取数据 GET

ElasticSearch学习总结(基础篇,可学习,可复习)_第33张图片

3、更新操作 POST _update推荐使用这种更新方式

ElasticSearch学习总结(基础篇,可学习,可复习)_第34张图片

简单的搜索

GET wumao/user/1

简单的条件查询 ,可以根据默认的映射规则,产生基本的查询!

ElasticSearch学习总结(基础篇,可学习,可复习)_第35张图片

复杂操作 搜索 select(排序、分页、高亮、精准查询!)

ElasticSearch学习总结(基础篇,可学习,可复习)_第36张图片
ElasticSearch学习总结(基础篇,可学习,可复习)_第37张图片

输出结果,不想要那么多结果!select name,desc . . . .

ElasticSearch学习总结(基础篇,可学习,可复习)_第38张图片

之后使用Java操作es,所有的方法和对象就是这里面的key!

排序

ElasticSearch学习总结(基础篇,可学习,可复习)_第39张图片

分页

ElasticSearch学习总结(基础篇,可学习,可复习)_第40张图片

数据下标还是从0开始的,和学的所有数据结构是一样的!

/search/{current}/{pageSize}

布尔值查询

must (and),所有的条件都要符合 where id = 1 and name =xxx

ElasticSearch学习总结(基础篇,可学习,可复习)_第41张图片

should( or ),所有的条件都要符合 where id = 1 orname =xxx

ElasticSearch学习总结(基础篇,可学习,可复习)_第42张图片

must_not(not)

ElasticSearch学习总结(基础篇,可学习,可复习)_第43张图片

过滤器filter

ElasticSearch学习总结(基础篇,可学习,可复习)_第44张图片

 gt  >  大于
 gte >= 大于等于
 lt  <  小于
 lte <= 小于等于

ElasticSearch学习总结(基础篇,可学习,可复习)_第45张图片

匹配多个条件

ElasticSearch学习总结(基础篇,可学习,可复习)_第46张图片

精确查询!

trem 查询是直接通过倒排索引指定的词条进行精确的查找的!

关于分词:

  • term,直接查询精确地

  • match,会使用分词器解析(先分析文档,通过分析的文档进行查询)

    两个类型 text keyword

    ElasticSearch学习总结(基础篇,可学习,可复习)_第47张图片

ElasticSearch学习总结(基础篇,可学习,可复习)_第48张图片ElasticSearch学习总结(基础篇,可学习,可复习)_第49张图片

多个值精确匹配

ElasticSearch学习总结(基础篇,可学习,可复习)_第50张图片

高亮查询!

ElasticSearch学习总结(基础篇,可学习,可复习)_第51张图片
ElasticSearch学习总结(基础篇,可学习,可复习)_第52张图片

  • 匹配
  • 按条件匹配
  • 精确匹配
  • 区间范围匹配
  • 匹配字段过滤
  • 多条件查询
  • 高亮查询

集成SpringBoot

找官方文档!

ElasticSearch学习总结(基础篇,可学习,可复习)_第53张图片
ElasticSearch学习总结(基础篇,可学习,可复习)_第54张图片

https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.12/index.html

1、找到原生的依赖

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

2、找对象

ElasticSearch学习总结(基础篇,可学习,可复习)_第55张图片

3、分析这个类中的方法

配置基本的项目

问题:创建项目默认的elasticsearch的默认版本是7.12.1,版本和本地不一致!

ElasticSearch学习总结(基础篇,可学习,可复习)_第56张图片
需要自己定义版本的依赖

ElasticSearch学习总结(基础篇,可学习,可复习)_第57张图片

分析源码

ElasticSearch学习总结(基础篇,可学习,可复习)_第58张图片

虽然导入了三个类,静态内部类,核心类只有一个

/**
 * Elasticsearch rest client configurations.
 *
 * @author Stephane Nicoll
 */
class ElasticsearchRestClientConfigurations {

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnMissingBean(RestClientBuilder.class)
	static class RestClientBuilderConfiguration {

		@Bean
		RestClientBuilderCustomizer defaultRestClientBuilderCustomizer(ElasticsearchRestClientProperties properties) {
			return new DefaultRestClientBuilderCustomizer(properties);
		}
	//第一个bean  RestClientBuilder
		@Bean
		RestClientBuilder elasticsearchRestClientBuilder(ElasticsearchRestClientProperties properties,
				ObjectProvider<RestClientBuilderCustomizer> builderCustomizers) {
			HttpHost[] hosts = properties.getUris().stream().map(this::createHttpHost).toArray(HttpHost[]::new);
			RestClientBuilder builder = RestClient.builder(hosts);
			builder.setHttpClientConfigCallback((httpClientBuilder) -> {
				builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(httpClientBuilder));
				return httpClientBuilder;
			});
			builder.setRequestConfigCallback((requestConfigBuilder) -> {
				builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(requestConfigBuilder));
				return requestConfigBuilder;
			});
			builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
			return builder;
		}

		private HttpHost createHttpHost(String uri) {
			try {
				return createHttpHost(URI.create(uri));
			}
			catch (IllegalArgumentException ex) {
				return HttpHost.create(uri);
			}
		}

		private HttpHost createHttpHost(URI uri) {
			if (!StringUtils.hasLength(uri.getUserInfo())) {
				return HttpHost.create(uri.toString());
			}
			try {
				return HttpHost.create(new URI(uri.getScheme(), null, uri.getHost(), uri.getPort(), uri.getPath(),
						uri.getQuery(), uri.getFragment()).toString());
			}
			catch (URISyntaxException ex) {
				throw new IllegalStateException(ex);
			}
		}

	}
	
	@Configuration(proxyBeanMethods = false)
	@ConditionalOnMissingBean(RestHighLevelClient.class)
	static class RestHighLevelClientConfiguration {

        //第二个bean  RestHighLevelClient 高级客户端,后面项目会用到!
		@Bean
		RestHighLevelClient elasticsearchRestHighLevelClient(RestClientBuilder restClientBuilder) {
			return new RestHighLevelClient(restClientBuilder);
		}

	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(Sniffer.class)
	@ConditionalOnSingleCandidate(RestHighLevelClient.class)
	static class RestClientSnifferConfiguration {

		@Bean
		@ConditionalOnMissingBean
		Sniffer elasticsearchSniffer(RestHighLevelClient client, ElasticsearchRestClientProperties properties) {
			SnifferBuilder builder = Sniffer.builder(client.getLowLevelClient());
			PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
			map.from(properties.getSniffer().getInterval()).asInt(Duration::toMillis)
					.to(builder::setSniffIntervalMillis);
			map.from(properties.getSniffer().getDelayAfterFailure()).asInt(Duration::toMillis)
					.to(builder::setSniffAfterFailureDelayMillis);
			return builder.build();
		}

	}

	static class DefaultRestClientBuilderCustomizer implements RestClientBuilderCustomizer {

		private static final PropertyMapper map = PropertyMapper.get();

		private final ElasticsearchRestClientProperties properties;

		DefaultRestClientBuilderCustomizer(ElasticsearchRestClientProperties properties) {
			this.properties = properties;
		}

		@Override
		public void customize(RestClientBuilder builder) {
		}

		@Override
		public void customize(HttpAsyncClientBuilder builder) {
			builder.setDefaultCredentialsProvider(new PropertiesCredentialsProvider(this.properties));
		}

		@Override
		public void customize(RequestConfig.Builder builder) {
			map.from(this.properties::getConnectionTimeout).whenNonNull().asInt(Duration::toMillis)
					.to(builder::setConnectTimeout);
			map.from(this.properties::getReadTimeout).whenNonNull().asInt(Duration::toMillis)
					.to(builder::setSocketTimeout);
		}

	}

	private static class PropertiesCredentialsProvider extends BasicCredentialsProvider {

		PropertiesCredentialsProvider(ElasticsearchRestClientProperties properties) {
			if (StringUtils.hasText(properties.getUsername())) {
				Credentials credentials = new UsernamePasswordCredentials(properties.getUsername(),
						properties.getPassword());
				setCredentials(AuthScope.ANY, credentials);
			}
			properties.getUris().stream().map(this::toUri).filter(this::hasUserInfo)
					.forEach(this::addUserInfoCredentials);
		}

		private URI toUri(String uri) {
			try {
				return URI.create(uri);
			}
			catch (IllegalArgumentException ex) {
				return null;
			}
		}

		private boolean hasUserInfo(URI uri) {
			return uri != null && StringUtils.hasLength(uri.getUserInfo());
		}

		private void addUserInfoCredentials(URI uri) {
			AuthScope authScope = new AuthScope(uri.getHost(), uri.getPort());
			Credentials credentials = createUserInfoCredentials(uri.getUserInfo());
			setCredentials(authScope, credentials);
		}

		private Credentials createUserInfoCredentials(String userInfo) {
			int delimiter = userInfo.indexOf(":");
			if (delimiter == -1) {
				return new UsernamePasswordCredentials(userInfo, null);
			}
			String username = userInfo.substring(0, delimiter);
			String password = userInfo.substring(delimiter + 1);
			return new UsernamePasswordCredentials(username, password);
		}

	}

}

具体的API测试

1、创建索引

2、判断文档是否存在

3、删除索引

4、创建文档

5、CRUD文档

@SpringBootTest
class WumaoEsApiApplicationTests {


    @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;


    //测试创建索引 在java中所有的请求都是用Request  PUT wumao_index
    @Test
    public void testCreateIndex() throws IOException {
        //1、创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("wumao_index");
        //2、客户端执行请求  IndicesClient,请求后获取响应
        CreateIndexResponse createIndexResponse = client.indices()
                .create(request, RequestOptions.DEFAULT);

        System.out.println(createIndexResponse);

    }

    //测试获取索引

    @Test
    void testExistsIndex() throws IOException {

        GetIndexRequest re = new GetIndexRequest("wumao_index");

        boolean exists = client.indices().exists(re,RequestOptions.DEFAULT);

        System.out.println(exists);
    }


    //测试删除索引
    @Test
    void testDeleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("wumao_index");
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);

        System.out.println(delete);
    }


    //添加文档
    @Test
    void testAddDocument() throws IOException {
        //创建对象
        User user = new User("五毛",3);
        //创建请求
        IndexRequest request = new IndexRequest("wumao_index");

        //设值一些规则 put /wumao_index/_doc/1
        request.id("1");
        request.timeout(TimeValue.timeValueSeconds(1));
        request.timeout("1s");

        //将我们的数据放入请求 json
        String string = JSON.toJSONString(user);
        request.source(string, XContentType.JSON);

        //客户端发送请求,获取响应的结果
        IndexResponse index = client.index(request, RequestOptions.DEFAULT);

        System.out.println(index.toString());
        System.out.println(index.status());//对应我们命令的返回状态


    }

    //获取文档
    @Test
    void testIsExists() throws IOException {

        //获取文档,判断是否存在 get/index/doc/1
        GetRequest index = new GetRequest("wumao_index", "1");

        //不获取返回的_source的上下文了
        index.fetchSourceContext(new FetchSourceContext(false));
        index.storedFields("_none_");
        boolean exists = client.exists(index, RequestOptions.DEFAULT);
        System.out.println(exists);
    }


    //获取文档的信息
    @Test
    void testGetDocument() throws IOException {

        GetRequest index = new GetRequest("wumao_index", "1");
        GetResponse fields = client.get(index, RequestOptions.DEFAULT);
        System.out.println(fields.getSourceAsString());
        System.out.println(fields);
    }


    //更新文档记录
    @Test
    void testUpdateDocument() throws IOException {
        UpdateRequest index = new UpdateRequest("wumao_index", "1");

        //设置超时时间
        index.timeout(TimeValue.timeValueSeconds(1));
        User user = new User("法外狂徒张三", 12);
        UpdateRequest doc = index.doc(JSON.toJSONString(user),XContentType.JSON);
        UpdateResponse update = client.update(index, RequestOptions.DEFAULT);
        System.out.println(update);
    }


    //删除文档记录
    @Test
    void testDeleteDocument() throws IOException {
        DeleteRequest request = new DeleteRequest("wumao_index", "1");
        //设置请求过期时间
        request.timeout("1s");
        DeleteResponse delete = client.delete(request, RequestOptions.DEFAULT);
        System.out.println(delete.status());
    }


    //特殊的,真的项目一般都是批量插入数据
    @Test
    void testBulkRequest() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();

        bulkRequest.timeout("10s");

        ArrayList<User> userList = new ArrayList<>();
        userList.add(new User("wumao",3));
        userList.add(new User("wumao1",23));
        userList.add(new User("wumao2",21));
        userList.add(new User("wumao3",12));
        userList.add(new User("wumao4",13));
        userList.add(new User("wumao5",23));
        userList.add(new User("wumao6",33));

        for (int i = 0; i < userList.size(); i++) {
            bulkRequest.add(new IndexRequest("wumao_index")
                    .source(JSON.toJSONString(userList.get(i)),XContentType.JSON)
            );
        }
        BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulk.hasFailures());//是否失败!
    }

    //查询
    // SearchRequest 搜索请求
    // SearchSourceBuilder 条件构造
    // HighlightBuilder 构建高亮
    // TermQueryBuilder 精确查询
    // MatchAllQueryBuilder 查询全部
    // xxxxQueryBuilder 对应之前的那些命令
    @Test
    void testSearch() throws IOException {
        SearchRequest request = new SearchRequest("wumao_index");
        //构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //查询条件,我么可以使用QueryBuilders 工具类来实现
        //QueryBuilders.termQuery 精确查询
        //QueryBuilders.matchAllQuery(); 匹配所有
        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        TermQueryBuilder termQuery = QueryBuilders.termQuery("name", "wumao");
            //查询过期时间
            sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

            request.source(sourceBuilder);

        SearchResponse search = client.search(request, RequestOptions.DEFAULT);
        System.out.println(JSON.toJSONString(search.getHits()));

        for (SearchHit hit : search.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

    //批量创建文档
    @Test
    void testBulkDocument() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        //设置过期时间
        bulkRequest.timeout("60s");

        ArrayList<User> userList = new ArrayList<>();
        userList.add(new User("qinfeng",3));
        userList.add(new User("qinfeng1",3));
        userList.add(new User("qinfeng2",3));
        userList.add(new User("qinfeng3",3));
        userList.add(new User("qinfeng4",3));
        userList.add(new User("qinfeng5",3));

        for (int i = 0; i < userList.size(); i++) {
            bulkRequest.add(new IndexRequest("wumao_index")
            .id(""+(i+1))
                    .source(JSON.toJSONString(userList.get(i)),XContentType.JSON));
        }
        BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);

        System.out.println(bulk.hasFailures());//判断是否失败

    }

}

ElasticSearch学习总结(基础篇,可学习,可复习)_第59张图片

实战案例

  • 爬虫

数据问题 数据库中获取,消息队列获取

爬取数据(获取请求返回的页面信息,筛选出我们所需要的)


<dependency>
    <groupId>org.jsoupgroupId>
    <artifactId>jsoupartifactId>
    <version>1.14.2version>
dependency>
 public List<Content> parseJD(String keyWords) throws Exception {
        //获取请求  https://search.jd.com/Search?keyword=java
        String url = "https://search.jd.com/Search?keyword="+keyWords;
        //解析网页 (Jsoup返回的Document就是Document对象)
        Document document = Jsoup.parse(new URL(url), 30000);
        //所有在js中使用的方法,在这里都可以使用
        Element element = document.getElementById("J_goodsList");


        ArrayList<Content> list = new ArrayList<>();

        //获取所有的li元素
        Elements elements = element.getElementsByTag("li");
        //这里的el就是每一个li标签
        for (Element el : elements) {
            //关于这种图片特别多的网站,都是延时加载的
            String price = el.getElementsByClass("p-price").eq(0).text();
            String title = el.getElementsByClass("p-name").eq(0).text();

            Content content = new Content();
            content.setTitle(title);
            content.setPrice(price);
            list.add(content);
        }
        return list;
    }
  • 前后端分离

  • 搜索高亮

   //解析数据放入到es中
    public Boolean parseContent(String keyWords) throws Exception {
        List<Content> contents = new HtmlParseUtil().parseJD(keyWords);

        //把查询到的数据放入到es中
        BulkRequest request = new BulkRequest();
        request.timeout("2m");
        for (int i = 0; i < contents.size(); i++) {
            System.out.println(JSON.toJSONString(contents.get(i)));
            request.add(
                    new IndexRequest("jd_goods")
                    .source(JSON.toJSONString(contents.get(i)), XContentType.JSON));
        }
        BulkResponse bulkResponse = restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
        return !bulkResponse.hasFailures();
    }
    //3.实现搜索高亮功能
    public List<Map<String,Object>> searchHighlightPage(String keyword,int pageNO,int pageSize) throws IOException {
        if (pageNO <=1){
            pageNO =1;
        }

        //条件搜索
        SearchRequest searchRequest = new SearchRequest("jd_goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //分页
        sourceBuilder.from(pageNO);
        sourceBuilder.size(pageSize);

        //精准匹配
        QueryBuilders.termQuery("title",keyword);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("title");
        highlightBuilder.requireFieldMatch(false); //高亮显示一个title只显示一个高亮就可以
        highlightBuilder.preTags("");
        highlightBuilder.postTags("");

        sourceBuilder.highlighter(highlightBuilder);

        //执行搜索
        searchRequest.source(sourceBuilder);

        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        ArrayList<Map<String,Object>> list = new ArrayList<>();
        for (SearchHit hit : searchResponse.getHits()) {

            //解析高亮字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            HighlightField title = highlightFields.get("title");
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();//原来的结果
            //解析高亮字段,将原来的字段换为我们高亮的字段即可!
            if (title!=null){
                Text[] fragments = title.fragments();
                String n_title="";
                for (Text text : fragments) {
                    n_title += text;
                }
                sourceAsMap.put("title",n_title); //高亮字段替换掉原来的内容即可!
            }
            list.add(sourceAsMap);
        }
        return list;
    }

本篇到这里就结束了!后续还会继续更新ElasticSearch调优、ElasticSearch集群以及面试题相关的内容,
感谢诸佬的点赞和支持。
如有不足之处,还希望诸佬指出不足之处,加以修正。

再见了各位小伙伴!

你可能感兴趣的