mongo学习使用记录2 spring data

log4j.rootLogger=INFO, stdout log4j.logger.org.springframework.data.mongodb.core=DEBUG, mongodb log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.Threshold=INFO
log4j.appender.stdout.ImmediateFlush=true
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %X{RequestId} - %m%n log4j.appender.mongodb=org.apache.log4j.ConsoleAppender
log4j.appender.mongodb.Target=System.out
log4j.appender.mongodb.Threshold=DEBUG
log4j.appender.mongodb.ImmediateFlush=true
log4j.appender.mongodb.layout=org.apache.log4j.PatternLayout
log4j.appender.mongodb.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %X{RequestId} - %m%n

public class MongoTemplate implements MongoOperations, ApplicationContextAware { private static final Logger LOGGER = LoggerFactory.getLogger(MongoTemplate.class); public void dropCollection(String collectionName) {
execute(collectionName, new CollectionCallback<Void>() {
public Void doInCollection(DBCollection collection) throws MongoException, DataAccessException {
collection.drop();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Dropped collection [{}]", collection.getFullName());
}
return null;
}
});

@Document(collection="person")
@CompoundIndexes({
@CompoundIndex(name = "age_idx", def = "{'lastName': 1, 'age': -1}", unique=true)
})
public class Person<T extends Address> { @Id
private String id;
@Indexed(unique = true)
private Integer ssn;
private String firstName;
@Indexed
private String lastName;
private Integer age;
@Transient
private Integer accountTotal;
@DBRef
private List<Account> accounts;
private T address; public Person(Integer ssn) {
this.ssn = ssn;
} @PersistenceConstructor
public Person(Integer ssn, String firstName, String lastName, Integer age, T address) {
this.ssn = ssn;
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
this.address = address;
}

1 @Document
2 public class Account {
3
4 @Id
5 private ObjectId id;
6 private Float total;
7
8 }

public class TagProperty {
private String type;
private int count;
}

@Document(collection = "tag")
public class Tag extends BaseEntity { @Field("user_id")
@Indexed
private String userId; //key->标签文本 value->标签属性
private Map<String, TagProperty> tags;
}

/* 1 */
{
"_id" : ObjectId("581074c63145d5e8cc498db7"),
"_class" : "nd.sdp.idea.modules.tag.entity.Tag",
"user_id" : "214372",
"tags" : {
"设计技巧" : {
"type" : "default",
"count" : 1
},
"生活启发" : {
"type" : "default",
"count" : 23
},
"随笔" : {
"type" : "user",
"count" : 0
}
},
"delete_flag" : false
}

@Document(collection = "locations")
public class Location extends BaseEntity {
@Field(value = "user_id")
private String userId;
private Set<String> locations;
}

@Document(collection = "idea_logs")
@CompoundIndexes(
@CompoundIndex(name = "_ii_df_idx_", def = "{'ideaId':1, 'deleteFlag':1}")
)
public class IdeaLog extends BaseEntity { @Field(value = "idea_id")
private String ideaId; private String info; @Field(value = "create_at")
private Long createAt; private Operator operator; @Field(value = "erp_order")
private ErpOrder erpOrder; private String evaluation;
}

public class Operator { @Field(value = "user_id")
private String userId; @Field(value = "user_name")
private String userName;
}

{
username: <用户名>,
password: <密码>,
tasks: [
{
taskname: <任务名>,
taskinfo: <任务描述>
}，{
taskname: <任务名>,
taskinfo: <任务描述>
}......
]
}

@Indexed
@Field(value = "delete_flag")
private Boolean deleteFlag = false;

@Document(collection = "#{T(com.nd.social.common.handler.TenantHandler).getTablePrefix().concat('block_content')}")
@CompoundIndexes(
@CompoundIndex(name = "idx_bc_t_sc_s", def = "{'tenant':1,'scope.code':1,'sourceId':1}", unique = true)
)
@TypeAlias("BlockContent")@CompoundIndexes(
@CompoundIndex(name = "_ui_s_df_idx_", def = "{'userId':1, 'status':1, 'deleteFlag':1}", unique = true)
)

private static final Sort SORT_BY_CREATE_TIME_DESC =
new Sort(Sort.Direction.DESC, "createAt");
List<Idea> finByUserIdAndDeleteFlagFalse(String userId, Sort sort);

命名查询：OrderBy...Desc/ASC
List<Idea> findByUserIdAndStatusInAndViewAtLessThanAndDeleteFlagFalseOrderByCreateAtDesc(String userId, List<IdeaStatus> status, long viewAt);

private Pageable getPageable(SearchVo condition) {
int limit = condition.getLimit();
int offset = condition.getOffset();
return new PageRequest(offset / limit, limit, SORT_BY_CREATE_TIME_DESC);
}

private int offset = 0;
private int limit = 15; public int getOffset() {
return offset;
} public void setOffset(int offset) {
this.offset = offset;
} public int getLimit() {
return limit <= 0 ? 15 : limit;
} public void setLimit(int limit) {
this.limit = limit;
}

page 页码，请求第几页数据(默认值：1) 可选
size 每页数量(默认值：30) 可选
new PageRequest(page - 1, size)

pageVo.setTotalPage(size == 0 ? 1 : (int) Math.ceil((double) total / (double) size));

public class PageVo<T> {
// 总数
private long totalCount;
// 总页数
private int totalPage;
// 页码
private int page;
// 单页数量
private int size;
// 结果列表
private List<T> items; public List<T> getItems() {
return items;
} public void setItems(List<T> items) {
this.items = items;
} public long getTotalCount() {
return totalCount;
} public void setTotalCount(long totalCount) {
this.totalCount = totalCount;
} public int getTotalPage() {
return totalPage;
} public void setTotalPage(int totalPage) {
this.totalPage = totalPage;
} public int getPage() {
return page;
} public void setPage(int page) {
this.page = page;
} public int getSize() {
return size;
} public void setSize(int size) {
this.size = size;
}
}

public class Items<T> { // 结果列表 可以是Set/List
private Collection<T> items; // 如果不需要 可以设置为items的size值
private long totalCount; public static <T> Items<T> of(Collection<T> list) {
Items<T> items = new Items<>();
items.setItems(list);
items.setTotalCount(list.size());
return items;
} public static <T> Items<T> of(Collection<T> list, long totalCount) {
Items<T> items = new Items<>();
items.setItems(list);
items.setTotalCount(totalCount);
return items;
} public Collection<T> getItems() {
return items;
} public void setItems(Collection<T> items) {
this.items = items;
} public long getTotalCount() {
return totalCount;
} public void setTotalCount(long totalCount) {
this.totalCount = totalCount;
}}

1 log4j.logger.org.springframework.data.mongodb.core=DEBUG, mongodb
2
3 log4j.appender.mongodb=org.apache.log4j.ConsoleAppender
4 log4j.appender.mongodb.Target=System.out
5 log4j.appender.mongodb.Threshold=DEBUG
6 log4j.appender.mongodb.ImmediateFlush=true
7 log4j.appender.mongodb.layout=org.apache.log4j.PatternLayout
8 log4j.appender.mongodb.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %X{RequestId} - %m%n

1 private static final Logger LOGGER = LoggerFactory.getLogger(MongoTemplate.class);
2
3 protected void executeQuery(Query query, String collectionName, DocumentCallbackHandler dch,
4 CursorPreparer preparer) {
5
6 Assert.notNull(query);
7
8 DBObject queryObject = queryMapper.getMappedObject(query.getQueryObject(), null);
9 DBObject sortObject = query.getSortObject();
10 DBObject fieldsObject = query.getFieldsObject();
11
12 if (LOGGER.isDebugEnabled()) {
13 LOGGER.debug("Executing query: {} sort: {} fields: {} in collection: {}", serializeToJsonSafely(queryObject),
14 sortObject, fieldsObject, collectionName);
15 }
16
17 this.executeQueryInternal(new FindCallback(queryObject, fieldsObject), preparer, dch, collectionName);
18 }

@Query(count = true, value = "{'$and':[{'tenant':?3},{'reportStatus':?0}," +
" {'dealTime':{'$gte':?1}}, {'dealTime':{'$lte':?2}}]}")
int countByStatusAndDealTimeBetween(ReportStatus status, Date begin, Date end, long tenant);@Query("{'$and':[{'userId':?0},{'deleteFlag':false}," +
"{'$or':[{'content':{'$regex':?1}},{'location':{'$regex':?1}},{'createAtStr':{'$regex':?1}}]}]}")
List<Idea> findByKeyWord(String userId, String key, Pageable pageable);

1 {
2 '$and': [
3 {
4 'userId': ?0
5 },
6 {
7 'deleteFlag': false
8 },
9 {
10 '$or': [
11 {
12 'content': {
13 '$regex': ?1
14 }
15 },
16 {
17 'location': {
18 '$regex': ?1
19 }
20 },
21 {
22 'createAtStr': {
23 '$regex': ?1
24 }
25 }
26 ]
27 }
28 ]
29 }

public <T> T findOne(Query query, Class<T> entityClass)
public boolean exists(Query query, Class<?> entityClass)
public <T> List<T> find(Query query, Class<T> entityClass)
public <T> T findById(Object id, Class<T> entityClass)public <T> T findAndModify(Query query, Update update, Class<T> entityClass)
public <T> T findAndModify(Query query, Update update, FindAndModifyOptions options, Class<T> entityClass)
public class FindAndModifyOptions {
boolean returnNew; // 是否返回更新后的值
boolean upsert; // 没有找到是否插入
boolean remove; // 找到是否删除
}public <T> T findAndRemove(Query query, Class<T> entityClass)
public long count(Query query, Class<?> entityClass) public void insert(Object objectToSave)
public void insert(Collection<? extends Object> batchToSave, Class<?> entityClass)
public void insertAll(Collection<? extends Object> objectsToSave)public void save(Object objectToSave) 保存/修改public WriteResult upsert(Query query, Update update, Class<?> entityClass)
public WriteResult updateFirst(Query query, Update update, Class<?> entityClass)
public WriteResult updateMulti(Query query, Update update, Class<?> entityClass)public WriteResult remove(Object object)
public WriteResult remove(Query query, String collectionName)public <T> List<T> findAll(Class<T> entityClass)
public <T> List<T> findAllAndRemove(Query query, Class<T> entityClass)

public DB getDb()
  DBCollection getCollection(String collectionName); DBCollection 中包含各种CRUD操作以及对集合本身的定义操作（索引、命名）
  public String getCollectionName(Class<?> entityClass)

public <T> MapReduceResults<T> mapReduce(String inputCollectionName, String mapFunction, String reduceFunction, Class<T> entityClass)
public <T> MapReduceResults<T> mapReduce(String inputCollectionName, String mapFunction, String reduceFunction,MapReduceOptions mapReduceOptions, Class<T> entityClass) public <T> GroupByResults<T> group(String inputCollectionName, GroupBy groupBy, Class<T> entityClass)public <O> AggregationResults<O> aggregate(TypedAggregation<?> aggregation, Class<O> outputType)
public <O> AggregationResults<O> aggregate(Aggregation aggregation, Class<?> inputType, Class<O> outputType)

public List<String> distinctUserId() {
return mongoTemplate.getCollection("ideas").distinct("user_id");
} public List<String> distinctLocation(String userId) {
DBObject query = Query.query(Criteria.where("user_id").is(userId)).getQueryObject();
return mongoTemplate.getCollection("ideas").distinct("location", query);
}

private final List<Order> orders;public Sort and(Sort sort) {
if (sort == null) {
return this;
}
ArrayList<Order> these = new ArrayList<Order>(this.orders);
for (Order order : sort) {
these.add(order);
}
return new Sort(these);
}

1 private Sort sort;
2 private int skip;
3 private int limit;
4
5 public Query skip(int skip) {
6 this.skip = skip;
7 return this;
8 }
9
10 public Query limit(int limit) {
11 this.limit = limit;
12 return this;
13 }
14
15 public Query with(Pageable pageable) {
16
17 if (pageable == null) {
18 return this;
19 }
20
21 this.limit = pageable.getPageSize();
22 this.skip = pageable.getOffset();
23
24 return with(pageable.getSort());
25 }
26
27 public Query with(Sort sort) {
28
29 if (sort == null) {
30 return this;
31 }
32
33 for (Order order : sort) {
34 if (order.isIgnoreCase()) {
35 throw new IllegalArgumentException(String.format("Gven sort contained an Order for %s with ignore case! "
36 + "MongoDB does not support sorting ignoreing case currently!", order.getProperty()));
37 }
38 }
39
40 if (this.sort == null) {
41 this.sort = sort;
42 } else {
43 this.sort = this.sort.and(sort);
44 }
45
46 return this;
47 }
48
49
50
51 private final Map<String, CriteriaDefinition> criteria = new LinkedHashMap<String, CriteriaDefinition>();
52
53 public static Query query(CriteriaDefinition criteriaDefinition) {
54 return new Query(criteriaDefinition);
55 }
56
57 public Query() {}
58
59
60 public Query(CriteriaDefinition criteriaDefinition) {
61 addCriteria(criteriaDefinition);
62 }
63
64
65 public Query addCriteria(CriteriaDefinition criteriaDefinition) {
66
67 CriteriaDefinition existing = this.criteria.get(criteriaDefinition.getKey());
68 String key = criteriaDefinition.getKey();
69
70 if (existing == null) {
71 this.criteria.put(key, criteriaDefinition);
72 } else {
73 throw new InvalidMongoDbApiUsageException("Due to limitations of the com.mongodb.BasicDBObject, "
74 + "you can't add a second '" + key + "' criteria. " + "Query already contains '"
75 + existing.getCriteriaObject() + "'.");
76 }
77
78 return this;
79 }

private String key;
private List<Criteria> criteriaChain;
private LinkedHashMap<String, Object> criteria = new LinkedHashMap<String, Object>();
private Object isValue = NOT_SET; public static Criteria where(String key) {
return new Criteria(key);
}
public Criteria and(String key) {
return new Criteria(this.criteriaChain, key);
}is ne lt lte gt gte in/all nin mod size exits type not regex
in: 包含其中一个即可
all:全部包含才可以 查询时要明确这多个值主键的关系是什么样的public Criteria orOperator(Criteria... criteria)
public Criteria andOperator(Criteria... criteria)
public Criteria norOperator(Criteria... criteria)

public Idea findIdeaNearTo(String userId, long createAt, boolean isNext) {
Criteria criteria = Criteria.where("user_id").is(userId).and("delete_flag").is(false);
Query query;
if (isNext) {
query = new Query(criteria).with(new Sort(Sort.Direction.ASC, "create_at"));
criteria.and("create_at").gt(createAt);
} else {
query = new Query(criteria).with(new Sort(Sort.Direction.DESC, "create_at"));
criteria.and("create_at").lt(createAt);
}
return mongoTemplate.findOne(query, Idea.class);
}

next:
{ "user_id" : "2107164232" , "delete_flag" : false , "create_at" : { "$gt" : 1474600921000}}
pre：
{ "user_id" : "2107164232" , "delete_flag" : false , "create_at" : { "$lt" : 1474600921000}}

public List<Idea> find(String userId, IdeaStatus status, OriginalityType type, long createAtFrom, long createAtTo) {
Criteria criteria = Criteria.where("user_id").is(userId)
.and("delete_flag").is(false)
.and("status").in(status);
if (type == null) {
criteria.orOperator(
Criteria.where("originality_type").exists(false), // 字段是否存在 exists
Criteria.where("originality_type").size(0)); // 字段是数组，大小 size
} else {
criteria.and("originality_type").in(type);
}
criteria.andOperator(
Criteria.where("create_at").gte(createAtFrom),
Criteria.where("create_at").lt(createAtTo)
);
return mongoTemplate.find(new Query(criteria), Idea.class);
}

1 {
2 "user_id": "290536",
3 "delete_flag": false,
4 "status": {
5 "$in": [
6 "originality"
7 ]
8 },
9 "$or": [
10 {
11 "originality_type": {
12 "$exists": false
13 }
14 },
15 {
16 "originality_type": {
17 "$size": 0
18 }
19 }
20 ],
21 "$and": [
22 {
23 "create_at": {
24 "$gte": 1445788800000
25 }
26 },
27 {
28 "create_at": {
29 "$lt": 1446393600000
30 }
31 }
32 ]
33 }

1 public Items<Idea> listOriginalities(String userId, SearchVo condition, Pageable pageable) {
2 List<Criteria> orCriteriaList = new ArrayList<>();
3 if (condition.getStatus() == null || condition.getStatus().size() == 0) {
4 orCriteriaList.add(Criteria.where("status").in(Arrays.asList(IdeaStatus.originality)));
5 } else {
6 for (IdeaStatus status : condition.getStatus()) {
7 orCriteriaList.add(Criteria.where("status").all(Arrays.asList(status, IdeaStatus.originality)));
8 }
9 }
10 Criteria criteria = Criteria.where("userId").is(userId).and("deleteFlag").is(false)
11 .orOperator(orCriteriaList.toArray(new Criteria[0]));
12
13 if (!CollectionUtils.isEmpty(condition.getTag())) {
14 criteria.and("tags").in(condition.getTag());
15 }
16 Query query = query(criteria).with(pageable);
17 Query countQuery = query(criteria);
18 return Items.of(mongoTemplate.find(query, Idea.class), mongoTemplate.count(countQuery, Idea.class));
19 }

{
"user_id": "2107164232",
"delete_flag": false,
"$or": [
{
"status": {
"$all": [
"discussing",
"originality"
]
}
},
{
"status": {
"$all": [
"considering",
"originality"
]
}
}
]
}

public BlockContent addIfNotExists(BlockContent blockContent, long tenant) {
Query query = Query.query(where("tenant").is(tenant)
.and("sourceId").is(blockContent.getSourceId())
.and("scope.code").is(blockContent.getScope().getCode())); Update update = getUpdate(blockContent); return operations.findAndModify(
query, update,
options().upsert(true).returnNew(false),
BlockContent.class
);
}
返回null 保存
返回旧值 更新 使用他的id

public void setBlockStatusAndRecoverTime(Set<String> ids, long tenant, Date recoverTime) {
Query query = Query.query(
where("_id").in(ids)
.and("tenant").is(tenant)
.and("blockStatus").is(BlockStatus.BLOCKED)); operations.updateMulti(
query,
Update.update("blockStatus", BlockStatus.RECOVER)
.set("recoverTime", recoverTime),
BlockContent.class
);
}

public Object testAggregation1() {
TypedAggregation<News> aggregation = Aggregation.newAggregation(
News.class,
project("evaluate"),
group("evaluate").count().as("totalNum"),
match(Criteria.where("totalNum").gte(85)),
sort(Sort.Direction.DESC, "totalNum")
);
AggregationResults<BasicDBObject> result = template.aggregate(aggregation, BasicDBObject.class);// 语句执行如下：
// {
// "aggregate": "news",
// "pipeline": [
// {
// "$project": {
// "evaluate": "$eval"
// }
// },
// {
// "$group": {
// "_id": "$evaluate",
// "totalNum": {
// "$sum": 1
// }
// }
// },
// {
// "$match": {
// "totalNum": {
// "$gte": 85
// }
// }
// },
// {
// "$sort": {
// "totalNum": -1
// }
// }
// ]
// }// 查询结果：[{ "_id" : 0 , "totalNum" : 5033}, { "_id" : 1 , "totalNum" : 4967}] --> {"0": 5033,"1": 4967} List<BasicDBObject> resultList = result.getMappedResults();
Map<Integer, Object> map = Maps.newHashMap();
for (BasicDBObject dbo : resultList) {
int eval = dbo.getInt("_id");
long num = dbo.getLong("totalNum");
map.put(eval, num);
}
return map; //使用此方法，如果封装好了某一个类，类里面的属性和结果集的属性一一对应，那么，Spring是可以直接把结果集给封装进去的
//就是AggregationResults<BasicDBObject> result = mongoTemplate.aggregate(agg, BasicDBObject);
// 中的BasicDBObject改为自己封装的类
//但是感觉这样做有点不灵活，其实吧，应该是自己现在火候还不到，还看不到他的灵活性，好处在哪里；等火候旺了再说呗
//所以，就用这个万能的BasicDBObject类来封装返回结果
}

public Object testAggregation2() {
TypedAggregation<News> aggregation = Aggregation.newAggregation(
News.class,
project("evaluate"),
group("evaluate").count().as("totalNum"),
match(Criteria.where("totalNum").gte(85)),
sort(Sort.Direction.DESC, "totalNum"),
project("evaluate", "totalNum").and("eval").previousOperation() //为分组的字段（_id）建立别名
);
AggregationResults<BasicDBObject> result = template.aggregate(aggregation, BasicDBObject.class);// 语句执行如下：
// {
// "aggregate": "news",
// "pipeline": [
// {
// "$project": {
// "evaluate": "$eval"
// }
// },
// {
// "$group": {
// "_id": "$evaluate",
// "totalNum": {
// "$sum": 1
// }
// }
// },
// {
// "$match": {
// "totalNum": {
// "$gte": 85
// }
// }
// },
// {
// "$sort": {
// "totalNum": -1
// }
// }
// ]
// }// 查询结果：[{ "eval" : 0 , "totalNum" : 5033}, { "eval" : 1 , "totalNum" : 4967}] --> {"0": 5033,"1": 4967} List<BasicDBObject> resultList = result.getMappedResults();
Map<Integer, Object> map = Maps.newHashMap();
for (BasicDBObject dbo : resultList) {
int eval = dbo.getInt("eval");
long num = dbo.getLong("totalNum");
map.put(eval, num);
}
return map;
}

/**
* 功能：unwind()的使用，通过Spring Data MongoDB
* unwind()就是$unwind这个命令的转换，
* $unwind - 可以将一个包含数组的文档切分成多个, 比如你的文档有 中有个数组字段 A, A中有10个元素, 那么
* 经过 $unwind处理后会产生10个文档，这些文档只有 字段 A不同
* 详见：http://my.oschina.net/GivingOnenessDestiny/blog/88006
*/
public Object testAggregation3() {
TypedAggregation<News> agg = Aggregation.newAggregation(
News.class,
unwind("classKey"),
project("evaluate", "classKey"),
// 这里说明一点就是如果group>=2个字段，那么结果集的分组字段就没有_id了，取而代之的是具体的字段名（和testAggregation()对比）
group("evaluate", "classKey").count().as("totalNum"),
sort(Sort.Direction.DESC, "totalNum")
); AggregationResults<NewsVo> result = template.aggregate(agg, NewsVo.class);
return result.getMappedResults();/* {
"aggregate": "news",
"pipeline": [
{
"$unwind": "$ckey"
},
{
"$project": {
"evaluate": "$eval",
"classKey": "$ckey"
}
},
{
"$group": {
"_id": {
"evaluate": "$evaluate",
"classKey": "$classKey"
},
"totalNum": {
"$sum": 1
}
}
},
{
"$sort": {
"totalNum": -1
}
}
]
}*/// [
// {
// "evaluate": "0",
// "class_key": "26",
// "total_num": 2457
// },
// {
// "evaluate": "0",
// "class_key": "A102",
// "total_num": 2449
// },
// {
// "evaluate": "0",
// "class_key": "24",
// "total_num": 2446
// }
// ]
}

/**
* db.videos.aggregate(
[
{ $match: { "frags.isnew" : true } },
{ $unwind: "$frags" },
{ $match: { "frags.isnew" : true } },
{ $group: {
_id: {cat1:"$cat1"},
count: { $sum: 1 },
publishdate2: { $max: "$publishdate"}
}
} ]
)
*/
Aggregation agg = newAggregation(
project("frags","cat1","publishdate"),//挑选所需的字段
match(
Criteria.where("frags.isnew").is(Boolean.TRUE)
.and("cat1").in(importantCat1List)
),//筛选符合条件的记录
unwind("frags"),//如果有MASTER-ITEM关系的表，需同时JOIN这两张表的，展开子项LIST，且是内链接，即如果父和子的关联ID没有的就不会输出
match(Criteria.where("frags.isnew").is(Boolean.TRUE)),
group("cat1")//设置分组字段
.count().as("updateCount")//增加COUNT为分组后输出的字段
.last("publishdate").as("publishDate"),//增加publishDate为分组后输出的字段
project("publishDate","cat1","updateCount")//重新挑选字段
.and("cat1").previousOperation()//为前一操作所产生的ID FIELD建立别名
); Aggregation agg = newAggregation(
project("authorName"),
group("authorName").count().as("sum")，
sort(sort),
limit(5)
);db.getCollection('ideas').aggregate([
{$match:{"delete_flag":false}},
{$group:{
_id:"$user_id",
count:{$sum:NumberLong(1)}
}},
{$match:{"count":{$gt:10}}}
]);
{"_id" : "551314", "count" : NumberLong(6)}
{"_id" : "201960", "count" : NumberLong(10)}project(String... fields)
unwind(String field)
group(String... fields) and count sum avg min max last first addToSet as 取名字
sort(Sort sort)
skip(int elementsToSkip)
limit(long maxElements)
match(Criteria criteria) public int countInfractionUserAmount(Date begin, Date end, long tenant) {
Aggregation aggregation = newAggregation(
match(where("tenant").is(tenant)
.andOperator(where("time").gte(begin),
where("time").lte(end))),
project("uids"),
unwind("uids"),
group("uids"),
group.count().as("count")
);
AggregationResults<Map> results = mongoOperations.aggregate(
aggregation, getInfractionCollection(), Map.class);
return MongoUtils.parseAggregationCount(results);
}public static int parseAggregationCount(AggregationResults<Map> results) {
List<Map> maps = results.getMappedResults();
if (CollectionUtils.isEmpty(maps)) {
return 0;
}
return Integer.parseInt(maps.get(0).get("count").toString());
}