1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 拉取 ES 镜像
docker pull docker.elastic.co/elasticsearch/elasticsearch:8.1.0
# 创建自定义网络
docker network create elastic
# 运行 ES 实例
docker run --name es01 --net elastic -p 9200:9200 -it docker.elastic.co/elasticsearch/elasticsearch:8.1.0

# 拉取 kibana 镜像
docker pull docker.elastic.co/kibana/kibana:8.1.0
# 运行 kibana 实例
docker run --name kibana --net elastic -p 5601:5601 docker.elastic.co/kibana/kibana:8.1.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 自动创建索引
POST /gear_test/_doc
{
  "name":"test"
}

# 搜索索引下所有记录
GET /gear_test/_search

# 删除索引
DELETE /gear_test

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 创建索引
PUT /customer?pretty

# 获取所有索引
GET /_cat/indices?

# 查看索引信息
GET /customer

# 新增记录，id自动赋值
POST /customer/_doc
{
  "name": "Tom"
}

# 指定id,新增/更新记录
POST /customer/_doc/1
{
  "name":"Jsck"
}

# 指定id,新增/更新记录
PUT /customer/_doc/1
{
  "name":"Jerry"
}

# 获取所有记录
GET /customer/_search

DELETE /customer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

# 从所有索引里查询
GET _search
{   
  "query": {
    # 所有匹配的值
    "match_all": {}

    # item 精确查询 相等
    "term": {
      "phone": "12345678909"
    }
    # items
    "terms": {
      "uid": [ 
        1234, 
        12345, 
        123456
      ] 
    }

    # range 字段值是否在某个范围
    "range": { 
      "uid": { 
        "gt": 1234,
        "lte": 12345
      } 
    } 

    # exists 字段是否存在
    "exists": { 
      "field":"msgcode" 
    } 

    # bool 合并多个过滤条件
    "bool": {
      "must": {
        "term": {
          "phone": "12345678909"
        }
      },
      "must_not": {
        "term": {
          "uid": 12345
        }
      },
      "should": [
        {
          "term": {
            "uid": 1234
          }
        },
        {
          "term": {
            "uid": 123456
          }
        }
      ],
      "adjust_pure_negative": true,
      "boost": 1
    }

    # wildcard 类似于SQL的like查询
    "wildcard": { 
       "message":"*wu*" 
    } 

    # regexp 正则查询
    "regexp": { 
       "message":"xu[0-9]" 
    } 

    # match 全文检索，使用ik_smart将"超级羽绒服"分词，再用分词结果到es中查询包含"超级"、"羽绒"、"羽绒服"（具体分词根据分词器变化）等分词的记录，进行评分排序输出。不指定分词器时采用默认分词器。
    "match": {
      "name": {
        "query": "超级羽绒服",
        "analyzer": "ik_smart"
      }
    }

    # match_phrase 不采用分词器，直接查找包含对应短语的记录
    # 与match的区别：match采用分词器，match_phrase不采用分词器
    "match_phrase": { 
      "address": "mill lane" 
    } 
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 创建索引，指定字段类型
PUT /example
{
  "mappings": {
    "properties": {
      "location": {
        "type": "geo_shape"
      }
    }
  }
}

# 新增数据
POST /example/_doc?refresh
{
  "name": "Wind & Wetter, Berlin, Germany",
  "location": {
    "type": "point",
    "coordinates": [ 13.400544, 52.530286 ]
  }
}

# 查询数据
GET /example/_search

# 删除索引
DELETE /example

1
2
3
4
5
6
7
8
9

# 新增数据
PUT /example/_doc?refresh
{
  "name": "Wind & Wetter, Berlin, Germany",
  "location": {
    "type": "point",
    "coordinates": [ 13.400544, 52.530286 ]
  }
}

1
2
3
4
5
6

# 新增数据
PUT /example/_doc?refresh
{
  "name": "Wind & Wetter, Berlin, Germany",
  "location": "POINT (13.400544 52.530286)"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// 通过https连接ES，不验证客户端证书
final CredentialsProvider credentialsProvider =
  new BasicCredentialsProvider();
credentialsProvider.setCredentials(AuthScope.ANY,
                                   new UsernamePasswordCredentials("elastic", "nCxouQfpOcxxBMBxX2+7"));

SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
  @Override
  public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
    return true;
  }
}).build();

RestClientBuilder builder = RestClient.builder(
  new HttpHost("localhost", 9200, "https"))
  .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
    @Override
    public HttpAsyncClientBuilder customizeHttpClient(
      HttpAsyncClientBuilder httpClientBuilder) {
      httpClientBuilder.setSSLContext(sslContext);
      // 去除主机名称的限制，否则只能从 localhost/127.0.0.1 访问
      httpClientBuilder.setSSLHostnameVerifier((s, sslSession) -> true);
      httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
      return httpClientBuilder;
    }
  });
RestClient restClient = builder.build();
ElasticsearchTransport transport = new RestClientTransport(
  restClient, new JacksonJsonpMapper());
ElasticsearchClient client = new ElasticsearchClient(transport);
BooleanResponse ping = client.ping();
System.out.println(ping);
restClient.close();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// Create the low-level client
RestClient restClient = RestClient.builder(
    new HttpHost("localhost", 9200)).build();

// Create the transport with a Jackson mapper
ElasticsearchTransport transport = new RestClientTransport(
    restClient, new JacksonJsonpMapper());

// And create the API client
ElasticsearchClient client = new ElasticsearchClient(transport);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

final CredentialsProvider credentialsProvider =
    new BasicCredentialsProvider();
credentialsProvider.setCredentials(AuthScope.ANY,
    new UsernamePasswordCredentials("user", "test-user-password"));

RestClientBuilder builder = RestClient.builder(
    new HttpHost("localhost", 9200))
    .setHttpClientConfigCallback(new HttpClientConfigCallback() {
        @Override
        public HttpAsyncClientBuilder customizeHttpClient(
                HttpAsyncClientBuilder httpClientBuilder) {
            return httpClientBuilder
                .setDefaultCredentialsProvider(credentialsProvider);
        }
    });