springboot整合mongo多数据源

该实例已测试

POM.XML

 <!-- Spring Boot mongodb 依赖-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-mongodb</artifactId>
 </dependency>

application.yml

  data:
         mongodb:
             primary:
                 uri: 192.168.0.103:27870
                 database:
                 username:
                 password:
                 authentication-database:
             second:
                 uri: 192.168.0.103:27870
                 database:
                 username:
                 password:
                 authentication-database:
             connectionsPerHost: 10
             options:
                 min-connections-per-host: 8
                 threads-allowed-to-block-for-connection-multiplier: 4
                 max-wait-time: 1500
                 socket-timeout: 1500

AbstractMongoConfig

 package com.haoyun.common.config.mongo;

 import com.mongodb.MongoClient;
 import com.mongodb.MongoClientOptions;
 import com.mongodb.MongoCredential;
 import com.mongodb.ServerAddress;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.mongodb.MongoDbFactory;
 import org.springframework.data.mongodb.core.SimpleMongoDbFactory;

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

 public class AbstractMongoConfig {

     protected List<String>    uri;
     protected String          username;
     protected String          password;
     protected String          authenticationDatabase;
     protected String          database;

     @Value("${spring.data.mongodb.connectionsPerHost}")
     private Integer connectionsPerHost;

     @Value("${spring.data.mongodb.options.min-connections-per-host}")
     private Integer minConnectionsPerHost;

     @Value("${spring.data.mongodb.options.threads-allowed-to-block-for-connection-multiplier}")
     private Integer threadsAllowedToBlockForConnectionMultiplier;

     @Value("${spring.data.mongodb.options.max-wait-time}")
     private Integer maxWaitTime;

     @Value("${spring.data.mongodb.options.socket-timeout}")
     private Integer socketTimeout;

     //覆盖默认的MongoDbFacotry
     public MongoDbFactory mongoDbFactory() {
         //客户端配置（连接数、副本集群验证）
         MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
         builder.connectionsPerHost(this.connectionsPerHost);
         builder.minConnectionsPerHost(this.minConnectionsPerHost);
         builder.threadsAllowedToBlockForConnectionMultiplier(this.threadsAllowedToBlockForConnectionMultiplier);
         builder.maxWaitTime(this.maxWaitTime);
         builder.socketTimeout(this.socketTimeout);

         MongoClientOptions mongoClientOptions = builder.build();

         List<ServerAddress> serverAddresses = new ArrayList<>();
         List<String> address = this.uri;
         for (String add : address) {
             String[] str = add.split(":");
             ServerAddress serverAddress = new ServerAddress(str[0], Integer.parseInt(str[1]));
             serverAddresses.add(serverAddress);
         }

         // 连接认证
         List<MongoCredential> mongoCredentialList = new ArrayList<>();
         if (this.username != null) {
             mongoCredentialList.add(MongoCredential.createScramSha1Credential(
                     this.username,
                     this.authenticationDatabase != null ? this.authenticationDatabase : this.database,
                     this.password.toCharArray()));
         }
         System.out.println("mongoCredentialList:" + mongoCredentialList.toString());

         //创建客户端和Factory
         MongoClient mongoClient = new MongoClient(serverAddresses, mongoCredentialList, mongoClientOptions);
         MongoDbFactory mongoDbFactory = new SimpleMongoDbFactory(mongoClient, this.database);

         return mongoDbFactory;
     }

     public List<String> getUri() {
         return uri;
     }

     public void setUri(List<String> uri) {
         this.uri = uri;
     }

     public String getUsername() {
         return username;
     }

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

     public String getPassword() {
         return password;
     }

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

     public String getAuthenticationDatabase() {
         return authenticationDatabase;
     }

     public void setAuthenticationDatabase(String authenticationDatabase) {
         this.authenticationDatabase = authenticationDatabase;
     }

     public String getDatabase() {
         return database;
     }

     public void setDatabase(String database) {
         this.database = database;
     }
 }

PrimaryMongoConfig

 package com.haoyun.common.config.mongo;

 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
 import org.springframework.data.mongodb.core.MongoTemplate;

 /**
  * @author milicool
  * Created on 2018/11/26
  */
 @Configuration
 @ConfigurationProperties(prefix = "spring.data.mongodb.primary")
 public class PrimaryMongoConfig extends AbstractMongoConfig {

     @Primary
     @Bean(name = "mongoTemplate")
     public MongoTemplate getMongoTemplate() {
         return new MongoTemplate(mongoDbFactory());
     }
 }

SecondMongoConfig

 package com.haoyun.common.config.mongo;

 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.mongodb.core.MongoTemplate;

 /**
  * @author milicool
  * Created on 2018/11/26
  */
 @Configuration
 @ConfigurationProperties(prefix="spring.data.mongodb.second")
 public class SecondMongoConfig extends AbstractMongoConfig {

     @Bean(name = "secondMmongoTemplate")
     public MongoTemplate getMongoTemplate() {
         return new MongoTemplate(mongoDbFactory());
     }
 }

MongoDao

 package com.haoyun.common.jdbc;

 import com.mongodb.client.result.UpdateResult;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.aggregation.Aggregation;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.stereotype.Repository;

 import javax.annotation.Resource;
 import java.util.List;

 @Repository("mongoDao")
 public class MongoDao {

     @Resource(name = "mongoTemplate")
     private MongoTemplate mongoTemplate;

     public void insert(Object o, String collectionName) {
         mongoTemplate.insert(o, collectionName);
     }

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

     public <T> List<T> findAll(Query query, String collectionName, Class<T> clazz) {
         return mongoTemplate.find(query, clazz, collectionName);
     }

     public int update(Query query, Update update, String collectionName) {
         UpdateResult writeResult = mongoTemplate.upsert(query, update, collectionName);
         return (int) writeResult.getModifiedCount();
     }

     public void createCollection(String collectionName) {
         mongoTemplate.createCollection(collectionName);
     }

     public <T> void remove(Query query, String collectionName) {
         mongoTemplate.remove(query, collectionName);
     }

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

     public <T> T findAndModify(Query query, Update update, String collectionName, Class<T> clazz) {
         return mongoTemplate.findAndModify(query, update, clazz, collectionName);
     }

     public <T> List<T> findAggregation(Aggregation agg, String collectionName, Class<T> clazz) {
         return mongoTemplate.aggregate(agg, collectionName, clazz).getMappedResults();
     }

 }

SecondMongoDao

package com.haoyun.common.jdbc;

import com.mongodb.client.result.UpdateResult;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.util.List;

@Repository("secondMongoDao")
public class SecondMongoDao {

    @Resource(name = "secondMmongoTemplate")
    private MongoTemplate mongoTemplate;

    public void insert(Object o, String collectionName) {
        mongoTemplate.insert(o, collectionName);
    }

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

    public <T> List<T> findAll(Query query, String collectionName, Class<T> clazz) {
        return mongoTemplate.find(query, clazz, collectionName);
    }

    public int update(Query query, Update update, String collectionName) {
        UpdateResult writeResult = mongoTemplate.upsert(query, update, collectionName);
        return (int) writeResult.getModifiedCount();
    }

    public void createCollection(String collectionName) {
        mongoTemplate.createCollection(collectionName);
    }

    public <T> void remove(Query query, String collectionName) {
        mongoTemplate.remove(query, collectionName);
    }

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

    public <T> T findAndModify(Query query, Update update, String collectionName, Class<T> clazz) {
        return mongoTemplate.findAndModify(query, update, clazz, collectionName);
    }

    public <T> List<T> findAggregation(Aggregation agg, String collectionName, Class<T> clazz) {
        return mongoTemplate.aggregate(agg, collectionName, clazz).getMappedResults();
    }

}

引入

测试

结语

有两处不爽的地方，为啥加一个数据源就要多个config和Dao, 所有的都公用一个行不行？（待优化）

长路漫漫, 走过了村落, 却忘记了你的脸庞