（十）springboot整合mongo多数据源

介绍 ： 在当前流行的NoSql数据库中，MongoDB是大家接触比较早和用的比较多的数据库。MongoDB是文档型的NoSql数据库，具有大数据量、高并发等优势，但缺点是不能建立实体关系，而且也没有事物管理机制。

1 引入maven依赖

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

lombok 的介紹可以看这篇博客lombok介绍

2 创建mongo.properties

这里的mongo.properties你也可以不创建，放在springboot默认的application.properties中也可以，这是在真实的项目实战中是需要很多配置的，如果都写在application.properties中，这样会显得很臃肿，所以我还是习惯性的单独提取出来吧，我还是讲mongo.porperties放在resouce根下的config中。

spring.data.test.mongodb.uri=mongodb://ctxxxx:Forxxxxxx2017@101.xx.x.xx:54341/mj_xxxx
spring.data.dev.mongo.uri=mongodb://maxxx:maxxxx@101.xx.xx.xx:54345/maxxxx

这里只有两个配置一个test，一个dev上面mongo的链接信息你替换成你自己的就可以了

3创建mongo实体类

     package com.lqf.springbootlearn.domain.mongo;


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

import java.io.Serializable;

/**
 * @description  : mongo中代理表实体
 * @author : lqf
 * @date : Create in 16:00 2018/5/9
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Document(collection = "mj_console_users")
public class ConsoleUser implements Serializable {

    private static final long serialVersionUID = -1L;

    /**
     * 主键
     */
    @Field("_id")
    private Integer id;

    /**
     * 电话
     */
    @Field("tel")
    private String tel;

    /**
     * 名称
     */
    @Field("name")
    private String name;

    /**
     * 密码
     */
    @Field("passwd")
    private String passwd;

    /**
     * 初始密码
     */
    @Field("init_pass")
    private String initPass;

    /**
     * 创建时间
     */
    @Field("create_time")
    private Long createTime;

    /**
     * 省
     */
    @Field("province")
    private String province;

    /**
     * 市
     */
    @Field("city")
    private String city;

    /**
     * 区
     */
    @Field("country")
    private String district;

    /**
     * 角色
     */
    @Field("role")
    private Integer role;

    /**
     * 房卡
     */
    @Field("numof_cards_2")
    private Integer numofCards2;

    /**
     * 是否赠送
     */
    @Field("can_give")
    private Boolean canGive;

    /**
     * 是否客服开通
     */
    @Field("is_kefu")
    private Boolean isKefu;

    /**
     * 渠道
     */
    @Field("qudao")
    private String qudao;

    /**
     * 代理星级
     */
    @Field("star")
    private Integer star;

    /**
     * 详细地址
     */
    @Field("addr")
    private String addr;

    /**
     * 微信
     */
    @Field("wechat")
    private String wechat;

    /**
     * 推荐人id
     */
    @Field("referrer_uid")
    private Integer referrerUid;

    /**
     * 父级id
     */
    @Field("parent_id")
    private Integer parentId;

    /**
     * 推荐人
     */
    @Field("referrer")
    private String referrer;

    /**
     * disable为true代理已封禁，反之
     */
    @Field("disable")
    private Boolean disable;

    /**
     * 客服id
     */
    @Field("n_kf_id")
    private String nKfId;

    /**
     * 推广员id
     */
    @Field("n_tgy_id")
    private String nTgyId;

    /**
     * 身份证正面存储位置
     */
    @Field("cardjustUrl")
    private String cardjustUrl;

    /**
     * 身份证背面存储位置
     */
    @Field("cardbackUrl")
    private String cardbackUrl;

    /**
     * 身份证号
     */
    @Field("idcard")
    private String idcard;

    /**
     * 是否进行了手机验证
     */
    @Field("mobile_verify")
    private Boolean mobileVerify;

    /**
     * 是否有自助充值功能
     */
    @Field("disable_zizhu")
    private Boolean disableZizhu;

    /**
     * 分支
     */
    @Field("branch")
    private Boolean branch;

    /**
     * 是否官方
     */
    @Field("is_official")
    private Boolean isOfficial;

    /**
     * 新代理赠卡true为怎送过
     */
    @Field("given_card")
    private Boolean givenCard;
}

4 数据源一

package com.lqf.springbootlearn.config.mongo;

import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientURI;
import com.mongodb.ReadPreference;
import org.springframework.boot.autoconfigure.mongo.MongoProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.*;
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.repository.config.EnableMongoRepositories;

/**
 * @Description : test mongo配置
 * @Author : lqf
 * @Date : Create in 14:10 2018/5/9
 */
@SuppressWarnings("ALL")
@Configuration
@PropertySource("classpath:config/mongo.properties")
@EnableMongoRepositories(mongoTemplateRef = "testMongoTemplate")
public class TestMongoConfig {

    @Primary
    @Bean
    @ConfigurationProperties(prefix = "spring.data.test.mongodb")
    public MongoProperties teMongoProperties() {
        return new MongoProperties();
    }

    @Primary
    @Bean(name = "testMongoTemplate")
    public MongoTemplate testMongoTemplate() throws Exception {
        return new MongoTemplate(testFactory(teMongoProperties()), MongoTemplateHolder.mongoConverter());
    }

    @Primary
    public MongoDbFactory testFactory(MongoProperties mongoProperties) throws Exception {
        MongoClientOptions.Builder options = new MongoClientOptions.Builder();
        options.readPreference(ReadPreference.secondary());
        options.connectionsPerHost(10);
        return new SimpleMongoDbFactory(new MongoClientURI(teMongoProperties().getUri(), options));
    }
}

5 数据源二

package com.lqf.springbootlearn.config.mongo;

import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientURI;
import com.mongodb.ReadPreference;
import org.springframework.boot.autoconfigure.mongo.MongoProperties;
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.context.annotation.PropertySource;
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.repository.config.EnableMongoRepositories;

/**
 * @Description : dev mongo配置
 * @Author : lqf
 * @Date : Create in 14:10 2018/5/9
 */
@SuppressWarnings("ALL")
@Configuration
@PropertySource("classpath:config/mongo.properties")
@EnableMongoRepositories(mongoTemplateRef = "devMongoTemplate")
public class DevMongoConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.data.dev.mongodb")
    public MongoProperties teMongoProperties() {
        return new MongoProperties();
    }

    @Bean(name = "devMongoTemplate")
    public MongoTemplate devMongoTemplate() throws Exception {
        return new MongoTemplate(devFactory(teMongoProperties()), MongoTemplateHolder.mongoConverter());
    }

    public MongoDbFactory devFactory(MongoProperties mongoProperties) throws Exception {
        MongoClientOptions.Builder options = new MongoClientOptions.Builder();
        options.readPreference(ReadPreference.secondary());
        options.connectionsPerHost(10);
        return new SimpleMongoDbFactory(new MongoClientURI(teMongoProperties().getUri(), options));
    }
}

6 获取指定数据源工具类

package com.lqf.springbootlearn.config.mongo;


import com.mongodb.DBCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

/**
 * @Description : mongo所有地区模板工具类
 * @Author : lqf
 * @Date : Create in 19:45 2018/5/9
 */
@Component
public class MongoTemplateHolder implements ApplicationContextAware {

    final static Logger logger = LoggerFactory.getLogger(MongoTemplateHolder.class);

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (MongoTemplateHolder.applicationContext == null) {
            MongoTemplateHolder.applicationContext = applicationContext;
        }
    }

    /**
     * 获取容器
     *
     * @return ApplicationContext
     */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 获取MongoTemplate模板
     *
     * @param source 数据源（你想要获取的数据源）
     * @return MongoTemplate
     */
    public static MongoTemplate getBean(String source) {

        if (StringUtils.isEmpty(source)) {
            logger.error("=========空的source不能获取mongoTemple=========");
            return null;
        }
        String beanName = source + "MongoTemplate";

        return (MongoTemplate) getApplicationContext().getBean(beanName);
    }

    /**
     * @param source 数据源
     * @param name 数据库名称
     * @return MongoCollection
     */
    public static DBCollection getCollection(String source, String name) {

        if (StringUtils.isEmpty(source)) {
            logger.error("=========空的source不能获取mongoTemple=========");
            return null;
        }
        if (StringUtils.isEmpty(name)) {
            logger.error("=========空的表名称不能获取MongoCollection<Document>=========");
//            throw new ValidateException(HttpCode.BAD_REQUEST, "无法获取集合！");
            //获取不到数据源的时候不能返回空应该抛出特定异常，这里为了方便直接返回null
            return null;
        }
        String beanName = source + "MongoTemplate";
        MongoTemplate template = (MongoTemplate) getApplicationContext().getBean(beanName);
        return template.getCollection(name);
    }

    public static MappingMongoConverter mongoConverter() {
        return (MappingMongoConverter) getApplicationContext().getBean("mongoConverter");
    }
}

7 mongo class 转换工具类

package com.lqf.springbootlearn.config.mongo;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.convert.*;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;

@Configuration
public class MongoClassConverter {

    @Bean(name = "mongoConverter")
    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(CustomConversions.class));
        } catch (NoSuchBeanDefinitionException ignore) {
        }

        // Don't save _class to mongo
        mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));

        return mappingConverter;
    }

}

你们可能会说上面的转换工具类是什么意思， 如果不写这个转换工具类你在通过mongoTempleate默认向表中插入数据的时候会在表中多一个_class的字段，通过这个转换类转换后不会出现这个_class字段。到这里位置mongo的多数据源配置就算完成了。每个人的业务需求可能是不一样的，我的业务需要是需要20多的mongo 数据源的，所以我不能通过springboot jpa的形式去实现，那样就太啰嗦了，如果你们的数据源比较少也可以通过jpa的形式去实现。下面随便测下链接就可以了，具体的操作就不测试了

@Test
    public void contextLoads() {

        MongoTemplate template = MongoTemplateHolder.getBean("test");
        List<ConsoleUser> consoleUsers = template.find(Query.query(new Criteria().and("_id").is(72178)), ConsoleUser.class);
        System.out.println(consoleUsers);
    }

谢谢下篇再见！