00、SpringBoot和 Mongo整合使用
01、MongoDB简介
MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。
MongoDB是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的,它支持的数据结构非常松散,是类似json的bson格式,因此可以存储比较复杂的数据类型。
MongoDB最大的特点是它支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且还支持对数据建立索引。
02、pxm.xml依赖
<!--SpringBoot整合MongoDB-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
03、配置文件
properties的配置
# MongoDB数据库
spring.data.mongodb.uri=mongodb://127.0.0.1:27017/testMongoDB
# 设置了密码的MongoDB配置方式
# MongoDB服务器连接地址
#spring.data.mongodb.host=127.0.0.1
# MongoDB服务器连接端口
#spring.data.mongodb.port=27017
# MongoDB的验证数据库
#spring.data.mongodb.authentication-database=admin
# MongoDB数据库用户
#spring.data.mongodb.username=root
# MongoDB数据库密码
#spring.data.mongodb.password=123456
# 带连接的数据库
#spring.data.mongodb.database=testMongoDB
spring:
data:
mongodb:
# mongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[database][?options]]
uri: mongodb://root:mkxiaoer@120.77.34.190:27017
database: traveldb
04、创建一个实体
package com.pug.mongo;
import lombok.*;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
import java.util.Date;
// lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@Document("kssmessage")
public class MessageMo implements java.io.Serializable {
@Id
private String id; //消息注解
@Field("userid")
private String userid;//消息来自的用户id
@Field("nickname")
private String nickname;//消息来自的用户昵称
@Field("avatar")
private String avatar;//消息来自的用户头像
@Field("msgtype")
private Integer msgtype;//消息的类似,1:系统消息 2:订单消息 3:用户注册奖励消息
@Field("toUserid")
private String toUserid;//消息的接收者
@Field("msgcontent")
private String msgcontent;//消息来自的用户id
@Field("ctime")
private Date createTime;//消息来自的用户id
}
05、创建一个Repository类
package com.pug.mongorepository;
import com.pug.mongo.MessageMo;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface MessageRepository extends MongoRepository<MessageMo,String> {
}
06、创建service和serviceimpl
package com.pug.mongoservice.message;
import com.pug.mongo.MessageMo;
public interface IMessageService {
/**
* 保存消息
* @param messageMo
* @return
*/
MessageMo saveMessage(MessageMo messageMo);
}
package com.pug.mongoservice.message;
import com.pug.mongo.MessageMo;
import com.pug.mongorepository.MessageRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
@Slf4j
public class MessageServiceImpl implements IMessageService {
@Autowired
private MessageRepository messageRepository;
@Override
public MessageMo saveMessage(MessageMo messageMo) {
messageMo = messageRepository.save(messageMo);
return messageMo;
}
}
07、Controller
package com.pug.web.msg;
import com.pug.config.anno.LoginCheck;
import com.pug.mongo.MessageMo;
import com.pug.mongoservice.message.IMessageService;
import com.pug.mongoservice.msg.IMsgService;
import com.pug.web.APIBaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
@Api(tags = "消息模块")
@RestController
@RequiredArgsConstructor
@LoginCheck
public class MessageController extends APIBaseController {
private final IMessageService messageService;
@PostMapping("/message/save")
@ApiOperation("保存系统消息")
public MessageMo saveMessageMo(MessageMo messageMo) {
return messageService.saveMessage(messageMo);
}
}
注意问题:
- save : 存在id就修改,不存在就保存
- insert:只保存,如果传递了数据库存在的id就报错。
01、如何认识MessageRepository
从代码中我们很容易看见:我们只要去实现一个接口:MongoRepository 就自动拥有了对mongodb的curd和分页查询和相关条件查询的功能。
- saveAll()
- findAll()
- findAll(Sort sort)
S insert(S entity);ListfindAll(Exampleexample);ListfindAll(Exampleexample);ListfindAll(Exampleexample, Sort sort);- Iterable findAll(Sort sort);
- Page findAll(Pageable pageable);
S save(S entity);IterablesaveAll(Iterableentities);- Optional findById(ID id);
- boolean existsById(ID id);
- Iterable findAll();
- Iterable findAllById(Iterable ids);
- void deleteById(ID id);
- void delete(T entity);
- void deleteAllById(Iterable<? extends ID> ids);
- void deleteAll();
为什么这样做:
- 接口:MessageRepository
- 接口:PagingAndSortingRepository
- 接口:QueryByExampleExecutor
- 接口:CrudRepository
接口意义:
- 职责分担
- 化整为零
- 保持一个单一只能原则
其实上面用一个接口就可以完成所有的定义,但是这样会很混乱。所有可以多个接口进行分开定义进行实现和继承。
背后原理:
- 动态代理
分析结论
对mongodb的collection表以及把90%单collection全部实现和完成.比如:
-
保存
- 批量保存
-
修改
- 批量修改
-
删除
- 批量删除
- 根据id删除
-
查询
- 查询所有
- 根据id查询返回document
- 根据条件查询
- 分页 & 排序
缺陷:
- 没有实现复杂的高级查询
- 分组
- 统计
- 聚合
所以必须使用MongoTemplate对象。
结论
-
MongoRepository 一系列的接口只是一个标准和规范,底层是通过动态代理来完成和处理。具体是谁来完成的呢?其实就是MongoTemplate对象来完成。
-
MongoTemplate才是真正意义上的处理curd+聚合分组的类。真正做事干活的其实就是它。
-
在开发中,如果你不想实现这个接口MongoRepository 也是可以,你可以全部使用MongoTemplate来操作也没问题,但是其实还建议去实现,这样至少单个collection 80%的功能都已经完成了、所有那剩下的20%的功能就用MongoTemplate来完成把。
-
你可以把MongoRepository 当做Mybatis的Mapper、把MongoTemplate当做SqlSession。
-
未来:elasticsearch也是如此:ElasticsearchRepository 和 ElasticsearchTemplate
-
未来:rabbit也是如此:RabbitMqTemplate
-
未来:kafka也是如此:KafkaTemplate
-
未来:redis也是如此:RedisTemplate
-
源码在哪里查看呢?
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency>
MongoTemplate初始化就是通过:spring-boot-starter-data-mongodb的starter在对应配置类进行初始化的。
/*
* Copyright 2012-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.autoconfigure.data.mongo;
import com.mongodb.ClientSessionOptions;
import com.mongodb.client.ClientSession;
import com.mongodb.client.MongoDatabase;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.mongo.MongoProperties;
import org.springframework.boot.autoconfigure.mongo.MongoProperties.Gridfs;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.support.PersistenceExceptionTranslator;
import org.springframework.data.mongodb.MongoDatabaseFactory;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.convert.DbRefResolver;
import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.convert.MongoConverter;
import org.springframework.data.mongodb.core.convert.MongoCustomConversions;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
import org.springframework.data.mongodb.gridfs.GridFsOperations;
import org.springframework.data.mongodb.gridfs.GridFsTemplate;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
/**
* Configuration for Mongo-related beans that depend on a {@link MongoDatabaseFactory}.
*
* @author Andy Wilkinson
*/
@Configuration(proxyBeanMethods = false)
@ConditionalOnBean(MongoDatabaseFactory.class)
class MongoDatabaseFactoryDependentConfiguration {
private final MongoProperties properties;
MongoDatabaseFactoryDependentConfiguration(MongoProperties properties) {
this.properties = properties;
}
@Bean
@ConditionalOnMissingBean(MongoOperations.class)
MongoTemplate mongoTemplate(MongoDatabaseFactory factory, MongoConverter converter) {
return new MongoTemplate(factory, converter);
}
@Bean
@ConditionalOnMissingBean(MongoConverter.class)
MappingMongoConverter mappingMongoConverter(MongoDatabaseFactory factory, MongoMappingContext context,
MongoCustomConversions conversions) {
DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context);
mappingConverter.setCustomConversions(conversions);
return mappingConverter;
}
@Bean
@ConditionalOnMissingBean(GridFsOperations.class)
GridFsTemplate gridFsTemplate(MongoDatabaseFactory factory, MongoTemplate mongoTemplate) {
return new GridFsTemplate(new GridFsMongoDatabaseFactory(factory, this.properties),
mongoTemplate.getConverter(), this.properties.getGridfs().getBucket());
}
/**
* {@link MongoDatabaseFactory} decorator to respect {@link Gridfs#getDatabase()} if
* set.
*/
static class GridFsMongoDatabaseFactory implements MongoDatabaseFactory {
private final MongoDatabaseFactory mongoDatabaseFactory;
private final MongoProperties properties;
GridFsMongoDatabaseFactory(MongoDatabaseFactory mongoDatabaseFactory, MongoProperties properties) {
Assert.notNull(mongoDatabaseFactory, "MongoDatabaseFactory must not be null");
Assert.notNull(properties, "Properties must not be null");
this.mongoDatabaseFactory = mongoDatabaseFactory;
this.properties = properties;
}
@Override
public MongoDatabase getMongoDatabase() throws DataAccessException {
String gridFsDatabase = this.properties.getGridfs().getDatabase();
if (StringUtils.hasText(gridFsDatabase)) {
return this.mongoDatabaseFactory.getMongoDatabase(gridFsDatabase);
}
return this.mongoDatabaseFactory.getMongoDatabase();
}
@Override
public MongoDatabase getMongoDatabase(String dbName) throws DataAccessException {
return this.mongoDatabaseFactory.getMongoDatabase(dbName);
}
@Override
public PersistenceExceptionTranslator getExceptionTranslator() {
return this.mongoDatabaseFactory.getExceptionTranslator();
}
@Override
public ClientSession getSession(ClientSessionOptions options) {
return this.mongoDatabaseFactory.getSession(options);
}
@Override
public MongoDatabaseFactory withSession(ClientSession session) {
return this.mongoDatabaseFactory.withSession(session);
}
}
}
02、MongoTemplate的基本方法
首先使用@Autowired注入MongoTemplate(后面直接使用,就不特殊说明)
@Autowired
private MongoTemplate mongoTemplate;
1.检索数据
Query对象
1 创建一个query对象(用来封装所有条件对象),再创建一个criteria对象(用来构建条件)
2 精准条件:criteria.and(“key”).is(“条件”)
模糊条件:criteria.and(“key”).regex(“条件”)
3、封装条件:query.addCriteria(criteria)
4、大于(创建新的criteria):Criteria gt = Criteria.where(“key”).gt(“条件”)
小于(创建新的criteria):Criteria lt = Criteria.where(“key”).lt(“条件”)
5、Query.addCriteria(new Criteria().andOperator(gt,lt));
6、一个query中只能有一个andOperator()。其参数也可以是Criteria数组。
7、排序 :query.with(new Sort(Sort.Direction.ASC, "age"). and(new Sort(Sort.Direction.DESC, "date")))
// 查询name=zs
Query query = Query.query(Criteria.where("name").is("zs"));
mongoTemplate.find(query,User.class);
mongoTemplate.find(query,User.class,"mongodb_user");
// 查询所有
mongoTemplate.findAll(User.class);
mongoTemplate.findAll(User.class,"mongodb_user");
// 分页查询 page页码,pageSize每页展示几个
Pageable pageable = PageRequest.of(page - 1, pageSize, Sort.by(Sort.Order.desc("date")));
Query query = new Query().with(pageable);
return this.mongoTemplate.find(query, User.class,"mongodb_user");
// 查询多个
Query query= Query.query(Criteria.where("id").in("id1","id2","id3")).with(Sort.by(Sort.Order.desc("date")));
List<Publish> list= this.mongoTemplate.find(query, User.class);
// 查询数量
Criteria criteria = Criteria.where("userId").is("12345")
.and("name").is(new ObjectId("张三"))
.and("address").is("上海");
Query query = Query.query(criteria);
long count = this.mongoTemplate.count(query, User.class);
2.插入数据
List<User> list = new ArrayList<>();
User user= new User();//
user.setName("admin");
user.setAddress("测试");
list.add(user);
// 保存对象到mongodb
mongoTemplate.save(user);
mongoTemplate.insert(user);
// 根据集合名称保存对象到mongodb
mongoTemplate.save(user,"mongodb_user");
mongoTemplate.insert(user,"mongodb_user");
// 根据集合名称保存list到mongodb
mongoTemplate.save(list,"mongodb_user");
mongoTemplate.insert(list,"mongodb_user");
mongoTemplate.insert(list,User.class);
3.更新数据
User user = new User();
user.setId("5d1312aeb1829c279c6c256b");
user.setName("admin");
user.setAddress("测试");
Query query = Query.query(Criteria.where("_id").is("5d1312aeb1829c279c6c256b"));
Update update = Update.update("name","zs");
// 更新一条数据
mongoTemplate.updateFirst(query,update, User.class);
mongoTemplate.updateFirst(query,update, "mongodb_user");
mongoTemplate.updateFirst(query,update, User.class,"mongodb_user");
// 更新多条数据
mongoTemplate.updateMulti(query,update, User.class);
mongoTemplate.updateMulti(query,update,"mongodb_user");
mongoTemplate.updateMulti(query,update, User.class,"mongodb_user");
// 更新数据,如果数据不存在就新增
mongoTemplate.upsert(query,update, User.class);
mongoTemplate.upsert(query,update,"mongodb_user");
mongoTemplate.upsert(query,update, User.class,"mongodb_user");
4.删除数据
List<MongoDbJavaTest> list = new ArrayList<>();
User user= new User();
user.setId("5d1312aeb1829c279c6c256b");
list.add(user);
Query query = Query.query(Criteria.where("_id").in("5d1312aeb1829c279c6c256b","5d13133ab1829c29d02ce29c"));
// 根据条件删除
mongoTemplate.remove(query);
mongoTemplate.remove(user);
mongoTemplate.remove(User.class);
// 根据条件删除(可删除多条)
mongoTemplate.remove(query,User.class,"mongodb_user");
05、案例分析
package com.fzy.javastudy.java.day_0906.model;
import lombok.Data;
import org.springframework.data.mongodb.core.mapping.Document;
import java.time.LocalDateTime;
@Data
@Document("student")
public class Student{
private String id;
private String username;
private String password;
private int age;
private String gender;
private LocalDateTime createTime;
}
- 实现
package com.fzy.javastudy.java.day_0906.service;
import com.fzy.javastudy.java.day_0906.model.*;
import com.fzy.javastudy.spring.apimodel.*;
import com.fzy.javastudy.spring.config.ServiceException;
import com.fzy.javastudy.spring.config.SystemException;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
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.Service;
import javax.annotation.Resource;
import java.util.List;
import java.util.regex.Pattern;
/**
* https://blog.csdn.net/sinat_35821285/article/details/83511203
*/
@Slf4j
@Service
public class MongoService {
@Resource
private MongoTemplate mongoTemplate;
/**
* 查询全部
*
* @return ApiResponse
*/
public ApiResponse findStudents() {
mongoTemplate.dropCollection(Customer.class);
List<Student> students = mongoTemplate.findAll(Student.class);
System.out.println(students);
long count = mongoTemplate.count(new Query().with(new Sort(Sort.Direction.ASC, "username")), Student.class);
return Api.ok(students, String.format("%s%d%s", "查询到", count, "条"));
}
/**
* 根据id查询
*
* @param id _id
* @return ApiResponse
*/
public ApiResponse findStudentByID(String id) {
Student student = mongoTemplate.findById(id, Student.class);
return Api.ok(student);
}
/**
* 准确查询
*
* @param student Student对象
* @return ApiResponse
*/
public ApiResponse findStudentListByMany(Student student) {
Query query = new Query(Criteria
.where("username").is(student.getUsername())
.and("gender").is(student.getGender())
.and("age").gt(student.getAge()));
List<Student> students = mongoTemplate.find(query, Student.class);
return Api.ok(students);
}
/**
* 模糊查询
* 模糊查询以 【^】开始 以【$】结束 【.*】相当于Mysql中的%
*
* @param username 用户名
* @return ApiResponse
*/
public ApiResponse findStudentsLikeName(String username) {
String regex = String.format("%s%s%s", "^.*", username, ".*$");
Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
Query query = new Query(Criteria.where("username").regex(pattern));
List<Student> students = mongoTemplate.find(query, Student.class);
return Api.ok(students);
}
/**
* 分页查询
*
* @param request
* @return
*/
public PageApiResponse findStudentsPage(StudentRequest request) {
try {
Query query = new Query();
if (StringUtils.isNotEmpty(request.getUsername())) {
String regex = String.format("%s%s%s", "^.*", request.getUsername(), ".*$");
Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
query.addCriteria(Criteria.where("username").regex(pattern));
}
int totalCount = (int) mongoTemplate.count(query, Student.class);
List<Student> studentList = mongoTemplate.find(query.skip(request.getOffset()).limit(request.getPageSize()), Student.class);
PageApiResponse response = PageApi.ok(studentList, totalCount, "获取列表成功");
response.setTotalPage(PageCounter.toTalPage(totalCount, request.getPageSize()));
response.handleRequest(request);
return response;
} catch (Exception e) {
throw new SystemException(-1, "获取分页数据出错");
}
}
/**
* 修改
*
* @param student Student
* @return ApiResponse
*/
public ApiResponse updateStudent(Student student) {
try {
Query query = new Query(Criteria.where("_id").is(student.getId()));
Update update = new Update();
update.set("username", student.getUsername());
update.set("password", student.getPassword());
update.set("age", student.getAge());
update.set("gender", student.getGender());
UpdateResult result = mongoTemplate.upsert(query, update, Student.class);
long count = result.getModifiedCount();
if (count > 0) {
return Api.ok(null, "更新成功");
}
throw new ServiceException(-1, "更新失败");
} catch (ServiceException e) {
throw e;
} catch (Exception e) {
e.printStackTrace();
throw new SystemException(-1, "更新出错");
}
}
/**
* 删除
*
* @param id id
* @return ApiResponse
*/
public ApiResponse delete(String id) {
try {
Query query = new Query(Criteria.where("_id").is(id));
DeleteResult result = mongoTemplate.remove(query, Student.class);
long count = result.getDeletedCount();
if (count > 0) {
return Api.ok(count, "删除成功");
}
throw new ServiceException(-1, String.format("【%s】%s", id, "不存在"));
} catch (ServiceException e) {
throw e;
} catch (Exception e) {
throw new SystemException(-1, "删除出错");
}
}
/**
* 新增
*
* @param student
* @return
*/
public ApiResponse createStudent(Student student) {
try {
Student insert = mongoTemplate.insert(student);
return Api.ok(insert);
} catch (Exception e) {
e.printStackTrace();
throw new SystemException(-1, "创建出错");
}
}
}
03、mongoTemplate.aggregate()聚合查询
一、概述
1. 聚合的表达式
MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等),并返回计算后的数据结果。有点类似sql语句中的 count(*)。
下表展示了一些聚合的表达式:
表达式 | 描述 | 实例 |
---|---|---|
$sum | 计算总和。 | db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", num_tutorial : { s u m : " sum : " sum:"likes"}}}]) |
$avg | 计算平均值 | db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", num_tutorial : { a v g : " avg : " avg:"likes"}}}]) |
$min | 获取集合中所有文档对应值得最小值。 | db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", num_tutorial : { m i n : " min : " min:"likes"}}}]) |
$max | 获取集合中所有文档对应值得最大值。 | db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", num_tutorial : { m a x : " max : " max:"likes"}}}]) |
$push | 在结果文档中插入值到一个数组中。 | db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", url : { p u s h : " push: " push:"url"}}}]) |
$addToSet | 在结果文档中插入值到一个数组中,但不创建副本。 | db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", url : { a d d T o S e t : " addToSet : " addToSet:"url"}}}]) |
$first | 根据资源文档的排序获取第一个文档数据。 | db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", first_url : { f i r s t : " first : " first:"url"}}}]) |
$last | 根据资源文档的排序获取最后一个文档数据 | db.mycol.aggregate([{KaTeX parse error: Expected '}', got 'EOF' at end of input: …roup : {_id : "by_user", last_url : { l a s t : " last : " last:"url"}}}]) |
2. 管道的概念
管道在Unix和Linux中一般用于将当前命令的输出结果作为下一个命令的参数。
MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。
表达式:处理输入文档并输出。表达式是无状态的,只能用于计算当前聚合管道的文档,不能处理其它的文档。
这里我们介绍一下聚合框架中常用的几个操作:
- $project:修改输入文档的结构。可以用来重命名、增加或删除域,也可以用于创建计算结果以及嵌套文档。
- m a t c h : 用 于 过 滤 数 据 , 只 输 出 符 合 条 件 的 文 档 。 match:用于过滤数据,只输出符合条件的文档。 match:用于过滤数据,只输出符合条件的文档。match使用MongoDB的标准查询操作。
- $limit:用来限制MongoDB聚合管道返回的文档数。
- $skip:在聚合管道中跳过指定数量的文档,并返回余下的文档。
- $unwind:将文档中的某一个数组类型字段拆分成多条,每条包含数组中的一个值。
- $group:将集合中的文档分组,可用于统计结果。
- $sort:将输入文档排序后输出。
- $geoNear:输出接近某一地理位置的有序文档。
3. 聚合查询示例:
db.articles.aggregate( [
{ $match : { score : { $gt : 70, $lte : 90 } } },
{ $group: { _id: null, count: { $sum: 1 } } }
] );
但是在代码中要如何实现类似以上功能呢?
二、代码实现(sum求和)
功能描述:
- 当name和course同时传参时,按id分组,统计总分数
- 按name分组,统计相同name的总分数
- 按course分组,统计总分数
public double getTotleScoreWithMongoTemplate(StudentScore studentScore) {
//封装查询条件
List<AggregationOperation> operations = new ArrayList<>();
if (StringUtils.isEmpty(studentScore.getName()) && StringUtils.isEmpty(studentScore.getCourse())){
//totleScore为StudentScore类中新建的属性,用于接收统计后的总分数;当然也可以使用score(或其他属性)接收
operations.add(Aggregation.group("id").sum("score").as("totleScore"));
}
if (!StringUtils.isEmpty(studentScore.getName())) {
operations.add(Aggregation.match(Criteria.where("name").is(studentScore.getName())));
operations.add(Aggregation.group("name").sum("score").as("totleScore"));
}
if (!StringUtils.isEmpty(studentScore.getCourse())) {
operations.add(Aggregation.match(Criteria.where("course").is(studentScore.getCourse())));
operations.add(Aggregation.group("course").sum("score").as("totleScore"));
}
Aggregation aggregation = Aggregation.newAggregation(operations);
//查询、并获取结果
AggregationResults<StudentScore> results = mongoTemplate.aggregate(aggregation, "studentScore", StudentScore.class);
double totleScore = results.getUniqueMappedResult().getTotleScore();
return totleScore;
}
对于其他的功能,可以修改以上代码自行测试,此处不再举例
Aggregation聚合查询
需求:在订单表中,根据buyerNick分组,统计每个buyerNick的电话、地址、支付总金额以及总商品数,返回结果是CustomerDetail。
/*
* project:列出所有本次查询的字段,包括查询条件的字段和需要搜索的字段;
* match:搜索条件criteria
* unwind:某一个字段是集合,将该字段分解成数组
* group:分组的字段,以及聚合相关查询
* sum:求和(同sql查询)
* count:数量(同sql查询)
* as:别名(同sql查询)
* addToSet:将符合的字段值添加到一个集合或数组中
* sort:排序
* skip&limit:分页查询
*/
public List<CustomerDetail> customerDetailList(Integer pageNum,String userId,String buyerNick,String itemId,List<String> phones) throws Exception{
Criteria criteria = Criteria.where("userId").is(userId);
Integer pageSize = 10;
Integer startRows = (pageNum - 1) * pageSize;
if(buyerNick != null && !"".equals(buyerNick)){
criteria.and("buyerNick").is(buyerNick);
}
if(phones != null && phones.size() > 0){
criteria.and("mobile").in(phoneList);
}
if(itemId != null && !"".equals(itemId)){
criteria.and("orders.numIid").is(itemId);
}
Aggregation customerAgg = Aggregation.newAggregation(
Aggregation.project("buyerNick","payment","num","tid","userId","address","mobile","orders"),
Aggregation.match(criteria),
Aggregation.unwind("orders"),
Aggregation.group("buyerNick").first("buyerNick").as("buyerNick").first("mobile").as("mobile").
first("address").as("address").sum("payment").as("totalPayment").sum("num").as("itemNum").count().as("orderNum"),
Aggregation.sort(new Sort(new Sort.Order(Sort.Direction.DESC, "totalPayment"))),
Aggregation.skip(startRows),
Aggregation.limit(pageSize)
);
List<CustomerDetail> customerList = tradeRepository.findAggregateList(new Query(criteria), userId, customerAgg,CustomerDetail.class);
return customerList;
}
public <T> List<T> findAggregateList(Query query,String userNickName, Aggregation aggregation,Class<T> clazz) {
AggregationResults<T> aggregate = this.mongoTemplate.aggregate(aggregation, collectionName, clazz);
List<T> customerDetails = aggregate.getMappedResults();
return customerDetails;
}
Trade表:
public class TradeInfo{
private String tid;//订单id
private Double payment;//支付金额
private String buyerNick;//买家昵称
private String address;//地址
private String mobile;//手机号
private Long num;//购买商品数量
private List<order> orders;子订单
}
CustomerDetail:
public class CustomerDetail{
private String buyerNick;//买家昵称
private Double totalPayment;//订单金额
private Integer orderNum;//订单数
private Integer itemNum;//商品数
private String address;//地址
}
聚合分组,先过滤字段为type=Constants.DataSetOpt.OPT_VIEW,通过dateSetId进行分组,并计算每组的个数,.first是需要显示的字段。
//浏览分组
private List<Document> flowGroup() {
Criteria criteria = Criteria.where("type").is(Constants.DataSetOpt.OPT_VIEW);
Aggregation agg = Aggregation.newAggregation(
Aggregation.match(criteria),
Aggregation.group("dataSetId")
.first("dataSetId").as("dataSetId")
.count()
.as("dataSetIdCount")
.first("dataSetType").as("dataSetType")
);
AggregationResults<Document> result = mongoTemplate.aggregate(agg,Access.class ,Document.class);
return result.getMappedResults();
}
也可以使用TypedAggregation的方式进行聚合分组,如下:
@Test
public void statTest(){
TypedAggregation<Statistics> agg = Aggregation.newAggregation(Statistics.class,
Aggregation.group("month")
.sum("totalVisit")
.as("sumTotalVisit")
.sum("totalDownload")
.as("sumTotalDownload"));
AggregationResults<Document> result = mongoTemplate.aggregate(agg, Document.class);
// return result.getMappedResults();
result.getMappedResults().forEach(document -> System.out.println(document));
}
addToSet使用方法示例
addToSet:将符合的字段值添加到一个集合或数组中\
聚合示例
private List<Document> groupCountryOfOrigin() {
Aggregation agg = Aggregation.newAggregation(
Aggregation.group("countryOfOrigin")
.first("countryOfOrigin").as("countryOfOrigin")
.addToSet("portEntry").as("portEntryList")
.addToSet("province").as("provinceList")
.addToSet("customName").as("customNameList")
);
AggregationResults<Document> result = mongoTemplate.aggregate(agg,CertificationBatchInfo.class , Document.class);
return result.getMappedResults();
}
聚合内如获取
List<Object> list = Lists.newArrayList();
List<Document> documents = groupCountryOfOrigin();
for (Document document : documents) {
Map<String, Object> map = Maps.newHashMap();
String countryOfOrigin = document.getString("countryOfOrigin");
//这个进口国流向过哪些口岸
List<String> portEntryList = document.getList("portEntryList", String.class);
//这个进口国流向过哪些省市
List<String> provinceList = document.getList("provinceList", String.class);
//这个进口国流向国内哪些种商品
List<String> customNameList = document.getList("customNameList", String.class);
map.put("countryOfOrigin",countryOfOrigin);
map.put("portEntryList",portEntryList);
map.put("provinceList",provinceList);
map.put("customNameList",customNameList);
list.add(map);
}
04、MongoTemplate 使用aggregate聚合查询
db.getCollection('trade').aggregate(
[ // $match 在$group 前过滤分组前数据 $match在$group之后过滤分组后的文档
{ $match : { CheckStatus : "邮件复核不一致" } },
{
$group :
{
_id : "$CheckStatus",
tradePriceSum : {$sum : "$TradePrice"},
undlRoundingSum : {$sum : "$UndlRounding"}
}
},
]
)
package com.htsc.thfx.framework.controller;
import com.htsc.thfx.framework.vo.ResultMessage;
import com.mongodb.BasicDBObject;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationOperation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.aggregation.GroupOperation;
import org.springframework.data.mongodb.core.query.BasicQuery;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@RestController
@RequestMapping("/mongo")
public class MongoController extends BaseController {
@Autowired
MongoTemplate mongoTemplate;
@GetMapping("/find")
public ResultMessage find(String[] keys, String[] values, String[] queryKey, @RequestParam(defaultValue = "trade") String collectionName) {
// 筛选条件
BasicDBObject dbObject = new BasicDBObject();
for (int i = 0; i < keys.length; i++) {
dbObject.put(keys[i], values[i]);
}
//指定返回的字段
BasicDBObject fieldsObject = new BasicDBObject();
for (String s : queryKey) {
fieldsObject.put(s, true);
}
Query query = new BasicQuery(dbObject.toJson(), fieldsObject.toJson());
List<HashMap> result = mongoTemplate.find(query, HashMap.class, collectionName);
return success(result);
}
@GetMapping("/group")
public ResultMessage group(String[] keys, String[] values,@RequestParam String groupKey, String[] queryKey, @RequestParam(defaultValue = "trade") String collectionName) {
// 聚合操作
List<AggregationOperation> operations = new ArrayList<>();
// 筛选条件
for (int i = 0; i < keys.length; i++) {
//operations.add(Aggregation.match(new Criteria(keys[i]).is(values[i])));
operations.add(Aggregation.match(Criteria.where(keys[i]).is(values[i])));
}
// 分组字段
GroupOperation groupOperation = Aggregation.group(groupKey);
// 聚合查询字段
for (int i = 0; i < queryKey.length; i++) {
groupOperation = groupOperation.sum(queryKey[i]).as(queryKey[i]);
}
// 添加选项 (聚合查询字段和添加筛选是有区别的注意)
operations.add(groupOperation);
// 最终聚合查询所有信息
Aggregation aggregation = Aggregation.newAggregation(operations);
// 查询结果
AggregationResults<HashMap> results = mongoTemplate.aggregate(aggregation, collectionName, HashMap.class);
//获取结果
List<HashMap> result = results.getMappedResults();
return success(result);
}
}