Spring boot整合 mongo，写通用查询，分页表格，分组堆积图

 

时隔多年我已经变成一个老后端了，哈哈今天试试写写博客，给大家分享一个springboot整合mongo通用查询，可动态指定分组条件聚合条件，筛选，排序条件的例子，支持分页，堆积图等 ，废话不多说，

1. 第一步，上maven

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
   <groupId>org.mongodb</groupId>
   <artifactId>mongo-java-driver</artifactId>
</dependency>

spring-boot-starter-data-mongodb整合spring的， mongo-java-driver驱动包，简单吧

 2 第二步 ，上DbFactory.懂一些spring骚操作的人也可以用yml去配置啊， 不懂骚操作的人来我这看代码吧

import cn.hutool.db.nosql.mongo.MongoFactory;
import com.mongodb.MongoClient;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;

//@Configuration
//@ConfigurationProperties(prefix = "spring.data.mongodb.primary")
public class MiningmodelDbFactory {
    public MongoDbFactory mongoFactory (){
        MongoClient client = new MongoClient("localhost",27017);
        return new SimpleMongoDbFactory(client,"miningmodel");
    }
    @Primary
    @Bean(name="mongoTemplate")
    public MongoTemplate getMongoTemplate(){
        return new MongoTemplate(mongoFactory());
    }
}

这个代码大家伙能理解吧， 创建了这个工厂方法类后，想要查询mongo的地方注入mongoTemplate这个就可以用了

第三步，上控制器

@Resource(name = "mongoTemplate")
private MongoTemplate mongoTemplate;

@SysLog(value="通用mongoPageList")
@ApiOperation(value="通用mongoPageList" , httpMethod="POST")
@RequestMapping(value="/selectMongoPageList" , method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
public String selectMongoPageList(Model model,@RequestBody JSONObject jsonParam) {
   MongoRequestModel mongoRequestModel = jsonParam.toJavaObject(MongoRequestModel.class);
   Aggregation agg = MonGoAggregationUtils.getAggByModelPage(mongoRequestModel);
   AggregationResults<JSONObject> results = mongoTemplate.aggregate(agg, mongoRequestModel.getCollectionName(), JSONObject.class);
   List<JSONObject> mappedResults = results.getMappedResults();
   return mappedResults.toString();
}

@SysLog(value="通用mongoPageList")
@ApiOperation(value="通用mongoCart" , httpMethod="POST")
@RequestMapping(value="/selectMongoCart" , method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
public APIResult<EHModel<Map<String, Object>>> selectMongoCart(Model model,@RequestBody JSONObject jsonParam) {
   MongoRequestModel mongoRequestModel = jsonParam.toJavaObject(MongoRequestModel.class);
   Aggregation agg = MonGoAggregationUtils.getAggByModelCart(mongoRequestModel);
   AggregationResults<JSONObject> results = mongoTemplate.aggregate(agg, mongoRequestModel.getCollectionName(), JSONObject.class);
   List<JSONObject> mappedResults = results.getMappedResults();
   List<Map<String, Object>> rows = Lists.newArrayList();
   Set<String> colset = Sets.newLinkedHashSet();
   Set<String> ptset = Sets.newLinkedHashSet();
   colset.add("pt");
   Map<String, Object> kvMap = Maps.newLinkedHashMap();
   //Map<String,Map<String, Object>> rowMaps = Maps.newLinkedHashMap();
   for(JSONObject jsonObject :mappedResults){
      String pt = jsonObject.getString("pt");
      String type = jsonObject.getString(mongoRequestModel.getQueryGroupCols().get(1));
      String cnt="0" ;
      if(mongoRequestModel.getQuerySums()!=null && !mongoRequestModel.getQuerySums().isEmpty()) {
         cnt = jsonObject.getString(mongoRequestModel.getQuerySums().get(0));
      }
      if(mongoRequestModel.getQueryCounts()!=null && !mongoRequestModel.getQueryCounts().isEmpty()){
         cnt = jsonObject.getString(mongoRequestModel.getQueryCounts().get(0));
      }
      if(mongoRequestModel.getQueryAvgs()!=null && !mongoRequestModel.getQueryAvgs().isEmpty()) {
         cnt = jsonObject.getString(mongoRequestModel.getQueryAvgs().get(0));
      }
      colset.add(type);
      kvMap.put("pt",pt);
      kvMap.put(type,cnt);
      if(!ptset.contains(pt)){
         rows.add(kvMap);
         ptset.add(pt);
         kvMap = Maps.newLinkedHashMap();
      }

   }
   EHModel<Map<String, Object>> ehModel = new EHModel<>();
   ChartData<Map<String, Object>> chartData = new ChartData<Map<String, Object>>();
   chartData.setColumns(new ArrayList<String>(colset));
   chartData.setRows(rows);
   ehModel.setChartData(chartData);
   return new APIResult<>(ehModel, "返回成功", APIResult.APIResultType.SUCCESS.getValue());
}

@SysLog(value="测试mongo")
@ApiOperation(value="测试mongo" , httpMethod="POST")
@RequestMapping(value="/selectMongo2" , method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
public String selectMongo2(Model model,@RequestBody JSONObject jsonParam) {

   List<Criteria> criteriaList = new ArrayList<>();
   Criteria c1 = Criteria.where("pt").lte("20200106").gte("20191225");
   String[] a = new String[]{"0", "1", "2", "3", "4", "5", "6","7","8"};

   criteriaList.add(Criteria.where("batterytype").in(a));
   criteriaList.add(c1);

   Criteria criteria = new Criteria();
   criteria = criteria.andOperator(criteriaList.toArray(new Criteria[criteriaList.size()]));

   Aggregation agg = Aggregation.newAggregation(

         // 第一步：挑选所需的字段，类似select *，*所代表的字段内容
         //Aggregation.project("pt", "end", "userId", "distance"),
         // 第二步：sql where 语句筛选符合条件的记录
         // Aggregation.match(Criteria.where("userId").is("asdf")),
         Aggregation.match(criteria),
         // 第三步：分组条件，设置分组字段
         Aggregation.group("pt","fail_reason").sum("cnt").as("cnts").sum("car_cnt").as("carCnts"),
         //Aggregation.group("pt","fail_reason").sum("cnt").as("cnts").sum("car_cnt").as("carCnts"),
         // 第四部：排序（根据某字段排序 倒序）
         // Aggregation.sort(Sort.Direction.DESC,"pt","fail_reason"),
         // 第五步：数量(分页)
         Aggregation.limit(10)
         // 第刘步：重新挑选字段
         //Aggregation.project("pt","fail_reason","cnts","carCnts")
   );


   AggregationResults<JSONObject> results = mongoTemplate.aggregate(agg, "rentbike_bigbattery_errorcode_report", JSONObject.class);

   List<JSONObject> mappedResults = results.getMappedResults();

   return mappedResults.toString();
}

 

控制层方法给大家了，再把Model和sql工具共享给大家吧

model 

import com.fasterxml.jackson.annotation.JsonProperty;

import java.util.List;
import java.util.Map;

public class MongoRequestModel {
    @JsonProperty("查询表名称")
    private String collectionName;
    @JsonProperty("开始时间")
    private String startTime;
    @JsonProperty("结束时间")
    private String endTime;
    @JsonProperty("相等判断")
    private Map<String,Object> queryEqualsReqJson;
    @JsonProperty("in集合判断")
    private  Map<String,Object> queryInReqJson;
    @JsonProperty("大于等于集合判断")
    private String queryGteReqJson;
    @JsonProperty("小于等于集合判断")
    private String queryLteReqJson;
    @JsonProperty("分组列头")
    private List<String> queryGroupCols;
    @JsonProperty("求和列集合")
    private List<String> querySums;
    @JsonProperty("计算次数")
    private List<String> queryCounts;
    @JsonProperty("求平均值")
    private List<String> queryAvgs;
    @JsonProperty("求平均值")
    private Integer pageSize;
    @JsonProperty("当前页数")
    private Integer pageIndex;
    @JsonProperty("排序字段")
    private List<String> querySortCols;

    public List<String> getQuerySortCols() {
        return querySortCols;
    }

    public void setQuerySortCols(List<String> querySortCols) {
        this.querySortCols = querySortCols;
    }



    public String getCollectionName() {
        return collectionName;
    }

    public void setCollectionName(String collectionName) {
        this.collectionName = collectionName;
    }

    public String getStartTime() {
        return startTime;
    }

    public void setStartTime(String startTime) {
        this.startTime = startTime;
    }

    public String getEndTime() {
        return endTime;
    }

    public void setEndTime(String endTime) {
        this.endTime = endTime;
    }

    public Map<String, Object> getQueryEqualsReqJson() {
        return queryEqualsReqJson;
    }

    public void setQueryEqualsReqJson(Map<String, Object> queryEqualsReqJson) {
        this.queryEqualsReqJson = queryEqualsReqJson;
    }

    public Map<String, Object> getQueryInReqJson() {
        return queryInReqJson;
    }

    public void setQueryInReqJson(Map<String, Object> queryInReqJson) {
        this.queryInReqJson = queryInReqJson;
    }

    public String getQueryGteReqJson() {
        return queryGteReqJson;
    }

    public void setQueryGteReqJson(String queryGteReqJson) {
        this.queryGteReqJson = queryGteReqJson;
    }

    public List<String> getQueryGroupCols() {
        return queryGroupCols;
    }

    public void setQueryGroupCols(List<String> queryGroupCols) {
        this.queryGroupCols = queryGroupCols;
    }

    public List<String> getQuerySums() {
        return querySums;
    }

    public void setQuerySums(List<String> querySums) {
        this.querySums = querySums;
    }

    public List<String> getQueryCounts() {
        return queryCounts;
    }

    public void setQueryCounts(List<String> queryCounts) {
        this.queryCounts = queryCounts;
    }

    public Integer getPageSize() {
        return pageSize;
    }

    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }

    public Integer getPageIndex() {
        return pageIndex;
    }

    public void setPageIndex(Integer pageIndex) {
        this.pageIndex = pageIndex;
    }

    public String getQueryLteReqJson() {
        return queryLteReqJson;
    }

    public void setQueryLteReqJson(String queryLteReqJson) {
        this.queryLteReqJson = queryLteReqJson;
    }


    public List<String> getQueryAvgs() {
        return queryAvgs;
    }

    public void setQueryAvgs(List<String> queryAvgs) {
        this.queryAvgs = queryAvgs;
    }

最后重点是工具类哈

import com.hellobike.ai.huashengsys.common.model.MongoRequestModel;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.Fields;
import org.springframework.data.mongodb.core.aggregation.GroupOperation;
import org.springframework.data.mongodb.core.query.Criteria;

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

public class MonGoAggregationUtils {

    public static Criteria getCriByModel(MongoRequestModel mongoRequestModel){
        List<Criteria> criteriaList = new ArrayList<>();
        Criteria criteria = new Criteria();

        //拼接PT日期
        criteriaList.add(criteria.where("pt").lte(mongoRequestModel.getEndTime()).gte(mongoRequestModel.getStartTime())) ;
        //拼接相等的条件
        Map<String, Object> maps = mongoRequestModel.getQueryEqualsReqJson();
        if(maps!=null && !maps.isEmpty()){
            for (String key :maps.keySet()) {
                //获取Map.Entry关系对象me
                String [] keys = key.split("@");
                if(keys!=null && keys.length>1){
                    if("I".equals(keys[1])){
                        Integer value2 = (Integer) maps.get(key);
                        criteriaList.add(Criteria.where(keys[0]).is(value2));
                    }
                    if("S".equals(keys[1])){
                        String value2 = (String) maps.get(key);
                        criteriaList.add(Criteria.where(keys[0]).is(value2));
                    }
                    if("D".equals(keys[1])){
                        Double value2 = (Double) maps.get(key);
                        criteriaList.add(Criteria.where(keys[0]).is(value2));
                    }
                }

            }
        }
        //拼接in条件
        maps = mongoRequestModel.getQueryInReqJson();

        if(maps!=null && !maps.isEmpty()){
            for (String key :maps.keySet()) {
                String [] keys = key.split("@");
                if(keys!=null && keys.length>1) {
                    if ("I".equals(keys[1])) {
                        Integer[] value2 = (Integer[]) maps.get(key);
                        criteriaList.add(Criteria.where(keys[0]).in(value2));
                    }
                    if ("S".equals(keys[1])) {
                        List value2 = (ArrayList) maps.get(key);
                        criteriaList.add(Criteria.where(keys[0]).in(value2));
                    }
                    if ("D".equals(keys[1])) {
                        Double[] value2 = (Double[]) maps.get(key);
                        criteriaList.add(Criteria.where(keys[0]).in(value2));
                    }
                }
            }
        }
        criteria = criteria.andOperator(criteriaList.toArray(new Criteria[criteriaList.size()]));
        return criteria;
    }

    public static Sort getSortByModel(MongoRequestModel mongoRequestModel){
        Sort sort =null;
        List<Sort.Order> orders = new ArrayList<Sort.Order>();
        for (String col:mongoRequestModel.getQuerySortCols()){
            String [] keys = col.split("@");
            if(keys!=null && keys.length>1){
                if("D".equals(keys[1])){
                    Sort.Order o = new Sort.Order(Sort.Direction.DESC,keys[0]);
                    orders.add(o);
                }else{
                    Sort.Order o = new Sort.Order(Sort.Direction.ASC,keys[0]);
                    orders.add(o);
                }
            }

        }
        sort = new Sort(orders);
        return  sort;
    }

    //拼接group
    public static GroupOperation getOptByModel(MongoRequestModel mongoRequestModel){
        GroupOperation opt = null;
        Fields fclos = null;
        for (int i =0;i<mongoRequestModel.getQueryGroupCols().size();i++){
            if(i==0){
                fclos = Fields.fields(mongoRequestModel.getQueryGroupCols().get(0));
            }else{
                fclos = fclos.and(mongoRequestModel.getQueryGroupCols().get(i));
            }
        }
        opt =  Aggregation.group(fclos);
        if(mongoRequestModel.getQuerySums()!=null && !mongoRequestModel.getQuerySums().isEmpty()) {
            for (String col : mongoRequestModel.getQuerySums()) {
                opt = opt.sum(col).as(col);
            }
        }
        if(mongoRequestModel.getQueryCounts()!=null && !mongoRequestModel.getQueryCounts().isEmpty()){
            for (String col:mongoRequestModel.getQueryCounts()){
                opt = opt.count().as(col);
            }
        }
        if(mongoRequestModel.getQueryAvgs()!=null && !mongoRequestModel.getQueryAvgs().isEmpty()) {
            for (String col : mongoRequestModel.getQueryAvgs()) {
                opt = opt.avg(col).as(col);
            }
        }
        return opt;
    }
    public static Aggregation getAggByModelCart(MongoRequestModel mongoRequestModel){
        if(mongoRequestModel==null){
            return null;
        }
        GroupOperation opt = getOptByModel(mongoRequestModel);
        Criteria criteria = getCriByModel(mongoRequestModel);
        Sort sort = getSortByModel(mongoRequestModel);
        Aggregation agg = Aggregation.newAggregation(
                Aggregation.match(criteria),
                opt,
                Aggregation.sort(sort)
        );
        return  agg;
    }

    public static Aggregation getAggByModelPage(MongoRequestModel mongoRequestModel){
        if(mongoRequestModel==null){
            return null;
        }
        GroupOperation opt = getOptByModel(mongoRequestModel);
        Criteria criteria = getCriByModel(mongoRequestModel);
        Sort sort = getSortByModel(mongoRequestModel);
        int pageSize = mongoRequestModel.getPageSize();
        int pageIndex = mongoRequestModel.getPageIndex();
        if(pageSize<1){
            pageSize = 10;
        }
        if(pageIndex<1){
            pageIndex = 1;
        }
        Aggregation agg = Aggregation.newAggregation(
                Aggregation.match(criteria),
                // 第三步：分组条件，设置分组字段
                opt,
                Aggregation.sort(sort),
                Aggregation.skip(pageIndex>1?(pageIndex-1)*pageSize:0),
                Aggregation.limit(pageSize)
        );
        return  agg;
    }
}

https://mp.csdn.net/console/editor/html/107821003大家伙转载的时候标明原作者是俺就行， 哈哈，有不懂的话欢迎提问，

邮箱xt12449850@163.com