ElasticSearch

准备

ES下载：ES6.8下载
Kibana下载：kibana6.8.8

elasticsearch 依赖

   <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>6.8.0</version>
        </dependency>

        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>6.8.0</version>
        </dependency>

配置

package com.cplatform.bshbp.crm.config;

import com.amazonaws.DefaultRequest;
import com.amazonaws.auth.*;
import com.amazonaws.http.HttpMethodName;
import com.amazonaws.regions.Regions;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.*;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.BasicHttpEntity;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.message.BasicHeader;
import org.apache.http.protocol.HttpContext;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import static org.apache.http.protocol.HttpCoreContext.HTTP_TARGET_HOST;


@Component
@Slf4j
public class ElasticSearchConfig {

    //服务名称
    @Value("${elasticsearch.serviceName}")
    private String serviceName;
    //线上地址
    @Value("${elasticsearch.esEndpoint}")
    private String esEndpoint;
    //连接线上地址 accessKey 连接线上地址
    @Value("${elasticsearch.accessKey}")
    private String accessKey;
    //连接线上地址 secretKey
    @Value("${elasticsearch.secretKey}")
    private String secretKey;

    //本地地址
    @Value("${elasticsearch.host}")
    private String host;
    //端口
    @Value("${elasticsearch.port}")
    private Integer port;
     //dev 本地环境
     @Value("${elasticsearch.profiles}")
     private String profiles;

    @Bean("RestHighLevelClient")
    public RestHighLevelClient restHighLevelClient() {
        if (StringUtils.equals(profiles, "dev")) {
            CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
//        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("", ""));
            return new RestHighLevelClient(RestClient.builder(getHttpHosts(host, port)).setHttpClientConfigCallback((HttpAsyncClientBuilder httpAsyncClientBuilder) -> httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider)));

        }
        AWSStaticCredentialsProvider awsStaticCredentialsProvider = new AWSStaticCredentialsProvider(
                new BasicAWSCredentials(accessKey, secretKey));
        AWS4Signer signer = new AWS4Signer();
        signer.setServiceName(serviceName);
        signer.setRegionName(Regions.CN_NORTHWEST_1.getName());
        HttpRequestInterceptor interceptor = new AWSRequestSignerInterceptor(serviceName, signer, awsStaticCredentialsProvider);
        return new RestHighLevelClient(RestClient.builder(HttpHost.create(esEndpoint)).setHttpClientConfigCallback(hacb -> hacb.addInterceptorLast(interceptor)));
    }


    private HttpHost[] getHttpHosts(String clientIps, int esHttpPort) {
        String[] clientIpList = clientIps.split(",");
        HttpHost[] httpHosts = new HttpHost[clientIpList.length];
        for (int i = 0; i < clientIpList.length; i++) {
            httpHosts[i] = new HttpHost(clientIpList[i], esHttpPort, "http");
        }
        return httpHosts;
    }



    /**
     * An {@link HttpRequestInterceptor} that signs requests using any AWS {@link Signer}
     * and {@link AWSCredentialsProvider}.
     */
    private static class AWSRequestSignerInterceptor implements HttpRequestInterceptor {
        /**
         * The service that we're connecting to. Technically not necessary.
         * Could be used by a future Signer, though.
         */
        private final String service;

        /**
         * The particular signer implementation.
         */
        private final Signer signer;

        /**
         * The source of AWS credentials for signing.
         */
        private final AWSCredentialsProvider awsCredentialsProvider;

        /**
         * @param service                service that we're connecting to
         * @param signer                 particular signer implementation
         * @param awsCredentialsProvider source of AWS credentials for signing
         */
        AWSRequestSignerInterceptor(final String service,
                                    final Signer signer,
                                    final AWSCredentialsProvider awsCredentialsProvider) {
            this.service = service;
            this.signer = signer;
            this.awsCredentialsProvider = awsCredentialsProvider;
        }

        /**
         * @param params list of HTTP query params as NameValuePairs
         * @return a multimap of HTTP query params
         */
        private static Map<String, List<String>> nvpToMapParams(final List<NameValuePair> params) {
            Map<String, List<String>> parameterMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
            for (NameValuePair nvp : params) {
                List<String> argsList =
                        parameterMap.computeIfAbsent(nvp.getName(), k -> new ArrayList<>());
                argsList.add(nvp.getValue());
            }
            return parameterMap;
        }

        /**
         * @param headers modeled Header objects
         * @return a Map of header entries
         */
        private static Map<String, String> headerArrayToMap(final Header[] headers) {
            Map<String, String> headersMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
            for (Header header : headers) {
                if (!skipHeader(header)) {
                    headersMap.put(header.getName(), header.getValue());
                }
            }
            return headersMap;
        }

        /**
         * @param header header line to check
         * @return true if the given header should be excluded when signing
         */
        private static boolean skipHeader(final Header header) {
            return ("content-length".equalsIgnoreCase(header.getName())
                    && "0".equals(header.getValue())) // Strip Content-Length: 0
                    || "host".equalsIgnoreCase(header.getName()); // Host comes from endpoint
        }

        /**
         * @param mapHeaders Map of header entries
         * @return modeled Header objects
         */
        private static Header[] mapToHeaderArray(final Map<String, String> mapHeaders) {
            Header[] headers = new Header[mapHeaders.size()];
            int i = 0;
            for (Map.Entry<String, String> headerEntry : mapHeaders.entrySet()) {
                headers[i++] = new BasicHeader(headerEntry.getKey(), headerEntry.getValue());
            }
            return headers;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void process(final HttpRequest request, final HttpContext context)
                throws IOException {
            URIBuilder uriBuilder;
            try {
                uriBuilder = new URIBuilder(request.getRequestLine().getUri());
            } catch (URISyntaxException e) {
                throw new IOException("Invalid URI", e);
            }

            // Copy Apache HttpRequest to AWS DefaultRequest
            DefaultRequest<?> signableRequest = new DefaultRequest<>(service);

            HttpHost host = (HttpHost) context.getAttribute(HTTP_TARGET_HOST);
            if (host != null) {
                signableRequest.setEndpoint(URI.create(host.toURI()));
            }
            final HttpMethodName httpMethod =
                    HttpMethodName.fromValue(request.getRequestLine().getMethod());
            signableRequest.setHttpMethod(httpMethod);
            try {
                signableRequest.setResourcePath(uriBuilder.build().getRawPath());
            } catch (URISyntaxException e) {
                throw new IOException("Invalid URI", e);
            }

            if (request instanceof HttpEntityEnclosingRequest) {
                HttpEntityEnclosingRequest httpEntityEnclosingRequest =
                        (HttpEntityEnclosingRequest) request;
                if (httpEntityEnclosingRequest.getEntity() != null) {
                    signableRequest.setContent(httpEntityEnclosingRequest.getEntity().getContent());
                }
            }
            signableRequest.setParameters(nvpToMapParams(uriBuilder.getQueryParams()));
            signableRequest.setHeaders(headerArrayToMap(request.getAllHeaders()));

            // Sign it
            signer.sign(signableRequest, awsCredentialsProvider.getCredentials());

            // Now copy everything back
            request.setHeaders(mapToHeaderArray(signableRequest.getHeaders()));
            if (request instanceof HttpEntityEnclosingRequest) {
                HttpEntityEnclosingRequest httpEntityEnclosingRequest =
                        (HttpEntityEnclosingRequest) request;
                if (httpEntityEnclosingRequest.getEntity() != null) {
                    BasicHttpEntity basicHttpEntity = new BasicHttpEntity();
                    basicHttpEntity.setContent(signableRequest.getContent());
                    httpEntityEnclosingRequest.setEntity(basicHttpEntity);
                }
            }
        }
    }

}

新增

//注入

@Autowired
private RestHighLevelClient restHighLevelClient;

 try {
            IndexRequest request = new IndexRequest('索引', "doc")
                    .id(id)
                    .source(JSONObject.toJSONString(object), XContentType.JSON);
            request.opType(DocWriteRequest.OpType.CREATE);
            IndexResponse response = restHighLevelClient.index(request, RequestOptions.DEFAULT);
            log.info(" ES 缓存：{}", JSONObject.toJSONString(response));
        } catch (Exception e) {
            e.printStackTrace();
            log.info("ES缓存错误：{}", e.getMessage());
        }

基本查询

            SearchRequest searchRequest = new SearchRequest();
            searchRequest.indices(‘索引’);
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            QueryBuilder queryBuilder = QueryBuilders.termQuery("_id", value);
            searchSourceBuilder.query(queryBuilder);
            searchRequest.source(searchSourceBuilder);
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            SearchHits hits = searchResponse.getHits();
            SearchHit[] hitsHits = hits.getHits();
            return Arrays.stream(hitsHits).map(hit -> JSON.parseObject(hit.getSourceAsString(), JSONObject.class))
                    .findAny().orElse(null);

复杂查询

        SearchRequest searchRequest = new SearchRequest();
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();

        queryBuilder.must(QueryBuilders.matchPhraseQuery("id", id));


        if (Objects.nonNull(record.getStatus())) {
            queryBuilder.must(QueryBuilders.matchPhraseQuery("status", record.getStatus()));
        }

        if (StringUtils.isNotBlank(record.getChangeType())) {
            if (StringUtils.equals("99",record.getChangeType())){
                queryBuilder.must(QueryBuilders.matchPhraseQuery("isExpire", 1));
            }else {
                queryBuilder.must(QueryBuilders.matchPhraseQuery("changeType", record.getChangeType()));
                queryBuilder.must(QueryBuilders.matchPhraseQuery("isExpire", 0));
            }
        }

        if (Objects.nonNull(record.getId())) {
            queryBuilder.must(QueryBuilders.matchPhraseQuery("id", String.valueOf(record.getId())));
        }

        if (StringUtils.isNotBlank(record.getStartDate())) {
            queryBuilder.must(QueryBuilders.rangeQuery("createTime").gte(DateUtil.date()));
        }

        if (StringUtils.isNotBlank(record.getEndDate())) {
            queryBuilder.must(QueryBuilders.rangeQuery("createTime").lte(DateUtil.date()));
        }

        searchSourceBuilder.query(queryBuilder);
        //排序条件
        searchSourceBuilder.sort("createTime", SortOrder.DESC);


            //分页查询
            searchSourceBuilder.from(record.getPage());
            searchSourceBuilder.size(record.getLimit());


        searchRequest.source(searchSourceBuilder);

        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        return searchResponse.getHits();

更新

 UpdateRequest request = new UpdateRequest(‘索引’, "doc", id)
                .doc(JSONObject.toJSONString(object), XContentType.JSON);
        try {
            UpdateResponse updateResponse = restHighLevelClient.update(request, RequestOptions.DEFAULT);
            log.info("ES{}"}
        } catch (Exception e) {
            e.printStackTrace();
            log.info("ES error {}", e.getMessage());
        }

删除

// 删除写一个kibana上面的语法
// DELETE 索引/文档名称/id

DELETE index/_doc/001

== 就先写到这吧，待更新！==

2023-05-06 03:16
ES 修改时间
ctx._source.字段名

POST user_coin_record_index/_update_by_query
{
    "query": {"term": {
  "changeType": {
    "value": "4"
  }
}},
  "script":{"source": "ctx._source.updateTime=(Long.parseLong('1672502399999'))"}
 
}