Elasticsearch

一、es客户端-kibana 

没有数据库概念，只有索引

索引=表

建索引：
建空索引（空表）：
PUT xxx
注意：如果没有设置表字段类型，则会默认类型

查询所有：
GET xxx/_search
{
    "query": {
        "match_all": {}
     }
}

统计：
GET /xxx/_count

模糊匹配：
GET xxx/_search
{
"query": {
    "match_phrase": {
        "title":"测试"
    }
 }
}
或
GET xxx/_search
{
"query": {
    "wildcard": {
        "source":"*测试*"
    }
 }
}

IN查询：
GET xxx/_search
{
"query": {
    "multi_match": {
        "level": [
            "测试",
            "开发"
        ]
     }
  }
}

刷新（如果新修改后，刷新一下）：
GET xxx/_refresh

二、java引入es

1.配置中添加

elasticsearch:
    nodes: xxx.xxx.xxx.xxx:xxx
    schema: http
    max-connect-total: 50
    max-connect-per-route: 10
    connection-request-timeout-millis: 500
    socket-timeout-millis: 100000
    connect-timeout-millis: 30000
    username: xxx
    password: xxx

2.代码配置

（1）EsClientBuilder.java

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.elasticsearch.client.RestHighLevelClient;
import org.springframework.stereotype.Component;
import java.util.List;

@Component
public class EsClientBuilder {

  private int connectTimeoutMillis = 1000;
  private int socketTimeoutMillis = 30000;
  private int connectionRequestTimeoutMillis = 500;
  private int maxConnectPerRoute = 10;
  private int maxConnectTotal = 30;
  private String username;
  private String password;

  private final List<HttpHost> httpHosts;

  private EsClientBuilder(List<HttpHost> httpHosts) {
    this.httpHosts = httpHosts;
  }

  public EsClientBuilder setConnectTimeoutMillis(int connectTimeoutMillis) {
    this.connectTimeoutMillis = connectTimeoutMillis;
    return this;
  }

  public EsClientBuilder setSocketTimeoutMillis(int socketTimeoutMillis) {
    this.socketTimeoutMillis = socketTimeoutMillis;
    return this;
  }

  public EsClientBuilder setConnectionRequestTimeoutMillis(int connectionRequestTimeoutMillis) {
    this.connectionRequestTimeoutMillis = connectionRequestTimeoutMillis;
    return this;
  }

  public EsClientBuilder setMaxConnectPerRoute(int maxConnectPerRoute) {
    this.maxConnectPerRoute = maxConnectPerRoute;
    return this;
  }

  public EsClientBuilder setMaxConnectTotal(int maxConnectTotal) {
    this.maxConnectTotal = maxConnectTotal;
    return this;
  }

  public EsClientBuilder setUserNameAndPassword(String username, String password) {
    this.username = username;
    this.password = password;
    return this;
  }

  public static EsClientBuilder build(List<HttpHost> httpHosts) {
    return new EsClientBuilder(httpHosts);
  }

  public RestHighLevelClient create() {
    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(
        AuthScope.ANY, new UsernamePasswordCredentials(username, password));

    HttpHost[] httpHostArr = httpHosts.toArray(new HttpHost[0]);
    RestClientBuilder builder = RestClient.builder(httpHostArr);

    builder.setRequestConfigCallback(
        requestConfigBuilder -> {
          requestConfigBuilder.setConnectTimeout(connectTimeoutMillis);
          requestConfigBuilder.setSocketTimeout(socketTimeoutMillis);
          requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeoutMillis);
          return requestConfigBuilder;
        });

    builder.setHttpClientConfigCallback(
        httpClientBuilder -> {
          httpClientBuilder.setMaxConnTotal(maxConnectTotal);
          httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
          httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
          return httpClientBuilder;
        });
    return new RestHighLevelClient(builder);
  }
}

​（2）ESConfig.java（连接ES客户端）

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

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

@Configuration
public class ESConfig {

  @Value("${elasticsearch.nodes}")
  private List<String> nodes;

  @Value("${elasticsearch.schema}")
  private String schema;

  @Value("${elasticsearch.max-connect-total}")
  private Integer maxConnectTotal;

  @Value("${elasticsearch.max-connect-per-route}")
  private Integer maxConnectPerRoute;

  @Value("${elasticsearch.connection-request-timeout-millis}")
  private Integer connectionRequestTimeoutMillis;

  @Value("${elasticsearch.socket-timeout-millis}")
  private Integer socketTimeoutMillis;

  @Value("${elasticsearch.connect-timeout-millis}")
  private Integer connectTimeoutMillis;

  @Value("${elasticsearch.username}")
  private String username;

  @Value("${elasticsearch.password}")
  private String password;

  @Bean
  public RestHighLevelClient restHighLevelClient() {
    List<HttpHost> httpHosts = new ArrayList<>();
    for (String node : nodes) {
      try {
        String[] parts = StringUtils.split(node, ":");
        Assert.notNull(parts, "Must defined");
        Assert.state(parts.length == 2, "Must be defined as 'host:port'");
        httpHosts.add(new HttpHost(parts[0], Integer.parseInt(parts[1]), schema));
      } catch (RuntimeException ex) {
        throw new IllegalStateException("Invalid ES nodes " + "property '" + node + "'", ex);
      }
    }

    return EsClientBuilder.build(httpHosts)
        .setConnectionRequestTimeoutMillis(connectionRequestTimeoutMillis)
        .setConnectTimeoutMillis(connectTimeoutMillis)
        .setSocketTimeoutMillis(socketTimeoutMillis)
        .setMaxConnectTotal(maxConnectTotal)
        .setMaxConnectPerRoute(maxConnectPerRoute)
        .setUserNameAndPassword(username, password)
        .create();
  }
}

3.使用，即增删改查 es中存储的数据

ES实现类：

import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.core.CountRequest;
import org.elasticsearch.client.core.CountResponse;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * ES实现类
 */
@Slf4j
@Service
public class ESserviceImpl implements ESservice {

    @Autowired
    private RestHighLevelClient esClient;
    

    @Value("${es.indexName}")
    private String ES_INDEXNAME;


    /**
     * ES查询
     */
    @Override
    public List<Map<String, Object>> searchES(BoolQueryBuilder boolQueryBuilder, Integer pageNum, Integer pageSize, SortBuilder sortBuilder){
        try {
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            sourceBuilder
                    .query(boolQueryBuilder)
                    .from(pageNum)
                    .size(pageSize)
                    .trackTotalHits(true)
                    .sort(sortBuilder);
            SearchRequest searchRequest = new SearchRequest(ES_INDEXNAME).source(sourceBuilder);
            log.info("searchES sourceBuilder={}", sourceBuilder);
            SearchResponse response = esClient.search(searchRequest, RequestOptions.DEFAULT);
            log.info("searchES response={}", response);
            return esResponseHandle(response);
        }catch (Exception e) {
            log.error("searchES 异常：", e);
            return null;
        }
    }

    /**
     * ES统计
     */
    @Override
    public long countES(BoolQueryBuilder boolQueryBuilder){
        long count = 0;
        try {
            SearchSourceBuilder sourceBuilderCount = new SearchSourceBuilder();
            sourceBuilderCount.query(boolQueryBuilder);
            CountRequest countRequest = new CountRequest(ES_INDEXNAME).source(sourceBuilderCount);
            CountResponse countResponse = esClient.count(countRequest, RequestOptions.DEFAULT);
            count = countResponse.getCount();
        } catch (Exception e) {
            log.error("countES 异常：", e);
        }
        return count;
    }

    //ES 查询结果处理
    private List<Map<String, Object>> esResponseHandle(SearchResponse response){
        List<Map<String, Object>> resultList = new ArrayList<>();
        if(response == null){return resultList;}
        SearchHits searchHits = response.getHits();
        if(searchHits == null){return resultList;}
        SearchHit[] searchHitsHits = searchHits.getHits();
        if(searchHitsHits == null || searchHitsHits.length == 0){return resultList;}
        for(SearchHit hit : searchHitsHits){
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();       
			resultList.add(sourceAsMap);
        }
        return resultList;
    }

   

}

调用ES实现方法：

BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
if(StringUtil.isNotEmpty(searchKey)){
	boolQueryBuilder.must(QueryBuilders.matchPhraseQuery("name", searchKey));  //matchPhraseQuery 相当于 like
}
//排序
SortBuilder sortBuilder = SortBuilders.fieldSort("xxx_date").order(SortOrder.DESC);
//ES 查询前50条 searchKey搜索条件下 xxx_date最新入库的
List<Map<String, Object>> policyList = eSservice.searchES(boolQueryBuilder, 0, 50, sortBuilder);
//ES 查询统计数
long esCount = eSservice.countES(boolQueryBuilder);


boolQueryBuilder.must(QueryBuilders.termsQuery("id", idList));  //termsQuery 相当于 in
boolQueryBuilder.must(QueryBuilders.termQuery("level", 1));  //termQuery 相当于 =