mongodb聚合查询

聚合查询

import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.mongodb.core.MongoOperations;
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 org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

@Component
public class Mongoaggregation {

  @Resource
  private MongoOperations mongoOperations;

  public void mongoaggregation (String collectionName) {
  
    Aggregation aggregation = Aggregation.newAggregation(
        Aggregation.match(new Criteria()
            .andOperator(
                Criteria.where("").gte("").lte(""),
                Criteria.where("").ne("").ne("")
            )
        ), Aggregation
            .group("","")
            .max("").as("")
            .min("").as("")
        , Aggregation.project("要查询的列1","2", "3","4"));
    AggregationResults<User> aggregate = mongoOperations.aggregate(aggregation, collectionName, User.class);
    return null;
  }
}

非聚合查询

import com.mongodb.client.MongoCollection;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.sgcc.eip.cable.common.dynamic.document.DynamicDocument;
import com.sgcc.eip.cable.common.dynamic.document.QueryParam;
import com.sgcc.eip.cable.common.dynamic.document.enums.MongoCondition;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Resource;
import org.apache.commons.collections.CollectionUtils;
import org.bson.Document;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Component;

@Component
public class DynamicRepository {

    @Resource
    private MongoOperations mongoOperations;

    public Set<String> getExistingCollection() {
        return this.mongoOperations.getCollectionNames();
    }

    public MongoCollection<Document> createCollection(String collectionName) {
        return this.mongoOperations.createCollection(collectionName);
    }

    public MongoCollection<Document> getCollection(String collectionName) {
        return this.mongoOperations.collectionExists(collectionName) ? this.mongoOperations.getCollection(collectionName)
                : this.createCollection(collectionName);
    }

    public DynamicDocument insert(String collectionName, DynamicDocument data) {
        return this.mongoOperations.insert(data, collectionName);
    }

    public Long delete(List<QueryParam> queryParams, String collectionName) {
      Query query = new Query();
      if (CollectionUtils.isNotEmpty(queryParams)) {
        Criteria criteria = new Criteria();
        queryParams.forEach(queryParam -> MongoCondition.execute(criteria, queryParam));
        query.addCriteria(criteria);
      }
      DeleteResult remove = this.mongoOperations.remove(query,  collectionName);
      return remove.getDeletedCount();
    }

    public Long update(List<QueryParam> queryParams, Update update,String collectionName) {
      Query query = new Query();
      if (CollectionUtils.isNotEmpty(queryParams)) {
        Criteria criteria = new Criteria();
        queryParams.forEach(queryParam -> MongoCondition.execute(criteria, queryParam));
        query.addCriteria(criteria);
      }
      UpdateResult updateResult = this.mongoOperations.upsert(query, update, collectionName);
      return updateResult.getModifiedCount();
    }

    public <T> List<T> query(String collectionName, List<QueryParam> queryParams, Class<T> resultEntity) {
        Query query = new Query();
        if (CollectionUtils.isNotEmpty(queryParams)) {
            Criteria criteria = new Criteria();
            queryParams.forEach(queryParam -> MongoCondition.execute(criteria, queryParam));
            query.addCriteria(criteria);
        }
        return this.mongoOperations.find(query, resultEntity, collectionName);
    }

    public <T> List<T> queryPage(String collectionName, List<QueryParam> queryParams, Class<T> resultEntity, int pageSize, int pageNum) {
        Query query = new Query();
        if (CollectionUtils.isNotEmpty(queryParams)) {
            Criteria criteria = new Criteria();
            queryParams.forEach(queryParam -> MongoCondition.execute(criteria, queryParam));
            query.addCriteria(criteria);
            query.skip((pageNum - 1) * pageSize);
            query.limit(pageSize);
        }
        return this.mongoOperations.find(query, resultEntity, collectionName);
    }

    public long count(String collectionName, List<QueryParam> queryParams) {
        Query query = new Query();
        if (CollectionUtils.isNotEmpty(queryParams)) {
            Criteria criteria = new Criteria();
            queryParams.forEach(queryParam -> MongoCondition.execute(criteria, queryParam));
            query.addCriteria(criteria);
        }
        return this.mongoOperations.count(query, collectionName);
    }

    public <T> List<T> query(String collectionName, List<QueryParam> queryParams, Class<T> resultEntity, Sort sort, Integer count) {
        Query query = new Query();
        if (CollectionUtils.isNotEmpty(queryParams)) {
            Criteria criteria = new Criteria();
            queryParams.forEach(queryParam -> MongoCondition.execute(criteria, queryParam));
            query.addCriteria(criteria);
            if(null != sort){
                query.with(sort);
            }
            if(null != count){
                query.limit(count);
            }
        }
        return this.mongoOperations.find(query, resultEntity, collectionName);
    }


    public <T> T queryOne(List<QueryParam> queryParams, Class<T> resultEntity, String collectionName) {
        Query query = new Query();
        if (CollectionUtils.isNotEmpty(queryParams)) {
            Criteria criteria = new Criteria();
            queryParams.forEach(queryParam -> MongoCondition.execute(criteria, queryParam));
            query.addCriteria(criteria);
        }
        return this.mongoOperations.findOne(query, resultEntity, collectionName);
    }

    public <T> T findAndModify(List<QueryParam> queryParams, List<QueryParam> updateParams, Class<T> resultEntity, String collectionName) {
        Query query = new Query();
        if (CollectionUtils.isNotEmpty(queryParams)) {
            Criteria criteria = new Criteria();
            queryParams.forEach(queryParam -> MongoCondition.execute(criteria, queryParam));
            query.addCriteria(criteria);
        }
        Update update = new Update();
        if (CollectionUtils.isNotEmpty(queryParams)) {
            updateParams.forEach(updateParam -> {
                update.set(updateParam.getField(), updateParam.getValue());
            });
        }
        return this.mongoOperations.findAndModify(query, update, resultEntity, collectionName);
    }

    public Map<String, Object> insert(String collectionName, Map<String, Object> data) {
        return this.mongoOperations.insert(data, collectionName);
    }
}