欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

利用?SpringBoot?在?ES?中實(shí)現(xiàn)類似連表查詢功能

 更新時(shí)間:2022年07月12日 15:16:38   作者:鴨血粉絲Tang  
這篇文章主要介紹了如何利用?SpringBoot?在?ES?中實(shí)現(xiàn)類似連表的查詢功能,本文通過示例代碼給大家介紹的非常詳細(xì),對大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值,需要的朋友可以參考下

一、摘要

在上篇文章中,我們詳細(xì)的介紹了如何在 ES 中精準(zhǔn)的實(shí)現(xiàn)嵌套json對象查詢?

那么問題來了,我們?nèi)绾卧诤蠖送ㄟ^技術(shù)方式快速的實(shí)現(xiàn) es 中內(nèi)嵌對象的數(shù)據(jù)查詢呢?

為了方便更容易掌握技術(shù),本文主要以上篇文章中介紹的通過商品找訂單為案例,利用 SpringBoot 整合 ES 實(shí)現(xiàn)這個(gè)業(yè)務(wù)需求,向大家介紹具體的技術(shù)實(shí)踐方案,存入es中的json數(shù)據(jù)結(jié)構(gòu)如下:

{
    "orderId":"1",
    "orderNo":"123456",
    "orderUserName":"張三",
    "orderItems":[
        {
            "orderItemId":"12234",
            "orderId":"1",
            "productName":"火腿腸",
            "brandName":"雙匯",
            "sellPrice":"28"
        },
        {
            "orderItemId":"12235",
            "orderId":"1",
            "productName":"果凍",
            "brandName":"匯源",
            "sellPrice":"12"
        }
    ]
}

廢話也不多說了,直接上代碼!

二、項(xiàng)目實(shí)踐

2.1添加依賴

在SpringBoot項(xiàng)目中,添加rest-high-level-client客戶端,方便與 ES 服務(wù)器連接通信,在這里需要注意一下,推薦客戶端的版本與 ES 服務(wù)器的版本號一致,不然會出現(xiàn)接口請求錯(cuò)誤等異常!

小編本次安裝的ES服務(wù)端版本號為6.8.2,因此客戶端也保持6.8.2,與之一致!

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

2.2配置 es 客戶端

為了更佳方便的使用 es,我們可以將其各個(gè)配置類進(jìn)行封裝,方便后續(xù)進(jìn)行維護(hù)。

  • 在application.properties配置文件中,定義 es 配置連接地址;
# 設(shè)置es參數(shù)
elasticsearch.scheme=http
elasticsearch.address=127.0.0.1:9200
elasticsearch.userName=
elasticsearch.userPwd=
elasticsearch.socketTimeout=5000
elasticsearch.connectTimeout=5000
elasticsearch.connectionRequestTimeout=5000
  • 創(chuàng)建ElasticSearch配置類,方便SpringBoot啟動(dòng)時(shí)注入;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Arrays;
import java.util.Objects;


@Configuration
public class ElasticSearchConfiguration {

    private static final Logger log = LoggerFactory.getLogger(ElasticSearchConfiguration.class);


    private static final int ADDRESS_LENGTH = 2;

    @Value("${elasticsearch.scheme:http}")
    private String scheme;

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

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

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

    @Value("${elasticsearch.socketTimeout:5000}")
    private Integer socketTimeout;

    @Value("${elasticsearch.connectTimeout:5000}")
    private Integer connectTimeout;

    @Value("${elasticsearch.connectionRequestTimeout:5000}")
    private Integer connectionRequestTimeout;

    /**
     * 初始化客戶端
     * @return
     */
    @Bean(name = "restHighLevelClient")
    public RestHighLevelClient restClientBuilder() {
        HttpHost[] hosts = Arrays.stream(address.split(","))
                .map(this::buildHttpHost)
                .filter(Objects::nonNull)
                .toArray(HttpHost[]::new);
        RestClientBuilder restClientBuilder = RestClient.builder(hosts);
        // 異步參數(shù)配置
        restClientBuilder.setHttpClientConfigCallback(httpClientBuilder -> {
            httpClientBuilder.setDefaultCredentialsProvider(buildCredentialsProvider());
            return httpClientBuilder;
        });

        // 異步連接延時(shí)配置
        restClientBuilder.setRequestConfigCallback(requestConfigBuilder -> {
            requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeout);
            requestConfigBuilder.setSocketTimeout(socketTimeout);
            requestConfigBuilder.setConnectTimeout(connectTimeout);
            return requestConfigBuilder;
        });

        return new RestHighLevelClient(restClientBuilder);
    }


    /**
     * 根據(jù)配置創(chuàng)建HttpHost
     * @param s
     * @return
     */
    private HttpHost buildHttpHost(String s) {
        String[] address = s.split(":");
        if (address.length == ADDRESS_LENGTH) {
            String ip = address[0];
            int port = Integer.parseInt(address[1]);
            return new HttpHost(ip, port, scheme);
        } else {
            return null;
        }
    }

    /**
     * 構(gòu)建認(rèn)證服務(wù)
     * @return
     */
    private CredentialsProvider buildCredentialsProvider(){
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userName,
                userPwd));
        return credentialsProvider;
    }
}
  • 封裝ElasticSearch客戶端服務(wù)類,方便公共調(diào)用處理
import com.fasterxml.jackson.databind.ObjectMapper;
import org.example.es.exception.CommonException;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
import org.elasticsearch.action.admin.indices.get.GetIndexResponse;
import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest;
import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsResponse;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
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.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.GetAliasesResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import java.util.Set;

@Component
public class ElasticSearchClient {

    private static final Logger log = LoggerFactory.getLogger(ElasticSearchClient.class);

    private static final ObjectMapper objectMapper = new ObjectMapper();

    @Autowired
    private RestHighLevelClient client;


    /**
     * 查詢?nèi)克饕?
     * @return
     */
    public Set<String> getAlias(){
        try {
            GetAliasesRequest request = new GetAliasesRequest();
            GetAliasesResponse response =  client.indices().getAlias(request, RequestOptions.DEFAULT);
            return response.getAliases().keySet();
        } catch (IOException e) {
            log.error("向es發(fā)起查詢?nèi)克饕畔⒄埱笫?, e);
        }
        return Collections.emptySet();
    }

    /**
     * 檢查索引是否存在
     * @param indexName
     * @return
     */
    public boolean existsIndex(String indexName){
        try {
            // 創(chuàng)建請求
            GetIndexRequest request = new GetIndexRequest().indices(indexName);
            // 執(zhí)行請求,獲取響應(yīng)
            boolean response = client.indices().exists(request, RequestOptions.DEFAULT);
            return response;
        } catch (Exception e) {
            log.error("向es發(fā)起查詢索引是否存在請求失敗,請求參數(shù):" + indexName, e);
        }
        return false;
    }


    /**
     * 查詢索引
     * @param indexName
     * @return
     */
    public String getIndex(String indexName){
        try {
            // 創(chuàng)建請求
            GetIndexRequest request = new GetIndexRequest().indices(indexName);
            // 執(zhí)行請求,獲取響應(yīng)
            GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
            return response.toString();
        } catch (Exception e) {
            log.error("向es發(fā)起查詢索引請求失敗,請求參數(shù):" + indexName, e);
        }
        return StringUtils.EMPTY;
    }

    /**
     * 創(chuàng)建索引
     * @param indexName
     * @param mapping
     * @return
     */
    public void createIndex(String indexName, Map<String, Object> mapping){
        try {
            CreateIndexRequest request = new CreateIndexRequest();
            //索引名稱
            request.index(indexName);
            //索引配置
            Settings settings = Settings.builder()
                    .put("index.number_of_shards", 3)
                    .put("index.number_of_replicas", 1)
                    .put("index.max_inner_result_window", 5000)
                    .build();
            request.settings(settings);
            //索引結(jié)構(gòu)
            request.mapping("_doc",mapping);
            //執(zhí)行請求,獲取響應(yīng)
            CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
            if(!response.isAcknowledged()){
                throw new CommonException("向es發(fā)起創(chuàng)建索引請求失敗");
            }
            log.info("向es發(fā)起創(chuàng)建索引請求成功,返回參數(shù):{}", response.index());
        } catch (Exception e) {
            log.error("向es發(fā)起創(chuàng)建索引請求失敗,請求參數(shù):" + indexName, e);
            throw new CommonException("向es發(fā)起創(chuàng)建索引請求失敗");
        }
    }


    /**
     * 刪除索引
     * @param indexName
     * @return
     */
    public void deleteIndex(String indexName){
        try {
            DeleteIndexRequest request = new DeleteIndexRequest(indexName);
            AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
            if(!response.isAcknowledged()){
                throw new CommonException("向es發(fā)起刪除索引請求失敗");
            }
            log.info("向es發(fā)起刪除索引請求成功,請求參數(shù):{}", indexName);
        } catch (Exception e) {
            log.error("向es發(fā)起刪除索引請求失敗,請求參數(shù):" + indexName, e);
            throw new CommonException("向es發(fā)起刪除索引請求失敗");
        }
    }


    /**
     * 查詢索引映射字段
     * @param indexName
     * @return
     */
    public String getMapping(String indexName){
        try {
            GetMappingsRequest request = new GetMappingsRequest().indices(indexName).types("_doc");
            GetMappingsResponse response = client.indices().getMapping(request, RequestOptions.DEFAULT);
            return response.toString();
        } catch (Exception e) {
            log.error("向es發(fā)起查詢索引映射字段請求失敗,請求參數(shù):" + indexName, e);
        }
        return StringUtils.EMPTY;
    }


    /**
     * 添加索引映射字段
     * @param indexName
     * @return
     */
    public void addMapping(String indexName, Map<String, Object> mapping){
        try {
            PutMappingRequest request = new PutMappingRequest();
            request.indices(indexName);
            request.type("_doc");
            //添加字段
            request.source(mapping);
            AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
            if(!response.isAcknowledged()){
                throw new CommonException("向es發(fā)起添加索引映射字段請求失敗");
            }
            log.info("向es發(fā)起添加索引映射字段請求成功,請求參數(shù):{}", toJson(request));
        } catch (Exception e) {
            log.error("向es發(fā)起添加索引映射字段請求失敗,請求參數(shù):" + indexName, e);
            throw new CommonException("向es發(fā)起添加索引映射字段請求失敗");
        }
    }


    /**
     * 向索引中添加文檔
     * @param indexName
     * @param id
     * @param obj
     */
    public void addDocument(String indexName, String id, Object obj){
        try {
            //向索引中添加文檔
            IndexRequest request = new IndexRequest();
            // 外層參數(shù)
            request.id(id);
            request.index(indexName);
            request.type("_doc");

            // 存入對象
            request.source(toJson(obj), XContentType.JSON);
            // 發(fā)送請求
            IndexResponse response = client.index(request, RequestOptions.DEFAULT);
            if(response.status().getStatus() >= 400){
                log.warn("向es發(fā)起添加文檔數(shù)據(jù)請求失敗,請求參數(shù):{},返回參數(shù):{}", request.toString(), response.toString());
                throw new CommonException("向es發(fā)起添加文檔數(shù)據(jù)請求失敗");
            }
        } catch (Exception e) {
            log.error("向es發(fā)起添加文檔數(shù)據(jù)請求失敗,請求參數(shù):" + indexName, e);
            throw new CommonException("向es發(fā)起添加文檔數(shù)據(jù)請求失敗");
        }
    }

    /**
     * 修改索引中的文檔數(shù)據(jù)
     * @param indexName
     * @param id
     * @param obj
     */
    public void updateDocument(String indexName, String id, Map<String,Object> obj){
        try {
            //修改索引中的文檔數(shù)據(jù)
            UpdateRequest request = new UpdateRequest();
            // 外層參數(shù)
            request.id(id);
            request.index(indexName);
            request.type("_doc");
            // 存入對象
            request.doc(obj);
            request.doc(toJson(obj), XContentType.JSON);
            // 發(fā)送請求
            UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
            if(response.status().getStatus() >= 400){
                log.warn("向es發(fā)起修改文檔數(shù)據(jù)請求失敗,請求參數(shù):{},返回參數(shù):{}", request.toString(), response.toString());
                throw new CommonException("向es發(fā)起修改文檔數(shù)據(jù)請求失敗");
            }
        } catch (Exception e) {
            log.error("向es發(fā)起修改文檔數(shù)據(jù)請求失敗,請求參數(shù):" + indexName, e);
            throw new CommonException("向es發(fā)起修改文檔數(shù)據(jù)請求失敗");
        }
    }



    /**
     * 刪除索引中的文檔數(shù)據(jù)
     * @param indexName
     * @param id
     */
    public void deleteDocument(String indexName, String id){
        try {
            //刪除索引中的文檔數(shù)據(jù)
            DeleteRequest request = new DeleteRequest();
            // 外層參數(shù)
            request.id(id);
            request.index(indexName);
            request.type("_doc");
            // 發(fā)送請求
            DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
            if(response.status().getStatus() >= 400){
                log.warn("向es發(fā)起刪除文檔數(shù)據(jù)請求失敗,請求參數(shù):{},返回參數(shù):{}", request.toString(), response.toString());
                throw new CommonException("向es發(fā)起刪除文檔數(shù)據(jù)請求失敗");
            }
        } catch (Exception e) {
            log.error("向es發(fā)起刪除文檔數(shù)據(jù)請求失敗,請求參數(shù):" + indexName, e);
            throw new CommonException("向es發(fā)起刪除文檔數(shù)據(jù)請求失敗");
        }
    }


    /**
     * 查詢索引中的文檔數(shù)據(jù)
     * @param indexName
     * @param id
     */
    public String getDocumentById(String indexName, String id){
        try {
            GetRequest request = new GetRequest();
            // 外層參數(shù)
            request.id(id);
            request.index(indexName);
            request.type("_doc");
            // 發(fā)送請求
            GetResponse response = client.get(request, RequestOptions.DEFAULT);
            response.getSourceAsString();
        } catch (Exception e) {
            log.error("向es發(fā)起查詢文檔數(shù)據(jù)請求失敗,請求參數(shù):" + indexName, e);
        }
        return StringUtils.EMPTY;
    }


    /**
     * 索引高級查詢
     * @param indexName
     * @param source
     * @return
     */
    public SearchResponse searchDocument(String indexName, SearchSourceBuilder source){
        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices(indexName);
        searchRequest.source(source);
        try {
            // 執(zhí)行請求
            SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
            return response;
        } catch (Exception e) {
            log.warn("向es發(fā)起查詢文檔數(shù)據(jù)請求失敗,請求參數(shù):" + searchRequest.toString(), e);
        }
        return null;
    }


    /**
     * 將對象格式化成json,并保持原字段類型輸出
     * @param object
     * @return
     */
    private String toJson(Object object) {
        try {
            return objectMapper.writeValueAsString(object);
        } catch (Exception e) {
            throw new CommonException(e);
        }
    }

}

2.3初始化索引結(jié)構(gòu)

在使用 es 對訂單進(jìn)行查詢搜索時(shí),我們需要先定義好對應(yīng)的訂單索引結(jié)構(gòu),內(nèi)容如下:

@ActiveProfiles("dev")
@RunWith(SpringRunner.class)
@SpringBootTest
public class OrderIndexServiceJunit {

    @Autowired
    private ElasticSearchClient elasticSearchClient;
    
    /**
     * 初始化索引結(jié)構(gòu)
     *
     * @return
     */
    @Test
    public void initIndex(){
        String indexName = "orderIndex-2022-07";
        // 創(chuàng)建請求
        boolean existsIndex = elasticSearchClient.existsIndex(indexName);
        if (!existsIndex) {
            Map<String, Object> properties = buildMapping();
            elasticSearchClient.createIndex(indexName, properties);
        }
    }

    /**
     * 構(gòu)建索引結(jié)構(gòu)
     *
     * @return
     */
    private Map<String, Object> buildMapping() {
        Map<String, Object> properties = new HashMap();
        //訂單id  唯一鍵ID
        properties.put("orderId", ImmutableBiMap.of("type", "keyword"));
        //訂單號
        properties.put("orderNo", ImmutableBiMap.of("type", "keyword"));
        //客戶姓名
        properties.put("orderUserName", ImmutableBiMap.of("type", "text"));
        
        //訂單項(xiàng)
        Map<String, Object> orderItems = new HashMap();
        //訂單項(xiàng)ID
        orderItems.put("orderItemId", ImmutableBiMap.of("type", "keyword"));
        //產(chǎn)品名稱
        orderItems.put("productName", ImmutableBiMap.of("type", "text"));
        //品牌名稱
        orderItems.put("brandName", ImmutableBiMap.of("type", "text"));
        //銷售金額,單位分*100
        orderItems.put("sellPrice", ImmutableBiMap.of("type", "integer"));
        properties.put("orderItems", ImmutableBiMap.of("type", "nested", "properties", orderItems));

        //文檔結(jié)構(gòu)映射
        Map<String, Object> mapping = new HashMap();
        mapping.put("properties", properties);
        return mapping;
    }
}

2.4向 es 中同步文檔數(shù)據(jù)

索引結(jié)構(gòu)創(chuàng)建好之后,我們需要將支持 es 搜索的訂單數(shù)據(jù)同步進(jìn)去。

將指定的訂單 ID 從數(shù)據(jù)庫查詢出來,并封裝成 es 訂單數(shù)據(jù)結(jié)構(gòu),保存到 es 中!

@ActiveProfiles("dev")
@RunWith(SpringRunner.class)
@SpringBootTest
public class OrderIndexServiceJunit {

    @Autowired
    private ElasticSearchClient elasticSearchClient;


    /**
     * 保存訂單到ES中
     * @param request
     */
    @Test
    public void saveDocument(){
        String indexName =  "orderIndex-2022-07";
        //從數(shù)據(jù)庫查詢最新訂單數(shù)據(jù),并封裝成對應(yīng)的es訂單結(jié)構(gòu)
        String orderId = "202202020202";
        OrderIndexDocDTO indexDocDTO = buildOrderIndexDocDTO(orderId);
        //保存數(shù)據(jù)到ES中
        elasticSearchClient.addDocument(indexName, indexDocDTO.getOrderId(), indexDocDTO);
    }

}

2.5內(nèi)嵌對象查詢

內(nèi)嵌對象查詢分兩種形式,比如,第一種通過商品、品牌、價(jià)格等條件,分頁查詢訂單數(shù)據(jù);第二種是通過訂單ID、商品、品牌、價(jià)格等,分頁查詢訂單項(xiàng)數(shù)據(jù)。具體的實(shí)踐,請看下文。

通過商品、品牌、價(jià)格等條件,分頁查詢訂單數(shù)據(jù);

@ActiveProfiles("dev")
@RunWith(SpringRunner.class)
@SpringBootTest
public class OrderIndexServiceJunit {

    @Autowired
    private ElasticSearchClient elasticSearchClient;


    /**
     * 通過商品、品牌、價(jià)格等條件,分頁查詢訂單數(shù)據(jù)
     * @param request
     */
    @Test
    public void search1(){
        //查詢索引,支持通配符
        String indexName = "orderIndex-*";
        String orderUserName = "張三";
        String productName = "薯?xiàng)l";
        // 條件搜索
        SearchSourceBuilder builder = new SearchSourceBuilder();

        //組合搜索
        BoolQueryBuilder mainBoolQuery = new BoolQueryBuilder();
        mainBoolQuery.must(QueryBuilders.matchQuery("orderUserName", orderUserName));

        //訂單項(xiàng)相關(guān)信息搜索
        BoolQueryBuilder nestedBoolQuery = new BoolQueryBuilder(); nestedBoolQuery.must(QueryBuilders.matchQuery("orderItems.productName", productName));
        //內(nèi)嵌對象搜索,需要指定path
        NestedQueryBuilder nestedQueryBuilder = QueryBuilders.nestedQuery("orderItems",nestedBoolQuery, ScoreMode.None);
        //子表查詢
        mainBoolQuery.must(nestedQueryBuilder);

        //封裝查詢參數(shù)
        builder.query(mainBoolQuery);

        //返回參數(shù)
        builder.fetchSource(new String[]{}, new String[]{});

        //結(jié)果集合分頁,從第一頁開始,返回最多四條數(shù)據(jù)
        builder.from(0).size(4);

        //排序
        builder.sort("orderId", SortOrder.DESC);
        log.info("dsl:{}", builder.toString());
        // 執(zhí)行請求
        SearchResponse response = elasticSearchClient.searchDocument(indexName, builder);
        // 當(dāng)前返回的總行數(shù)
        long count = response.getHits().getTotalHits();
        // 返回的具體行數(shù)
        SearchHit[] searchHits = response.getHits().getHits();
  log.info("response:{}", response.toString());
    }

}

通過訂單ID、商品、品牌、價(jià)格等,分頁查詢訂單項(xiàng)數(shù)據(jù);

@ActiveProfiles("dev")
@RunWith(SpringRunner.class)
@SpringBootTest
public class OrderIndexServiceJunit {

    @Autowired
    private ElasticSearchClient elasticSearchClient;


    /**
     * 通過訂單ID、商品、品牌、價(jià)格等,分頁查詢訂單項(xiàng)數(shù)據(jù)
     * @param request
     */
    @Test
    public void search2(){
        //查詢索引,支持通配符
        String indexName = "orderIndex-*";
        String orderId = "202202020202";
        String productName = "薯?xiàng)l";
        // 條件搜索
        SearchSourceBuilder builder = new SearchSourceBuilder();

        //組合搜索
        BoolQueryBuilder mainBoolQuery = new BoolQueryBuilder();
        mainBoolQuery.must(QueryBuilders.termQuery("_id", orderId));

        //訂單項(xiàng)相關(guān)信息搜索
        BoolQueryBuilder nestedBoolQuery = new BoolQueryBuilder(); nestedBoolQuery.must(QueryBuilders.matchQuery("orderItems.productName", productName));
        //內(nèi)嵌對象搜索,需要指定path
        NestedQueryBuilder nestedQueryBuilder = QueryBuilders.nestedQuery("orderItems",nestedBoolQuery, ScoreMode.None);

        //內(nèi)嵌對象分頁查詢
        InnerHitBuilder innerHitBuilder = new InnerHitBuilder();
        //結(jié)果集合分頁,從第一頁開始,返回最多四條數(shù)據(jù)
        innerHitBuilder.setFrom(0).setSize(4);
        //只返回訂單項(xiàng)id
        innerHitBuilder.setFetchSourceContext(new FetchSourceContext(true, new String[]{"orderItems.orderItemId"}, new String[]{}));
        innerHitBuilder.addSort(SortBuilders.fieldSort("orderItems.orderItemId").order(SortOrder.DESC));
        nestedQueryBuilder.innerHit(innerHitBuilder);
        
        //子表查詢
        mainBoolQuery.must(nestedQueryBuilder);

        //封裝查詢參數(shù)
        builder.query(mainBoolQuery);

        //返回參數(shù)
        builder.fetchSource(new String[]{}, new String[]{});

        //結(jié)果集合分頁,從第一頁開始,返回最多四條數(shù)據(jù)
        builder.from(0).size(4);

        //排序
        builder.sort("orderId", SortOrder.DESC);
        log.info("dsl:{}", builder.toString());
        // 執(zhí)行請求
        SearchResponse response = elasticSearchClient.searchDocument(indexName, builder);
        // 當(dāng)前返回的訂單主表總行數(shù)
        long count = response.getHits().getTotalHits();
        // 返回的訂單主表數(shù)據(jù)
        SearchHit[] searchHits = response.getHits().getHits();
        // 返回查詢的的訂單項(xiàng)分頁數(shù)據(jù)
        Map<String, SearchHits> = searchHit[0].getInnerHits();
        log.info("response:{}", response.toString());
    }

}

三、小結(jié)

本文主要以通過商品名稱查詢訂單數(shù)據(jù)為案例,介紹利用 SpringBoot 整合 es 實(shí)現(xiàn)數(shù)據(jù)的高效搜索,內(nèi)容如果難免有些遺漏,歡迎網(wǎng)友指出!

相關(guān)文章

  • Java編寫多功能萬年歷程序的實(shí)例分享

    Java編寫多功能萬年歷程序的實(shí)例分享

    這里我們來作一個(gè)Java編寫多功能萬年歷程序的實(shí)例分享,可以查詢公元?dú)v、農(nóng)歷、節(jié)氣與節(jié)日等,十分全面,下面就來具體看一下:
    2016-06-06
  • Java多線程編程之ThreadLocal詳解

    Java多線程編程之ThreadLocal詳解

    這篇文章主要介紹了Java多線程編程之ThreadLocal詳解,ThreadLocal是Java中的一個(gè)線程局部變量,該變量在多線程并發(fā)執(zhí)行時(shí),為每個(gè)線程都提供了一個(gè)獨(dú)立的副本,簡單來說,ThreadLocal提供了一種在多線程環(huán)境中,使每個(gè)線程綁定自己獨(dú)立的變量的方法,需要的朋友可以參考下
    2023-09-09
  • SpringBoot-Maven打包壓縮瘦身方式

    SpringBoot-Maven打包壓縮瘦身方式

    這篇文章主要介紹了SpringBoot-Maven打包壓縮瘦身方式,具有很好的參考價(jià)值,希望對大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教
    2024-05-05
  • Spring Security permitAll()不允許匿名訪問的操作

    Spring Security permitAll()不允許匿名訪問的操作

    這篇文章主要介紹了Spring Security permitAll()不允許匿名訪問的操作,具有很好的參考價(jià)值,希望對大家有所幫助。如有錯(cuò)誤或未考慮完全的地方,望不吝賜教
    2021-06-06
  • 2018版java多線程面試題集合及答案

    2018版java多線程面試題集合及答案

    這篇文章主要為大家詳細(xì)介紹了2018版java多線程面試題集合及答案,具有一定的參考價(jià)值,感興趣的小伙伴們可以參考一下
    2018-09-09
  • java web中的servlet3 upload上傳文件實(shí)踐

    java web中的servlet3 upload上傳文件實(shí)踐

    這篇文章主要介紹了servlet3 upload上傳文件實(shí)踐,非常不錯(cuò),具有參考借鑒價(jià)值,需要的朋友可以參考下
    2017-11-11
  • Java的List集合中泛型使用詳解

    Java的List集合中泛型使用詳解

    這篇文章主要介紹了Java的List集合中泛型使用詳解,泛型類,如果沒有指定具體的數(shù)據(jù)類型,此時(shí),操作類型是Object,泛型的類型參數(shù)只能是類類型,不能是基本數(shù)據(jù)類型,需要的朋友可以參考下
    2023-12-12
  • Java實(shí)現(xiàn)轉(zhuǎn)跳不同系統(tǒng)使用枚舉加switch的方式示例

    Java實(shí)現(xiàn)轉(zhuǎn)跳不同系統(tǒng)使用枚舉加switch的方式示例

    今天小編就為大家分享一篇關(guān)于Java實(shí)現(xiàn)轉(zhuǎn)跳不同系統(tǒng)使用枚舉加switch的方式示例,小編覺得內(nèi)容挺不錯(cuò)的,現(xiàn)在分享給大家,具有很好的參考價(jià)值,需要的朋友一起跟隨小編來看看吧
    2018-12-12
  • Java中的Object類詳細(xì)介紹

    Java中的Object類詳細(xì)介紹

    這篇文章主要介紹了Java中的Object類詳細(xì)介紹,本文講解了Object類的作用、Object類的主要方法、Object類中不能被重寫的方法、Object類的equals方法重寫實(shí)例等內(nèi)容,需要的朋友可以參考下
    2015-06-06
  • Java List的sort()方法改寫compare()實(shí)現(xiàn)升序,降序,倒序的案例

    Java List的sort()方法改寫compare()實(shí)現(xiàn)升序,降序,倒序的案例

    這篇文章主要介紹了Java List的sort()方法改寫compare()實(shí)現(xiàn)升序,降序,倒序的案例,具有很好的參考價(jià)值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2021-03-03

最新評論