学习elasticsearch_大数据系统-终身学习网

elasticsearch

代码下载：https://gitee.com/pipea/elasticsearch

Http操作

1.索引操作

创建索引

对比关系型数据库，创建索引就等同于创建数据库
在 Postman 中，向 ES 服务器发 PUT 请求：
http://127.0.0.1:9200/shopping

获取索引

在 Postman 中，向 ES 服务器发 GET 请求：
http://127.0.0.1:9200/shopping（单个）
http://127.0.0.1:9200/_cat/indices?v（所有）

删除索引

在 Postman 中，向 ES 服务器发 DELETe 请求：
http://127.0.0.1:9200/shopping

1.文档数据

文档数据的创建

在 Postman 中，向 ES 服务器发 POST 请求：>http://127.0.0.1:9200/shopping/_doc
http://127.0.0.1:9200/shopping/_create
如果id自己定义则可以使用PUT请求（id直接跟在url后）

文档数据的查看

在 Postman 中，向 ES 服务器发 GET 请求：>http://127.0.0.1:9200/shopping/_doc/1001（单个）
http://127.0.0.1:9200/shopping/_search（所有）

文档数据的修改

在 Postman 中，向 ES 服务器发 POST 请求：
http://127.0.0.1:9200/shopping/_update/1001（单个）
http://127.0.0.1:9200/shopping/_doc/1001（所有）
修改所有可以使用PUT请求

文档数据的删除

在 Postman 中，向 ES 服务器发DELETE 请求：
http://127.0.0.1:9200/shopping/_doc/1001

文档数据的条件查询，分页查询，排序查询

在 Postman 中，向 ES 服务器发GET 请求：
http://127.0.0.1:9200/shopping/_search

json数据
条件单个

{
    "query":{
        "match":{
            "category":"小米"
        }
    }
}

条件所有

{
    "query":{
        "match_all":{
        }
    }
}

条件分页排序

{
    "query":{
        "match_all":{
        }
    },
    "from":2,
    "size":2,
    "_source":["title"],
    "sort":{
        "price":{
            "order":"desc"
        }
    }
}

文档数据的多条件，范围查询

在 Postman 中，向 ES 服务器发GET 请求：
http://127.0.0.1:9200/shopping/_search

json数据

{
    "query":{
        "bool":{
            "should":[
                {
                "match":{
                    "category":"小米"
                    }
                },
                {
                "match":{
                    "category":"华为"
                    }
                }
            ],
            "filter":{
                "range":{
                    "price":{
                        "gt":20000
                    }
                }
            }
        }
    }
}

全文检索，完全匹配，高亮查询

在 Postman 中，向 ES 服务器发GET 请求：
http://127.0.0.1:9200/shopping/_search

{
    "query":{
        "match_phrase":{
            "category":"小米"
        }
    },
    "highlight":{
        "fields":{
            "category":{}
        }
    }
}

聚合查询

在 Postman 中，向 ES 服务器发GET 请求：
http://127.0.0.1:9200/shopping/_search

json数据

{
    // "aggs":{//聚合操作
    //     "price_group":{ //名称 随意起名
    //         "terms":{  //分组操作
    //             "field":"price"  //分组字段
    //         }
    //     }
    // },
    "aggs":{//聚合操作
        "price_avg":{ //名称 随意起名
            "avg":{  //平均值
                "field":"price"  //分组字段
            }
        }
    },
    "size":0 //不用查询原始数据
}

映射关系

在 Postman 中，向 ES 服务器发GET 请求：
http://127.0.0.1:9200/shopping/_search

json数据

{
    "properties":{
        "name":{
            "type":"text", //文本  允许全文检索
            "index":true  //允许索引查询
        },
        "sex":{
            "type":"keyword", //映射关系  必须查询值对应才能查到  不允许全文检索
            "index":true
        },
        "tel":{
            "type":"keyword",
            "index":false   //查询不到
        }
    }
}

映射关系的查询

在 Postman 中，向 ES 服务器发GET 请求：
http://127.0.0.1:9200/user/_search

json数据

{
    "query":{
        "match":{
            "sex":"男"
        }
    }
}

集群节点

在 Postman 中，向 ES 服务器发GET 请求：
http://localhost:1001/_cluster/health

linux单节点

在 Postman 中，向 ES 服务器发GET 请求：
http://pipi01:9200/_cat/indices?v

13.集群分片
在 Postman 中，向 ES 服务器发PUT 请求：
http://localhost:1001/users/_settings

json数据

// {
//  "settings" : {
//  "number_of_shards" : 3,
//  "number_of_replicas" : 1
//  } 
// }


{
 "number_of_replicas" : 2
}

14.分词器

在 Postman 中，向 ES 服务器发GET请求：
http://localhost:9200/my_index/_analyze

json数据

{
 "text":"The quick & brown fox",
 "analyzer": "my_analyzer"
}

15.自定义分词器

在 Postman 中，向 ES 服务器发PUT 请求：
http://localhost:9200/my_index

json数据

{
 "settings": {
 "analysis": {
 "char_filter": {
 "&_to_and": {
 "type": "mapping",
 "mappings": [ "&=> and "]
 }},
 "filter": {
 "my_stopwords": {
 "type": "stop",
 "stopwords": [ "the", "a" ]
 }},
 "analyzer": {
 "my_analyzer": {
 "type": "custom",
 "char_filter": [ "html_strip", "&_to_and" ],
 "tokenizer": "standard",
 "filter": [ "lowercase", "my_stopwords" ]
 }}
}}}

常用API：

//多条件查询
//大条件------->用来组装小条件     
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
//查询条件  //参数使用QueryBuilders.xxxQuery()进行组装
//小条件
boolQueryBuilder.filter();
boolQueryBuilder.must();
........
//使用NativeSearchQuery进行总查询  withXxx()进行条件组装
NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder().withQuery(boolQueryBuilder).build();

//聚合查询  查询条件
FilterAggregationBuilder refundFilter = AggregationBuilders.filter("banlanceRefund", boolQueryBuilder);
refundFilter.subAggregation(AggregationBuilders.sum("balanceRefundAmt").field("pay_amt"));
//将聚合条件放入总查询钟   addAggregation()进行条件组装
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
queryBuilder.addAggregation(refundFilter);
NativeSearchQuery searchQuery = queryBuilder.build();
//进行查询  参数(查询条件,操作实体类,索引)
SearchHits orders = esTemplate.search(searchQuery, SaleOrderDetailEsVo.class, IndexCoordinates.of("oms_sale_pay"));
//1.得到查询到得聚合条件结果
Aggregations csAgg = orders.getAggregations();
Map csAggMap = csAgg.getAsMap();
//ParsedSum sum聚合函数使用
ParsedSum orderAmtSum = (ParsedSum) csAggMap.get("balanceRefundAmt");
//ParsedValueCount count聚合函数使用.....
ParsedValueCount merMapIdCount = (ParsedValueCount) csAggMap.get("merMapIdCount");
//----------------------------------------------------------------------------------
//2.得到查询到得聚合条件结果
Aggregations csAgg = recharges.getAggregations();
Map csAggMap = csAgg.getAsMap();
ParsedFilter recharge = (ParsedFilter) csAggMap.get("banlanceRefund");
ParsedSum rechargeAmt =  recharge.getAggregations().get("balanceRefundAmt");

案例

根据交易类型查询商户日交易额

es索引

PUT：localhost:9200/order

{
    "mappings":{
        "properties":{
            "order_no":{
            "type" : "text",
            "analyzer":"keyword"
            },
            "user_id":{
            "type" : "long"
            },
            "mer_id":{
            "type" : "long"
            },
            "mer_name":{
            "type" : "text"
            },
            "pay_type":{
            "type" : "integer"
            },
            "pay_money":{
            "type" : "double"
            },
            "status":{
            "type" : "integer"
            },
            "create_time":{
            "type" : "long"
            }
        }
    }
}

es数据

自己插入数据…此处省略…
POST：http://127.0.0.1:9200/order/_doc/

{
        "pay_title":"卖香肠1",
        "pay_Id":"2",
        "pay_type":"1",
        "pay_money":"2.3"
}

Maven依赖



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.3.5.RELEASE
         
    
    nuc.zy.edu
    es-jd
    0.0.1-SNAPSHOT
    es-jd
    Demo project for Spring Boot
    
        1.8
        7.8.0
    
    

        
        
            org.jsoup
            jsoup
            1.10.2
        


        
            org.springframework.boot
            spring-boot-starter-data-elasticsearch
        
        
            org.springframework.boot
            spring-boot-starter-thymeleaf
        
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            com.alibaba
            fastjson
            1.2.62
        

        
            org.springframework.boot
            spring-boot-devtools
            runtime
            true
        
        
            org.springframework.boot
            spring-boot-configuration-processor
            true
        
        
            org.projectlombok
            lombok
            true
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        
                            org.projectlombok
                            lombok

yml配置

server.port=9090
#关闭thymeleaf的缓存
#spring.thymeleaf.cache=false

## es 服务地址
#elasticsearch.host=127.0.0.1
## es 服务端口
#elasticsearch.port=9200
# 配置日志级别,开启 debug 日志
#logging.level.com.atguigu.es=debug

spring.elasticsearch.rest.uris=127.0.0.1:9200

工具类

package nuc.zy.edu.utils;

import org.joda.time.DateTime;

import java.util.Date;


public class DateUtil {

    public static String format(Date date, String pattern) {
        DateTime dateTime = new DateTime(date);
        return dateTime.toString(pattern);
    }

    public static Long dayEndTimeSSS(Date date) {
        if (date == null) {
            date = new Date();
        }

        String day = format(date, "yyyyMMdd");
        return dayEndTimeSSS(Long.parseLong(day));
    }

    public static Long dayEndTimeSSS(Long date) {
//        return Long.parseLong(String.valueOf(date + "235959999"));
        return Long.parseLong(String.valueOf(date));
    }

    public static Long dayEndTimeSSS() {
        return dayEndTimeSSS(new Date());
    }
}

实体类

package nuc.zy.edu.es.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;




@Data
@AllArgsConstructor
@NoArgsConstructor
@document(indexName = "order")
public class Order {
    //id
    @Id
    private String id ;
    //订单编号
    @Field(type = FieldType.Text,name = "order_no")
    private String orderNo ;
    //用户唯一Id
    @Field(type = FieldType.Long,name = "user_id")
    private Long userId ;
    //商户编号
    @Field(type = FieldType.Long,name = "mer_id")
    private Long merId;
    //商户名称
    @Field(type = FieldType.Text,name = "mer_name")
    private String merName;
    //交易类型  微信1  支付宝2   现金3   银行卡4
    @Field(type = FieldType.Integer,name = "pay_type")
    private Integer payType ;
    //交易金额
    @Field(type = FieldType.Double,name = "pay_money")
    private Double payMoney ;
    //订单状态   1已支付   2未支付  3取消
    @Field(type = FieldType.Integer,name = "status")
    private Integer status;
    //创建时间
    @Field(type = FieldType.Long,name = "create_time")
    private Long createTime ;
}

package nuc.zy.edu.es.entity.rep;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;


@Data
@AllArgsConstructor
@NoArgsConstructor
public class RepParamVo {
    //商户编号
    private Long merId;
    //微信交易金额
    private BigDecimal wxMoneyCount ;
    //支付宝交易金额
    private BigDecimal payMoneyCount ;
    //现金交易金额
    private BigDecimal cashMoneyCount ;
    //银行卡交易金额
    private BigDecimal cardMoneyCount ;
    //总金额
    private BigDecimal MoneyCount ;
}

package nuc.zy.edu.es.entity.req;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;


@Data
@AllArgsConstructor
@NoArgsConstructor
public class ReqParamVo {
    //商户编号
    private Long merId;
    //起始时间
    private Date startTime;
    //终止时间
    private Date endTime;
}

业务类（两种方法）

package nuc.zy.edu.es.service;

import lombok.extern.slf4j.Slf4j;
import nuc.zy.edu.es.entity.Order;
import nuc.zy.edu.es.entity.rep.RepParamVo;
import nuc.zy.edu.es.entity.req.ReqParamVo;
import nuc.zy.edu.utils.DateUtil;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.filter.ParsedFilter;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.metrics.ParsedSum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;


@Service
@Slf4j
public class OrderEsService {
    @Autowired
    private ElasticsearchRestTemplate restTemplate;

    //根据交易类型查询商户日交易额
    public RepParamVo queryOrderMoney(ReqParamVo reqParamVo) {
        //查询条件
        Long startTime = DateUtil.dayEndTimeSSS(reqParamVo.getStartTime());
        Long endTime = DateUtil.dayEndTimeSSS(reqParamVo.getEndTime());
        Long merId = reqParamVo.getMerId();
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder() ;
        List list = allQueryOrderMoney(merId, startTime, endTime);
        for (FilterAggregationBuilder builder : list) {
            queryBuilder.addAggregation(builder) ;
        }
        NativeSearchQuery build = queryBuilder.build();
        SearchHits order = restTemplate.search(build, Order.class, IndexCoordinates.of("order"));
        long totalHits = order.getTotalHits();
        RepParamVo repParamVo = new RepParamVo() ;
        if (totalHits > 0) {
            Aggregations aggregations = order.getAggregations();
            Map asMap = aggregations.getAsMap();
            //微信
            ParsedFilter wxFilter = (ParsedFilter) asMap.get("wx");
            ParsedSum wxMoneyCount = wxFilter.getAggregations().get("wxMoneyCount");
            BigDecimal wxBigDecimal = new BigDecimal(wxMoneyCount.value());
            repParamVo.setWxMoneyCount(wxBigDecimal);
            //支付宝
            ParsedFilter payFilter = (ParsedFilter) asMap.get("pay");
            ParsedSum payMoneyCount = payFilter.getAggregations().get("payMoneyCount");
            BigDecimal payBigDecimal = new BigDecimal(payMoneyCount.value());
            repParamVo.setPayMoneyCount(payBigDecimal);
            //现金
            ParsedFilter cashFilter = (ParsedFilter) asMap.get("cash");
            ParsedSum cashMoneyCount = cashFilter.getAggregations().get("cashMoneyCount");
            BigDecimal cashBigDecimal = new BigDecimal(cashMoneyCount.value());
            repParamVo.setCashMoneyCount(cashBigDecimal);
            //银行卡
            ParsedFilter cardFilter = (ParsedFilter) asMap.get("card");
            ParsedSum cardMoneyCount = cardFilter.getAggregations().get("cardMoneyCount");
            BigDecimal cardBigDecimal = new BigDecimal(cardMoneyCount.value());
            repParamVo.setCardMoneyCount(cardBigDecimal);
            //商编
            repParamVo.setMerId(merId);
            //总金额
            BigDecimal moneyCount = new BigDecimal(0) ;
            moneyCount = moneyCount.add(wxBigDecimal).add(payBigDecimal).add(cashBigDecimal).add(cardBigDecimal);
            repParamVo.setMoneyCount(moneyCount);
        }
        return repParamVo ;
    }



    //根据交易类型查询商户日交易额
    public RepParamVo queryOrderMoney1(ReqParamVo reqParamVo) {
        //查询条件
        Long startTime = DateUtil.dayEndTimeSSS(reqParamVo.getStartTime());
        Long endTime = DateUtil.dayEndTimeSSS(reqParamVo.getEndTime());
        Long merId = reqParamVo.getMerId();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //商编
        if (!StringUtils.isEmpty(merId)) {
            boolQueryBuilder.filter(QueryBuilders.termQuery("mer_id", merId));
        }
        //查询日期
        if (!StringUtils.isEmpty(startTime) && !StringUtils.isEmpty(endTime)) {
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("create_time").gte(startTime).lte(endTime));
        }
        //订单状态
        boolQueryBuilder.filter(QueryBuilders.termQuery("status", "1"));
        NativeSearchQuery build = new NativeSearchQueryBuilder()
                .withQuery(boolQueryBuilder)
                .addAggregation(AggregationBuilders.terms("payType").field("pay_type")
                .subAggregation(AggregationBuilders.sum("payMoney").field("pay_money")))
                .build();
        SearchHits order = restTemplate.search(build, Order.class, IndexCoordinates.of("order"));
        long totalHits = order.getTotalHits();
        RepParamVo repParamVo = new RepParamVo() ;
        //商编
        repParamVo.setMerId(merId);
        //总金额
        BigDecimal moneyCount = new BigDecimal(0) ;
        if (totalHits > 0) {
            Aggregations aggregations = order.getAggregations();
            Map asMap = aggregations.getAsMap();
            ParsedTerms parsedTerms = (ParsedTerms)asMap.get("payType");
//            ParsedTerms parsedTerms = aggregations.get("payType") ;
//            Terms.Bucket bucketByKey = parsedTerms.getBucketByKey("1");
//            System.out.println(((ParsedSum)bucketByKey.getAggregations().get("payMoney")).value());
            for (Terms.Bucket bucket : parsedTerms.getBuckets()) {
                Long key = (Long)bucket.getKey();
                ParsedSum payMoney = bucket.getAggregations().get("payMoney");
                BigDecimal payBigDecimal = new BigDecimal(payMoney.value());
                if (key == 1) {
                    repParamVo.setWxMoneyCount(payBigDecimal);
                }
                if (key == 2) {
                    repParamVo.setPayMoneyCount(payBigDecimal);
                }
                if (key == 3) {
                    repParamVo.setCashMoneyCount(payBigDecimal);
                }
                if (key == 4) {
                    repParamVo.setCardMoneyCount(payBigDecimal);
                }
                moneyCount = moneyCount.add(payBigDecimal) ;
            }
            repParamVo.setMoneyCount(moneyCount);
        }
        return repParamVo ;
    }




    //总查询
    private List allQueryOrderMoney(Long merId, Long startTime, Long endTime) {
        List list = new ArrayList<>() ;
        FilterAggregationBuilder wxAggregationBuilder = wxQueryOrderMoney(merId, startTime, endTime);
        FilterAggregationBuilder payAggregationBuilder = payQueryOrderMoney(merId, startTime, endTime);
        FilterAggregationBuilder cashAggregationBuilder = cashQueryOrderMoney(merId, startTime, endTime);
        FilterAggregationBuilder cardAggregationBuilder = cardQueryOrderMoney(merId, startTime, endTime);
        list.add(wxAggregationBuilder) ;
        list.add(payAggregationBuilder) ;
        list.add(cashAggregationBuilder) ;
        list.add(cardAggregationBuilder) ;
        return list ;
    }


    //微信查询
    private FilterAggregationBuilder wxQueryOrderMoney(Long merId, Long startTime, Long endTime) {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //商编
        if (!StringUtils.isEmpty(merId)) {
            boolQueryBuilder.filter(QueryBuilders.termQuery("mer_id", merId));
        }
        //查询日期
        if (!StringUtils.isEmpty(startTime) && !StringUtils.isEmpty(endTime)) {
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("create_time").gte(startTime).lte(endTime));
        }

        boolQueryBuilder.filter(QueryBuilders.termQuery("pay_type", "1"));
        //订单状态
        boolQueryBuilder.filter(QueryBuilders.termQuery("status", "1"));
        FilterAggregationBuilder wx = AggregationBuilders.filter("wx", boolQueryBuilder);
        FilterAggregationBuilder builder = wx.subAggregation(AggregationBuilders.sum("wxMoneyCount").field("pay_money"));
        return builder ;
    }


    //支付宝查询
    private FilterAggregationBuilder payQueryOrderMoney(Long merId, Long startTime, Long endTime) {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //商编
        if (!StringUtils.isEmpty(merId)) {
            boolQueryBuilder.filter(QueryBuilders.termQuery("mer_id", merId));
        }
        //查询日期
        if (!StringUtils.isEmpty(startTime) && !StringUtils.isEmpty(endTime)) {
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("create_time").gte(startTime).lte(endTime));
        }

        boolQueryBuilder.filter(QueryBuilders.termQuery("pay_type", "2"));
        //订单状态
        boolQueryBuilder.filter(QueryBuilders.termQuery("status", "1"));
        FilterAggregationBuilder wx = AggregationBuilders.filter("pay", boolQueryBuilder);
        FilterAggregationBuilder builder = wx.subAggregation(AggregationBuilders.sum("payMoneyCount").field("pay_money"));
        return builder ;
    }

    //现金查询
    private FilterAggregationBuilder cashQueryOrderMoney(Long merId, Long startTime, Long endTime) {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //商编
        if (!StringUtils.isEmpty(merId)) {
            boolQueryBuilder.filter(QueryBuilders.termQuery("mer_id", merId));
        }
        //查询日期
        if (!StringUtils.isEmpty(startTime) && !StringUtils.isEmpty(endTime)) {
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("create_time").gte(startTime).lte(endTime));
        }

        boolQueryBuilder.filter(QueryBuilders.termQuery("pay_type", "3"));
        //订单状态
        boolQueryBuilder.filter(QueryBuilders.termQuery("status", "1"));
        FilterAggregationBuilder wx = AggregationBuilders.filter("cash", boolQueryBuilder);
        FilterAggregationBuilder builder = wx.subAggregation(AggregationBuilders.sum("cashMoneyCount").field("pay_money"));
        return builder ;
    }


    //银行卡查询
    private FilterAggregationBuilder cardQueryOrderMoney(Long merId, Long startTime, Long endTime) {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //商编
        if (!StringUtils.isEmpty(merId)) {
            boolQueryBuilder.filter(QueryBuilders.termQuery("mer_id", merId));
        }
        //查询日期
        if (!StringUtils.isEmpty(startTime) && !StringUtils.isEmpty(endTime)) {
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("create_time").gte(startTime).lte(endTime));
        }

        boolQueryBuilder.filter(QueryBuilders.termQuery("pay_type", "4"));
        //订单状态
        boolQueryBuilder.filter(QueryBuilders.termQuery("status", "1"));
        FilterAggregationBuilder wx = AggregationBuilders.filter("card", boolQueryBuilder);
        FilterAggregationBuilder builder = wx.subAggregation(AggregationBuilders.sum("cardMoneyCount").field("pay_money"));
        return builder ;
    }


}

测试类

package nuc.zy.edu;
import nuc.zy.edu.es.entity.rep.RepParamVo;
import nuc.zy.edu.es.entity.req.ReqParamVo;
import nuc.zy.edu.es.service.OrderEsService;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;


@RunWith(SpringRunner.class)
@SpringBootTest
class EsJdApplicationTests {
    @Autowired
    private OrderEsService orderEsService ;


    @Test
    public void test06() {
        ReqParamVo reqParamVo = new ReqParamVo() ;
        reqParamVo.setMerId(1001L);
//        reqParamVo.setMerId(1002L);
        reqParamVo.setStartTime(new Date());
        reqParamVo.setEndTime(new Date());
        RepParamVo repParamVo = orderEsService.queryOrderMoney1(reqParamVo);
        System.out.println("+++++repParamVo++++" + repParamVo);
    }
}

Dao层

@Repository
public interface GoodsDao extends ElasticsearchRepository {}

Service层

public interface GoodsService {}

@Service
@Slf4j
public class GoodsServiceImpl implements GoodsService {}

练习（常用Api） es索引

localhost:9200/long_test

{
    "mappings":{
        "properties":{
                    "pay_title":{
                        "type":"text",
                        "analyzer":"keyword"
                    },
                    "pay_Id":{
                        "type":"long"
                    },
                    "pay_type":{
                        "type":"integer"
                    },
                    "pay_money":{
                        "type":"double"
                    }
        }
    }
}

es数据

自己随便插入…省略…
POST：http://127.0.0.1:9200/long_test/_doc/

{
    "pay_title": "dddd",
    "pay_Id": "你好啊",
    "pay_type": "真棒",
    "pay_money": "真棒"
}

package nuc.zy.edu;

import nuc.zy.edu.dao.GoodsDao;
import nuc.zy.edu.entity.LongTest;
import nuc.zy.edu.entity.User;
import nuc.zy.edu.es.entity.rep.RepParamVo;
import nuc.zy.edu.es.entity.req.ReqParamVo;
import nuc.zy.edu.es.service.OrderEsService;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.filter.ParsedFilter;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedTerms;
import org.elasticsearch.search.aggregations.metrics.ParsedMax;
import org.elasticsearch.search.aggregations.metrics.ParsedSum;
import org.elasticsearch.search.aggregations.metrics.ParsedValueCount;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.test.context.junit4.SpringRunner;

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

@RunWith(SpringRunner.class)
@SpringBootTest
class EsJdApplicationTests {

    @Autowired
    private ElasticsearchRestTemplate restTemplate ;
    @Test
    void contextLoads() {
    }

    @Autowired
    private GoodsDao goodsDao ;

    @Test
    public void test01() {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.filter(QueryBuilders.termQuery("name", "dddd")) ;
//        boolQueryBuilder.filter() ;
        FilterAggregationBuilder filter = AggregationBuilders.filter("zhang", boolQueryBuilder);
        filter.subAggregation(AggregationBuilders.count("nameSum").field("id")) ;
        NativeSearchQuery build = new NativeSearchQueryBuilder()
                .addAggregation(filter)
//                .withQuery(boolQueryBuilder)
                .build();
        SearchHits search = restTemplate.search(build, User.class, IndexCoordinates.of("user"));
        long totalHits = search.getTotalHits();
        System.out.println(totalHits);
//        search.stream().map(a -> {
//            System.out.println(a.getContent().toString());
//            return null;
//        }).collect(Collectors.toList());
        if (totalHits > 0) {
//            search.stream().map(a -> {
//                a.
//            })
            Aggregations aggregations = search.getAggregations();
            Map asMap = aggregations.getAsMap();
            ParsedFilter name = (ParsedFilter)asMap.get("zhang");
            System.out.println("ParsedFilter" + name);
            ParsedValueCount nameSum = name.getAggregations().get("nameSum");
            System.out.println("nameSum" + nameSum.value());
        }
    }

    @Test
    public void test02() {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.filter(QueryBuilders.termQuery("name", "张")) ;
        FilterAggregationBuilder filter = AggregationBuilders.filter("zhang", boolQueryBuilder);
        filter.subAggregation(AggregationBuilders.count("idSum").field("age")) ;
        NativeSearchQuery build = new NativeSearchQueryBuilder()
                .addAggregation(filter)
//                .withQuery(boolQueryBuilder)
                .build();
        SearchHits search = restTemplate.search(build, User.class, IndexCoordinates.of("user"));
        long totalHits = search.getTotalHits();
        System.out.println(totalHits);
        if (totalHits > 0) {
            if (search.getAggregations() != null){
                Aggregations aggregations = search.getAggregations();
                Map asMap = aggregations.getAsMap();
                ParsedFilter name = (ParsedFilter)asMap.get("zhang");
                ParsedValueCount idSum = name.getAggregations().get("idSum");
                System.out.println("idSum" + idSum.value());
            }
        }
    }

    @Test
    public void test03() {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.filter(QueryBuilders.termQuery("host_inst_no", "你")) ;
//        FilterAggregationBuilder filter = AggregationBuilders.filter("zhang", boolQueryBuilder);
//        filter.subAggregation(AggregationBuilders.count("hostInstNo")) ;
        NativeSearchQuery build = new NativeSearchQueryBuilder()
//                .addAggregation(filter)
                .withQuery(boolQueryBuilder)
                .build();
        SearchHits search = restTemplate.search(build, User.class, IndexCoordinates.of("oms_recharge_order"));
        long totalHits = search.getTotalHits();
        System.out.println(totalHits);
        search.getSearchHits().stream().map(a ->{
            System.out.println(a.getContent());
            return null ;
        }).collect(Collectors.toList()) ;
        if (totalHits > 0) {
            if (search.getAggregations() != null){
                Aggregations aggregations = search.getAggregations();
                Map asMap = aggregations.getAsMap();
                ParsedFilter name = (ParsedFilter)asMap.get("zhang");
                ParsedValueCount partnerName = name.getAggregations().get("partnerName");
                System.out.println("partnerName" + partnerName.value());
            }
        }
    }


    @Test
    public void test04() {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder
                .filter(QueryBuilders.termQuery("pay_title","张宇测试"))
                .filter(QueryBuilders.rangeQuery("pay_name").lte(20211021))
                .filter(QueryBuilders.termQuery("pay_type",200))
                .filter(QueryBuilders.termQuery("pay_money",23.26));

        FilterAggregationBuilder filter = AggregationBuilders.filter("zhangyu",boolQueryBuilder);
        filter.subAggregation(AggregationBuilders.count("count").field("pay_name"));
        filter.subAggregation(AggregationBuilders.sum("sum").field("pay_type"));
        filter.subAggregation(AggregationBuilders.max("max").field("pay_money"));
        filter.subAggregation(AggregationBuilders.terms("terms").field("pay_name"));
        NativeSearchQuery build = new NativeSearchQueryBuilder()
                .addAggregation(filter)
                .build();
        SearchHits search = restTemplate.search(build, LongTest.class, IndexCoordinates.of("long_test"));
        long totalHits = search.getTotalHits();
        System.out.println("totalHits" + totalHits);
//        if (totalHits > 0){
//            search.getSearchHits().stream().map(a -> {
//                System.out.println(a.getContent());
//                return null ;
//            }).collect(Collectors.toList()) ;
//        }

        Aggregations aggregations = search.getAggregations();
        Map asMap = aggregations.getAsMap();
        ParsedFilter zhangyu = (ParsedFilter)asMap.get("zhangyu");
        ParsedValueCount count = zhangyu.getAggregations().get("count");
        System.out.println("count------" + count.value());
        ParsedSum sum = zhangyu.getAggregations().get("sum");
        System.out.println("sum------" + sum.value());
        ParsedMax max = zhangyu.getAggregations().get("max");
        System.out.println("max------" + max.value());
        ParsedTerms terms = zhangyu.getAggregations().get("terms");
        terms.getBuckets().stream().map(a -> {
            System.out.println("getKey---------" + a.getKey());
            System.out.println("getDocCount-----------" + a.getDocCount());
            return null;
        }).collect(Collectors.toList());
    }




    @Test
    public void test05() {
        List list = new ArrayList<>() ;
        list.add("卖香肠") ;
        list.add("买辣条啦") ;
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder
                .filter(QueryBuilders.termsQuery("pay_title",list));
//                .filter(QueryBuilders.termsQuery("pay_title","卖香肠","买辣条啦"));
//                .filter(QueryBuilders.rangeQuery("pay_name").lte(2))
//                .filter(QueryBuilders.termQuery("pay_type",2))
//                .filter(QueryBuilders.termQuery("pay_money",1.03)) ;
        FilterAggregationBuilder filter = AggregationBuilders.filter("zhangyu",boolQueryBuilder);
        filter.subAggregation(AggregationBuilders.count("count").field("pay_Id"));
//        filter.subAggregation(AggregationBuilders.sum("sum").field("pay_type"));
//        filter.subAggregation(AggregationBuilders.max("max").field("pay_money"));
//        filter.subAggregation(AggregationBuilders.terms("terms").field("pay_name"));
        NativeSearchQuery build = new NativeSearchQueryBuilder()
                .addAggregation(filter)
                .build();
        SearchHits search = restTemplate.search(build, LongTest.class, IndexCoordinates.of("test"));
        long totalHits = search.getTotalHits();
        System.out.println("totalHits" + totalHits);

        Aggregations aggregations = search.getAggregations();
        Map asMap = aggregations.getAsMap();
        ParsedFilter zhangyu = (ParsedFilter)asMap.get("zhangyu");
        ParsedValueCount count = zhangyu.getAggregations().get("count");
        System.out.println("count------" + count.value());
//        ParsedSum sum = zhangyu.getAggregations().get("sum");
//        System.out.println("sum------" + sum.value());
//        ParsedMax max = zhangyu.getAggregations().get("max");
//        System.out.println("max------" + max.value());
//        ParsedTerms terms = zhangyu.getAggregations().get("terms");
//        terms.getBuckets().stream().map(a -> {
//            System.out.println("getKey---------" + a.getKey());
//            System.out.println("getDocCount-----------" + a.getDocCount());
//            return null;
//        }).collect(Collectors.toList());
    }
}

学习elasticsearch

大数据系统相关栏目本月热门文章