mongodb的简单操作以及统计查询详细使用步骤

1.首先pom文件引入mongodb的依赖

 

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

 2.application.properties配置mongodb的连接信息

#ip
spring.data.mongodb.host=10.33.43.100
#端口
spring.data.mongodb.port=7000
#数据库
spring.data.mongodb.database=pdms
#用户名
spring.data.mongodb.username=pdms_user
#密码
spring.data.mongodb.password=i9dmn4Ya

 3.封装的通用实体类，新建实体的时候继承它，自己定义需要的字段可以减少重复代码

 

package com.example.start.mongodb;

import lombok.Data;
import org.springframework.data.mongodb.core.mapping.Field;
import java.time.LocalDateTime;

/**
 * @Author luckylittle
 * @Date 12:34 2020/12/6
 * @Description
 */
@Data
public class BaseMongoEntity {
    @Field(value = "_id")
    protected String id;

    @Field(value = "insert_time")
    protected LocalDateTime insertTime;

    @Field(value = "update_time")
    protected LocalDateTime updateTime;
    
    @Field(value = "delete_status")
    protected Integer deleteStatus;

    @Field(value = "version")
    protected Integer version;
}

4.测试使用的实体类 

 

package com.example.start.mongodb;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.mongodb.core.mapping.Document;

/**
 * @Author luckylittle
 * @Date 12:34 2020/12/6
 * @Description
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Document(collection = "tb_student")
public class Student extends BaseMongoEntity {
    private String name;
    private String age;
}

 5.封装dao，一些通用的curd方法，其它DAO可以继承它，可以减少重复代码

package com.example.start.mongodb;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;

/**
 * @Author luckylittle
 * @Date 13:07 2020/12/6
 * @Description
 */
public abstract class MongoBaseAbstractDao<T> {
    @Autowired
    protected MongoTemplate mongoTemplate;

    /**
     * 钩子方法,由子类实现返回反射对象的类型
     *
     * @return
     */
    protected abstract Class<T> getEntityClass();

    /**
     * 保存或更新一个对象，
     *
     * @param t
     * @return
     */
    public void save(T t) {
        this.mongoTemplate.save(t);
    }

    /**
     * 保存一个对象
     *
     * @param t
     */
    public void insert(T t) {
        this.mongoTemplate.insert(t);
    }

    /**
     * 根据Id从Collection中查询对象
     *
     * @return
     */
    public T queryById(String id) {
        Query query = new Query();
        Criteria criteria = Criteria.where("_id").is(id);
        query.addCriteria(criteria);
        return this.mongoTemplate.findOne(query, this.getEntityClass());
    }

    public List<T> queryByIdList(Collection<String> ids) {
        Query query = new Query();
        Criteria criteria = Criteria.where("_id").in(ids);
        query.addCriteria(criteria);
        return this.mongoTemplate.find(query, this.getEntityClass());
    }

    /**
     * 根据条件查询集合
     *
     * @param query 查询条件
     * @return 满足条件的集合
     */
    public List<T> queryList(Query query) {
        return this.mongoTemplate.find(query, this.getEntityClass());
    }

    /**
     * 通过条件查询单个实体，有一个结果的话取第一个
     *
     * @param query
     * @return
     */
    public T queryOne(Query query) {
        return this.mongoTemplate.findOne(query, this.getEntityClass());
    }

    public List<T> queryAll() {
        return this.mongoTemplate.findAll(this.getEntityClass());
    }

    /**
     * 通过条件进行分页查询
     *
     * @param query 查询条件
     * @param start 查询起始值 ， 类似mysql查询中的 limit start, size 中的 start
     * @param size  查询大小 ，类似mysql查询中的 limit start, size 中的 size
     * @return 满足条件的集合
     */
    public List<T> getPage(Query query, int start, int size) {
        query.skip(start);
        query.limit(size);
        List<T> lists = this.mongoTemplate.find(query, this.getEntityClass());
        return lists;
    }


    /**
     * 根据条件查询库中符合记录的总数,为分页查询服务
     *
     * @param query 查询条件
     * @return 满足条件的记录总数
     */
    public Long getPageCount(Query query) {
        return this.mongoTemplate.count(query, this.getEntityClass());
    }

    /**
     * 根据Id删除用户
     *
     * @param id
     */
    public void deleteById(String id) {
        deleteByIds(Arrays.asList(id));
    }

    public void deleteByIds(List<String> ids) {
        Criteria criteria = Criteria.where("_id").in(ids);
        if (null != criteria) {
            Query query = new Query(criteria);
            if (null != query && this.queryOne(query) != null) {
                this.mongoTemplate.remove(query, this.getEntityClass());
            }
        }
    }

    /**
     * 删除对象
     *
     * @param t
     */
    public void delete(T t) {
        this.mongoTemplate.remove(t);
    }

    public void batchSave(List<T> list) {
        this.mongoTemplate.insertAll(list);
    }
}

 6.新建一个dao进行数据的入库的测试

 

package com.example.start.mongodb;

import org.springframework.stereotype.Repository;

import java.util.UUID;

/**
 * @Author luckylittle
 * @Date 13:10 2020/12/6
 * @Description
 */
@Repository
public class StudentDao extends MongoBaseAbstractDao<Student> {
    @Override
    protected Class<Student> getEntityClass() {
        return Student.class;
    }

    public void addStudent() {
        Student student = new Student();
        student.setId(UUID.randomUUID().toString());
        student.setName("程大侠");
        mongoTemplate.save(student);
    }
}

 7.使用mongodb数据库连接工具NoSqlBooster for MongoDb查看数据入库情况。

 

8.mongodb简单查询

 

Criteria	Mongodb	说明
Criteria and (String key)	$and	并且
Criteria andOperator (Criteria…​ criteria)	$and	并且
Criteria orOperator (Criteria…​ criteria)	$or	或者
Criteria gt (Object o)	$gt	大于
Criteria gte (Object o)	$gte	大于等于
Criteria in (Object…​ o)	$in	包含
Criteria is (Object o)	$is	等于
Criteria lt (Object o)	$lt	小于
Criteria lte (Object o)	$lte	小等于
Criteria nin (Object…​ o)	$nin	不包含

 

Query query = new Query();
Criteria criteria = Criteria.where("_id").is(id);
query.addCriteria(criteria);
LogUtils.logDebug("[Mongo Dao ]queryById:" + query);
return this.mongoTemplate.findOne(query, this.getEntityClass());

 9.mongodb聚合查询Aggregation函数的使用

 

• $project：修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
• $match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
• $limit：用来限制MongoDB聚合管道返回的文档数。
• $skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
• $unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。
• $group：将集合中的文档分组，可用于统计结果。
• $sort：将输入文档排序后输出。
• $geoNear：输出接近某一地理位置的有序文档。

        // 查询条件
        Criteria criteria = new Criteria();
        if (CollectionUtils.isNotEmpty(idList)) {
            criteria.and("point_id").in(idList);
        }
        Aggregation agg =
                Aggregation.newAggregation(
                        Aggregation.match(
                                Criteria.where("event_time_utc")
                                        .gte(DstUtils.isoToLocalTimeWithZone(dto.getBeginTime()).getTime())),
                        Aggregation.match(
                                Criteria.where("event_time_utc")
                                        .lte(DstUtils.isoToLocalTimeWithZone(dto.getEndTime()).getTime())),
                        Aggregation.match(criteria),
                        Aggregation.group("event_day").first("event_day").as("eventDay"),
                        Aggregation.sort(new Sort(Sort.Direction.ASC, "eventDay")));
        AggregationResults<RecordDto> outPut =
                mongoTemplate.aggregate(agg, "tb_record", RecordDto.class);
        List<RecordDto> list = outPut.getMappedResults();