SpringBoot操作MongoDB

依赖和配置

pom.xml依赖

<!-- MongoDB -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<!-- spring Mongo配置包 -->
<dependency>
    <groupId>com.spring4all</groupId>
    <artifactId>mongodb-plus-spring-boot-starter</artifactId>
    <version>1.0.0.RELEASE</version>
</dependency>

application.properties常用配置

#MongoDB
spring:
  data:
    mongodb:
        #单机连接配置
      uri: mongodb://admin:admin@11.22.33.44:12345/cache
      #副本集连接配置
      uri: mongodb://admin:admin@11.22.33.44:12345,12.22.32.42:12345,13.23.33.43:12345/cache
      option:
        socket-timeout: 20000
        heartbeat-socket-timeout: 20000
        max-connection-per-host: 500
        threads-allowed-to-block-for-connection-multiplier: 500
        max-wait-time: 10000
        min-heartbeat-frequency: 100
        heartbeat-frequency: 10000
        max-connection-idle-time: 50000
        max-connection-life-time: 0
#配置MongoTemplate日志
logging.level.org.springframework.data.mongodb.core.MongoTemplate=DEBUG

更多配置说明

#mongo配置
#mongo服务的端口号
spring.data.mongodb.port=27017
#mongo服务的地址
spring.data.mongodb.host=xxxxxx
#mongo服务的登录名称
spring.data.mongodb.username=xxxxx
#mongo服务的密码
spring.data.mongodb.password=xxxxxxx
#此人的验证数据库
spring.data.mongodb.authentication-database=xxxxxxxx
#待连接数据库
spring.data.mongodb.database=xxxxxxxx
#mongo最大的池子数
spring.data.mongodb.option.max-connection-per-host=100
#设置允许阻塞等待连接的线程数的乘数。
spring.data.mongodb.option.threads-allowed-to-block-for-connection-multiplier=5
#套接字选择超时时间
spring.data.mongodb.option.server-selection-timeout=30000
#最大等待时间
spring.data.mongodb.option.max-wait-time=120000
#池化连接的最大空闲时间。零值表示空闲时间没有限制。超出其空闲时间的池化连接将被关闭，并在必要时由新连接替换。
spring.data.mongodb.option.max-connection-idle-time=300000
#服务器断开时间
spring.data.mongodb.option.max-connection-idle-time=300000
#连接超时实际那
spring.data.mongodb.option.connect-timeout=10000
# 设置套接字超时
spring.data.mongodb.option.socket-timeout=0
#会话一直存在的会引发socket异常
spring.data.mongodb.option.socket-keep-alive=false
#设置启用SSL
spring.data.mongodb.option.ssl-enabled=false
#定义是否允许使用无效的主机名。
spring.data.mongodb.option.ssl-invalid-host-name-allowed=false
#设置驱动程序注册的JMX bean是否应始终为MBean，无论VM是Java还是更高版本。
spring.data.mongodb.option.always-use-m-beans=false
#设置用于群集心跳的连接的套接字超时。
spring.data.mongodb.option.heartbeat-socket-timeout=20000
#设置用于群集心跳的连接的连接超时。
spring.data.mongodb.option.heartbeat-connect-timeout=20000
#设置最小心跳频率。如果驱动程序必须经常重新检查服务器的可用性，它将至少在上一次检查后等待很长时间，以避免浪费精力。默认值为500毫秒。
spring.data.mongodb.option.min-heartbeat-frequency=500
#设置心跳频率。这是驱动程序将尝试确定群集中每个服务器的当前状态的频率。默认值为10,000毫秒
spring.data.mongodb.option.heartbeat-frequency=10000
#可配置默认值为15毫秒
spring.data.mongodb.option.local-threshold=15

启动类

//重点是添加这个注解，配置才能生效 - @EnableMongoPlus
@EnableMongoPlus
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

工具类 - 常用

package cn.javaex.springboot.util;
import java.util.List;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
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.Component;

/**
 * MongoDB 工具类
 */
@Component
public class MongoDBUtils {

    public static MongoDBUtils mongoDBUtils;

    @Autowired
    private MongoTemplate mongoTemplate;

    @PostConstruct
    public void init() {
        mongoDBUtils = this;
    }

    /**
     * 保存数据对象，集合为数据对象中@Document 注解所配置的collection
     * 
     * @param obj 数据对象
     */
    public static void save(Object obj) {
        mongoDBUtils.mongoTemplate.save(obj);
    }

    /**
     * 指定集合保存数据对象
     * 
     * @param obj 数据对象
     * @param collectionName 集合名
     */
    public static void save(Object obj, String collectionName) {
        mongoDBUtils.mongoTemplate.save(obj, collectionName);
    }

    /**
     * 根据数据对象中的id删除数据，集合为数据对象中@Document 注解所配置的collection
     * 
     * @param obj 数据对象
     */
    public static void delete(Object obj) {
        mongoDBUtils.mongoTemplate.remove(obj);
    }

    /**
     * 指定集合 根据数据对象中的id删除数据
     * 
     * @param obj 数据对象
     * @param collectionName 集合名
     */
    public static void delete(Object obj, String collectionName) {
        mongoDBUtils.mongoTemplate.remove(obj, collectionName);
    }

    /**
     * 根据key，value到指定集合删除数据
     * 
     * @param key 键
     * @param value 值
     * @param collectionName 集合名
     */
    public static void deleteByKey(String key, Object value, String collectionName) {
        Query query = new Query();
        query.addCriteria(new Criteria(key).is(value));
        mongoDBUtils.mongoTemplate.remove(query, collectionName);
    }

    /**
     * 指定集合 修改数据，且仅修改找到的第一条数据
     * 
     * @param accordingKey 修改条件 key
     * @param accordingValue 修改条件 value
     * @param updateKeys 修改内容 key数组
     * @param updateValues 修改内容 value数组
     * @param collectionName 集合名
     */
    public static void updateFirst(String accordingKey, Object accordingValue,
            String[] updateKeys, Object[] updateValues, String collectionName) {
        Criteria criteria = Criteria.where(accordingKey).is(accordingValue);
        Query query = Query.query(criteria);
        Update update = new Update();
        for (int i=0; i<updateKeys.length; i++) {
            update.set(updateKeys[i], updateValues[i]);
        }
        mongoDBUtils.mongoTemplate.updateFirst(query, update, collectionName);
    }

    /**
     * 指定集合修改数据，且修改所找到的所有数据
     * 
     * @param accordingKey 修改条件 key
     * @param accordingValue 修改条件 value
     * @param updateKeys 修改内容 key数组
     * @param updateValues 修改内容 value数组
     * @param collectionName 集合名
     */
    public static void updateAll(String accordingKey, Object accordingValue,
            String[] updateKeys, Object[] updateValues, String collectionName) {
        Criteria criteria = Criteria.where(accordingKey).is(accordingValue);
        Query query = Query.query(criteria);
        Update update = new Update();
        for (int i = 0; i < updateKeys.length; i++) {
            update.set(updateKeys[i], updateValues[i]);
        }
        mongoDBUtils.mongoTemplate.updateMulti(query, update, collectionName);
    }

    /**
     * 根据条件查询出所有结果集 集合为数据对象中@Document 注解所配置的collection
     * 
     * @param obj 数据对象
     * @param findKeyArr 查询条件 key
     * @param findValueArr 查询条件 value
     * @return
     */
    public static List<? extends Object> find(Object obj, String[] findKeyArr, Object[] findValueArr) {
        Criteria criteria = null;
        for (int i=0; i<findKeyArr.length; i++) {
            if (i==0) {
                criteria = Criteria.where(findKeyArr[i]).is(findValueArr[i]);
            } else {
                criteria.and(findKeyArr[i]).is(findValueArr[i]);
            }
        }
        Query query = Query.query(criteria);
        List<? extends Object> resultList = mongoDBUtils.mongoTemplate.find(query, obj.getClass());
        return resultList;
    }

    /**
     * 指定集合 根据条件查询出所有结果集
     * 
     * @param obj 数据对象
     * @param findKeyArr 查询条件 key
     * @param findValueArr 查询条件 value
     * @param collectionName 集合名
     * @return
     */
    public static List<? extends Object> find(Object obj, String[] findKeyArr, Object[] findValueArr, String collectionName) {
        Criteria criteria = null;
        for (int i=0; i<findKeyArr.length; i++) {
            if (i==0) {
                criteria = Criteria.where(findKeyArr[i]).is(findValueArr[i]);
            } else {
                criteria.and(findKeyArr[i]).is(findValueArr[i]);
            }
        }
        Query query = Query.query(criteria);
        List<? extends Object> resultList = mongoDBUtils.mongoTemplate.find(query, obj.getClass(), collectionName);
        return resultList;
    }

    /**
     * 指定集合 根据条件查询出所有结果集 并排倒序
     * 
     * @param obj 数据对象
     * @param findKeyArr 查询条件 key
     * @param findValueArr 查询条件 value
     * @param collectionName 集合名
     * @param sort 排序字段
     * @return
     */
    public static List<? extends Object> find(Object obj, String[] findKeyArr, Object[] findValueArr, String collectionName ,String sort) {
        Criteria criteria = null;
        for (int i = 0; i < findKeyArr.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeyArr[i]).is(findValueArr[i]);
            } else {
                criteria.and(findKeyArr[i]).is(findValueArr[i]);
            }
        }
        Query query = Query.query(criteria);
        query.with(new Sort(Direction.DESC, sort));
        List<? extends Object> resultList = mongoDBUtils.mongoTemplate.find(query, obj.getClass(), collectionName);
        return resultList;
    }

    /**
     * 根据条件查询出符合的第一条数据 集合为数据对象中 @Document 注解所配置的collection
     * 
     * @param obj 数据对象
     * @param findKeyArr 查询条件 key
     * @param findValueArr 查询条件 value
     * @return
     */
    public static Object findOne(Object obj, String[] findKeyArr, Object[] findValueArr) {
        Criteria criteria = null;
        for (int i=0; i<findKeyArr.length; i++) {
            if (i==0) {
                criteria = Criteria.where(findKeyArr[i]).is(findValueArr[i]);
            } else {
                criteria.and(findKeyArr[i]).is(findValueArr[i]);
            }
        }
        Query query = Query.query(criteria);
        Object resultObj = mongoDBUtils.mongoTemplate.findOne(query, obj.getClass());
        return resultObj;
    }

    /**
     * 指定集合 根据条件查询出符合的第一条数据
     * 
     * @param obj 数据对象
     * @param findKeyArr 查询条件 key
     * @param findValueArr 查询条件 value
     * @param collectionName 集合名
     * @return
     */
    public static Object findOne(Object obj, String[] findKeyArr, Object[] findValueArr, String collectionName) {
        Criteria criteria = null;
        for (int i=0; i<findKeyArr.length; i++) {
            if (i==0) {
                criteria = Criteria.where(findKeyArr[i]).is(findValueArr[i]);
            } else {
                criteria.and(findKeyArr[i]).is(findValueArr[i]);
            }
        }
        Query query = Query.query(criteria);
        Object resultObj = mongoDBUtils.mongoTemplate.findOne(query, obj.getClass(), collectionName);
        return resultObj;
    }

    /**
     * 查询出所有结果集 集合为数据对象中 @Document 注解所配置的collection
     * 
     * @param obj 数据对象
     * @return
     */
    public static List<? extends Object> findAll(Object obj) {
        List<? extends Object> resultList = mongoDBUtils.mongoTemplate.findAll(obj.getClass());
        return resultList;
    }

    /**
     * 指定集合 查询出所有结果集
     * 
     * @param obj 数据对象
     * @param collectionName 集合名
     * @return
     */
    public static List<? extends Object> findAll(Object obj, String collectionName) {
        List<? extends Object> resultList = mongoDBUtils.mongoTemplate.findAll(obj.getClass(), collectionName);
        return resultList;
    }
}