elasticsearch7.6.2和logstash安装和初步

已于 2022-11-28 23:48:23 修改
阅读量1.5k 收藏 1
点赞数 1
分类专栏： 文一西路的日子 文章标签： elasticsearch java 大数据
于 2022-11-28 22:07:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moneywenxue/article/details/128009861
版权

一、linux安装

参考以下链接：
Linux（centos7）如何部署ElasticSearch7.6.2单节点跟集群（es部署指南）

二、window安装

参考下文更加详细：windows ElasticSearch 7.6.0集群搭建

2.1 下载elasticsearch7.6.2window版

可去官网：
也可去社区：elastic中文社区下载地址

2.2 解压

解压后图片

2.3 节点配置

改elasticsearch7.6.2的配置文件elasticsearch.yml，该文件路径为es1/conf/elasticsearch.yml

2.3.1 节点一

#集群名称，保证唯一
cluster.name: my-elasticsearch
#节点名称，必须不一样
node.name: node-1
#必须为本机的IP地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9201
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9301
#设置集群自动发现机器IP集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]
#是否支持跨域，默认为false
http.cors.enabled: true
#当设置允许跨域，默认为*,表示支持所有域名
http.cors.allow-origin: "*"
#指定master
cluster.initial_master_nodes: node-1

2.3.2 节点二

#集群名称，保证唯一
cluster.name: my-elasticsearch
#节点名称，必须不一样
node.name: node-2
#必须为本机的IP地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9202
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9302
#设置集群自动发现机器IP集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]
#是否支持跨域，默认为false
http.cors.enabled: true
#当设置允许跨域，默认为*,表示支持所有域名
http.cors.allow-origin: "*"
#指定master
cluster.initial_master_nodes: node-1

2.3.2 节点三

#集群名称，保证唯一
cluster.name: my-elasticsearch
#节点名称，必须不一样
node.name: node-3
#必须为本机的IP地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9203
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9303
#设置集群自动发现机器IP集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]
#是否支持跨域，默认为false
http.cors.enabled: true
#当设置允许跨域，默认为*,表示支持所有域名
http.cors.allow-origin: "*"
#指定master
cluster.initial_master_nodes: node-1

2.4 分别启动三台机器

进入各自bin目录，执行：

./eslasticsearch

如上方法依次启动三个节点的，启动完成之后可以看到三个节点成功。
成功后使用浏览器进入:127.0.0.1:9200，查看是否成功。

三、Cerebro的使用（未设置账号密码）

本人在window测试环境搭建，es访问和cerebro访问都未设置密码，如果要设置账号密码，可参考此文：Elastic监控工具 - cerebro

3.1 下载window版本cerebro

下载地址：cerebro下载地址
因为我是window版本，下载.zip文件，linux可选择.tgz。

3.2 解压 cerebro-0.8.5.zip

略。

3.3 启动

打开命令行窗口，在cerebro/bin目录，执行

./cerebro

3.4 进入cerebro主页

启动完成之后在浏览器输入： http://localhost:9000/

3.5 在Node Address中输入节点地址

在上图Node Address中输入节点地址，任一节点地址都行：
在这里插入图片描述
点击Connect，即可看到当前集群中三个节点状态：
在这里插入图片描述
关于cerebro的一些基本功能，后续再详述。

四、logstash安装

4.1 安装及使用

参考文章:
logstash同步数据到es

4.2 我的安装及使用

4.2.1 增加xx.conf

增加logstash-test-log-sync.conf配置：

input {
        stdin {}
        jdbc {
                type => "jdbc"
                jdbc_connection_string => "jdbc:mysql://127.0.0.1:3306/test_db?useUnicode=true&allowMultiQuerie=true&characterEncoding=utf-8&serverTimezone=UTC"
                # 数据库连接账号密码；
                jdbc_user => "root"
                jdbc_password => "root"
                # MySQL依赖包路径；
                jdbc_driver_library => "E:\Java\Document\m2\repository\mysql\mysql-connector-java\5.1.21\mysql-connector-java-5.1.21.jar"
                # the name of the driver class for mysql
                jdbc_driver_class => "com.mysql.jdbc.Driver"
                #是否开启分页
                jdbc_paging_enabled => "true"
                #分页条数
                jdbc_page_size => "50000"
                # 执行的sql 文件路径+名称
                #statement_filepath => "/data/my_sql2.sql"
                #SQL语句，也可以使用statement_filepath来指定想要执行的SQL
                #statement => "SELECT * FROM `user` where id > :sql_last_value"
				statement => "SELECT * FROM `user`"
                #每一分钟做一次同步
                schedule => "* * * * *"
                #是否将字段名转换为小写，默认true（如果有数据序列化、反序列化需求，建议改为false）
                lowercase_column_names => false
                # 是否记录上次执行结果，true表示会将上次执行结果的tracking_column字段的值保存到last_run_metadata_path指定的文件中；
                record_last_run => true
                # 需要记录查询结果某字段的值时，此字段为true，否则默认tracking_column为timestamp的值；
                use_column_value => true
                # 需要记录的字段，用于增量同步，需是数据库字段
                tracking_column => "id"
                # record_last_run上次数据存放位置；
                last_run_metadata_path => "E:\\JavaSoftWare\\ES\\logstash-7.6.2\\sql_last_value"
                #是否将字段名转换为小写，默认true（如果有数据序列化、反序列化需求，建议改为false）
                clean_run => false
        }
}
 
filter {
    json {
        source => "message"
        remove_field => ["message"]
    }
	mutate  {
        remove_field => ["@timestamp","@version"]
    }
}
 
output {
        elasticsearch {
                 # 配置ES集群地址
                hosts => ["127.0.0.1:9201","127.0.0.1:9202","127.0.0.1:9203"]
                 # 索引名字，必须小写
				index => "logstash-test"
				#数据唯一索引（建议使用数据库KeyID）
				document_id => "%{id}"
        }
        stdout {
        }
}

4.2.2 执行命令

执行命令：

 ./logstash -f ../conf/logstash-test-log-sync.conf

下面是我执行过程中遇到的报错日志，以及解决方法，逐一列出，希望对诸君有用。

4.2.2.1 报错一：

![在这里插入图片描述](https://img-blog.csdnimg.cn/9f6d0a1db7e64bb38c2c4ad1014100be.png在这里插入图片描述
解决方法：把logstash-test-log-sync.conf配置字符集需要UTF-无BOM 保存。
参考文章：Elasticsearch解决分页慢以及日志整合监控的方案

4.2.2.2 报错二：

继续执行：

./logstash -f ../conf/logstash-test-log-sync.conf

报错如下：
在这里插入图片描述
原因：es集群地址填写不对。
解决方法：如下地址填写正确：
在这里插入图片描述

4.2.2.3 报错三

不是报错，是卡在这里一致不执行，我设置的是默认，一分钟执行一次：
在这里插入图片描述

4.2.2.4 报错四

在这里插入图片描述
原来是mysql链接错误，改为：
在这里插入图片描述

4.3 结果

最终logstash执行成功。
查看执行结果：
在这里插入图片描述

五、es的demo

5.1 spring-boot-starter-data-elasticsearch(基于es 5.1)

优点：

  • 封装了很多通用方法以及注解式操作简化了开发流程。
  • 与springBoot 集成更快速。

缺点：

  • elasticsearch官方更新的版本速度太快，而springboot速度明显略慢。
  • elasticsearch随着版本升级API略有变化，spring-data-elasticsearch容易遇到版本不兼容问题。

5.1.1 引入依赖

	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
			<version>2.1.0.RELEASE</version>
		</dependency>

5.1.2 配置

spring:
    data:
        elasticsearch:
            cluster-name: my-elasticsearch
            cluster-nodes: 127.0.0.1:9301,127.0.0.1:9302,127.0.0.1:9303

5.1.3 创建实体类

@Data
@ToString
@Document(indexName = "global_search_index",type = "global_search")
public class ESGlobalSearch implements Serializable {
	/**
	 * ID,唯一字段
	 */
	@Id
	@Field(type= FieldType.Keyword,store = true)
	private String id;

	/**
	 * 主题（搜索关键字）
	 */
	@Field(type = FieldType.Text,store = true,analyzer = "ik_max_word",searchAnalyzer = "ik_max_word")
	private String title;

	/**
	 * 主题副本（提高搜索精度）
	 */
	@Field(type = FieldType.Text,store = true,analyzer = "standard")
	private String roughTitle;

	/**
	 * 标签（预留字段,搜索扩展）
	 */
	@Field(type = FieldType.Text,store = true,analyzer = "ik_max_word",searchAnalyzer = "ik_max_word")
	private String label;

	/**
	 * 内容（预留字段）
	 */
	@Field(type = FieldType.Text,store = true,analyzer = "ik_max_word",searchAnalyzer = "ik_max_word")
	private String content;

	/**
	 * 应用类型（1.医生;2.医院;3.应用）
	 */
	@Field(type = FieldType.Integer,store = true)
	private Integer applicationType;

	/**
	 * 应用类型信息
	 */
	@Field(type = FieldType.Text,store = true)
	private String applicationInfo;
}

5.1.4 创建xxRepository

public interface ESGlobalSearchMapper  extends ElasticsearchRepository<ESGlobalSearch,String> {
	/**
	 * 根据标题检索
	 * @param title
	 * @param roughTitle
	 * @return
	 */
	List<ESGlobalSearch> findByTitleOrRoughTitle(String title, String roughTitle);
}

5.1.5 测试

@SpringBootTest(classes = EsApplication.class)
@RunWith(SpringRunner.class)
public class EsGlobalSearchTest {
	@Autowired
	ESGlobalSearchMapper esGlobalSearchMapper;
	@Test
	public void saveTest(){
		ESGlobalSearch esGlobalSearch = new ESGlobalSearch();
		esGlobalSearch.setApplicationInfo("1");
		esGlobalSearch.setApplicationType(1);
		esGlobalSearch.setContent("测试Content");
		esGlobalSearch.setId("1");
		esGlobalSearch.setLabel("测试Label");
		esGlobalSearch.setRoughTitle("测试");
		esGlobalSearch.setTitle("测试title");
		ESGlobalSearch save = esGlobalSearchMapper.save(new ESGlobalSearch());
	}

	@Test
	public void findAllTest(){
		Iterable<ESGlobalSearch> iter = esGlobalSearchMapper.findAll();
		for (ESGlobalSearch esGlobalSearch : iter) {
			System.out.println(esGlobalSearch);
		}
	}

	/**
	 * 它可以根据名称，自动实现功能
	 */
	@Test
	public void findByTitleOrRoughTitle(){
		List<ESGlobalSearch> list = esGlobalSearchMapper.findByTitleOrRoughTitle("张", "张");
		for (ESGlobalSearch esGlobalSearch : list) {
			System.out.println(esGlobalSearch);
		}
	}

	/**
	 * 基本查询
	 */
	@Test
	public void testQuery(){
		// 词条查询
		MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "周国岭");
		//执行查询
		Iterable<ESGlobalSearch> items = this.esGlobalSearchMapper.search(queryBuilder);
		items.forEach(item -> System.out.println(item));
	}

	@Test
	public void testFuzzyQuery(){
		NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
		queryBuilder.withQuery(QueryBuilders.fuzzyQuery("title","杭州"));

		Page<ESGlobalSearch> page = this.esGlobalSearchMapper.search(queryBuilder.build());
		List<ESGlobalSearch> list = page.getContent();
		list.forEach(esGlobalSearch -> System.out.println(esGlobalSearch));
	}
	/**
	 * es分页处理
	 */
	@Test
	public void testNativeQuery2(){
		// 构建查询条件
		NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
		// 添加基本的分词查询
		queryBuilder.withQuery(QueryBuilders.termQuery("title", "杭州"));
		queryBuilder.withQuery(QueryBuilders.matchAllQuery());
		// 初始化分页参数
		int page = 0;
		int size = 3;
		// 设置分页参数
		queryBuilder.withPageable(PageRequest.of(page, size));
		// 执行搜索，获取结果
		Page<ESGlobalSearch> pages = this.esGlobalSearchMapper.search(queryBuilder.build());
		// 打印总条数
		System.out.println(pages.getTotalElements());
		// 打印总页数
		System.out.println(pages.getTotalPages());
		// 每页大小
		System.out.println(pages.getSize());
		// 当前页
		System.out.println(pages.getNumber());

		List<ESGlobalSearch> list = pages.getContent();
		list.forEach( esGlobalSearch -> System.out.println(esGlobalSearch));
	}

	/**
	 * 排序
	 */
	@Test
	public void testSort(){
		NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
		//查询全部
		queryBuilder.withQuery(QueryBuilders.matchAllQuery());
		// 初始化分页参数
		int page = 0;
		int size = 3;
		// 设置分页参数
		queryBuilder.withPageable(PageRequest.of(page, size));
		queryBuilder.withSort(SortBuilders.fieldSort("id").order(SortOrder.DESC));
		// 执行搜索，获取结果
		Page<ESGlobalSearch> pages = this.esGlobalSearchMapper.search(queryBuilder.build());
		List<ESGlobalSearch> list = pages.getContent();
		list.forEach( esGlobalSearch -> System.out.println(esGlobalSearch));

	}

	@Test
	public void testBooleanQuery() {
		NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
		builder.withQuery(QueryBuilders.boolQuery().must(QueryBuilders.termQuery("title", "周国岭"))
				.must(QueryBuilders.termQuery("roughTitle", "周国岭"))
		);

		Page<ESGlobalSearch> list = this.esGlobalSearchMapper.search(builder.build());
		for (ESGlobalSearch item : list) {
			System.out.println(item);
		}
	}
}

5.1.6 更多查询

简介
spring data elsaticsearch提供了三种构建查询模块的方式：

基本的增删改查：继承spring data提供的接口就默认提供
接口中声明方法：**无需实现类。**spring data根据方法名，自动生成实现类，方法名必须符合一定的规则
接口只要继承 ElasticsearchRepository 类即可。默认会提供很多实现，比如 CRUD 和搜索相关的实现。类似于 JPA 读取数据。
支持的默认方法有：
count(), findAll(), findOne(ID), delete(ID), deleteAll(), exists(ID), save(DomainObject), save(Iterable)。

接口的命名是遵循规范的。常用命名规则如下：

表格内容摘自官网（官方文档:传送门）

关键字方法命名Elasticsearch查询DSL语法示例
AndfindByNameAndPrice{ “query” : { “bool” : { “must” : [ { “query_string” : { “query” : “?”, “fields” : [ “name” ] } }, { “query_string” : { “query” : “?”, “fields” : [ “price” ] } } ] } }}
OrfindByNameOrPrice{ “query” : { “bool” : { “should” : [ { “query_string” : { “query” : “?”, “fields” : [ “name” ] } }, { “query_string” : { “query” : “?”, “fields” : [ “price” ] } } ] } }}
IsfindByName{ “query” : { “bool” : { “must” : [ { “query_string” : { “query” : “?”, “fields” : [ “name” ] } } ] } }}
NotfindByNameNot{ “query” : { “bool” : { “must_not” : [ { “query_string” : { “query” : “?”, “fields” : [ “name” ] } } ] } }}
BetweenfindByPriceBetween{ “query” : { “bool” : { “must” : [ {“range” : {“price” : {“from” : ?, “to” : ?, “include_lower” : true, “include_upper” : true } } } ] } }}
LessThanfindByPriceLessThan{ “query” : { “bool” : { “must” : [ {“range” : {“price” : {“from” : null, “to” : ?, “include_lower” : true, “include_upper” : false } } } ] } }}
LessThanEqualfindByPriceLessThanEqual{ “query” : { “bool” : { “must” : [ {“range” : {“price” : {“from” : null, “to” : ?, “include_lower” : true, “include_upper” : true } } } ] } }}
GreaterThanfindByPriceGreaterThan{ “query” : { “bool” : { “must” : [ {“range” : {“price” : {“from” : ?, “to” : null, “include_lower” : false, “include_upper” : true } } } ] } }}
GreaterThanEqualfindByPriceGreaterThan{ “query” : { “bool” : { “must” : [ {“range” : {“price” : {“from” : ?, “to” : null, “include_lower” : true, “include_upper” : true } } } ] } }}
BeforefindByPriceBefore{ “query” : { “bool” : { “must” : [ {“range” : {“price” : {“from” : null, “to” : ?, “include_lower” : true, “include_upper” : true } } } ] } }}
AfterfindByPriceAfter{ “query” : { “bool” : { “must” : [ {“range” : {“price” : {“from” : ?, “to” : null, “include_lower” : true, “include_upper” : true } } } ] } }}
LikefindByNameLike
StartingWithfindByNameStartingWith{ “query” : { “bool” : { “must” : [ { “query_string” : { “query” : “?*”, “fields” : [ “name” ] }, “analyze_wildcard”: true } ] } }}
EndingWithfindByNameEndingWith{ “query” : { “bool” : { “must” : [ { “query_string” : { “query” : “*?”, “fields” : [ “name” ] }, “analyze_wildcard”: true } ] } }}
Contains/ContainingfindByNameContaining{ “query” : { “bool” : { “must” : [ { “query_string” : { “query” : “?”, “fields” : [ “name” ] }, “analyze_wildcard”: true } ] } }}
In (when annotated as FieldType.Keyword)findByNameIn(Collectionnames){ “query” : { “bool” : { “must” : [ {“bool” : {“must” : [ {“terms” : {“name” : [“?”,“?”]}} ] } } ] } }}
InfindByNameIn(Collectionnames){ “query”: {“bool”: {“must”: [{“query_string”:{“query”: “”?" “?”", “fields”: [“name”]}}]}}}
NotIn(when annotated as FieldType.Keyword)findByNameNotIn(Collectionnames) { “query” : { “bool” : { “must” : [ {“bool” : {“must_not” : [ {“terms” : {“name” : [“?”,“?”]}} ] } } ] } }}
NotInfindByNameNotIn(Collectionnames){“query”: {“bool”: {“must”: [{“query_string”: {“query”: “NOT(”?" “?”)", “fields”: [“name”]}}]}}}
NearfindByStoreNearNot Supported Yet !
TruefindByAvailableTrue{ “query” : { “bool” : { “must” : [ { “query_string” : { “query” : “true”, “fields” : [ “available” ] } } ] } }}
FalsefindByAvailableFalse{ “query” : { “bool” : { “must” : [ { “query_string” : { “query” : “false”, “fields” : [ “available” ] } } ] } }}
OrderByfindByAvailableTrueOrderByNameDesc{ “query” : { “bool” : { “must” : [ { “query_string” : { “query” : “true”, “fields” : [ “available” ] } } ] } }, “sort”:[{“name”:{“order”:“desc”}}] }

按接口的命名方法示例：
如 5.1.4

5.1.7 创建索引

@SpringBootTest(classes = EsApplication.class)
@RunWith(SpringRunner.class)
public class EsXcCourseTest {
	@Autowired
	ElasticsearchTemplate elasticsearchTemplate;


	@Test
	public void createIndex(){
		// 创建索引，会根据Item类的@Document注解信息来创建
		boolean createFlag = elasticsearchTemplate.createIndex(EsXcCourse.class);
		System.out.println("####:"+createFlag);
		// 配置映射，会根据Item类中的id、Field等字段来自动完成映射
		elasticsearchTemplate.putMapping(EsXcCourse.class);
	}

}

5.1.8 高级查询

Data ElasticSearch 支持了一些常见的查询
但是一些高级查询呢？可以使用类组装DSL语法支持

 /**
     * 聚合查询-groupBy
     * 聚合所有的年龄
     */
    @Test
    public void groupByAge() {
	//1.构建查询对象
	NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
	nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms("groupByAge")
		.field("age").size(30));
	SearchHits<EmployeeInfo> search = elasticsearchRestTemplate.search(nativeSearchQueryBuilder.build(), EmployeeInfo.class);

	Aggregations aggregations = search.getAggregations();

	//解析聚合分组后结果数据
	ParsedLongTerms parsedLongTerms = aggregations.get("groupByAge");
	//groupBy后的年龄集
	List<String> ageList = parsedLongTerms.getBuckets().stream().map(Terms.Bucket::getKeyAsString).collect(Collectors.toList());
	System.out.println(ageList);
    }

/**
 * 分页查询
 * 带参数
 */
@Test
public void listPageMatch() {
    int pageNo = 1;
    int pageSize = 5;

    NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
    nativeSearchQueryBuilder.withQuery(QueryBuilders.matchQuery("name", "小"));

    //注：Pageable类中 pageNum需要减1,如果是第一页 数值为0
    Pageable pageable = PageRequest.of(pageNo - 1, pageSize);
    nativeSearchQueryBuilder.withPageable(pageable);

    SearchHits<EmployeeInfo> searchHitsResult = elasticsearchRestTemplate.search(nativeSearchQueryBuilder.build(), EmployeeInfo.class);
    //7.获取分页数据
    SearchPage<EmployeeInfo> searchPageResult = SearchHitSupport.searchPageFor(searchHitsResult, pageable);


    System.out.println("分页查询");
    System.out.println(String.format("totalPages:%d, pageNo:%d, size:%d", searchPageResult.getTotalPages(), pageNo, pageSize));
    System.out.println(JSON.toJSONString(searchPageResult.getSearchHits(), SerializerFeature.PrettyFormat));
}

5.1.9 gitee地址

传送门

5.1.10 参考文章：

SpringBoot-starter-data整合Elasticsearch

5.2 elasticsearch-rest-high-level-client

5.2.1 引入依赖

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

		<!-- high-level client ，默认依赖的elasticsearch存在版本差异，排除后添加统一的es版本-->
		<dependency>
			<groupId>org.elasticsearch.client</groupId>
			<artifactId>elasticsearch-rest-high-level-client</artifactId>
			<version>7.6.2</version>
			<!--<exclusions>
				<exclusion>
					<groupId>org.elasticsearch</groupId>
					<artifactId>elasticsearch</artifactId>
				</exclusion>
			</exclusions>-->
		</dependency>

5.2.2 配置

yml配置：

elasticsearch:
    hostlist: ${eshostlist:127.0.0.1:9201,127.0.0.1:9202,127.0.0.1:9203,} #多个结点中间用逗号分隔

配置类：

@Slf4j
@Configuration
public class ElasticsearchConfig {
	@Value("${elasticsearch.hostlist}")
	private String hostlist;
	@Bean
	public RestHighLevelClient restHighLevelClient(){
		//解析hostlist配置信息
		String[] split = hostlist.split(",");
		//创建HttpHost数组，其中存放es主机和端口的配置信息
		HttpHost[] httpHostArray = new HttpHost[split.length];
		for(int i=0;i<split.length;i++){
			String item = split[i];
			httpHostArray[i] = new HttpHost(item.split(":")[0], Integer.parseInt(item.split(":")[1]), "http");
		}
		//创建RestHighLevelClient客户端
		return new RestHighLevelClient(RestClient.builder(httpHostArray));
	}

	//项目主要使用RestHighLevelClient，对于低级的客户端暂时不用
	@Bean
	public RestClient restClient(){
		//解析hostlist配置信息
		String[] split = hostlist.split(",");
		//创建HttpHost数组，其中存放es主机和端口的配置信息
		HttpHost[] httpHostArray = new HttpHost[split.length];
		for(int i=0;i<split.length;i++){
			String item = split[i];
			httpHostArray[i] = new HttpHost(item.split(":")[0], Integer.parseInt(item.split(":")[1]), "http");
		}
		return RestClient.builder(httpHostArray).build();
	}
}

5.2.3 操作

@RestController
@RequestMapping("/demo")
@Slf4j
public class DemoController {
	@Autowired
	RestHighLevelClient restHighLevelClient;
	@RequestMapping("/test")
	public String test() throws IOException {
		// 1 创建检索请求
		SearchRequest searchRequest = new SearchRequest("xc_course");
		// 指定索引
		//searchRequest.indices("global_search_index");
		// 构造检索条件 DSL
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

		/*sourceBuilder.query(); 匹配查询
	    sourceBuilder.from(); 分页查询 from 起始，size 尺寸
	    sourceBuilder.size();
	    sourceBuilder.aggregation(); 聚合
		*/
		//全文检索
		//MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("name", "java");
		//精准搜索
		//TermQueryBuilder queryBuilder = QueryBuilders.termQuery("name", "java");
		TermQueryBuilder queryBuilder=QueryBuilders.termQuery("studymodel","201002");
		sourceBuilder.query(queryBuilder);

		System.out.println(sourceBuilder.toString());
		searchRequest.source(sourceBuilder);
		// 2 执行检索
		SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
		// 3 分析响应结果
		System.out.println("========:"+response.toString());
		return response.toString();
	}

	@RequestMapping("/test2")
	public String test2() throws IOException {
		// 1 创建检索请求
		SearchRequest searchRequest = new SearchRequest("xc_course");
		// 指定索引
		//searchRequest.indices("global_search_index");
		// 构造检索条件 DSL
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		//TermQueryBuilder queryBuilder=QueryBuilders.termQuery("studymodel","201002");
		MatchAllQueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
		sourceBuilder.query(queryBuilder);

		System.out.println(sourceBuilder.toString());
		searchRequest.source(sourceBuilder);
		// 2 执行检索
		SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
		// 3 分析响应结果
		System.out.println("========:"+response.toString());
		return response.toString();
	}

	@RequestMapping("/test3")
	public String test3() throws IOException {
		// 1 创建检索请求
		SearchRequest searchRequest = new SearchRequest("logstash-test");
		// 指定索引
		//searchRequest.indices("global_search_index");
		// 构造检索条件 DSL
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		//TermQueryBuilder queryBuilder=QueryBuilders.termQuery("studymodel","201002");
		MatchAllQueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
		sourceBuilder.query(queryBuilder);

		System.out.println(sourceBuilder.toString());
		searchRequest.source(sourceBuilder);
		// 2 执行检索
		SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
		// 3 分析响应结果
		System.out.println("========:"+response.toString());
		return response.toString();
	}
}

5.2.3 gitee地址

传送门

5.2.4 参考文章：

参考文章
elasticsearch-rest-high-level-client操作

六、使用对应的ik分词器

analyzer [ik_smart] not found for field [name]

七、ES内存设置

    ES默认安装后设置的内存是1GB，对任何一个现实业务来说，这个设置太小了。如果是通过解压安装的ES，则在es安装文件中包含一个jvm.option文件，添加如下命令来设置ES的堆大小,Xms表示堆的初始大小，Xms表示可分配的最大内存，都是1GB。
    确保 Xmx 和 Xms 的大小是相同的，其目的是为了能够在 Java 垃圾回收机制清理完 堆区后不需要重新分隔计算堆区的大小而浪费资源，可以减轻伸缩堆大小带来的压力。    假设你有一个 64G 内存的机器，按照正常思维思考，你可能会认为把 64G 内存都给 ES 比较好，但现实是这样吗， 越大越好？虽然内存对 ES 来说是非常重要的，但是答案 是否定的！ 因为 ES 堆内存的分配需要满足以下两个原则：

  • 不要超过物理内存的 50%：Lucene 的设计目的是把底层 OS 里的数据缓存到内存中。 Lucene
    的段是分别存储到单个文件中的，这些文件都是不会变化的，所以很利于缓存，同时操作系 统也会把这些段文件缓存起来，以便更快的访问。如果我们设置的堆内存过大，Lucene 可用的内存将会减少，就会严重影响降低 Lucene 的全文本查 询性能。
  • 堆内存的大小最好不要超过 32GB(总内存64G)：在 Java 中，所有对象都分配在堆上，然后有一个 Klass Pointer 指 针指向它的类元数据。 这个指针在 64 位的操作系统上为 64 位，64 位的操作系统可以使用更多的内存（2^64）。在 32 位 的系统上为 32 位，32 位的操作系统的最大寻址空间为 4GB（2^32）。 但是 64 位的指针意味着更大的浪费，因为你的指针本身大了。浪费内存不算，更糟糕的是，更大的 指针在主内存和缓存器（例如 LLC, L1 等）之间移动数据的时候，会占用更多的带宽。 最终我们都会采用 31 G 设置 -Xms 31g -Xmx 31g 。
  • 假设你有个机器有 128 GB 的内存，你可以创建两个节点，每个节点内存分配不超过 32 GB。 也就是说 不超过 64 GB 内存给 ES 的堆内存，剩下的超过 64 GB 的内存给 Lucene。

参考文章：
ES的内存设置
ElasticSearch系列（七）es内存大小设置

八、其他的参考文章

这些参考文章也很重要，烦请诸君有空一定要看：
ES的内存设置

使用Logstash来实时同步MySQL数据到ES

使用LOGSTASH 将数据导入到ES

logstash同步数据到es

Logstash 从Mysql同步数据到ES

ES数据类型

钱多多_qdd
关注
专栏目录
基于Logstash由SQLServer向Elasticsearch同步数据：环境准备【SQL Server data to Elasticsearch using LogStash】
iOS逆向与安全
03-14 830
整体介绍文档：https://docs.microsoft.com/en-us/sql/relational-databases/track-changes/about-change-tracking-sql-server?elasticsearch-head 则是一款开源的ElasticSearch管理界面，它的项目主页为：https://github.com/mobz/elasticsearch-head。英文差的朋友可以把URL中的en-us改成zh-cn来看中文的文档。
安装Elasticsearch7.6.2和elasticsearch-analysis-ik-7.6.2，以及Kibana7.6.2，在CentOS 7操作系统上的安装教程
aaa_4的博客
08-29 1228
安装Elasticsearch7.6.2和elasticsearch-analysis-ik-7.6.2，以及Kibana7.6.2，在CentOS 7操作系统上的安装教程
elasticsearch7.6.2 集群研究及搭建过程（windows版）
LUNG108的博客
06-02 598
一、压缩包方式 1. 下载解压 https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.6.2-windows-x86_64.zip 2. 启动 解压之后，追加一些配置config/elasticsearch.yml，启动 #是否启用xpack xpack.ml.enabled: false # 允许跨域访问 http.cors.enabled: true http.cors.allow-origin:...
Docker安装ElasticSearch 版本7.6.2
悟能的师兄的专栏
01-21 8418
一、Docker 部署 ElasticSearch 1、从仓库中查找所有ElasticSearch的镜像 [hn-jw@iZbp1gp1t778obaz5m8vk8Z elasticsearch]$ docker search elasticsearch [hn-jw@iZbp1gp1t778obaz5m8vk8Z elasticsearch]$ 2、选择一个版本镜像进行拉取 [hn-jw@iZbp1gp1t778obaz5m8vk8Z elasticsearch]$ docker pull
Cerebro 安装和配置指南
最新发布
gitblog_07711的博客
09-13 263
Cerebro 安装和配置指南 cerebro 项目地址: https://gitcode.com/gh_mirrors/cere/cerebro 1. 项目基础介绍和主要...
ElasticSearch7.6.2安装与简单操作
cgl_dong的博客
06-12 2250
ElasticSearch7.6.2安装与简单操作 Es系列工具都是开箱即用，所以安装比较简单，各个系统下都是解压即可 前置环境： windows10 ES7.6.2 Kibana7.6.2 ：Es的可视化操作工具 ES中值得注意的事项： ​ type逐渐移除，预计版本8中将消失 ​ head插件在高等级的版本中，不支持直接安装，需要nodejs支持，我没有使用这个插件。 ​ SpringBoot与Es的整合，需要注意版本支持，且在7.x的ES版本中客户端更新为高级操作客户端，在 Spring
Elasticsearch系列（六）--安装Logstash
ljj2312的专栏
07-05 330
1.下载Logstash安装包 logstash-6.4.0.tar.gz 2.解压 tar -zxvf logstash-6.4.0.tar.gz -C ../ 3.安装logstash-input-jdbc和logstash-output-elasticsearch插件 cd logstash-6.4.0/ 安装插件的命令分别是(在Logstash主目录下运行)： ./bin/l...
ElasticSearch
Welcome to My blog
07-08 405
文章目录全文检索基础一、什么是全文检索？1.全文检索流程2.相关概念2.1. 索引库二. ElasticSearch简介2.1 什么是ElasticSearch2.2 ElasticSearch的使用案例2.3 ElasticSearch对比Solr三.ElasticSearch相关概念(术语)3.1概述3.2 Elasticsearch核心概念3.2.1 索引 index3.2.2 类型 type3.2.3 字段Field3.2.4 映射 mapping3.2.5 文档 document3.2.6 接近.
ES7.6.2+ik7.6.2+head7.6.2+logstash-7.6.2.zip
07-28
1. **Elasticsearch (ES7.6.2)**：Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎，用于实时的全文检索、日志聚合以及数据分析。版本 7.6.2 提供了优化的性能、稳定性和新特性。它支持横向扩展，...
elasticsearch-7.6.2-windows-x86_64安装包,无需积分下载
06-25
10. **社区支持**：Elasticsearch拥有庞大的社区，提供了丰富的插件和解决方案，如Kibana（可视化工具）、Logstash（日志收集）和Beats（轻量级数据发送者）等，形成了ELK（Elasticsearch、Logstash、Kibana）堆栈。...
ElasticSearch7.6.2 五种工具安装包之一
01-29
Elasticsearch 7.6.2 是一个高度可扩展、高性能的开源全文搜索引擎，广泛用于实时数据分析、日志聚合和搜索应用。它基于 Lucene 库构建，提供了分布式、RESTful 风格的接口，使得操作简单而高效。Elasticsearch 的五...
elasticsearch-7.6.2-linux-x86_64.tar.gz
04-04
elasticsearch最新版：elasticsearch-7.6.2-linux-x86_64.tar.gz。elastic家族其他产品（含windows、linux版）最新版亦可从我的资源页获取https://download.csdn.net/user/u010887744/uploads，如果没找到你想要的可以前往公众号zxiaofan留言
Windows下安装ElasticSearch7.6.2
haiming0415的博客
08-10 2204
Windows下安装ElasticSearch Elasticsearch == 7.6.2 下载地址：链接：https://pan.baidu.com/s/1P3hFp4Zv1Z4v46MAJ1arqQ 提取码：cqn4 1、安装JDK ElasticSearch是基于lucence开发的，也就是运行需要java jdk支持。所以要先安装JAVA环境。 由于ElasticSearch 5.x 往后依赖于JDK 1.8的，所以现在我们下载JDK 1.8或者更高版本。 下载JDK1.8,下载完成后安装。
ElasticSearch7.6.2
IT__Small_white的博客
05-04 686
ElasticSearch7.6.2 本文章中的内容，博主学习至B站《狂神说Java》：https://www.bilibili.com/video/BV17a4y1x7zq 最终成果为爬取京东网站商品内容，插入Elasticsearch的索引中，再从索引中查询出并查询关键字高亮显示到本地网页中。 1，创建springboot项目，导入elasticsearch的依赖以及解析网页jsoup依赖和阿...
Elasticsearch-2 安装Kibana 安装Logstash
飘然渡沧海的博客
03-31 1152
Elasticsearch 下载 这里我安装的跟我的es对应版本 https://www.elastic.co/cn/downloads/past-releases/kibana-7-1-0 建议大家尽量使用对应版本，避免造成不兼容 解压安装 解压 tar -zxvf kibana-7.1.0-linux-x86_64.tar.gz 找到kibana.yml 修改端口，因为我上一张修改了es的端口号，所以这里也要修改一下 /kibana-7.1.0-linux-x86_64/config server.
Docker 安装Elasticsearch7.6.2
sinat_32408363的博客
03-01 2684
安装Elasticsearch版本 为7.6.2 1、docker拉取Elasticsearch sudo docker pull elasticsearch:7.6.2 2.添加配置目录 sudo mkdir -p /es/elasticsearch/config 3.添加数据目录 sudo mkdir -p /es/elasticsearch/data 4 配置详情 echo "http.host: 0.0.0.0" >> /es/elasticse...
CentOS 7.6安装 Elasticsearch7.6.2
天外有天，人外有人。 专注品质 不断创新 让精益求精成为习惯
12-23 1312
安装Java11 参照：https://blog.csdn.net/CsethCRM/article/details/112221486
Linux 安装ElasticSearch7.6.2和Kibana7.6.2
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
10-17 1555
最近公司业务正好需要使用到ElasticSearch进行全文搜索和评分。就花时间简单学习了一下，本篇博客是期间学习内容的整理汇总。由于项目使用的spring boot是2.3.12版本对应的ElasticSearch为7.6.2版本。本篇博客主要介绍Linux安装ElasticSearch7.6.2和Kibana7.6.2通过本篇博客可以成功安装和使用。ps：kibana为ElasticSearch提供web界面。
elasticsearch7.6.2集群源码安装(含x-pack白金 head插件)
qq_25934401的博客
06-02 1828
一、搭建最新版本的elasticsearch7.6.2集群源码安装 环境 服务器 配置 服务 系统 es版本 节点名字 192.168.10.60 20G 12core 200G磁盘 node.master/node.data CentOS 7.7 es7.6.2 master-1/node-1 192.168.10.61 20G 12core 200G磁盘 node.master/node.data CentOS 7.7 es7.6.2 master-2/node-2 192.
Elasticsearch 7.6.2版本发布，支持Linux和Windows
它也是 Elastic Stack（之前称为 ELK Stack）的一部分，Elastic Stack 包括 Elasticsearch、Kibana、Beats 和 Logstash。Elasticsearch 用于存储和检索数据，Logstash 用于数据收集，Kibana 用于数据可视化，Beats ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值