docker快速部署ES

前言

记录docker快速部署es

注：如果测试案例执行失败，可能原因在docker 磁盘和内存太小导致得 ，磁盘必须要大于3.9G，ES才能分片，空出足够得内存和磁盘后 重启es执行命令： docker restart es8

操作

去除https访问-启动docker

docker run -d \

--name es8 \

-p 9200:9200 \

--memory=2g \

--memory-swap=2g \

--ulimit memlock=-1:-1 \

-e "discovery.type=single-node" \

-e "ELASTIC_PASSWORD=123456" \

-e "xpack.security.enabled=true" \

-e "xpack.security.http.ssl.enabled=false" \

-e "bootstrap.memory_lock=true" \

-e "ES_JAVA_OPTS=-Xms1g -Xmx1g" \

elasticsearch:8.11.1

springboot3.x版本集成es （注：springboot2.x和spring3.x依赖版本是有区别 ）

yml配置

elasticsearch:

uris: http://172.16.10.40:9200

username: elastic

password: 123456

connect-timeout: 5s

socket-timeout: 60s

pom.xml

<!-- Elasticsearch 8 官方客户端 -->

<dependency>

<groupId>co.elastic.clients</groupId>

<artifactId>elasticsearch-java</artifactId>

<version>8.11.1</version>

</dependency>

<dependency>

<groupId>org.elasticsearch.client</groupId>

<artifactId>elasticsearch-rest-client</artifactId>

<version>8.11.1</version>

</dependency>

<!-- JSON-P 实现 -->

<dependency>

<groupId>org.glassfish</groupId>

<artifactId>jakarta.json</artifactId>

<version>2.0.1</version>

</dependency>

添加config 类

package cloud.jiuwei.store.config;

import co.elastic.clients.elasticsearch.ElasticsearchClient;

import co.elastic.clients.transport.ElasticsearchTransport;

import co.elastic.clients.transport.rest_client.RestClientTransport;

import co.elastic.clients.json.jackson.JacksonJsonpMapper;

import org.apache.http.HttpHost;

import org.apache.http.auth.AuthScope;

import org.apache.http.auth.UsernamePasswordCredentials;

import org.apache.http.client.CredentialsProvider;

import org.apache.http.impl.client.BasicCredentialsProvider;

import org.elasticsearch.client.RestClient;

import org.elasticsearch.client.RestClientBuilder;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.boot.context.properties.ConfigurationProperties;

import lombok.Data;

import java.time.Duration;

@Configuration

@ConfigurationProperties(prefix = "elasticsearch")

@Data

public class ElasticsearchConfig {

private String uris;

private String username;

private String password;

private Duration connectTimeout;

private Duration socketTimeout;

@Bean

public ElasticsearchClient elasticsearchClient() {

RestClientBuilder builder = RestClient.builder(

HttpHost.create(uris)

);

// 超时配置

builder.setRequestConfigCallback(requestConfigBuilder ->

requestConfigBuilder

.setConnectTimeout((int) connectTimeout.toMillis())

.setSocketTimeout((int) socketTimeout.toMillis())

);

// 认证配置

if (username != null && password != null) {

CredentialsProvider credentialsProvider =

new BasicCredentialsProvider();

credentialsProvider.setCredentials(

AuthScope.ANY,

new UsernamePasswordCredentials(username, password)

);

builder.setHttpClientConfigCallback(httpClientBuilder ->

httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider)

);

}

RestClient restClient = builder.build();

ElasticsearchTransport transport =

new RestClientTransport(restClient, new JacksonJsonpMapper());

return new ElasticsearchClient(transport);

}

}

测试案例

package cloud.jiuwei.store.coupon.service;

import cloud.jiuwei.store.config.Product;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.elasticsearch.core.search.Hit;
import co.elastic.clients.transport.endpoints.BooleanResponse;
import lombok.SneakyThrows;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import lombok.extern.slf4j.Slf4j;

@SpringBootTest
@Slf4j
public class CouponBatchServiceTest {


    @Autowired
    private ElasticsearchClient client;

    @SneakyThrows
    @Test
    public void testPing() {
       BooleanResponse ping = client.ping();
       System.out.println("连接成功: " + ping.value());
    }

    @SneakyThrows
    @Test
    void esDemoAllInOne()  {

       String indexName = "product_test";

       // 1️⃣ 删除旧索引（避免重复报错）
       try {
          client.indices().delete(d -> d.index(indexName));
          System.out.println("旧索引已删除");
       } catch (Exception ignored) {
       }

       // 2️⃣ 创建索引
       client.indices().create(c -> c.index(indexName));
       System.out.println("索引创建成功");

       // 3️⃣ 插入数据
       Product product = new Product(1L, "iPhone 15", 8999.0);

       client.index(i -> i
             .index(indexName)
             .id(product.getId().toString())
             .document(product)
       );

       System.out.println("数据插入成功");

       // 4️⃣ 刷新索引（非常重要！否则可能查不到）
       client.indices().refresh(r -> r.index(indexName));

       // 5️⃣ 查询
       SearchResponse<Product> response = client.search(s -> s
                   .index(indexName)
                   .query(q -> q
                         .match(m -> m
                               .field("name")
                               .query("15")
                         )
                   ),
             Product.class
       );

       System.out.println("查询结果：");

       for (Hit<Product> hit : response.hits().hits()) {
          System.out.println(hit.source());
       }

       // 6️⃣ 删除索引
       client.indices().delete(d -> d.index(indexName));
       System.out.println("索引删除完成");

       System.out.println("全部流程执行完毕 ✅");
    }

}