spring boot 集成mongodb

一、相关依赖

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

二、配置文件

spring.data.mongodb.uri=mongodb://adminUser:adminPass@localhost:27017/?authSource=admin&authMechanism=SCRAM-SHA-1
spring.data.mongodb.database=users

多个 IP 集群可以采用以下配置：
spring.data.mongodb.uri=mongodb://user:pwd@ip1:port1,ip2:port2/databases

三、基本操作方法封装

package com.wcf.mongo.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.mongodb.client.ListIndexesIterable;
import com.mongodb.client.model.IndexOptions;
import com.mongodb.client.model.Indexes;
import com.wcf.mongo.entity.MongoBaseInfo;
import org.bson.Document;
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 org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @author wangcanfeng
 * @description 简单的mongodb使用接口
 * @Date Created in 17:24-2019/3/20
 */
@Service
public class SimpleMongoServiceImpl<T extends MongoBaseInfo> implements SimpleMongoService<T> {

    /**
     * 注入template，减少重复代码
     */
    @Autowired
    private MongoTemplate mongoTemplate;


    /**
     * 功能描述: 创建一个集合
     * 同一个集合中可以存入多个不同类型的对象，我们为了方便维护和提升性能，
     * 后续将限制一个集合中存入的对象类型，即一个集合只能存放一个类型的数据
     *
     * @param name 集合名称，相当于传统数据库的表名
     * @return:void
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/20 17:27
     */
    @Override
    public void createCollection(String name) {
        mongoTemplate.createCollection(name);
    }

    /**
     * 功能描述: 创建索引
     * 索引是顺序排列，且唯一的索引
     *
     * @param collectionName 集合名称，相当于关系型数据库中的表名
     * @param filedName      对象中的某个属性名
     * @return:java.lang.String
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/20 16:13
     */
    @Override
    public String createIndex(String collectionName, String filedName) {
        //配置索引选项
        IndexOptions options = new IndexOptions();
        // 设置为唯一
        options.unique(true);
        //创建按filedName升序排的索引
        return mongoTemplate.getCollection(collectionName).createIndex(Indexes.ascending(filedName), options);
    }


    /**
     * 功能描述: 获取当前集合对应的所有索引的名称
     *
     * @param collectionName
     * @return:java.util.List<java.lang.String>
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/20 16:46
     */
    @Override
    public List<String> getAllIndexes(String collectionName) {
        ListIndexesIterable<Document> list = mongoTemplate.getCollection(collectionName).listIndexes();
        //上面的list不能直接获取size，因此初始化arrayList就不设置初始化大小了
        List<String> indexes = new ArrayList<>();
        for (Document document : list) {
            document.entrySet().forEach((key) -> {
                //提取出索引的名称
                if (key.getKey().equals("name")) {
                    indexes.add(key.getValue().toString());
                }
            });
        }
        return indexes;
    }

    /**
     * 功能描述: 往对应的集合中插入一条数据
     *
     * @param info           存储对象
     * @param collectionName 集合名称
     * @return:void
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/20 16:46
     */
    @Override
    public void insert(T info, String collectionName) {
        mongoTemplate.insert(info, collectionName);
    }

    /**
     * 功能描述: 往对应的集合中批量插入数据，注意批量的数据中不要包含重复的id
     *
     * @param infos 对象列表
     * @return:void
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/20 16:47
     */
    @Override
    public void insertMulti(List<T> infos, String collectionName) {
        mongoTemplate.insert(infos, collectionName);
    }

    /**
     * 功能描述: 使用索引信息精确更改某条数据
     *
     * @param id             唯一键
     * @param collectionName 集合名称
     * @param info           待更新的内容
     * @return:void
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/20 18:42
     */
    @Override
    public void updateById(String id, String collectionName, T info) {
        Query query = new Query(Criteria.where("id").is(id));
        Update update = new Update();
        String str = JSON.toJSONString(info);
        JSONObject jQuery = JSON.parseObject(str);
        jQuery.forEach((key, value) -> {
            //因为id相当于传统数据库中的主键，这里使用时就不支持更新，所以需要剔除掉
            if (!key.equals("id")) {
                update.set(key, value);
            }
        });
        mongoTemplate.updateMulti(query, update, info.getClass(), collectionName);
    }

    /**
     * 功能描述: 根据id删除集合中的内容
     *
     * @param id             序列id
     * @param collectionName 集合名称
     * @param clazz          集合中对象的类型
     * @return:void
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/20 16:47
     */
    @Override
    public void deleteById(String id, Class<T> clazz, String collectionName) {
        // 设置查询条件，当id=#{id}
        Query query = new Query(Criteria.where("id").is(id));
        // mongodb在删除对象的时候会判断对象类型，如果你不传入对象类型，只传入了集合名称，它是找不到的
        // 上面我们为了方便管理和提升后续处理的性能，将一个集合限制了一个对象类型，所以需要自行管理一下对象类型
        // 在接口传入时需要同时传入对象类型
        mongoTemplate.remove(query, clazz, collectionName);
    }

    /**
     * 功能描述: 根据id查询信息
     *
     * @param id             注解
     * @param clazz          类型
     * @param collectionName 集合名称
     * @return:java.util.List<T>
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/20 16:47
     */
    @Override
    public T selectById(String id, Class<T> clazz, String collectionName) {
        // 查询对象的时候，不仅需要传入id这个唯一键，还需要传入对象的类型，以及集合的名称
        return mongoTemplate.findById(id, clazz, collectionName);
    }

    /**
     * 功能描述: 查询列表信息
     * 将集合中符合对象类型的数据全部查询出来
     *
     * @param collectName 集合名称
     * @param clazz       类型
     * @return:java.util.List<T>
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/21 10:38
     */
    @Override
    public List<T> selectList(String collectName, Class<T> clazz) {
        return selectList(collectName, clazz, null, null);
    }

    /**
     * 功能描述: 分页查询列表信息
     *
     * @param collectName 集合名称
     * @param clazz       对象类型
     * @param currentPage 当前页码
     * @param pageSize    分页大小
     * @return:java.util.List<T>
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/21 10:38
     */
    @Override
    public List<T> selectList(String collectName, Class<T> clazz, Integer currentPage, Integer pageSize) {
        //设置分页参数
        Query query = new Query();
        //设置分页信息
        if (!ObjectUtils.isEmpty(currentPage) && ObjectUtils.isEmpty(pageSize)) {
            query.limit(pageSize);
            query.skip(pageSize * (currentPage - 1));
        }
        return mongoTemplate.find(query, clazz, collectName);
    }


    /**
     * 功能描述: 根据条件查询集合
     *
     * @param collectName 集合名称
     * @param conditions  查询条件，目前查询条件处理的比较简单，仅仅做了相等匹配，没有做模糊查询等复杂匹配
     * @param clazz       对象类型
     * @param currentPage 当前页码
     * @param pageSize    分页大小
     * @return:java.util.List<T>
     * @since: v1.0
     * @Author:wangcanfeng
     * @Date: 2019/3/21 10:48
     */
    @Override
    public List<T> selectByCondition(String collectName, Map<String, String> conditions, Class<T> clazz, Integer currentPage, Integer pageSize) {
        if (ObjectUtils.isEmpty(conditions)) {
            return selectList(collectName, clazz, currentPage, pageSize);
        } else {
            //设置分页参数
            Query query = new Query();
            query.limit(pageSize);
            query.skip(currentPage);
            // 往query中注入查询条件
            conditions.forEach((key, value) -> query.addCriteria(Criteria.where(key).is(value)));
            return mongoTemplate.find(query, clazz, collectName);
        }
    }
}

四、连接池配置

mongodb:
 address: localhost:27017
 database: soms
 username: admin
 password: 123456
 # 连接池配置
 clientName: soms-task # 客户端的标识，用于定位请求来源等
 connectionTimeoutMs: 10000   # TCP连接超时，毫秒
 readTimeoutMs: 15000    # TCP读取超时，毫秒
 poolMaxWaitTimeMs: 3000    #当连接池无可用连接时客户端阻塞等待的时长，单位毫秒
 connectionMaxIdleTimeMs: 60000  #TCP连接闲置时间，单位毫秒
 connectionMaxLifeTimeMs: 120000  #TCP连接最多可以使用多久，单位毫秒
 heartbeatFrequencyMs: 20000   #心跳检测发送频率，单位毫秒
 minHeartbeatFrequencyMs: 8000  #最小的心跳检测发送频率，单位毫秒
 heartbeatConnectionTimeoutMs: 10000 #心跳检测TCP连接超时，单位毫秒
 heartbeatReadTimeoutMs: 15000  #心跳检测TCP连接读取超时，单位毫秒
 connectionsPerHost: 100    # 每个host的TCP连接数
 minConnectionsPerHost: 5   #每个host的最小TCP连接数
 #计算允许多少个线程阻塞等待可用TCP连接时的乘数，算法： threadsAllowedToBlockForConnectionMultiplier*connectionsPerHost，当前配置允许10*20个线程阻塞  
 threadsAllowedToBlockForConnectionMultiplier: 10

配置类

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.util.List;
@Data
@Validated
@Component
@ConfigurationProperties(prefix = "mongodb")
public class MongoClientOptionProperties {
  /** 基础连接参数 */
 private String database;
 private String username;
 private String password;
 @NotNull
 private List<String> address;
 /** 客户端连接池参数 */
 @NotNull
 @Size(min = 1)
  private String clientName;
 /** socket连接超时时间 */
 @Min(value = 1)
  private int connectionTimeoutMs;
 /** socket读取超时时间 */
 @Min(value = 1)
  private int readTimeoutMs;
 /** 连接池获取链接等待时间 */
 @Min(value = 1)
  private int poolMaxWaitTimeMs;
 /** 连接闲置时间 */
 @Min(value = 1)
  private int connectionMaxIdleTimeMs;
 /** 连接最多可以使用多久 */
 @Min(value = 1)
  private int connectionMaxLifeTimeMs;
 /** 心跳检测发送频率 */
 @Min(value = 2000)
  private int heartbeatFrequencyMs;
 /** 最小的心跳检测发送频率 */
 @Min(value = 300)
  private int minHeartbeatFrequencyMs;
 /** 计算允许多少个线程阻塞等待时的乘数，算法：threadsAllowedToBlockForConnectionMultiplier*connectionsPerHost */
 @Min(value = 1)
  private int threadsAllowedToBlockForConnectionMultiplier;
 /** 心跳检测连接超时时间 */
 @Min(value = 200)
  private int heartbeatConnectionTimeoutMs;
 /** 心跳检测读取超时时间 */
 @Min(value = 200)
  private int heartbeatReadTimeoutMs;
 /** 每个host最大连接数 */
 @Min(value = 1)
  private int connectionsPerHost;
 /** 每个host的最小连接数 */
 @Min(value = 1)
  private int minConnectionsPerHost;

连接池配置

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.data.mongodb.core.convert.*;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
import java.util.ArrayList;
import java.util.List;
@Configuration
public class MongoConfig {
  private final Logger log = LoggerFactory.getLogger(MongoConfig.class);
 /**
 * 自定义mongo连接池 * * @param properties
 * @return
 */
 @Bean
 @Autowired public MongoDbFactory mongoDbFactory(MongoClientOptionProperties properties) {
    //创建客户端参数
 MongoClientOptions options = mongoClientOptions(properties);
 //创建客户端和Factory
 List<ServerAddress> serverAddresses = new ArrayList<>();
 for (String address : properties.getAddress()) {
      String[] hostAndPort = address.split(":");
 String host = hostAndPort[0];
 int port = Integer.parseInt(hostAndPort[1]);
 ServerAddress serverAddress = new ServerAddress(host, port);
 serverAddresses.add(serverAddress);
 }
    String username = properties.getUsername();
 String password = properties.getPassword();
 String database = properties.getDatabase();
 MongoClient mongoClient;
 if (StringUtils.isNotEmpty(username) && StringUtils.isNotEmpty(password)) {
      //创建认证客户端
 MongoCredential mongoCredential = MongoCredential.createScramSha1Credential(
          username,
 database,
 password.toCharArray());
 mongoClient = new MongoClient(serverAddresses.get(0), mongoCredential, options);
 } else {
      //创建非认证客户端
 mongoClient = new MongoClient(serverAddresses, options);
 }
    SimpleMongoDbFactory mongoDbFactory = new SimpleMongoDbFactory(mongoClient, database);
 log.info("mongodb注入成功");
 return mongoDbFactory;
 }
  @Bean(name = "mongoTemplate")
  @Autowired
 public MongoTemplate getMongoTemplate(MongoDbFactory mongoDbFactory) {
    return new MongoTemplate(mongoDbFactory);
 }
  /**
 * mongo客户端参数配置 * * @return
 */
 public MongoClientOptions mongoClientOptions(MongoClientOptionProperties properties) {
    return MongoClientOptions.builder()
        .connectTimeout(properties.getConnectionTimeoutMs())
        .socketTimeout(properties.getReadTimeoutMs()).applicationName(properties.getClientName())
        .heartbeatConnectTimeout(properties.getHeartbeatConnectionTimeoutMs())
        .heartbeatSocketTimeout(properties.getHeartbeatReadTimeoutMs())
        .heartbeatFrequency(properties.getHeartbeatFrequencyMs())
        .minHeartbeatFrequency(properties.getMinHeartbeatFrequencyMs())
        .maxConnectionIdleTime(properties.getConnectionMaxIdleTimeMs())
        .maxConnectionLifeTime(properties.getConnectionMaxLifeTimeMs())
        .maxWaitTime(properties.getPoolMaxWaitTimeMs())
        .connectionsPerHost(properties.getConnectionsPerHost())
        .threadsAllowedToBlockForConnectionMultiplier(
            properties.getThreadsAllowedToBlockForConnectionMultiplier())
        .minConnectionsPerHost(properties.getMinConnectionsPerHost()).build();
 }
  @Bean
 public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory, MongoMappingContext context, BeanFactory beanFactory) {
    DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
 MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context);
 try {
      mappingConverter.setCustomConversions(beanFactory.getBean(MongoCustomConversions.class));
 } catch (NoSuchBeanDefinitionException ignore) {
    }
    // Don"t save _class to dao
 mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));
 return mappingConverter;
 }
}

五、问题集

1、mongodb 3.0认证问题

MongoDB’s implementation of SCRAM-SHA-1 represents an improvement in security over the previously-used MONGODB-CR, providing: * A tunable work factor (iterationCount), * Per-user random salts rather than server-wide salts, * A cryptographically stronger hash function (SHA-1 rather than MD5), and * Authentication of the server to the client as well as the client to the server.

MongoDB 3.0新增了一种认证机制(authenticationMechanisms) SCRAM-SHA-1, 并把他设置为默认的方式. 而Spring Boot里默认使用旧的认证机制. 这就造成了不一致从而认证通不过. 解决方法有两种:

（1） 把Mongodb的认证机制改了: mongodb支持如下几种:

SCRAM-SHA-1	
MONGODB-CR
MONGODB-X509
GSSAPI (Kerberos)
PLAIN (LDAP SASL)　　

把Mongodb的认证方式改变一下自然能解决问题. 可以同时支持多个.

setParameter:
    authenticationMechanisms: MONGODB-CR,SCRAM-SHA-1
    enableLocalhostAuthBypass: false
    logLevel: 4　　

但是既然MongoDB从3.0开始用SCRAM-SHA-1作为默认,应该是有道理的, 比如安全性方面比MONGODB-CR更好之类的.

（2）改变认证方式, 就只能改java代码了 我们看一下Spring Boot的源码; org.springframework.boot.autoconfigure.mongo.MongoProperties 的 createMongoClient方法:

public MongoClient createMongoClient(MongoClientOptions options)
		throws UnknownHostException {
	try {
		if (hasCustomAddress() || hasCustomCredentials()) {
			if (options == null) {
				options = MongoClientOptions.builder().build();
			}
			List<MongoCredential> credentials = null;
			if (hasCustomCredentials()) {
				String database = this.authenticationDatabase == null ? getMongoClientDatabase()
						: this.authenticationDatabase;
				credentials = Arrays.asList(MongoCredential.createMongoCRCredential(
						this.username, database, this.password));
			}
			String host = this.host == null ? "localhost" : this.host;
			int port = this.port == null ? DEFAULT_PORT : this.port;
			return new MongoClient(Arrays.asList(new ServerAddress(host, port)),
					credentials, options);
		}
		// The options and credentials are in the URI
		return new MongoClient(new MongoClientURI(this.uri, builder(options)));
	}
	finally {
		clearPassword();
	}
}　　

可以看到它是用MongoCredential.createMongoCRCredential方法来创建认证信息, 并且没有留出任何公开的接口让你改变这一行为. 这个真是不应该呀. 找到问题所在, 其实解决就非常方便了, 使用createScramSha1Credential方法既可.

 首先创建一个MongoDBConfiguration类, 用于创建MongoClient实例.

@Configuration
@EnableConfigurationProperties(MongoProperties.class)
public class MongoDBConfiguration {
    @Autowired
    private MongoProperties properties;
    @Autowired(required = false)
    private MongoClientOptions options;
    private Mongo mongo;
    @PreDestroy
    public void close() {
        if (this.mongo != null) {
            this.mongo.close();
        }
    }
    @Bean
    public Mongo mongo() throws UnknownHostException {
        this.mongo = this.properties.createMongoClient(this.options);
        return this.mongo;
    }
}　　

2、解决SpringBoot MongoDB插入文档默认生成_class字段问题 

@Configuration
public class SpringMongoConfig{
 
 
  @Bean
 public  MongoTemplate mongoTemplate() throws Exception {
 
    //remove _class
    MappingMongoConverter converter = 
        new MappingMongoConverter(mongoDbFactory(), new MongoMappingContext());
    converter.setTypeMapper(new DefaultMongoTypeMapper(null));
 
    MongoTemplate mongoTemplate = new MongoTemplate(mongoDbFactory(), converter);
 
    return mongoTemplate;
 
  }
 
}

3、spring boot 集成mongodb 开启事务

@Configuration
public class TransactionConfig {

    @Bean
    MongoTransactionManager transactionManager(MongoDbFactory factory){
        return new MongoTransactionManager(factory);
    }

}

六、其他学习资料参考

MongoDB中文手册|官方文档中文版