Spring Boot MongoDB 使用MongoTemplate 操作

Spring Boot 集成MongoDB 

1、在POM中添加mongoDB支持

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

2、在application.porperties 配置文件中配置mongodb的连接信息

#mongo
spring.data.mongodb.database= #数据库
spring.data.mongodb.host=#地址
spring.data.mongodb.username=#用户名
spring.data.mongodb.password=#密码
spring.data.mongodb.port=#端口

3、创建Mongodb工具类

package com.ydrt.cp.mapper.mongo;

import com.ydrt.cp.util.PageBean;
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 org.springframework.data.mongodb.core.query.Update;

import java.lang.reflect.ParameterizedType;
import java.util.List;

/**
 * Stone.Cai
 * 2020年6月2日13:46:09
 * 添加
 * mongo 工具
 * @param <T>
 */
public class MongoBaseDao<T> {


    /**
     * Stone.Cai
     * 2020年6月3日17:08:47
     * 添加
     * 注入工具
     */
    @Autowired
    protected MongoTemplate mongoTemplate;



    /**
     * Stone.Cai
     * 2020年6月2日13:54:39
     * 添加
     * 根据查询条件查询信息
     * @param query
     * @return
     */
    public List<T> find(Query query) {
        return mongoTemplate.find(query, this.getEntityClass());
    }


    /**
     * Stone.Cai
     * 2020年6月2日13:56:01
     * 添加
     * 指定表查询数据
     * @param query
     * @param collectionName
     * @return
     */
    public List<T> find(Query query, String collectionName) {
        return mongoTemplate.find(query, this.getEntityClass(), collectionName);
    }


    /**
     * Stone.Cai
     * 2020年6月2日13:56:59
     * 添加
     * 通过唯一条件查询一条数据
     * @param query
     * @return
     */
    public T findOne(Query query) {
        return mongoTemplate.findOne(query, this.getEntityClass());
    }

    /**
     * Stone.Cai
     * 2020年6月2日13:57:34
     * 添加
     * 根据唯一条件指定表查询一条数据
     * @param query
     * @param collectionName
     * @return
     */
    public T findOne(Query query, String collectionName) {
        return mongoTemplate.findOne(query, this.getEntityClass(), collectionName);
    }


    /**
     * Stone.Cai
     * 2020年6月2日13:58:50
     * 添加
     * 通过条件更新数据
     * @param query
     * @param update
     */
    public void update(Query query, Update update) {
        mongoTemplate.findAndModify(query, update, this.getEntityClass());
    }


    /**
     * Stone.Cai
     * 2020年6月2日13:59:51
     * 添加
     * 根据查询条件指定表更新数据
     * @param query
     * @param update
     * @param collectionName
     */
    public void update(Query query, Update update, String collectionName) {
        mongoTemplate.findAndModify(query, update, this.getEntityClass(), collectionName);
    }


    /**
     * Stone.Cai
     * 2020年6月2日14:00:38
     * 添加
     * 根据数据id 这里是指的MONGO自己生成的ID
     * @param id
     * @param collectionName
     */
    public void removeById(String id, String collectionName){
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").is(id));
        mongoTemplate.remove(query, collectionName);
    }


    /**
     * Stone.Cai
     * 2020年6月2日14:29:32
     * 添加
     * 根据_id删除
     * @param id
     */
    public void removeById(String id){
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").is(id));
        mongoTemplate.remove(query);
    }


    /**
     * Stone.Cai
     * 2020年6月2日14:31:01
     * 添加
     * 根据条件进行删除
     * @param query
     */
    public void removeByQuery(Query query){
        mongoTemplate.findAndRemove(query,this.getEntityClass());
    }


    /**
     * Stone.Cai
     * 2020年6月2日14:31:57
     * 添加
     * 根据条件进行删除 并指定表
     * @param query
     * @param collectionName
     */
    public void removeByQuery(Query query, String collectionName){
        mongoTemplate.findAndRemove(query,this.getEntityClass(),collectionName);
    }




    /**
     * Stone.Cai
     * 2020年6月2日13:53:26
     * 添加
     * 获取当前要操作的实体类
     * @return
     */
    public Class<T> getEntityClass(){
        Class<T> tClass = (Class<T>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        return tClass;
    }

    /**
     * Stone.Cai
     * 2020年6月2日14:01:36
     * 添加
     * 保存一个对象到MONGO
     * @param entity
     * @return
     */
    public T save(T entity) {
        mongoTemplate.save(entity);
        return entity;
    }

    /**
     * Stone.Cai
     * 2020年6月2日14:02:07
     * 添加
     * 保存一个对象并指定表保存对象到MONGO
     * @param entity
     * @param collectionName
     * @return
     */
    public T save(T entity, String collectionName) {
        mongoTemplate.insert(entity, collectionName);
        return entity;
    }


    /**
     * Stone.Cai
     * 2020年6月2日14:03:03
     * 添加
     * 根据ID查询 这里ID指的是mongo自己生成的id
     * @param id
     * @return
     */
    public T findById(String id) {
        return mongoTemplate.findById(id, this.getEntityClass());
    }


    /**
     * Stone.Cai
     * 2020年6月2日14:04:26
     * 添加
     *  根据ID查询 并指定表 这里ID指的是mongo自己生成的id
     * @param id
     * @param collectionName
     * @return
     */
    public T findById(String id, String collectionName) {
        return mongoTemplate.findById(id, this.getEntityClass(), collectionName);
    }


    /**
     * Stone.Cai
     * 2020年6月2日14:05:19
     * 添加
     * 根据条件查询数据条数
     * @param query
     * @return
     */
    public long count(Query query){
        return mongoTemplate.count(query, this.getEntityClass());
    }

    /**
     * Stone.Cai
     * 2020年6月2日14:05:19
     * 添加
     * 根据条件查询数据条数指定表
     * @param query
     * @return
     */
    public long count(Query query, String collectionName){
        return mongoTemplate.count(query, this.getEntityClass(), collectionName);
    }


    /**
     * Stone.Cai
     * 2020年6月2日14:08:17
     * 添加
     * 分页查询
     * @param page
     * @param query
     * @return
     */
    public PageBean findPage(PageBean page, Query query){
        long count = this.count(query);
        page.setResourceSize(count);
        int pageNumber = page.getCurrentPage();
        int pageSize = page.getPageSize();
        query.skip((pageNumber - 1) * pageSize).limit(pageSize);
        List<T> rows = this.find(query);
        page.setData(rows);
        return page;
    }


    /**
     * Stone.Cai
     * 2020年6月2日14:08:17
     * 添加
     * 分页查询 区分表名
     * @param page
     * @param query
     * @return
     */
    public PageBean findPage(PageBean page, Query query, String collectionName){
        long count = this.count(query);
        page.setResourceSize(count);
        int pageNumber = page.getCurrentPage();
        int pageSize = page.getPageSize();
        query.skip((pageNumber - 1) * pageSize).limit(pageSize);
        List<T> rows = this.find(query,collectionName);
        page.setData(rows);
        return page;
    }





}

4、有了工具类就可以操作MongoDB了,我们这边写一个服务来继承这个工具在服务里写我们的逻辑。在这之前我们还是要和hibernate一样配置一下我们的实体类

实体类USER Class 和Base  user 和Class 是一对一关系 Class 和user 是一对多的关系

package com.ydrt.cp.bean.mongo;

import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.DBRef;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

import java.util.Date;

/**
 * Stone.Cai
 * 2020年6月2日09:53:32
 * 添加
 * 用户数据
 */
@Document(collection = "user_info") //指定表
public class MongoUsers extends MongoBase {


    @Indexed //这个表示在这个字段上创建索引
    @Field("userId")
    private Long userId;


    @Field("userName")
    private String username;

    @Field("password")
    private String password;

    @Field("del")
    private Boolean del;

    @Field("userInfo") //这个是内置了一个对象和其他字段是一样的
    private MongoUserInfo userInfo;


    @DBRef //这个表示这个类引用了下面这个类的这样写应该是一对一吧
    private MongoClassInfo classInfo;

    private Date createDate=new Date();



    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Boolean getDel() {
        return del;
    }

    public void setDel(Boolean del) {
        this.del = del;
    }

    public MongoUserInfo getUserInfo() {
        return userInfo;
    }

    public void setUserInfo(MongoUserInfo userInfo) {
        this.userInfo = userInfo;
    }

    public MongoClassInfo getClassInfo() {
        return classInfo;
    }

    public void setClassInfo(MongoClassInfo classInfo) {
        this.classInfo = classInfo;
    }
}

package com.ydrt.cp.bean.mongo;

import org.apache.commons.lang3.StringUtils;
import org.springframework.data.annotation.Id;

import java.util.UUID;

/**
 * Stone.Cai
 * 2020年6月3日17:17:09
 * 添加
 * BASE
 */
public class MongoBase {

    @Id //这个是指定数据的ID在mongo里如果有这字段会mongo就不会自动创建id了
    private String id;

    public String getId() {
        if(StringUtils.isBlank(id)){
            return  UUID.randomUUID().toString().replaceAll("-","");
        }
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

package com.ydrt.cp.bean.mongo;

import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.DBRef;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

import java.util.List;

@Document(collection = "class_info")
public class MongoClassInfo extends MongoBase {


    @Indexed
    @Field("classId")
    private Long classId;

    @Indexed
    @Field("className")
    private String className;

    @DBRef
    private List<MongoUsers> usersList;

    public Long getClassId() {
        return classId;
    }

    public void setClassId(Long classId) {
        this.classId = classId;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public List<MongoUsers> getUsersList() {
        return usersList;
    }

    public void setUsersList(List<MongoUsers> usersList) {
        this.usersList = usersList;
    }
}

5、创建一个用户服务

package com.ydrt.cp.service;

import com.ydrt.cp.bean.mongo.MongoClassInfo;
import com.ydrt.cp.bean.mongo.MongoUsers;
import com.ydrt.cp.mapper.mongo.MongoBaseDao;
import com.ydrt.cp.util.ResultData;
import org.springframework.beans.factory.annotation.Autowired;
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 java.util.List;

/**
 * Stone.Cai
 * 2020年6月1日17:16:21
 * 添加
 * mongo 服务
 */
@Service
public class MongoUserService extends MongoBaseDao<MongoUsers> {


    @Autowired
    private MongoClassService mongoClassService;

    /**
     * Stone.Cai
     * 2020年6月2日14:19:31
     * 添加
     * 保存一个对象到MONGO
     * @param users
     * @return
     */
    public ResultData saveUser(MongoUsers users){
        //查询id是否已存在
        Query query=new Query();
        Criteria criteria = Criteria.where("userId").is(users.getUserId());
        query.addCriteria(criteria);
        List<MongoUsers> list= this.find(query);
        if(list.size()!=0){
            return ResultData.error("用户数据已存在！");
        }
//这个地方在保存用户的时候需要把CLASS的引用放入
        MongoClassInfo classInfo= mongoClassService.findMongoClassInfoByClassId(users.getClassInfo());
        users.setClassInfo(classInfo);
        this.save(users);
        return ResultData.success();
    }

    /**
     * Stone.Cai
     * 2020年6月2日14:33:19
     * 添加
     * 根据Id删除数据
     * @return
     */
    public ResultData remvoeUsersByUserId(MongoUsers users){
        Query query=new Query();
        query.addCriteria(Criteria.where("userId").is(users.getUserId()));
        this.removeByQuery(query);
        return ResultData.success();
    }

    /**
     * Stone.Cai
     * 2020年6月2日17:21:43
     * 添加
     * 更新用户信息
     * @param users
     * @return
     */
    public  ResultData updateMongUserById(MongoUsers users){
        Query query = new Query(Criteria.where("userId").is(users.getUserId()));
        Update update =new Update();
        update.set("del","0");
        update.set("username",users.getUsername());
         this.update(query,update);
         return ResultData.success();
    }


    /**
     * Stone.Cai
     * 2020年6月3日10:38:37
     * 添加
     * 获取用户信息根据ID
     * @param users
     * @return
     */
    public ResultData findUserByUserId(MongoUsers users){
        Query query = new Query(Criteria.where("userId").is(users.getUserId()));
        MongoUsers  users1= this.findOne(query);
        return ResultData.success(users1);
    }

/**
     * Stone.Cai
     * 2020年6月3日10:38:37
     * 添加
     * 获取用户信息昵称获取
     * @param users
     * @return
     */
    public ResultData findUserByNickName(MongoUsers users){
        Query query = new Query(Criteria.where("userInfo.nickName").is(users.getUserInfo().getNickName()));
        MongoUsers  users1= this.findOne(query);
        return ResultData.success(users1);
    }

}

package com.ydrt.cp.service;

import com.ydrt.cp.bean.mongo.MongoClassInfo;
import com.ydrt.cp.bean.mongo.MongoUsers;
import com.ydrt.cp.mapper.mongo.MongoBaseDao;
import com.ydrt.cp.util.ResultData;
import org.bson.types.ObjectId;
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 java.util.Collections;
import java.util.List;

/**
 * Stone.Cai
 * 2020年6月3日10:27:34
 * 添加
 * 班级
 */
@Service
public class MongoClassService extends MongoBaseDao<MongoClassInfo> {


    /**
     * Stone.Cai
     * 2020年6月3日10:29:31
     * 添加
     * 保存班级
     * @param classInfo
     * @return
     */
    public ResultData saveMongoClassInfo(MongoClassInfo classInfo){
        Query query=new Query();
//这里的查询是或者的关系 就是className 存在或是classId 存在就会提示数据存在
        query.addCriteria(new Criteria().orOperator(Criteria.where("className").is(classInfo.getClassName()),Criteria.where("classId").is(classInfo.getClassId())));
        List<MongoClassInfo> list= this.find(query);
        if(list.size()!=0){
            return ResultData.error("班级已存在！");
        }
        classInfo.setUsersList(Collections.emptyList());
        this.save(classInfo);
        return ResultData.success();
    }


    /**
     * Stone.Cai
     * 根据ClassId获取班级数据
     * @param classInfo
     * @return
     */
    public MongoClassInfo findMongoClassInfoByClassId(MongoClassInfo classInfo){
        Query query=new Query();
        Criteria criteria = Criteria.where("classId").is(classInfo.getClassId());
        query.addCriteria(criteria);
        MongoClassInfo classInfo1= this.findOne(query);
//这里先把班级查询出来 在根据id把班级下用户数据查询出来
        Query userquery=new Query();
        userquery.addCriteria(Criteria.where("classInfo.$id").is(new ObjectId(classInfo1.getId())));
        classInfo1.setUsersList(mongoTemplate.find(userquery, MongoUsers.class));
        return classInfo1;
    }


    /**
     * Stone.Cai
     * 2020年6月3日15:36:36
     * 添加
     * 根据ID获取班级信息
     * @param classInfo
     * @return
     */
    public ResultData findMongoClassInfoByClassIdResult(MongoClassInfo classInfo){
        return ResultData.success(findMongoClassInfoByClassId(classInfo));
    }



 /**
     * Stone.Cai
     * 2020年6月4日09:22:43
     * 添加
     * 根据名称模糊搜索
     * @param classInfo
     * @return
     */
    public ResultData findMongoClassInfoByNameLike(MongoClassInfo classInfo){
        Query query=new Query();
        query.addCriteria(Criteria.where("className").regex(".*?"+classInfo.getClassName()+".*"));
        return ResultData.success(this.find(query),this.count(query));
    }

/**
     * Stone.Cai
     * 2020年6月4日09:38:12
     * 添加
     * 使用IN查询数据
     * @param classInfo
     * @return
     */
    public ResultData findMongoClassInfoByClassIdIn(List<MongoClassInfo> classInfo){
        List<Long> ids=new ArrayList<>();
        for (MongoClassInfo mongoClassInfo : classInfo) {
            ids.add(mongoClassInfo.getClassId());
        }
        Query query=new Query();
        query.addCriteria(Criteria.where("classId").in(ids));
        return ResultData.success(this.find(query),this.count(query));
    }

/**
     * Stone.Cai
     * 2020年6月4日10:00:10
     * 添加
     * 分页查询
     * @param pageBean
     * @param classInfo
     * @return
     */
    public ResultData findClassInfoPage(PageBean pageBean,MongoClassInfo classInfo){
        Query query=new Query();
      return  ResultData.success(this.findPage(pageBean,query));
    }


    


}