Elasticsearch实战——JAVA客户端API

最新推荐文章于 2024-07-07 16:23:04 发布
最新推荐文章于 2024-07-07 16:23:04 发布
阅读量497 收藏 3
点赞数 1
分类专栏： 搜索引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dwjf321/article/details/103854116
版权

Elasticsearch实战——JAVA客户端API

文章目录

1. 创建spring-boot项目

1.1 pom.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.elasticsearch.java.api</groupId>
	<artifactId>elasticsearch-java-api</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>es</name>
	<description>elasticsearch的java api使用</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
			<exclusions>
				<exclusion>
					<groupId>org.elasticsearch</groupId>
					<artifactId>elasticsearch</artifactId>
				</exclusion>
				<exclusion>
					<groupId>org.apache.lucene</groupId>
					<artifactId>lucene-core</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.elasticsearch.client</groupId>
			<artifactId>elasticsearch-rest-high-level-client</artifactId>
			<version>7.5.0</version>
		</dependency>
	<dependency>
      <groupId>org.elasticsearch</groupId>
      <artifactId>elasticsearch</artifactId>
	<version>7.5.0</version>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

1.2 启动类配置

//关闭spring-boot的自动装配elasticsearch
@SpringBootApplication(exclude = {ElasticsearchAutoConfiguration.class})
public class RunApplication {
	
	public static void main(String[] args) throws IOException {
		SpringApplication.run(RunApplication.class, args);
    }
}

1.3 properties配置

#elasticesearch配置
elasticsearch.node[0].host=127.0.0.1
elasticsearch.node[0].port=9200

1.4 ElasticSearchProperties.java配置

@Configuration
@ConfigurationProperties(prefix = "elasticsearch")
public class ElasticSearchProperties {
    private List<ESNode> node;
    private int connectTimeOut = 1000;
    private int socketTimeOut = 30000;
    private int connectionRequestTimeOut = 500;
    private int maxConnectNum = 100;
    private int maxConnectPreRoute = 100;


    public int getConnectTimeOut() {
        return connectTimeOut;
    }

    public void setConnectTimeOut(int connectTimeOut) {
        this.connectTimeOut = connectTimeOut;
    }

    public int getSocketTimeOut() {
        return socketTimeOut;
    }

    public void setSocketTimeOut(int socketTimeOut) {
        this.socketTimeOut = socketTimeOut;
    }

    public int getConnectionRequestTimeOut() {
        return connectionRequestTimeOut;
    }

    public void setConnectionRequestTimeOut(int connectionRequestTimeOut) {
        this.connectionRequestTimeOut = connectionRequestTimeOut;
    }

    public int getMaxConnectNum() {
        return maxConnectNum;
    }

    public void setMaxConnectNum(int maxConnectNum) {
        this.maxConnectNum = maxConnectNum;
    }

    public int getMaxConnectPreRoute() {
        return maxConnectPreRoute;
    }

    public void setMaxConnectPreRoute(int maxConnectPreRoute) {
        this.maxConnectPreRoute = maxConnectPreRoute;
    }

    public List<ESNode> getNode() {
        return node;
    }

    public void setNode(List<ESNode> node) {
        this.node = node;
    }
}

public class ESNode {
    private String host;
    private int port;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

}

1.5 ElasticSearchConfiguration.java配置

import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig.Builder;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestClientBuilder.HttpClientConfigCallback;
import org.elasticsearch.client.RestClientBuilder.RequestConfigCallback;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class ElasticSearchConfiguration {
	ElasticSearchProperties properties;
	
	@Autowired
	public ElasticSearchConfiguration(ElasticSearchProperties properties) {
		this.properties = properties;
	}
	
	@Bean("client")
	public RestHighLevelClient client() {
		List<HttpHost> list = new ArrayList<HttpHost>();
		List<ESNode> node = properties.getNode();
		for (ESNode n : node) {
			list.add(new HttpHost(n.getHost(), n.getPort()));
		}
		HttpHost[] array = list.toArray(new HttpHost[list.size()]);
		RestClientBuilder builder = RestClient.builder(array);
		setConnectTimeOutConfig(builder);
		setMutiConnectConfig(builder);
		RestHighLevelClient client = new RestHighLevelClient(builder);
		return client;
	}
	
	
	/**
	 * 主要关于异步httpclient的连接延时配置
	 * @param builder 
	 */
	private void setConnectTimeOutConfig(RestClientBuilder builder) {
		builder.setRequestConfigCallback(new RequestConfigCallback() {

			@Override
			public Builder customizeRequestConfig(Builder requestConfigBuilder) {
				requestConfigBuilder.setConnectTimeout(properties.getConnectTimeOut());
				requestConfigBuilder.setSocketTimeout(properties.getSocketTimeOut());
				requestConfigBuilder.setConnectionRequestTimeout(properties.getConnectionRequestTimeOut());
				return requestConfigBuilder;
			}

		});

	}

	/**
	 * 主要关于异步httpclient的连接数配置
	 * @param builder 
	 */
	private void setMutiConnectConfig(RestClientBuilder builder) {
		builder.setHttpClientConfigCallback(new HttpClientConfigCallback() {

			@Override
			public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
				// 指定最大总连接值
				httpClientBuilder.setMaxConnTotal(properties.getMaxConnectNum());
				// 指定每个路由值的最大连接
				httpClientBuilder.setMaxConnPerRoute(properties.getMaxConnectPreRoute());
				return httpClientBuilder;
			}
		});
	}
}

2. JAVA API操作

public class Source {
    private String id;
    private String source;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getSource() {
        return source;
    }

    public void setSource(String source) {
        this.source = source;
    }
}

2.1 引用的java类

import org.apache.commons.lang.StringUtils;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.admin.indices.alias.Alias;
import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest;
import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeResponse;
import org.elasticsearch.action.admin.indices.settings.put.UpdateSettingsRequest;
import org.elasticsearch.action.admin.indices.shrink.ResizeRequest;
import org.elasticsearch.action.admin.indices.shrink.ResizeResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchScrollRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.PutMappingRequest;
import org.elasticsearch.cluster.routing.Preference;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.Scroll;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.List;
import java.util.Map;

2.2 索引管理

2.2.1 创建索引
	/**
	 * 创建索引
	 * @param index 索引名称
	 * @param settings
	 * @param mapping
	 * @param aliasName 索引别名
	 * @return
	 */
	public boolean createIndex(String index, String settings, String mapping, String... aliasName){
		assert StringUtils.isNotBlank(index);
		assert StringUtils.isNotBlank(settings);
		assert StringUtils.isNotBlank(mapping);
		CreateIndexRequest request = new CreateIndexRequest(index);
		alias(request, aliasName);
		if (!StringUtils.isEmpty(settings)){
			request.settings(settings,XContentType.JSON);
		}
		if (!StringUtils.isEmpty(mapping)){
			request.mapping(mapping,XContentType.JSON);
		}


		try {
			CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
			return response.isAcknowledged();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return false;
	}

	private void alias(CreateIndexRequest request, String[] aliasName) {
		if (aliasName != null){
			for (String name : aliasName) {
				if (StringUtils.isEmpty(name)){
					continue;
				}
				Alias alias = new Alias(name);
				request.alias(alias);
			}
		}
	}
2.2.2 修改setting
	/**
	 * 修改setting
	 * @param index
	 * @param settings
	 * @return
	 */
	public boolean settings(String index,String settings){
		assert StringUtils.isNotBlank(index);
		assert StringUtils.isNotBlank(settings);
		UpdateSettingsRequest request = new UpdateSettingsRequest(index);
		try {
			request.settings(settings,XContentType.JSON);
			AcknowledgedResponse response = client.indices().putSettings(request, RequestOptions.DEFAULT);
			return response.isAcknowledged();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return false;
	}
2.2.3 修改mapping
	/**
	 * 修改mapping
	 * @param index
	 * @param mapping
	 * @return
	 */
	public boolean mapping(String index, String mapping){
		assert StringUtils.isNotBlank(index);
		assert StringUtils.isNotBlank(mapping);
		PutMappingRequest request = new PutMappingRequest(index);
		try {
			AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
			return response.isAcknowledged();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return false;
	}
2.2.4 别名操作
	/**
	 * 别名操作
	 * @param index 索引名称
	 * @param alias 别名
	 * @param type  操作类型
	 * @return
	 */
	public boolean alias(String index, String alias,IndicesAliasesRequest.AliasActions.Type type){
		IndicesAliasesRequest request = new IndicesAliasesRequest();
		request.origin(index);
		IndicesAliasesRequest.AliasActions actions = new IndicesAliasesRequest.AliasActions(type);
		actions.alias(alias);
		request.addAliasAction(actions);
		try {
			AcknowledgedResponse response = client.indices().updateAliases(request, RequestOptions.DEFAULT);
			return response.isAcknowledged();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return false;
	}
2.2.5 合并索引
	/**
	 * 合并索引
	 * @param maxNumSegment 预计合并后的最大分段数量
	 * @param indices
	 * @return
	 */
	public boolean forceMerge(int maxNumSegment, String... indices){
		ForceMergeRequest request = new ForceMergeRequest();
		if (indices != null){
			request.indices(indices);
		}
		request.maxNumSegments(maxNumSegment);
		ForceMergeListener listener = new ForceMergeListener();
		client.indices().forcemergeAsync(request, RequestOptions.DEFAULT, listener);
		return true;
	}

	class ForceMergeListener implements ActionListener<ForceMergeResponse> {

		@Override
		public void onResponse(ForceMergeResponse response) {
			RestStatus status = response.getStatus();
			if (status == RestStatus.OK){
				System.out.println("合并索引成功");
			}else {
				System.out.println("合并索引失败");
			}
		}

		@Override
		public void onFailure(Exception e) {
			System.out.println("合并索引失败");
			e.printStackTrace();
		}
	}
2.2.6 缩小索引
/**
	 * 缩小索引
	 * @param sourceIndex
	 * @param targetIndex
	 * @param targetSetting
	 * @return
	 */
	public boolean shrink(String sourceIndex, String targetIndex, String targetSetting){
		ResizeRequest request = new ResizeRequest(targetIndex, sourceIndex);
		org.elasticsearch.action.admin.indices.create.CreateIndexRequest createIndexRequest = new org.elasticsearch.action.admin.indices.create.CreateIndexRequest(targetIndex);
		createIndexRequest.settings(targetSetting, XContentType.JSON);
		request.setTargetIndex(createIndexRequest);
		client.indices().shrinkAsync(request,RequestOptions.DEFAULT, null);
		return true;
	}

	class ShrinkListener implements ActionListener<ResizeResponse> {

		@Override
		public void onResponse(ResizeResponse response) {
			if (response.isAcknowledged()){
				System.out.println("缩小索引成功");
			}else {
				System.out.println("缩小索引失败");
			}
		}

		@Override
		public void onFailure(Exception e) {
			System.out.println("缩小索引失败");
			e.printStackTrace();
		}
	}

2.3 文档管理

2.3.1 创建文档
	/**
	 * 创建索引
	 * @throws IOException
	 */
	public void createDoc(String index, Source source) throws IOException {
		try {
            IndexRequest indexRequest = new IndexRequest(index);
            indexRequest.id(source.getId());
            indexRequest.source(source.getSource(), XContentType.JSON);
            //同步请求
            client.index(indexRequest, RequestOptions.DEFAULT);
		} catch (Exception e) {
			e.printStackTrace();
			
		}
	}
2.3.2 批量创建文档
	/**
	 * 批量创建
	 * @param sourceList
	 * @param index
	 */
	public void bulkCreateDoc(String index, List<Source> sourceList) {
		try {
			BulkRequest bulkRequest = new BulkRequest();
			for (Source source : sourceList) {
				IndexRequest request = new IndexRequest(index);
				if (StringUtils.isNotBlank(source.getId())){
					request.id(source.getId());
				}
				if (StringUtils.isBlank(source.getSource())){
					continue;
				}
				request.source(source.getSource(), XContentType.JSON);
				bulkRequest.add(request);
			}
			client.bulk(bulkRequest,RequestOptions.DEFAULT);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
2.3.3 更新文档
	/**
	 * 创建索引
	 * @throws IOException
	 */
	public void updateDoc(String index, Source source) throws IOException {
		try {
            UpdateRequest updateRequest = new UpdateRequest();
            updateRequest.index(index);
			updateRequest.id(source.getId());
            updateRequest
                .doc(source.getSource(), XContentType.JSON)
                //设置重试次数
                .retryOnConflict(3);
            //同步更新
            client.update(updateRequest);
		} catch (Exception e) {
			e.printStackTrace();
			
		}
	}
2.3.4 批量更新文档
	/**
	 * 批量更新
	 * @param index
	 * @param sourceList
	 */
	public void bulkUpdateDoc(String index, List<Source> sourceList) {
		try {
			BulkRequest bulkRequest = new BulkRequest(index);
			for (Source source : sourceList) {
				UpdateRequest request = new UpdateRequest();
				if (StringUtils.isBlank(source.getId()) || StringUtils.isBlank(source.getSource())){
					continue;
				}
				request.id(source.getId());
				request.doc(source.getSource(), XContentType.JSON);
				bulkRequest.add(request);
			}
			client.bulk(bulkRequest,RequestOptions.DEFAULT);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

2.4 搜索API

2.4.1 根据ID获取文档
	/**
	 * 根据ID获取文档
	 * @param index
	 * @param docId
	 * @return
	 * @throws IOException
	 */
	public List<Source> getDocById(String index, String... docId) throws IOException {
		MultiGetRequest request = new MultiGetRequest();
		for (String id : docId) {
			request.add(index,id);
		}
		MultiGetResponse response = client.mget(request, RequestOptions.DEFAULT);
		MultiGetItemResponse[] responseList = response.getResponses();
		List<Source> result = new ArrayList<>(responseList.length);
		for (MultiGetItemResponse item : responseList) {
			String value = item.getResponse().getSourceAsString();
			Source source = new Source();
			source.setId(item.getId());
			source.setSource(value);
			result.add(source);
		}
		return result;
	}
2.4.2 根据查询条件搜索
	/**
	 * 根据查询条件搜索
	 * @param builder
	 * @param index
	 * @return
	 */	
	public SearchResponse search(SearchSourceBuilder builder, String index) {
		SearchRequest searchRequest = new SearchRequest(index);
        //查询优先级，默认轮询
		//searchRequest.preference(Preference.PREFER_NODES.name());
		//SearchType.DEFAULT;
		//SearchType.DFS_QUERY_THEN_FETCH;提升相关度
		//searchRequest.searchType(SearchType.QUERY_THEN_FETCH.name());
		searchRequest.source(builder);
		/**
		 * 默认对于size>0的request的结果是不会被cache的，即使在index设置中启用了request cache也不行。
		 * 只有在请求的时候，手动加入reqeust cache参数，才可以对size>0的请求进行result cache。
		 * 如果是search，默认是不缓存的，除非你手动打开request_cache=true，在发送请求的时候
		 * 如果是aggr，默认是缓存的，不手动打开request_cache=true，也会缓存聚合的结果
		 */
		//searchRequest.requestCache(true);
		try {
			SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
			
			return response;
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}
2.4.3 滚动查询
Scroll scroll = new Scroll(TimeValue.timeValueMinutes(10));
int size = 1000;
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.from(0);
builder.size(size);
SearchResponse response = search(builder, scroll, index);
SearchHits hits = response.getHits();
SearchHit[] h = hits.getHits();
while (h.length > 0) {
    for (SearchHit doc : h) {
        String id = doc.getId();
        String s = doc.getSourceAsString();
    }
    if (h.length != size) {
        break;
    }
    String scrollId = response.getScrollId();
    response = client.scroll(scrollId, scroll);
    hits = response.getHits();
    h = hits.getHits();
}

public SearchResponse search(SearchSourceBuilder builder, Scroll scroll) {
    SearchRequest request = new SearchRequest();
    request.indices(index);
    request.scroll(scroll);
    request.source(builder);
    try {
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);
        return response;
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    }
}

public SearchResponse scroll(String scrollId, Scroll scroll){
    try {
        SearchScrollRequest request = new SearchScrollRequest(scrollId);
        request.scroll(scroll);
        SearchResponse response = client.searchScroll(request,RequestOptions.DEFAULT);
        return response;
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    }
}

3. 关注我

搜索微信公众号：java架构强者之路
在这里插入图片描述

dwjf321
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Elasticsearch Client 实战
u014296502的专栏
09-22 585
ES 也提供了 Java 的接口，Java 是目前非常火爆流行的语言，本课时将主要介绍如何使用 ES 的 Java 接口，对 ES 进行操作，我们将对 Java Rest Client 的 Java High Level Rest Client 作为开发工具进行介绍。 我是使用 IDEA 社区版作为开发工具，创建了一个 Spring Boot 项目，创建细节这里不过多介绍。 Maven 依赖 Ma...
传智教育|2022最新版Java学习路线图全集汇总——Java学习到底学什么？一文详解
CZ-001的博客
08-02 1336
2022版Java学习路线图来了！
ElasticSearch的JAVA 客户端（JAVA API）
ShareBoy
12-26 2649
客户端 您可以通过多种方式使用Java客户端：   1. 在现有集群上执行标准的索引创建（index），获取（get）， 删除（delete），查找（search）。   2.在正在运行的集群上执行管理工作。 获取ElasticSearch客户端很简单。获取客户端的最常见方法是创建一个连接到集群的TransportClient。 重点： 客户端和集群必须有相同的主版本（比如：2.x或
Elasticsearch 基本操作 ---- Java API 方式
立志成为一个前端、后端、测试全方位发展的程序员
12-20 1663
Elasticsearch基本操作 文章目录Elasticsearch基本操作一、访问ES服务器二、索引操作2.1 创建索引2.2 查看索引2.3 删除索引三、文档操作3.1 创建文档3.2 修改文档3.3 查询文档3.4 删除文档四、批量操作4.1 批量插入文档4.2 批量删除文档4.3 查询操作 一、访问ES服务器 1. 导入依赖 <!-- elasticsearch的客户端 --> <dependency> <groupId>org.elasticsearc
Java整合ElasticSearch教程全网独一份（保姆级）
最新发布
边走、边悟、迟早变好
07-07 3470
ES是一个使用Java语言并且基于Lucene编写的搜索引擎框架，他提供了分布式的全文搜索功能，提供了一个统一的基于RESTful风格的WEB接口，官方客户端也对多种语言都提供了相应的API。Lucene：Lucene本身就是一个搜索引擎的底层。分布式：ES主要是为了突出他的横向扩展能力。全文检索：将一段词语进行分词，并且将分出的单个词语统一的放到一个分词库中，在搜索时，根据关键字去分词库中检索，找到匹配的内容。（倒排索引）
Java API操作ES
m0_60162373的博客
04-11 6984
1. 导入依赖 <dependencies> <!-- ES的高阶的客户端API --> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>.
ElasticSearch的JAVA API
布谷鸟
04-27 464
ES对Java提供一套操作索引库的工具包，即Java API。所有的ES操作都使用Client对象执行。 (一)导入依赖 <dependencies> <!-- es依赖包--> <dependency> <groupId>org.elasticsearch.client</groupI...
properties找不到 java_java Properties用法及文件找不到的终极解决方案
weixin_30092093的博客
02-12 1018
J2SE 的 Tiger 版本增强了这个类，不仅可以用它在单独一行中指定用等号分隔的多个键-值对，还可以用XML 文件装载和保存这些键-值对。在 驯服 Tiger的这一期文章中，John Zukowski 展示了如何驾驭这匹新一代的“役马”。J2SE 1.5 以前的版本要求直接使用 XML 解析器来装载配置文件并存储设置。虽然这并非是一件困难的事情，并且解析器是平台的标准部分，但是额外的工作总是有...
java操作ElasticSearch(包含增删改查及基础语法操作)
2401_84415415的博客
04-18 939
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的MyBtis知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的MyBtis知识脑图原件（包括上方的面试解析xmind文档）
Elasticsearch实战系列-RESTful API使用
Ricky
02-24 1万+
上一篇文章中我们已经启动Elasticsearch了，接下来我们就可以与Elasticsearch进行通信，例如插入数据、检索数据、删除数据等等。Elasticsearch 提供了Java API和RESTful API 两种方式来与之通信。Java API如果你使用的是 JAVA，Elasticsearch 内置了两个客户端，你可以在你的代码中使用： 节点客户端: 节点客户端以一个 无数据节点
Java分布式项目实战视频
09-30
- 使用ELK（Elasticsearch、Logstash、Kibana）栈收集、分析和可视化日志数据，帮助快速定位问题原因。 通过以上内容的学习与实践，我们不仅可以掌握Java在分布式系统开发中的核心技术和方法论，还能够在实际工作中...
【ES使用】Java API操作ES宝典（7.x版本及其以下）
qq_34263207的博客
11-17 4652
今天老坛就带大家看一看在7.x及其以下的版本下如何使用Java API来操作ES
Java 连接ES方式
难得糊涂
09-01 8445
1. 整合案例一（使用Java API） 这种方式，官方已经明确表示在ES 7.0版本中将弃用TransportClient客户端，且在8.0版本中完全移除它，我在学习ES时，版本已经是6.4.0了。 版本搭配：SpringBoot 2.0.5，ES 5.5.0 1.1 依赖如下： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" x
使用java客户端连接es集群，配置多个节点
wangyibo123ok的博客
07-10 3114
在 Java 客户端中，你可以使用 Elasticsearch 提供的官方 Java 客户端库（Elasticsearch Java High-Level REST Client）来连接到 Elasticsearch 集群，并指定多个初始主机（节点）的地址。如果一个节点被标记为不健康或下线，你可以更新 Java 客户端的连接配置，将其从可用节点列表中移除。使用重试机制：在 Java 客户端代码中实现重试机制，当与一个节点的连接失败时，尝试连接其他节点。对象，并设置相应的故障监听器。
使用Java连接Elasticsearch数据库（验证用户/不验证用户）
weixin_64317282的博客
12-22 1819
最近用JAVA连接数据库，特别是在es上踩了很多坑，专门写一篇文章记录一下，这篇文章主要解决下面两个问题：1.Elasticsearch数据库低级客户端Java Low Level REST Client连接es数据库；2.Elasticsearch数据库使用版本不匹配
HttpAsync试用
z69183787的专栏
11-21 1373
pom：  4.5 4.1 org.projectlombok lombok ${lombok.version} org.apache.httpcomponents httpasyncclient
Elasticsearch：从 Spring Boot 应用中连接 Elasticsearch
Elastic 中国社区官方博客
10-20 4338
在之前的文章 “Elasticsearch：通过 Spring Boot 创建 REST APIs 来访问 Elasticsearch”，我详细描述了如何在 Spring Boot 应用中使用elasticsearch-rest-high-level-client 库来和 Elasticsearch 来进行连接。在今天的文章中，我将使用另外一个库spring-boot-starter-data-elasticsearch 来和 Elasticsearch 进行连接。这种方法非常简单直接。 为了方便大...
HttpClient实现同步(sync)和异步(Async)
热门推荐
零度的博客专栏
03-02 1万+
pom： [html] view plain copy print? 4.5 4.1 dependencies>          dependency>              groupId>org.projectlombokgroupId>              artifactId>lombokartifactId>
高并发下ES对象的创建问题
Nicky_LC的博客
12-10 4093
问题场景： 业务为定时任务，每隔一分钟加载文件夹下的新产生的文件（每分钟新增文件数大约100~200个），解析文件内容写入es。 1）根据host来生成一个对象，使用这一个对象进行es操作：因为并发操作，100个线程全部占满，经调查发现瓶颈在于这一个对象进行发送，故此方案舍弃！ 2）根据业务区分定时任务，当前一个调度周期的任务创建一个对象，同时缓存下来，定时清除5分钟未使用的缓存对象：此方案在初期执行时没有问题，在执行一段时间后，会报以下异常： Caused by: java.io.IOExcep
使用Java高级客户端操作Elasticsearch实战
本文将介绍如何使用Elasticsearch的Java高级客户端进行操作，并提供相关依赖信息及示例代码。 在Java开发中，Elasticsearch的高级客户端提供了方便、灵活的方式来与Elasticsearch集群进行交互。这个客户端是基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值