es新建索引，搜索

PUT /order_auto/
{
"settings":{
"index":{
"number_of_shards" : "3",
"number_of_replicas" : "0"
}
}
}
 
PUT /order_auto/_doc/_mappings?include_type_name=true
{
"properties": {
"id": {
"type": "keyword"
},
"orderNo": {
"type": "keyword"
},
"status": {
"type": "text"
},
"pushed": {
"type": "keyword"
},
"requestDecisionNo": {
"type": "keyword"
},
"initParam": {
"type": "keyword"
},
"customerId": {
"type": "keyword"
},
"name": {
"type": "keyword"
},
"channelId": {
"type": "keyword"
},
"channelName": {
"type": "keyword"
},
"idCard": {
"type": "keyword"
},
"phone": {
"type": "text"
},
"operateType": {
"type": "keyword"
},
"requestDecisionParam": {
"type": "keyword"
},
"requestManualParam": {
"type": "keyword"
},
"manualResult": {
"type": "keyword"
},
"decisionResult": {
"type": "keyword"
},
"sceneNo": {
"type": "keyword"
},
"storeFlag": {
"type": "keyword"
},
"artificialFlag": {
"type": "keyword"
},
"manualPushed": {
"type": "keyword"
},
"branchInfo": {
"type": "keyword"
},
"createTime": {
"type": "date",
"format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
},
"updateTime": {
"type": "date",
"format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
}
}
}

上面，新建es索引。

es搜索

package com.jzsk.rms.order.web.base.configures.es;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.jzsk.rms.order.domain.consts.Const;
import com.jzsk.rms.order.domain.dto.OrderEs;
import com.jzsk.rms.order.domain.enums.order.OrderStateEnum;
import com.jzsk.rms.order.domain.enums.order.OrderStateVOEnum;
import com.jzsk.rms.order.domain.vo.orderquery.OrderQueryReqParam;
import com.jzsk.rms.order.domain.vo.orderquery.OrderQueryRespVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.beanutils.BeanUtils;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.Timevalue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;



@Slf4j
@Component
public class ElasticSearchOperation {

    @Resource
    EsConfig esConfig;

    private final RestHighLevelClient restHighLevelClient;

    public ElasticSearchOperation(RestHighLevelClient restHighLevelClient) {
        this.restHighLevelClient = restHighLevelClient;
    }

    
    public boolean add(String indexName, Object data, String indexId) {
        if (indexName == null || data == null || indexId == null) {
            return false;
        }
        IndexRequest request = new IndexRequest(indexName);
        request.id(indexId);
        request.source(JSONObject.toJSonString(data), XContentType.JSON);
        try {
            IndexResponse indexResponse = restHighLevelClient.index(request, RequestOptions.DEFAULT);
            if (indexResponse == null) {
                return false;
            }
            log.info("写入es成功，风控订单号：{}", indexId);
            return (indexResponse.getResult() == DocWriteResponse.Result.CREATED
                    || indexResponse.getResult() == DocWriteResponse.Result.UPDATED);
        } catch (Throwable e) {
            log.error(
                    "ElasticSearchGateway#add's params  indexName={} and data={} and indexId = {} and Exception Occurred:",
                    indexName, JSONObject.toJSonString(data), indexId, e);
        }
        return false;
    }


    
    public Boolean update(OrderEs orderEs) {
        log.info("更新订单到es请求参数:{}", JSON.toJSonString(orderEs));
        UpdateRequest updateRequest = new UpdateRequest(esConfig.getIndexName(), String.valueOf(orderEs.getId()));
        updateRequest.retryonConflict(3);
        updateRequest.doc(JSON.toJSonString(orderEs), XContentType.JSON);
        // 操作ES
        UpdateResponse updateResponse = null;
        try {
            log.info("es更新数据,rq:{}", JSON.toJSonString(updateRequest));
            updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        } catch (Exception e) {
            log.error("es订单更新失败", e);
        }
        return updateResponse != null && updateResponse.status().getStatus() == 200;
    }


    
    public Map search(OrderQueryReqParam entity) throws IOException {
        BoolQueryBuilder boolBuilder = QueryBuilders.boolQuery();
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        String status = entity.getStatus();
        if (StrUtil.isNotEmpty(status)) {
            //待决策和初始化
            if (String.valueOf(OrderStateVOEnum.待审核.getCode()).equals(status)) {
                TermsQueryBuilder termsQuery = QueryBuilders.termsQuery("status",
                        OrderStateEnum.待决策.getCode(), String.valueOf(OrderStateEnum.初始化.getCode()));
                boolBuilder.must(termsQuery);
            }
            //待人工审核，人工审核中
            if (String.valueOf(OrderStateVOEnum.电核中.getCode()).equals(status)) {
                TermsQueryBuilder termsQuery = QueryBuilders.termsQuery("status",
                        OrderStateEnum.待人工审核.getCode(), String.valueOf(OrderStateEnum.人工审核中.getCode()));
                boolBuilder.must(termsQuery);
            }
            //机核挂起
            MatchQueryBuilder matchQueryBuilder = null;
            if (String.valueOf(OrderStateVOEnum.机核挂起.getCode()).equals(status)) {
                matchQueryBuilder = QueryBuilders.matchQuery("status",
                        OrderStateEnum.挂起.getCode());
                boolBuilder.must(matchQueryBuilder);
            }
            //外部取消
            if (String.valueOf(OrderStateVOEnum.外部取消.getCode()).equals(status)) {
                matchQueryBuilder = QueryBuilders.matchQuery("status",
                        OrderStateEnum.已取消.getCode());
            }
            if (String.valueOf(OrderStateVOEnum.审核通过.getCode()).equals(status)) {
                matchQueryBuilder = QueryBuilders.matchQuery("status", status);
            }
            if (String.valueOf(OrderStateVOEnum.审核拒绝.getCode()).equals(status)) {
                matchQueryBuilder = QueryBuilders.matchQuery("status", status);
            }
            boolBuilder.must(matchQueryBuilder);
        }
        if (Const.STORE_ORDER.equals(entity.getStoreFlag())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("storeFlag", entity.getStoreFlag());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getOrderNo())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("orderNo", entity.getOrderNo());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getCustomerId())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("customerId", entity.getCustomerId());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getChannelId())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("channelId", entity.getChannelId());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getFkOrderNo())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("id", entity.getFkOrderNo());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getBranchInfo())) {
            WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery("branchInfo", "*" + entity.getBranchInfo() + "*");
            boolBuilder.must(wildcardQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getDecisionResult())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("decisionResult", entity.getDecisionResult());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getArtificialFlag())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("artificialFlag", entity.getArtificialFlag());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getSceneCode())) {
            MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("sceneCode", entity.getSceneCode());
            boolBuilder.must(matchQueryBuilder);
        }
        if (StrUtil.isNotEmpty(entity.getStartTime()) && StrUtil.isNotEmpty(entity.getEndTime())) {
            RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("createTime");
            rangeQueryBuilder.gte(entity.getStartTime());
            rangeQueryBuilder.lte(entity.getEndTime());
            boolBuilder.must(rangeQueryBuilder);
        }

        sourceBuilder.query(boolBuilder);
        sourceBuilder.from((entity.getPageNum() - 1) * entity.getPageSize());
        sourceBuilder.size(entity.getPageSize());
        sourceBuilder.timeout(new Timevalue(20, TimeUnit.SECONDS));
        String[] fields = {"id", "orderNo", "status", "requestDecisionNo", "customerId", "name", "channelId", "channelName",
                "idCard", "phone", "operateType", "requestDecisionTime", "decisionResult", "sceneNo", "sceneName",
                "createTime", "updateTime", "artificialFlag", "manualPushed", "storeFlag", "branchInfo"};
        sourceBuilder.fetchSource(fields, new String[]{});
        SearchRequest searchRequest = new SearchRequest(esConfig.getIndexName());
        //按照更新时间排序
        FieldSortBuilder fsb = SortBuilders.fieldSort("createTime");
        fsb.order(SortOrder.DESC);
        sourceBuilder.sort(fsb);
        sourceBuilder.query(boolBuilder);
        sourceBuilder.trackTotalHits(true);
        searchRequest.source(sourceBuilder);
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        List> result = setSearchResponse(response);
        log.info("查询响应:{}", result);
        List list = new ArrayList<>();
        for (Map stringObjectMap : result) {
            OrderQueryRespVO vo = MapToBean(stringObjectMap, OrderQueryRespVO.class);
            //做状态映射
            vo.setStatusValue(cast(vo.getStatus()));
            list.add(vo);
        }
        Map map = new HashMap<>(4);
        map.put("list", list);
        map.put("total", response.getHits().getTotalHits().value);
        return map;
    }

    
    private List> setSearchResponse(SearchResponse searchResponse) {
        ArrayList> list = new ArrayList<>();
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            Map sourceAsMap = hit.getSourceAsMap();
            list.add(sourceAsMap);
        }
        return list;
    }


    
    public static  T MapToBean(Map map, Class clazz) {
        try {
            T bean = clazz.newInstance();
            BeanUtils.populate(bean, map);
            return bean;
        } catch (Exception e) {
            log.error("map转对象异常");
        }
        return null;
    }


    
    public String cast(Integer status) {
        //待审核
        if (OrderStateEnum.初始化.getCode().equals(status) ||
                OrderStateEnum.待决策.getCode().equals(status)) {
            return OrderStateVOEnum.待审核.getValue();
        }
        //机核中
        if (OrderStateEnum.决策中.getCode().equals(status)) {
            return OrderStateVOEnum.机核中.getValue();
        }
        //电核中
        if (OrderStateEnum.待人工审核.getCode().equals(status) ||
                OrderStateEnum.人工审核中.getCode().equals(status)) {
            return OrderStateVOEnum.电核中.getValue();
        }
        //审核通过
        if (OrderStateEnum.审核通过.getCode().equals(status)) {
            return OrderStateVOEnum.审核通过.getValue();
        }
        //审核拒绝
        if (OrderStateEnum.审核拒绝.getCode().equals(status)) {
            return OrderStateVOEnum.审核拒绝.getValue();
        }
        //外部取消
        if (OrderStateEnum.已取消.getCode().equals(status)) {
            return OrderStateVOEnum.外部取消.getValue();
        }
        return OrderStateVOEnum.机核挂起.getValue();
    }


}