spring boot 集成mongoDB操作

引入依赖

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

application.yml配置mongo

spring:
  data:
    mongodb:
      uri: mongodb://appdb:appdb@node01:28017/appdb
#      username: appdb
#      password: 3EF7C9080589F0AB
#      authentication-database: appdb
#      host: node01
#      port: 28017
#      database: appdb

 

好了开始job演习，下面直接开始实际项目为标准来记录mongoDb的使用

1：一般情况下会创建一个PO实体类来维护mongo集合字段，当然如果说你的表字段变化比较频繁可以知己使用JsonObject来接收，当然使用Document BDObjec都是可以的。

我们创建实体类User

 

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Document("user")
public class User implements Serializable {

    @Id
    private String id;
    private String userName;
    private String userId;
    private Integer age;
    private String sex;
    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
    private Date birthDay;
}

mongoTemplate操作

save:

   public void save(Object entity) {
        getMongoTemplate().save(entity);
    }

    public void save(Object entity, String collectionName) {
        getMongoTemplate().save(entity, collectionName);
    }

    public void save(Iterable<?> entities, String collectionName) {
        getMongoTemplate().insert(entities, collectionName);
    }

 

find查询

  /**
     * 查询一条记录
     *
     * @param query
     * @param poClass
     * @param <T>
     * @return
     */
    public <T> T findOne(Query query, Class<T> poClass) {
        return getMongoTemplate().findOne(query, poClass);
    }

    public <T> T findOne(Query query, String collectionName, Class<T> poClass) {
        return getMongoTemplate().findOne(query, poClass, collectionName);
    }

    /**
     * 查询符合条件的所有记录
     *
     * @param query
     * @param poClass
     * @param <T>
     * @return List
     */

    public <T> List<T> findList(Query query, Class<T> poClass) {
        return getMongoTemplate().find(query, poClass);
    }

    public <T> List<T> findList(Query query, String collectionName, Class<T> poClass) {
        return getMongoTemplate().find(query, poClass, collectionName);
    }

分页查询

 

 /**
     * 分页查询
     *
     * @param query
     * @param collectionName
     * @param poClass
     * @param pageInfo
     * @param <T>
     * @return
     */
    public <T> List<T> findByPage(Query query, String collectionName, Class<T> poClass, PageInfo pageInfo) {
        if (pageInfo == null) {
            return getMongoTemplate().find(query, poClass, collectionName);
        }
        pageInfo.setTotalRecords(getMongoTemplate().count(query, collectionName));
        query.skip(pageInfo.getStartIndex()).limit(pageInfo.getResults());
        return getMongoTemplate().find(query, poClass, collectionName);
    }

    public <T> List<T> findByPage(Query query, Class<T> poClass, PageInfo pageInfo) {
        if (pageInfo == null) {
            return getMongoTemplate().find(query, poClass);
        }
        pageInfo.setTotalRecords(count(query, poClass));
        return getMongoTemplate().find(query.skip(pageInfo.getStartIndex()).limit(pageInfo.getResults()), poClass);

    }

    public <T> List<T> findByPageWithSort(Query query, Class<T> poClass, String collectionName, PageInfo pageInfo, Sort sort) {
        query.with(sort);
        if (pageInfo == null) {
            return getMongoTemplate().find(query, poClass, collectionName);
        }
        pageInfo.setTotalRecords(count(query, collectionName));
        return getMongoTemplate().find(query.skip(pageInfo.getStartIndex()).limit(pageInfo.getResults()), poClass);

    }


    /**
     * 查询指定字段
     *
     * @param queryObject
     * @param queryField
     * @param collections
     * @return List
     */
    public List<JSONObject> findToJSONObject(JSONObject queryObject, JSONObject queryField, String collections, Sort sort) {
        Query query = new Query();
        if (queryObject != null) {
            if (queryField != null) {
                query = new BasicQuery(JSON.toJSONString(queryObject), JSON.toJSONString(queryField));
            } else {
                query = new BasicQuery(JSON.toJSONString(queryObject));
            }
        }
        if (sort != null) {
            query.with(sort);
        }
        return getMongoTemplate().find(query, JSONObject.class, collections);
    }

聚合操作：

    /**
     * 分组查询
     *
     * @param aggregation
     * @param collections
     * @param clazz
     * @param <T>
     * @return List
     */
    public <T> List<T> findByGroup(Aggregation aggregation, String collections, Class<T> clazz) {
        AggregationResults<T> result = getMongoTemplate().aggregate(aggregation, collections, clazz);
        return result.getMappedResults();
    }

count统计

 

/**
     * 统计查询
     *
     * @param query
     * @param poClass
     * @param <T>
     * @return
     */
    public <T> long count(Query query, Class<T> poClass) {
        return getMongoTemplate().count(query, poClass);
    }

    public long count(Query query, String collectionName) {
        return getMongoTemplate().count(query, collectionName);
    }

更新操作

 

 /**
     * 删除
     *
     * @param query
     * @param poClass
     * @param <T>
     * @return
     */
    public <T> int delete(Query query, Class<T> poClass) {
        DeleteResult result = getMongoTemplate().remove(query, poClass);
        return (int) result.getDeletedCount();
    }

    public int delete(Query query, String collections) {
        DeleteResult result = getMongoTemplate().remove(query, collections);
        return (int) result.getDeletedCount();
    }

    /**
     * 批量更新操作
     *
     * @param query
     * @param update
     * @param poClass
     * @param <T>
     * @return
     */
    public <T> int update(Query query, Update update, Class<T> poClass) {
        return (int) getMongoTemplate().updateMulti(query, update, poClass).getModifiedCount();
    }

    public int update(Query query, Update update, String collections) {
        return (int) getMongoTemplate().updateMulti(query, update, collections).getModifiedCount();
    }

    /**
     * 只更新符合条件的第一个
     *
     * @param query
     * @param update
     * @param collectionName
     * @return
     */
    public int updateFirst(Query query, Update update, String collectionName) {
        return (int) getMongoTemplate().updateFirst(query, update, collectionName).getModifiedCount();
    }

 

    public boolean collectionExists(String collection) {
        return getMongoTemplate().collectionExists(collection);
    }

    public String getCollectionName(Class<Employee> employeeClass) {
        return getMongoTemplate().getCollectionName(employeeClass);
    }

上面介绍了MongoTemplate API主要方法，在实际操作中，对于数据的CRUD操作都是基于上面的API，下面介绍一些聚合操作的一些方法，对于上面给出的实体类User的基本操作也可以使用以上APi方法

Aggregation聚合操作

分组条件统计

 

ProjectionOperation projectionOperation = Aggregation.project("userName","age", "sex", "userId");
MatchOperation matchOperation = Aggregation.match(Criteria.where("userId").ne(""));
GroupOperation groupOperation = Aggregation.group("userId","userName").count().as("totalUser")
        .sum(ConditionalOperators.Cond.when(Criteria.where("age").gte(20)).then(1).otherwise(0)).as("ages");
Aggregation aggregation = Aggregation.newAggregation( projectionOperation,groupOperation, matchOperation);

return mongoTemplate.aggregate(aggregation, User.class, JSONObject.class).getMappedResults();

测试输出：

{"success":true,"code":"200","msg":"操作成功","data":[{"totalUser":1,"ages":1,"_id":{"userId":"24","userName":"小王"}},{"totalUser":1,"ages":1,"_id":{"userId":"23","userName":"小王11"}},{"totalUser":4,"ages":4,"_id":{"userId":"25","userName":"小王"}},{"totalUser":3,"ages":2,"_id":{"userId":"25","userName":"小王22"}}]}

多个嵌套分组聚合操作

 @Override
    public List<JSONObject> group3() {
        ConditionalOperators.Cond cond =ConditionalOperators.Cond
                .when(Criteria.where("age").gte(20))
                .then(1).otherwise(0);
        MatchOperation matchOperation = Aggregation.match(Criteria.where("userId").ne(""));
        GroupOperation groupOperation = Aggregation.group("userId","userName").count().as("totalUser")
                .sum(cond).as("ages")
                .addToSet("sex").as("sex")
                .addToSet("birthDay").as("birthDay");

        //嵌套分组 将前面分组的ID再次分组
//        GroupOperation groupOperation1 = Aggregation.group("_id.userId").addToSet("userName").as("userName");
        //将前面分组的输出结果再次分组
        GroupOperation groupOperation1 = Aggregation.group("ages")
                .addToSet("userName").as("userName")
                .addToSet("userName").as("userName")
                .addToSet("userId").as("userId")
                //如果前面没有sex 直接使用是会包报错找不到sex字段
                .addToSet("sex").as("sex")
                .addToSet("birthDay").as("birthDay");
        Aggregation aggregation = Aggregation.newAggregation(groupOperation,groupOperation1, matchOperation);

        return mongoTemplate.aggregate(aggregation, User.class, JSONObject.class).getMappedResults();
    }

输出结果：

{
	"success": true,
	"code": "200",
	"msg": "操作成功",
	"data": [
		{
			"birthDay": [
				[
					"2020-11-20T12:02:20.000+00:00"
				]
			],
			"sex": [
				[
					"女"
				]
			],
			"_id": 4,
			"userName": [
				"小王"
			],
			"userId": [
				"25"
			]
		},
		{
			"birthDay": [
				[
					"2020-11-20T12:02:20.000+00:00"
				]
			],
			"sex": [
				[
					"女",
					"男"
				]
			],
			"_id": 2,
			"userName": [
				"小王22"
			],
			"userId": [
				"25"
			]
		},
		{
			"birthDay": [
				[
					"2020-11-20T12:02:20.000+00:00"
				]
			],
			"sex": [
				[
					"女"
				]
			],
			"_id": 1,
			"userName": [
				"小王11",
				"小王"
			],
			"userId": [
				"24",
				"23"
			]
		}
	]
}

distinct去重

    public List<String> distinct() {
        Query query = new Query();
        query.addCriteria(Criteria.where("age").ne(null));
        List<String> userNames = mongoTemplate.findDistinct(query, "userName", User.class, String.class);
        return userNames;
    }

测试输出： 

{

    "success": true,

    "code": "200",

    "msg": "操作成功",

    "data": [

        "小王",

        "小王11",

        "小王22"

    ]

}