elk使用爬坑记录 3 之 SpringBoot 中 Elasticsearch 相关API的使用

最新推荐文章于 2023-10-05 20:47:18 发布
最新推荐文章于 2023-10-05 20:47:18 发布
阅读量472 收藏
点赞数 1
分类专栏： J2EE 文章标签： Java elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zj20142213/article/details/100607005
版权
  1. 首先需要再application.properties中配置elasticsearch的相关属性：
#-----------------elasticsearch相关的配置------------------
es.host=192.168.X.X
es.port=9200
es.scheme=http
es.time-out=60000
es.max.batch=10000
  1. EsUtils.java
package com.innovamed.amo.common.log.operation.es.server.utils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.annotation.PostConstruct;

import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;
import com.innovamed.amo.common.log.operation.es.server.enums.EsIndexSchemaEnums;
import com.innovamed.amo.common.log.operation.es.server.model.EsEntity;

/***
* 
* Copyright: Copyright (c) 2019 Jun_Zhou
* 
* @ClassName: EsUtils.java
* @Description: es操作相关的枚举类;
* 
* @version: v1.0.0
* @author: JunZhou
* @Email: 1769676159@qq.com
* @Site: CERNO
* @date: 2019年9月6日 上午9:32:44
*/
@SuppressWarnings("rawtypes")
//@Component
public class EsUtils
{
	@Value("${es.host}")
    public String host;
    @Value("${es.port}")
    public int port;
    @Value("${es.scheme}")
    public String scheme;
    @Value("${es.time-out}")
    public String timeOut;
    @Value("${es.max.batch}")
    public String maxBatchOpNum;

    public static final String    INDEX_NAME = EsIndexSchemaEnums.AMO_OPERATION_LOG_INDEX.getIndexName();
    public static final String  INDEX_SCHEMA = EsIndexSchemaEnums.AMO_OPERATION_LOG_INDEX.getIndexSchema();
    public static RestHighLevelClient client = null;


    @PostConstruct
    public void init() 
    {
        try {
	            if (client != null) 
	            {
	                client.close();
	            }
	            	initIndex();
        	} catch (Exception e) {
        			e.printStackTrace();
        			System.exit(0);
        }
    }
    
    /***
           * 初始化索引;
     * @throws Exception
     * @throws IOException
     */
	public void initIndex() throws Exception, IOException
	{
		HttpHost httpHost = new HttpHost(host, port, scheme);
                 client   = new RestHighLevelClient(RestClient.builder(httpHost));
		if (this.indexExist(INDEX_NAME)) 
		{
		    return;
		}
		CreateIndexRequest request = new CreateIndexRequest(INDEX_NAME);
						   request.settings(Settings.builder().put("index.number_of_shards", 3).put("index.number_of_replicas", 2));
						   request.mapping(INDEX_SCHEMA, XContentType.JSON);
		CreateIndexResponse    res = client.indices().create(request, RequestOptions.DEFAULT);
		if (!res.isAcknowledged()) 
		{
		    throw new RuntimeException("初始化失败");
		}
	}

    /**
     * @Des:         判断某个index是否存在
     * @param index: es的索引名称;
     * @return       boolean
     * @throws       Exception
     */
    public boolean indexExist(String index) throws Exception {
        GetIndexRequest request = new GetIndexRequest(index);
        			    request.local(false);
        			    request.humanReadable(true);
        			    request.includeDefaults(false);
            return client.indices().exists(request, RequestOptions.DEFAULT);
    }

    /**
     * @Des:          插入/更新一条记录
     * @param index:  索引名称;
     * @param entity: es数据实体;
     */
    public void insertOrUpdateOne(String index, EsEntity entity) 
    {
        IndexRequest request = new IndexRequest(index);
        			 request.id(entity.getId());
        			 request.source(JSON.toJSONString(entity.getData()), XContentType.JSON);
        try {
            		 client.index(request, RequestOptions.DEFAULT);
        	} catch (Exception e) 
            {
                   throw new RuntimeException(e);
            }
     }

    /**
     * @Des:         批量插入数据
     * @param index: index名称;
     * @param list:  待插入的数据列表;
     */
    public void insertBatch(String index, List<EsEntity> list) {
        BulkRequest request = new BulkRequest();
        list.forEach(item -> request.add(new IndexRequest(index).id(item.getId())
                .source(JSON.toJSONString(item.getData()), XContentType.JSON)));
        try 
        {
            		client.bulk(request, RequestOptions.DEFAULT);
        } catch (Exception e) {
            	throw new RuntimeException(e);
        }
    }

    /**
     * @Des:          批量删除
     * @param index:  索引名称;
     * @param delSet: 待删除的数据集合;
     */
    public <T> void deleteBatch(String index, Collection<T> delSet) {
        BulkRequest request = new BulkRequest();
        delSet.forEach(item -> request.add(new DeleteRequest(index, item.toString())));
        try {
            client.bulk(request, RequestOptions.DEFAULT);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Des: 			搜索指定索引中的指定数据;
     * @param index:	指定的索引名称;
     * @param builder:	查询参数
     * @param c:		结果类对象的class对象;
     * @return java.util.ArrayList
     */
    public <T> List<T> search(String index, SearchSourceBuilder builder, Class<T> c) {
        SearchRequest request = new SearchRequest(index);
        request.source(builder);
        try {
            SearchResponse    	response  = 	client.search(request, RequestOptions.DEFAULT);
            SearchHit[] 			hits  = 	response.getHits().getHits();
            List<T> res = new ArrayList<>(hits.length);
            for (SearchHit hit : hits) 
            	{
                	res.add(JSON.parseObject(hit.getSourceAsString(), c));
            	}
            	return res;
        	} catch (Exception e) 
        	{
        		throw new RuntimeException(e);
        	}
    }

    /**
     * @Des:        删除指定的index
     * @param index：索引名称;
     */
    public void deleteIndex(String index) 
    {
        try 
        {
            client.indices().delete(new DeleteIndexRequest(index), RequestOptions.DEFAULT);
        } catch (Exception e) {
               throw new RuntimeException(e);
        }
    }

    /**
     * @Des: 			根据条件删除数据;
     * @param index:	指定的索引名称;
     * @param builder:	条件构造器;
     */
    public void deleteByQuery(String index, QueryBuilder builder) 
    {
        DeleteByQueryRequest request = new DeleteByQueryRequest(index);
        request.setQuery(builder);
        //设置批量操作数量,最大为10000
        request.setBatchSize(Integer.parseInt(maxBatchOpNum));
        request.setConflicts("proceed");
        try {
            	client.deleteByQuery(request, RequestOptions.DEFAULT);
        	} catch (Exception e) 
        	{
        		throw new RuntimeException(e);
        	}
    }
    
}
  1. AmoOperationLogController.java
package com.innovamed.amo.common.log.operation.es.server.controller;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.innovamed.amo.common.log.operation.es.client.annotation.AccessLog;
import com.innovamed.amo.common.log.operation.es.client.model.OperationLog;
import com.innovamed.amo.common.log.operation.es.server.constants.OpTypeConstants;
import com.innovamed.amo.common.log.operation.es.server.model.EsEntity;
import com.innovamed.amo.common.log.operation.es.server.utils.EsUtils;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.UUID;

/***
* 
* Copyright: Copyright (c) 2019 Jun_Zhou
* 
* @ClassName: AmoOperationLogController.java
* @Description: Amo项目的用户行为日志操作控制器;
* 
* @version: v1.0.0
* @author: JunZhou
* @Email: 1769676159@qq.com
* @Site: CERNO
* @date: 2019年9月6日 上午8:57:56
*/
//@RestController
@RequestMapping("/amo_operation_log")
public class AmoOperationLogController
{
    @Autowired
    private EsUtils esUtil;

    /**
     * @Des:   根据记录的Id获取某一个索引下的文档记录;
     * @param: uuid
     * @return
     */
    @GetMapping("/{uuid}")
    public OperationLog getById(@PathVariable("uuid") int uuid) {
        SearchSourceBuilder builder = 	new SearchSourceBuilder();
        					builder.query(new TermQueryBuilder("uuid", uuid));
        List<OperationLog> 			res 	= 	esUtil.search(EsUtils.INDEX_NAME, builder, OperationLog.class);
        					if (res.size() > 0) {
        						return res.get(0);
        					} else {
        	return null;
        					}
    }

    /**
     * @Des:	获取指定索引下的全部文档记录;
     * @return
     */
    @GetMapping("/")
    public List<OperationLog> getAll() {
        return esUtil.search(EsUtils.INDEX_NAME, new SearchSourceBuilder(), OperationLog.class);
    }

    /***
     * @Des:			根据关键信息搜索指定索引下的文档;
     * @param uuid:		文档的uuid;
     * @param operator:	操作者;
     * @return
     */
    @GetMapping("/search")
    public List<OperationLog> searchByUserIdAndName(@RequestParam("uuid") String uuid,@RequestParam("operator")  String operator) {
        BoolQueryBuilder 	boolQueryBuilder = new BoolQueryBuilder();
        			     	//boolQueryBuilder.must(QueryBuilders.termQuery("uuid", uuid));
        			     	boolQueryBuilder.must(QueryBuilders.matchQuery("operator", operator));
        SearchSourceBuilder builder = new SearchSourceBuilder();
        					builder.size(10).query(boolQueryBuilder);
        return esUtil.search(EsUtils.INDEX_NAME, builder, OperationLog.class);

    }
    
    
    /***
     * @Des:	根据关键词模糊搜索某用户的行为日志;
     * @param:  operationLog:操作日志实体;
     * @return
     */
    @GetMapping("/fuzzyQueryByCondition")
    public List<OperationLog> searchByCondition(@RequestBody OperationLog operationLog) {
    	String uuid = operationLog.getUuid();
    	String operator = operationLog.getOperator();
        BoolQueryBuilder 	boolQueryBuilder = new BoolQueryBuilder();
        				 	boolQueryBuilder.must(QueryBuilders.termQuery("uuid", uuid));
        				    boolQueryBuilder.must(QueryBuilders.fuzzyQuery("operator", operator));
        SearchSourceBuilder builder = new SearchSourceBuilder();
        					builder.size(10).query(boolQueryBuilder);
        return esUtil.search(EsUtils.INDEX_NAME, builder, OperationLog.class);
    }

    /***
     * @Des:	单个插入用户的操作日志;
     * @param:  operationLog:用户行为日志实体;
     */
    @PutMapping("/")
    public void putOne(@RequestBody OperationLog operationLog) {
        EsEntity<OperationLog> entity = new EsEntity<OperationLog>(operationLog.getUuid(), operationLog);
        esUtil.insertOrUpdateOne(EsUtils.INDEX_NAME, entity);
    }

    /***
     * @Des:					批量插入用户的操作日志;
     * @param operationLogSet:  用户行为日志的集合;
     */
    @SuppressWarnings("rawtypes")
	@PutMapping("/many")
    @AccessLog(type=OpTypeConstants.ADD,des="批量插入用户的操作日志")
    public void putList(@RequestBody List<OperationLog> operationLogSet) {
    	List<OperationLog>  logSet  =  new ArrayList<OperationLog>();
    				for (int i = 0; i < 1; i++)
					{
    					Date date = new Date();
    					OperationLog opLog 		   = 	new OperationLog();
    								 opLog.setUuid(UUID.fastUUID().toString());
    								 opLog.setOperationType("DEL");
    								 opLog.setOperationDes("Del by Id");
    								 opLog.setOperator("JunZhou");
    								 opLog.setReferIp("127.0.0.1");
    								 opLog.setReferMac("0000::0000::0000");
    								 opLog.setCreateTime(DateUtil.formatDateTime(date));
    								 opLog.setOperateTime(DateUtil.formatDateTime(date));
    								 opLog.setOperateResult("SUCCESS");
    								 opLog.setCreator("LOGGER");
    								 logSet.add(opLog);
					}
    				operationLogSet = logSet;
        List<EsEntity> list  =  new ArrayList<EsEntity>();
        operationLogSet.forEach(item -> list.add(new EsEntity<OperationLog>(item.getUuid(), item)));
        esUtil.insertBatch(EsUtils.INDEX_NAME, list);
    }

    /***
     * @Des:   批量删除指定索引下的文档数据;
     * @param: list
     */
    @DeleteMapping("/deleteBatch")
    public void deleteBatch(List<Integer> list) {
        esUtil.deleteBatch(EsUtils.INDEX_NAME, list);
    }

    /***
     * @Des:	根据操作用户的信息删除指定索引下的用户行为日志的文档;
     * @param:  operator
     */
    @DeleteMapping("/operator/{operator}")
    public void deleteByUserId(@PathVariable("operator") int operator) {
        esUtil.deleteByQuery(EsUtils.INDEX_NAME, new TermQueryBuilder("operator", operator));
    }

}
  1. EsIndexConstants.java
package com.innovamed.amo.common.log.operation.es.server.constants;
/***
* 
* Copyright: Copyright (c) 2019 Jun_Zhou
* 
* @ClassName: IndexConstants.java
* @Description: es索引的默认常量集合;
* 
* @version: v1.0.0
* @author: JunZhou
* @Email: 1769676159@qq.com
* @Site: CERNO
* @date: 2019年9月6日 上午9:24:30
 */
public class EsIndexConstants
{   
	/**
	 * amo用户行为日志记录的es索引结构描述json结构;
	 */
	public static final String AMO_OPERATION_LOG_INDEX = 
			"{\r\n" + 
			"   \"properties\":{\r\n" + 
			"	\"referMac\":			{\"type\":\"text\"},\r\n" + 
			"	\"creator\": 			{\r\n" + 
			"						\"type\":\"text\",\r\n" + 
			"						\"index\":true,\r\n" + 
			"						\"analyzer\":\"ik_max_word\",\r\n" + 
			"						\"search_analyzer\":\"ik_smart\"\r\n" + 
			"						},\r\n" + 
			"	\"operationDes\": 	{\r\n" + 
			"						\"type\":\"text\",\r\n" + 
			"						\"index\":true,\r\n" + 
			"						\"analyzer\":\"ik_max_word\",\r\n" + 
			"						\"search_analyzer\":\"ik_smart\"\r\n" + 
			"						},\r\n" + 
			"	\"operateResult\":	{\"type\":\"text\",\r\n" + 
			"						 \"index\":true\r\n" + 
			"						},\r\n" + 
			"	\"createTime\": 		{\"type\":\"date\",\r\n" + 
			"						 \"index\":true,\r\n" + 
			"						 \"format\":\"yyyy-MM-dd HH:mm:ss || yyyy-MM-dd || yyyy/MM/dd HH:mm:ss|| yyyy/MM/dd ||epoch_millis\"\r\n" + 
			"									},\r\n" + 
			"	\"operateTime\": 		{\"type\":\"date\",\r\n" + 
			"						 \"index\":true,\r\n" + 
			"						 \"format\":\"yyyy-MM-dd HH:mm:ss || yyyy-MM-dd || yyyy/MM/dd HH:mm:ss|| yyyy/MM/dd ||epoch_millis\"\r\n" + 
			"									},\r\n" + 
			"	\"operationType\": 	{\"type\":\"text\"},\r\n" + 
			"	\"referIp\": 			{\"type\":\"text\",\r\n" + 
			"						 \"index\":true\r\n" + 
			"						},\r\n" + 
			"	\"uuid\": 			{\"type\":\"text\",\r\n" + 
			"						 \"index\":true\r\n" + 
			"						 },\r\n" + 
			"	\"operator\": 		{\"type\":\"text\",\r\n" + 
			"						 \"index\":true\r\n" + 
			"						}\r\n" + 
			"			}\r\n" + 
			"}";
}
  1. 注意事项：
    a.再elasticsearch中时间戳格式对应的type为date，定义格式如下：
"createTime": 		{"type":"date",
						 "index":true,
						 "format":"yyyy-MM-dd HH:mm:ss || yyyy-MM-dd || yyyy/MM/dd HH:mm:ss|| yyyy/MM/dd ||epoch_millis"
									},
	"operateTime": 		{"type":"date",
						 "index":true,
						 "format":"yyyy-MM-dd HH:mm:ss || yyyy-MM-dd || yyyy/MM/dd HH:mm:ss|| yyyy/MM/dd ||epoch_millis"
									},

b.Kibanaz中的时间会比上海时间早八个小时，为了最简单的解决时间匹配问题，建议在将数据导入elasticsearch中的时候自动向后偏移8小时,如下所示：

//用户行为的发生时间,注意向后偏移8小时，否则在kibana中将显示有误;
Date date = DateUtil.offsetHour(DateUtil.date(), -8);

代码资源（代码已做保密处理）：操作elasticsearch的java restful api

SuperPurse
关注
专栏目录
SpringBoot集成elasticsearch 7.17.3及常规应用
wohaipagui的博客
05-11 4477
elasticsearch 7.17.3下载地址： 链接：https://pan.baidu.com/s/1o30iawcZPhV6sYcd9jym9g?pwd=0nt0 提取码：0nt0 前提：需要安装elasticsearch工具 一、创建项目 1.创建个空项目 在这里插入图片描述 默认的（Developer Tools）都需要勾选，最主要的是NoSQL中选中ElasticSearch 配置编译版本 二、修改配置 1. 删除maven没用的插件 2. 修改spring版本到本地版本 3
SpringBoot整合ElasticSearch实现多版本的兼容
最新发布
2401_84094979的博客
05-04 856
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！[{“id”:2,“name”:“李四”,“age”:14,“description”:“李四是个测试工程师”,“createtm”: “1980-2-15 19:01:32”}, {“id”:1,“name”:“张三”,“age”:20,“description”:“张三是个Java开发工程师”, “createtm”: “2018-4-25 11:07:42”}, {“id”:3,“name”:“王五”,
SpringBoot2.0整合Elasticsearch6.0使用ElasticsearchRepository接口实践
01-23
SpringBoot2.0整合Elasticsearch6.0,使用SpringBoot对ES支持ElasticsearchRepository接口API，ElasticsearchTemplate接口API实现ES的增删改查实践
Elasticsearch集成spring boot操作API
weixin_51627264的博客
11-19 291
找到Elasticsearch Clients选择Java client找到所需的maven依赖 依赖以下包 初始化 创建配置类 具体api测试 创建实体类**user 测试API操作
ElasticSearch集成Spring boot详解（相关API操作）
Java是世界上最好的语言
12-04 1183
官方文档 https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/index.html 工程创建 自行创建Spring boot 工程即可。 引入依赖 需要和自己安装的es版本一致 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-start.
SpringBoot+检索：ElasticSearch
ycd500756的博客
07-05 431
简述 ElasticSearch 是可以快速的存储、搜索和分析海量数据。Spring Boot通过整合Spring Data ElasticSearch为我们提供了非常便捷的检索功能支持。 Elasticsearch是一个分布式搜索服务，提供Restful API，底层基于Lucene，采用 多shard（分片）的方式保证数据安全，并且提供自动resharding的功能。...
SpringBoot集成ElasticSearch API操作
我是60岁程序员
10-18 1012
&amp;lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&amp;gt; &amp;lt;project xmlns=&quot;http://maven.apache.org/POM/4.0.0&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;
SpringBoot整合Elasticsearch完整源码
02-16
Spring Data Elasticsearch是Spring Data项目的一部分，它为Elasticsearch提供了一套易于使用的API和Repository抽象，使得在Spring Boot应用中操作Elasticsearch变得简单。 8. **es-sample**： 这个文件名可能...
java版斗地主源码-ELK:es-api:es整合springboot，常用api测试；es-jd:仿京东商城，使用es海量数据搜索以及高亮
06-04
类似谷歌、百度这种大数据全文搜索引擎的场景都可以使用ElasticSearch作为底层支持框架，可见ElasticSearch提供的搜索能力确实强大，世面上很多时候我们简称ElasticSearch为es。Logstash是ELK的中央数据流引擎，用于...
springboot - 2.7.3版本 - （五）整合Elasticsearch+Logstash+Kibana（ELK）
09-28
在本文中，我们将深入探讨如何使用Spring Boot 2.7.3版本与Elasticsearch、Logstash和Kibana（通常称为ELK Stack）进行集成，以便高效地收集、存储和分析应用程序日志。ELK Stack是日志管理和监控的强大工具，其中...
ElasticSearch（10）—SpringBoot集成ES
༺࿈无关痛痒࿈༻的博客
04-16 343
上一篇：ElasticSearch（9）—Rest风格 SpringBoot项目集成ES 一、引入依赖    首先创建一个springboot项目，并勾选下图中的一些基本依赖： 官方文档es-client依赖 按照官方文档，springboot项目集成es首先需要导入es客户端，但是因为在创建项目的时候勾选了elasticsearch的起步依赖，查看该起步依赖发现底层已经引用了高级客户端 ...
SpringBoot整合ElasticSearch及API详解
倔强100%的博客
11-25 1247
ELK简介 ELK是三个开源软件的缩写，分别表示：Elasticsearch , Logstash, Kibana , 它们都是开源软件。 Elasticsearch是个开源分布式搜索引擎，提供搜集、分析、存储数据三大功能。它的特点有：分布式，零配置，自动发现，索引自动分片，索引副本机制，restful风格接口，多数据源，自动搜索负载等。 Logstash 主要是用来日志的搜集、分析、过滤日志的工具，支持大量的数据获取方式。一般工作方式为c/s架构，client端安装在需要收集日志的主机上，server端负
【ELK技术栈】详解 SpringBoot 集成 ElasticSearch 之项目实战：关于索引的API操作、关于文档的API操作
Zhou_LC的博客
09-23 337
文章目录1 相应的官方文档2 项目实战2.1 添加依赖2.2 添加配置类2.3 关于索引的API操作2.3.1 创建索引2.3.2 索引是否存在2.3.3 删除索引2.4 关于文档的API操作2.4.1 添加文档2.4.2 文档是否存在2.4.3 获取文档信息2.4.4 更新文档信息2.4.5 删除文档2.4.6 批量添加文档2.4.7 条件查询文档 1 相应的官方文档 1、ES 的依赖 <dependency> <groupId>org.elasticsear
Springboot整合elasticSearch的官方API实例
weixin_30539625的博客
06-09 355
前言：在上一篇博客中,我介绍了从零开始安装ElasticSearch,es是可以理解为一个操作数据的中间件,可以把它作为数据的存储仓库来对待,它具备强大的吞吐能力和计算能力，其基于Lucene服务器开发,在搜索领域具有统治般的地位。平时可以通过命令来执行语句来查询ES,但是在实际的开发中，还是以使用API居多，关于ES的第三方框架有很多，比如BBOSS、spring也对其进行封装叫做spring-...
SpringBoot：SpringBoot整合Elasticsearch案例
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
02-16 1万+
声明：原作者：微信公众号：悟空聊架构 文章目录声明：原作者：微信公众号：悟空聊架构前言一、Elasticsearch 组件库介绍二、整合检索服务1.1 添加搜索服务模块1.2 配置 Maven 依赖1.3 注册搜索服务到注册中心1.4 添加 ES 配置类1.5 测试 ES Client 自动加载1.6 测试 ES 简单插入数据1.7 测试 ES 查询复杂语句1.7.1 构造检索条件17.2 获取命中记录的详情1.7.3 获取年龄分布聚合信息1.7.4 获取平均薪资聚合信息三、实战：同步 ES 数据3.1 定
ES报错：org.elasticsearch.client.Request.＜init＞(Ljava/lang/String；Ljava/lang/String；)V
xzj80927的博客
09-13 2058
今天ES执行时，报这个错误： org.elasticsearch.client.Request.<init>(Ljava/lang/String;Ljava/lang/String;)V Maven： <!-- elasticSearch start --> <dependency> <groupId>org.elasticsearch.client</groupId> .
基于SpringBoot的ElasticSearch操作（超详细教程）
Coder
10-05 5565
基于SpringBoot+Elasticsearch的操作项目， 从零到一，囊括了es本身的API操作、java代码的请求 （索引操作、doc操作插入、精准搜索、模糊搜索、聚合搜索等）
生产环境使用elasticsearch遇到的一些问题以及解决方法（不断更新）
热门推荐
云端分布式搜索技术
11-17 7万+
1.由gc引起节点脱离集群      因为gc时会使jvm停止工作，如果某个节点gc时间过长，master ping3次（zen discovery默认ping失败重试3次）不通后就会把该节点剔除出集群，从而导致索引进行重新分配。 解决方法： （1）优化gc，减少gc时间。（2）调大zen discovery的重试次数（es参数：ping_retries）和超时时间（es参数：ping_ti
【ElasticSearch教程】--- Elasticsearch JavaApi 索引操作（十七）
maoye的博客
05-11 750
JavaApi 索引操作 与RESTful api类似， java api 是采用代码的形式操作索引，也有相同的索引增、改、查操作。下面我们对api 一一进行测试。 创建索引 步骤： 创建HttpHost对象，该对象主要用于链接ES服务器的描述，包含了, host, port, schema。 创建RestClientBuilder对象，该对象由RestClient对象的静态方法build创建，需要带入HttpHost。集群应该还可以带入多个HttpHost。 创建关键对象RestHighLevelCli
springboot elk 4560
09-11
Spring Boot是一个用于创建独立的、生产级的Spring应用程序的框架。ELK是指Elasticsearch、Logstash和Kibana的组合，用于处理和可视化日志数据。 如果你想在Spring Boot应用程序中集成ELK，你可以按照以下步骤进行操作： 1. 首先，确保你已经安装了Elasticsearch、Logstash和Kibana。你可以从官方网站下载并安装它们。 2. 在你的Spring Boot应用程序中，添加适当的依赖项。对于Elasticsearch，你可以使用Spring Data Elasticsearch提供的依赖项。对于Logstash，你可以使用Logstash的Java API或者将日志数据发送到Logstash的TCP/UDP端口。对于Kibana，你可以直接使用Kibana的Web界面。 3. 配置Elasticsearch和Logstash。在Spring Boot应用程序中，你可以在application.properties或application.yml文件中配置Elasticsearch的连接信息。对于Logstash，你需要创建一个Logstash配置文件，指定从哪里获取日志数据，并将其发送到Elasticsearch。 4. 在你的Spring Boot应用程序中记录日志。使用Spring Boot的内置日志记录功能（如logback或log4j），将日志记录到日志文件或控制台。 5. 在Kibana中可视化日志数据。打开Kibana的Web界面，并创建适当的索引模式和可视化仪表板，以便查看和分析日志数据。 这只是一个简单的概述，如果你需要更详细的指导，请参考Spring Boot、Elasticsearch、Logstash和Kibana的官方文档。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值