[转载] --- springboot mongoTemplate聚合操作Demo代码

最新推荐文章于 2024-08-05 10:01:57 发布
转载 最新推荐文章于 2024-08-05 10:01:57 发布 · 7.8k 阅读 · 1 ·
CC 4.0 BY-SA版权
原文链接：https://www.cnblogs.com/tangzhe/p/9579908.html

本文深入探讨了使用MongoDB聚合框架进行复杂数据查询和分析的方法，通过多个示例展示了如何运用匹配、分组、排序等操作来高效处理大量数据，特别关注于数据统计和用户行为分析。 
package com.tangzhe.mongodb.mongotemplate;

import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
import com.tangzhe.mongodb.BaseTest;
import com.tangzhe.mongodb.Student;
import com.tangzhe.shop.document.MBalanceIncrease;
import com.tangzhe.shop.document.MVip;
import com.tangzhe.shop.entity.AmountChart;
import com.tangzhe.shop.entity.VipChart;
import com.tangzhe.test.document.PlayareaStatistics;
import com.tangzhe.test.util.DateUtils;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Duration;
import java.time.Instant;
import java.util.*;

import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;

public class MongoTemplateTest2 extends BaseTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    //@Test
    public void test01() {
//        List<PlayareaStatistics> list = mongoTemplate.find(
//                Query.query(
//                        new Criteria().andOperator(
//                                Criteria.where("areaId").is(21),
//                                Criteria.where("type").is("READ")
//                        )
//                ),
//                PlayareaStatistics.class);
//        System.out.println(list);

//        GroupByResults<PlayareaStatistics> group = mongoTemplate.group(
//                Criteria.where("areaId").is(21),
//                "playarea_statistics",
//                new GroupBy("type"),
//                PlayareaStatistics.class);
//        System.out.println(group);

        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("areaId").is(21)),
                group("type").count().as("sum"));
        AggregationResults<BasicDBObject> outputTypeCount =
                mongoTemplate.aggregate(aggregation, PlayareaStatistics.class, BasicDBObject.class);

        for (Iterator<BasicDBObject> iterator = outputTypeCount.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            System.out.println(obj);
        }
    }

    //@Test
    public void test02() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("areaId").is(21)
                                .andOperator(Criteria.where("type").is("READ"))),
                group("city").count().as("sum"));
        AggregationResults<BasicDBObject> outputTypeCount =
                mongoTemplate.aggregate(aggregation, PlayareaStatistics.class, BasicDBObject.class);

        for (Iterator<BasicDBObject> iterator = outputTypeCount.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            System.out.println(obj);
        }
    }

    //@Test
    public void test03() throws ParseException {
        // 默认查当月第一天至当天之间的数据
        //Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse("2018-05-02 00:00:00");
        String beginTime = DateUtils.getMonthFirstDay(date);
        String endTime = DateUtils.getMonthLastDay(date);
        Date beginDate = sdf.parse(beginTime);
        Date endDate = sdf.parse(endTime);

        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("areaId").is(21L)
                                .andOperator(
                                        Criteria.where("operateTime").gte(beginDate).lt(endDate),
                                        Criteria.where("type").is("READ"))),
                group("logDate").count().as("sum"));
        AggregationResults<BasicDBObject> outputTypeCount =
                mongoTemplate.aggregate(aggregation, PlayareaStatistics.class, BasicDBObject.class);

        Map<String, Integer> map = new HashMap<>();
        for (Iterator<BasicDBObject> iterator = outputTypeCount.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            String day = ((String) obj.get("_id")).substring(8, 10); // day
            map.put(day, (Integer) obj.get("sum"));
        }

        System.out.println(map);
    }

    //@Test
    public void test04() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse("2018-05-02 00:00:00");
        String beginTime = DateUtils.getMonthFirstDay(date);
        String endTime = DateUtils.getMonthLastDay(date);
        Date beginDate = sdf.parse(beginTime);
        Date endDate = sdf.parse(endTime);
    }

    @Test
    public void test05() throws ParseException {
        Date date = new Date();
        String today = DateUtils.formatToString(date, "yyyy-MM-dd");
        String thisMonth = DateUtils.formatToString(date, "yyyy-MM");
        List<MVip> list = mongoTemplate.find(
                Query.query(
                        Criteria.where("day").is("2018-03-28")
                ), MVip.class);
        System.out.println(list.size());
    }

    @Test
    public void test06() {
        Date date = new Date();
        String today = DateUtils.formatToString(date, "yyyy-MM-dd");
        String thisMonth = DateUtils.formatToString(date, "yyyy-MM");
        Double sum = 0.0;
        List<MBalanceIncrease> list = mongoTemplate.find(
                Query.query(
                        Criteria.where("day").is("2018-03-28")
                ), MBalanceIncrease.class);
        for (MBalanceIncrease balance : list) {
            sum = new BigDecimal(sum).add(new BigDecimal(balance.getAmount().toString())).doubleValue();
        }

        DecimalFormat decimalFormat = new DecimalFormat("#.00");
        sum = Double.valueOf(decimalFormat.format(sum));
        System.out.println(sum);
    }

    @Test
    public void test07() {
        Date date = new Date();
        String today = DateUtils.formatToString(date, "yyyy-MM-dd");
        String thisMonth = DateUtils.formatToString(date, "yyyy-MM");
        Double sum = 0.0;
        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("day").in(DateUtils.getPast7Date())),
                group("day")
                        .sum("amount").as("total")
                        //.push("createDate").as("date")
                        .first("day").as("day"),
                project("total", "day"),
                sort(Sort.Direction.DESC, "day"));
        AggregationResults<BasicDBObject> outputTypeCount =
                mongoTemplate.aggregate(aggregation, MBalanceIncrease.class, BasicDBObject.class);

        for (Iterator<BasicDBObject> iterator = outputTypeCount.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            System.out.println(obj);
        }
    }

    @Test
    public void test08() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("day").is("2018-08-16")),
                group("day").sum("amount").as("total"));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MBalanceIncrease.class, BasicDBObject.class);

        System.out.println(result.getMappedResults().get(0).get("total"));
    }

    @Test
    public void test09() {
        List<String> past7Date = DateUtils.getPast7Date();
        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("day").in(past7Date)),
                group("day")
                        .sum("amount").as("total")
                        .first("day").as("day"),
                project("total", "day"),
                sort(Sort.Direction.DESC, "day"));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MBalanceIncrease.class, BasicDBObject.class);

        List<AmountChart> sevenDays = new ArrayList<>();
        Map<String, Double> map = new HashMap<>();
        for (Iterator<BasicDBObject> iterator = result.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            map.put(obj.get("day").toString(), Double.valueOf(obj.get("total").toString()));
        }

        for (String day : past7Date) {
            if (map.containsKey(day)) {
                sevenDays.add(new AmountChart(day, map.get(day)));
            } else {
                sevenDays.add(new AmountChart(day, 0.0));
            }
        }

        System.out.println(sevenDays);
        AmountChart amountChart = sevenDays.get(0);
        System.out.println(amountChart);
    }

    @Test
    public void test10() {
        List<String> past6Months = DateUtils.getPast6Months();
        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("month").in(past6Months)),
                group("month")
                        .sum("amount").as("total")
                        .first("month").as("month"),
                project("total", "month"),
                sort(Sort.Direction.DESC, "month"));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MBalanceIncrease.class, BasicDBObject.class);

        List<AmountChart> sixMonths = new ArrayList<>();
        Map<String, Double> map = new HashMap<>();
        for (Iterator<BasicDBObject> iterator = result.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            map.put(obj.get("month").toString(), Double.valueOf(obj.get("total").toString()));
        }

        for (String month : past6Months) {
            if (map.containsKey(month)) {
                sixMonths.add(new AmountChart(month, map.get(month)));
            } else {
                sixMonths.add(new AmountChart(month, 0.0));
            }
        }

        System.out.println(sixMonths);
        AmountChart monthAmount = sixMonths.get(0);
        System.out.println(monthAmount);
    }

    @Test
    public void test11() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("province").is("江苏")),
                group("province").sum("amount").as("total"));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, com.tangzhe.shop.service.MOrder.class, BasicDBObject.class);

        System.out.println(result.getMappedResults().get(0).get("total"));
    }

    @Test
    public void test12() {
        // 查询当日 老方法
        List<MVip> list = mongoTemplate.find(
                Query.query(
                        Criteria.where("province").is("江苏").and("day").is("2018-08-16")
                ), MVip.class);
        System.out.println(list.size());

        // 查询当日 新方法
        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("province").is("江苏").and("day").is("2018-08-16")),
                group("province").count().as("total"));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MVip.class, BasicDBObject.class);

        for (Iterator<BasicDBObject> iterator = result.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            System.out.println(obj);
        }
        System.out.println(result.getMappedResults().get(0).get("total"));
    }

    @Test
    public void test13() {
        // 查询近7日 老方法
        List<VipChart> sevenDays = new ArrayList<>();
        List<String> past6Date = DateUtils.getPast7Date();
        for (String day : past6Date) {
            int dc = mongoTemplate.find(
                    Query.query(
                            Criteria.where("province").is("江苏").and("day").is(day)
                    ), MVip.class).size();
            VipChart vipChart = new VipChart(day, dc);
            sevenDays.add(vipChart);
        }
        sevenDays.forEach(System.out::println);

        // 查询近7日 新方法
        List<String> past7Date = DateUtils.getPast7Date();
        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("province").is("江苏").and("day").in(past7Date)),
                group("day")
                        .count().as("total")
                        .first("day").as("day"),
                project("total", "day"),
                sort(Sort.Direction.DESC, "day"));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MVip.class, BasicDBObject.class);

        for (Iterator<BasicDBObject> iterator = result.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            System.out.println(obj);
        }
    }

    @Test
    public void test14() {
        // 查询累计 老方法
        int total = mongoTemplate.find(
                Query.query(
                        Criteria.where("city").is("苏州")
                ), MVip.class).size();
        System.out.println(total);

        // 查询累计 新方法
        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("city").is("苏州")),
                group("province").count().as("total"));
        AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(aggregation, MVip.class, BasicDBObject.class);
        total = Integer.valueOf(result.getMappedResults().get(0).get("total").toString());
        System.out.println(total);
    }

    @Test
    public void test15() {
        Map<String, Integer> map = new HashMap<>();
        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("province").is("江苏")),
                group("city").count().as("total"));
        AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(aggregation, MVip.class, BasicDBObject.class);
        for (Iterator<BasicDBObject> iterator = result.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            System.out.println(obj);
            map.put(obj.get("_id").toString(), Integer.valueOf(obj.get("total").toString()));
        }
        System.out.println();
    }

    /**
     * 关联查询
     */
    @Test
    public void test16() {
        Instant start = Instant.now();
        Aggregation aggregation = Aggregation.newAggregation(
                match(
                        Criteria.where("id").is("5b7a5fa1d0c5852d745c4e81")),
                        lookup("class_info", "classId", "_id", "class_info")
                );
        AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(aggregation, Student.class, BasicDBObject.class);
        for (Iterator<BasicDBObject> iterator = result.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            System.out.println(obj);
        }
        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).toMillis());
    }

    @Test
    public void test17() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("province").is("江苏")),
                group("userId").count().as("total").push("city").as("city"),
                match(Criteria.where("total").gte(2)),
                project("total", "city"));
        AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(aggregation, MCustomerSave.class, BasicDBObject.class);
        int total = result.getMappedResults().size();
        System.out.println(total);
    }

    @Test
    public void test18() {
        Map<String, Integer> map = new HashMap<>();
        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("province").is("江苏")),
                group("city").count().as("total"));
        AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(aggregation, MCustomerSave.class, BasicDBObject.class);
        for (Iterator<BasicDBObject> iterator = result.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            String city = obj.get("_id").toString();
            aggregation = Aggregation.newAggregation(
                    match(Criteria.where("city").is(city)),
                    group("userId").count().as("total"),
                    match(Criteria.where("total").gte(2)));
            AggregationResults<BasicDBObject> res = mongoTemplate.aggregate(aggregation, MCustomerSave.class, BasicDBObject.class);
            map.put(city, res.getMappedResults().size());
        }
        System.out.println();
    }

}

package com.tangzhe.mongodb.mongotemplate;

import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
import com.tangzhe.mongodb.BaseTest;
import com.tangzhe.shop.document.MOrder;
import com.tangzhe.shop.document.MUser;
import com.tangzhe.shop.document.MVipRecord;
import com.tangzhe.shop.service.Product;
import com.tangzhe.test.util.DateUtils;
import org.bson.types.Decimal128;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.query.Criteria;

import java.math.BigDecimal;
import java.time.Duration;
import java.time.Instant;
import java.util.*;

import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;

public class ShopTest extends BaseTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 一共获取了多少食堂劵
     */
    @Test
    public void test01() {
        Instant start = Instant.now();

        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                unwind("productList"),
                group("userId").sum("productList.ticket").as("total"));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);
        System.out.println(result.getMappedResults().get(0).get("total"));

        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).toMillis());
    }

    /**
     * 一共节约了多少钱
     */
    @Test
    public void test02() {
        Instant start = Instant.now();

        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                group("userId")
                        .sum("orgAmount").as("orgAmount")
                        .sum("payAmount").as("payAmount"),
                project("orgAmount", "payAmount")
                        .and("orgAmount").minus("payAmount").as("saveAmount"));
        AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);

        BigDecimal saveAmount = ((Decimal128)result.getMappedResults().get(0).get("saveAmount")).bigDecimalValue();
        System.out.println(saveAmount);

        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).toMillis());
    }

    /**
     *  一共支付了多少钱
     */
    @Test
    public void test03() {
        Instant start = Instant.now();

        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                group("userId").sum("payAmount").as("total"));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);

        System.out.println(result.getMappedResults().get(0).get("total"));

        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).toMillis());
    }

    /**
     * 下单总共原始价多少钱
     */
    @Test
    public void test04() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                group("userId").sum("orgAmount").as("total"));
        AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);

        BigDecimal orgAmount = ((Decimal128) result.getMappedResults().get(0).get("total")).bigDecimalValue();
        System.out.println(orgAmount);
    }

    /**
     * 交易的产品比例(含产品类型和比例)
     */
    @Test
    public void test05() {
        Instant start = Instant.now();

        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                project("productList"));
        AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);

        int sum = 0;
        for (Iterator<BasicDBObject> iterator = result.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            List<Product> products = (List<Product>) obj.get("productList");
            sum += products.size();
        }

        aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                unwind("productList"),
                group("productList.productType").count().as("total"));
        result = mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);

        Map<String, BigDecimal> rateMap = new HashMap<>();
        int i = 0;
        BigDecimal other = new BigDecimal(0);
        for (Iterator<BasicDBObject> iterator = result.iterator(); iterator.hasNext(); ) {
            DBObject obj = iterator.next();
            if (i == 6) {
                rateMap.put((String)obj.get("_id"), new BigDecimal(1).subtract(other));
                break;
            }
            BigDecimal rate = new BigDecimal((int)obj.get("total")).divide(new BigDecimal(sum));
            rateMap.put((String)obj.get("_id"), rate);
            other = other.add(rate);
            i ++;
        }

        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).toMillis());
    }

    /**
     * 一共下了多少单
     */
    @Test
    public void test06() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                group("userId").count().as("count"));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);

        int count = (int) result.getMappedResults().get(0).get("count");
        System.out.println(count);
    }

    /**
     * 最喜欢的店铺(即下单最多的店铺)
     */
    @Test
    public void test07() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                group("shopId").count().as("count"),
                sort(Sort.Direction.DESC, "count"),
                limit(1));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);

        long shopId = (long) result.getMappedResults().get(0).get("_id");
        int count = (int) result.getMappedResults().get(0).get("count");
        System.out.println(shopId);
        System.out.println(count);
    }

    /**
     * 下单最多的那天和下单数量
     */
    @Test
    public void test08() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                project().andExpression("{$dateToString:{format:'%Y-%m-%d',date: '$createTime'}}").as("createTime"),
                group("createTime").count().as("count"),
                sort(Sort.Direction.DESC, "count"),
                limit(1));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);
        String day = (String) result.getMappedResults().get(0).get("_id");
        int count = (int) result.getMappedResults().get(0).get("count");
        System.out.println(day);
        System.out.println(count);
    }

    /**
     * 花费金额最多的那天和金额
     */
    @Test
    public void test09() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)
                        .and("createTime").gte(DateUtils.fromString("2018-01-01 16:00:57", "yyyy-MM-dd HH:mm:ss")).lte(new Date())),
                project("payAmount").andExpression("{$dateToString:{format:'%Y-%m-%d',date: '$createTime'}}").as("createTime"),
                group("createTime").sum("payAmount").as("total"),
                sort(Sort.Direction.DESC, "total"),
                limit(1));
        AggregationResults<BasicDBObject> result =
                mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);
        String day = (String) result.getMappedResults().get(0).get("_id");
        BigDecimal amount = ((Decimal128)result.getMappedResults().get(0).get("total")).bigDecimalValue();
        System.out.println(day);
        System.out.println(amount);
    }

    /**
     * 前3笔最多消费
     */
    @Test
    public void test10() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                sort(Sort.Direction.DESC, "payAmount"),
                limit(3));
        AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);

        List<MOrder> orders = new ArrayList<>(3);

        for (BasicDBObject bd : result.getMappedResults()) {
            MOrder order = new MOrder();
            order.setOrderId(bd.getString("orderId"));
            order.setPayAmount((Decimal128) bd.get("payAmount"));
            order.setShopId(bd.getLong("shopId"));
            order.setCreateTime(bd.getDate("createTime"));
            orders.add(order);
        }
        System.out.println(orders);
    }

    /**
     * 第一笔交易信息
     */
    @Test
    public void test11() {
        Aggregation aggregation = Aggregation.newAggregation(
                match(Criteria.where("userId").is(8744L)),
                sort(Sort.Direction.ASC, "createTime"),
                limit(1));
        AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(aggregation, MOrder.class, BasicDBObject.class);
        BasicDBObject bd = result.getMappedResults().get(0);
        MOrder order = new MOrder();
        order.setOrderId(bd.getString("orderId"));
        order.setPayAmount((Decimal128) bd.get("payAmount"));
        order.setShopId(bd.getLong("shopId"));
        order.setCreateTime(bd.getDate("createTime"));
        System.out.println("第一笔交易时间为 " + DateUtils.formatToString(order.getCreateTime(), "yyyy-MM-dd HH:mm:ss"));
        System.out.println("第一笔交易金额为 " + order.getPayAmount().bigDecimalValue().setScale(2, BigDecimal.ROUND_HALF_DOWN));
        System.out.println("第一笔交易商家id为 " + order.getShopId());
        System.out.println("第一笔交易订单号为 " + order.getOrderId());
    }

    /**
     * 查询成为会员的时间和第几位会员
     */
    @Test
    public void test12() {
        Long userId = 1L;

        Aggregation agg = Aggregation.newAggregation(
                match(
                        Criteria.where("userId").is(userId)
                                .and("afterUserType").is("FORMAL_VIP")),
                sort(Sort.Direction.ASC, "startTime"),
                limit(1));
        AggregationResults<BasicDBObject> result1 = mongoTemplate.aggregate(agg, MVipRecord.class, BasicDBObject.class);

        agg = Aggregation.newAggregation(
                match(
                        Criteria.where("startTime")
                                .lt(result1.getMappedResults().get(0).getDate("startTime"))));
        AggregationResults<BasicDBObject> result2 = mongoTemplate.aggregate(agg, MVipRecord.class, BasicDBObject.class);
        int count = result2.getMappedResults().size() + 1;
        System.out.println("您成为会员的时间：" + DateUtils.formatToString(result1.getMappedResults().get(0).getDate("startTime"), "yyyy-MM-dd hh:mm:ss"));
        System.out.println("您是第" + count + "位会员");
    }

    /**
     * 查询注册时间和是第几位用户
     */
    @Test
    public void test13() {
        Instant start = Instant.now();
        Long userId = 1L;
        Aggregation agg = Aggregation.newAggregation(
                match(Criteria.where("userId").is(userId)));
        AggregationResults<BasicDBObject> result1 = mongoTemplate.aggregate(agg, MUser.class, BasicDBObject.class);
        agg = Aggregation.newAggregation(
                match(
                        Criteria.where("createTime")
                                .lt(result1.getMappedResults().get(0).getDate("createTime"))),
                project("userId"));
        AggregationResults<BasicDBObject> result2 = mongoTemplate.aggregate(agg, MUser.class, BasicDBObject.class);
        int count = result2.getMappedResults().size() + 1;
        System.out.println("您成为用户的时间：" + DateUtils.formatToString(result1.getMappedResults().get(0).getDate("createTime"), "yyyy-MM-dd hh:mm:ss"));
        System.out.println("您是第" + count + "位注册用户");
        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).toMillis());
    }

}
Springboot 整合mongodb以及mongo数据操作工具类代码实现
洛阳泰山的博客
03-08 2495
pom文件里添加mongodb依赖 <!-- mongodb --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency>
MongoDB中的聚合操作
北辰
04-09 471
MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值、求和等)，并返回计算后的数据结果，有点类似MySQL语句中的count(*)。
springboot整合MongoDB测试demo 代码
闲走天涯的博客
07-24 602
springboot MongoDB测试demo 代码 demo分为4个类，分别为: 学生实体类-student、课程实体类-course、springboot持久层-mongoDao、springboot控制层-mongoController 1、学生实体类-student 注解进行声明对应的MongoDB 数据设置 /** * 描述: * 实体类-学生 student * @author 闲走天涯 * @create 2021/7/23 13:53 */ @Data @Document(col
springboot MongoTemplate 之Aggregation 实现常见操作
热门推荐
万米高空的博客
02-25 1万+
很多复杂的查询都是从简单的部分组合的实现,续接昨天的通过Query查询后，今天接着补充聚合管道-Aggregation进行数据查询，处理。相比较Query查询，Aggregation再处理数据时会方便很多，也便于优化查询语句。 首先springboot引入mongodb的配置也是从引入pom依赖->配置文件中mongodb的连接信息配置->在具体service中注入MongoTemplate 。这些上一篇文章都已经有写，不在重复。 需要注意导包是这些：org.springframewor..
SpringBoot整合MongoDB（附MongoDB做缓存demo源码）
Nicer_feng's blog
10-18 986
SpringBoot整合MongoDB 之前我们讲解了MongoDB在不同环境的安装和MongoDB的CRUD以及Robo3T可视化工具操作MongoDB，今天我们来看看实际业务中整合MongoDB的场景。 本文我们主要是通过两种方法实现SpringBoot整合MongoDB，最后写一个小demo来理解MongoDB在实际业务中的应用。
springboot集成mongodb简单demo
meepoGuan的博客
09-15 347
前提当然是有mongodb应用，安装可以参考之前写的一篇https://blog.youkuaiyun.com/u011890101/article/details/82698773 创建springboot应用，添加依赖，这里使用data下的mongo包 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupI...
SpringBoot使用MongoTemplate详解
谁念西风独自凉
03-05 2372
SpringBoot 使用MongoTemplate 操作MongoDB详解
【主流技术】MongoTemplate 与 Spring Boot 项目集成（附CURD技巧）
最新发布
weixin_43248862的博客
08-05 955
MongoTemplate 是Spring Data MongoDB 中的一个核心类，为 Spring 与 MongoDB 数据库的交互提供了丰富的功能集，包括创建、更新、删除和查询 MongoDB 文档的便利操作，并提供了编程语言的领域对象（POJO）和 MongoDB 文档之间的映射。
SpringBoot整合MongoDB使用MongoTemplate完整示例
在本实例“springboot整合mongodb用MongoTemplate”中，核心知识点围绕如何在 Spring Boot 项目中集成 MongoDB 数据库，并利用 MongoTemplate 进行 CRUD（增删改查）操作展开。首先，项目的依赖管理是关键一步。...
springboot集成mongoDB高级聚合查询,关联查询
m0_67391518的博客
08-02 1310
使用该阶段符分组查询该。
springboot整合mongodb用MongoTemplate.rar
03-19
pringboot整合mongodb用MongoTemplate，完整的一个demo实例
mongodb java简单demo
08-18
java连接mongodb ，创建集合，添加、修改、查询、删除文档
springboot+mongoDB整合demo
萝卜坑
07-17 1035
springboot+mongoDB整合 1、安装mongoDB 去MongoDB官网下载一个合适的安装包，下载地址： https://www.mongodb.com/download-center?jmp=nav#community 完成下载后进行安装，具体安装教程不展开，可参考如下博文： https://blog.youkuaiyun.com/qq_42908549/article/details/814...
springboot使用MongoTemplate分组统计数据
Mr_Dai的博客
06-02 6613
根据messageStatus字段分组统计不同状态的数据量，相当于mysql里的group by 关键字。 使用mongo里的aggregation聚合关键字。 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.c..
MongoDB+springboot+spring+MongoTemplate简单Demo
天之道居同文。
03-13 217
【代码】MongoDB+springboot+spring+MongoTemplate简单Demo。
入门：MongoDB基本命令及整合Springboot使用
肥柯博客
08-21 900
MongoDB 1、基本概述 MongoDB是以JSON为数据模型的文档型的介于关系数据库和非关系数据库之间的产品（虽然更多称它为非关系数据库）。它直接操作的对象是内存，通过映射把数据持久化到硬盘。 MongoDB追求一个对象一个数据表，无论对象与对象之间存在怎样的关系，它的表与表之间是没有关联性的。因此，对于关联关系，我们只需要在类中维护好它们的关系就好。因此严格来说，MongoDB又不属于数据库，它应该是一种以数据结构化存储方法的集合。 MongoDB 将数据存储为一个文档，数据结构由键值(key=&
mongoTemplate简单用法（增删改查）
07-03 4505
MongoDB 教程 MongoDB 入门 MongoDB 优势 MongoDB 安装 MongoDB 数据建模 MongoDB 创建数据库 MongoDB 删除数据库 MongoDB 创建集合 MongoDB 删除集合 MongoDB 数据类型 MongoDB 插入文档 MongoDB 查询文档 分页时查找数量： 1 2 3 4 ...
七、MongoTemplate使用介绍
I want to know a little more.
08-27 9554
一、mongo实体类的映射 实体类 /* *功能：用户 *@author:victor.z *@date:2018/8/17 下午5:37 *@version:1.0 */ @Document(collection="user") public class User implements Serializable { @Id private String id; ...
mongodb及mongoTemplate 一些简单记录
if_you_can_please_do的博客
12-14 2078
//时间区间 Criteria.where(&quot;time&quot;).gte(weekStartDate).lte(weekEndDate); //正则匹配以val开始不包含本身的字符 Criteria.where(&quot;val&quot;).regex(&quot;^&quot; + val + &quot;.+&quot;); //查询in列表,结果会按照id顺序排列 Criteria.where(&quot;
Spring Boot演示项目demo-tbk-springboot详解
“demo-tbk-springboot”是一个基于Spring Boot框架构建的演示项目，主要用于展示如何使用Spring Boot快速搭建一个现代化的Java后端Web应用。该项目以“master”分支的形式存在，文件结构为“demo-tbk-springboot-...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值