多个数据源Mongo连接

MongoDB ：
https://my.oschina.net/u/3452433/blog/2999501
多个数据源Mongo连接：
https://juejin.im/post/5cf73090f265da1b7b317887
文档：
https://docs.spring.io/spring-data/mongodb/docs/2.1.3.RELEASE/reference/html/#mapping-usage

SpringBoot 配置多个MongoTemplate

 

前言：

Spring Boot支持应用程序中创建多个Mongo模板连接到两个不同的mongo服务器。

创建多个Mongo连接

application.properties/yml

properties:
primary.mongodb.host=<primary_mongodb_host>
primary.mongodb.port=<primary_mongodb_port>
primary.mongodb.database=<primary_mongodb_database>


secondary.mongodb.host=<secondary_mongodb_host>
secondary.mongodb.port=<secondary_mongodb_port>
secondary.mongodb.database=<secondary_mongodb_database>

yml:
primary:
    mongodb:
        host:<primary_mongodb_host>
        port:<primary_mongodb_port>
        database:<primary_mongodb_database>

secondary:
    mongodb:
        host:<secondary_mongodb_host>
        port:<primary_mongodb_port>
        database:<secondary_mongodb_database>
复制代码

创建配置类：

public abstract class AbstractMongoConfig {
    //mongodb配置属性    
    private String host, database;
    private int port;
    //Setter methods go here..     
    /*      
     * 创建MongoDBFactory的方法
     * 两个MongoDB连接共用    
     */
    public MongoDbFactory mongoDbFactory() throws Exception {
        return new SimpleMongoDbFactory(new MongoClient(host, port), database);
    }
    /*     
     * Factory method to create the MongoTemplate     
     */
    abstract public MongoTemplate getMongoTemplate() throws Exception;
}复制代码

连接配置：

//Master-MongoTemplate
@Configuration  
@ConfigurationProperties(prefix = "primary.mongodb") //前缀指向
public class CommonMongoConfig extends AbstractMongoConfig {
    /**
     * MongoTemplate实现
     * @Bean为创建的mongotemplate实例提供一个名称（primarymongotemplate）
     * @Primary 设为默认
     */
    @Primary
    @Override
    public @Bean(name = "primaryMongoTemplate") MongoTemplate getMongoTemplate() throws Exception {
        return new MongoTemplate(mongoDbFactory());
    }
}复制代码

// Slave-mongoTempalte
@Configuration 
class @ConfigurationProperties(prefix = "secondary.mongodb") //前缀映射
public class SecondaryMongoConfig extends AbstractMongoConfig {
    
    @Override public @Bean(name = "secondaryMongoTemplate")
    MongoTemplate getMongoTemplate() throws Exception {
        return new MongoTemplate(mongoDbFactory());
    }
}复制代码

使用

//Using MongoTemplate for primary database
@Autowired
@Qualifier(value = "primaryMongoTemplate") //primarymongotemplate为默认的mongotemplate
protected MongoTemplate mongoTemplate;


//Using mongoTemplate for secondary database
@Autowired
@Qualifier(value = "secondaryMongoTemplate")
protected MongoTemplate mongoTemplate;

————————————————————————————————————————————————

基于SpringBoot 框架MongoDB 一些简单的查询方式

https://www.jianshu.com/p/119b88464967

添加jar包，mingo数据库是一款分布式文件存储的数据库，不支持事务，不支持表连接。

首先导入依赖

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

jar包提供的 MongoTemplate 模板进行查询

Query ： 创建查询对象用来查询

 Criteria是标准查询的接口，可以引用静态的Criteria.where的把多个条件组合在一起，就可以轻松地将多个方法标准和查询连接起来，方便我们操作查询语句。

查询

根据关键字查询

//查询对象
Query query = new Query();
//  Criteria是标准查询的接口，可以引用静态的Criteria.where的把多个条件组合在一起，就可以轻松地将多个方法标准和查询连接起来，方便我们操作查询语句。
query.addCriteria(Criteria.where("name").is(name));
mongoTemplate.findOne(query,User.class); // 若是find()这里返回的是一个对象，查询一个用findOne()

查询多个用and连接起来即可

query.addCriteria(Criteria.where("name").is(name).and("xxx").is(xxx));

模糊查询

采用正则匹配查询

//正则  name是你需要输入的查询值
Pattern  pattern = Pattern.compile("^.*"+  name +".*$", Pattern.CASE_INSENSITIVE);
//创建查询对象
Query query = new Query();
//设置模糊查询
query.addCriteria(Criteria.where("name").regex(pattern));

或者

mongoTemplate.find(Query.query(Criteria.where("name").regex("填写匹配字符")),User.class);

正则源码方法：

//字符串
public Criteria regex(String re) {
    return this.regex(re, (String)null);
}

public Criteria regex(String re, @Nullable String options) {
    return this.regex(this.toPattern(re, options));
}
//正则表达式
public Criteria regex(Pattern pattern) {
    Assert.notNull(pattern, "Pattern must not be null!");
    if (this.lastOperatorWasNot()) {
        return this.not(pattern);
    } else {
        this.isValue = pattern;
        return this;
    }
}

public Criteria regex(BsonRegularExpression regex) {
    if (this.lastOperatorWasNot()) {
        return this.not(regex);
    } else {
        this.isValue = regex;
        return this;
    }
}

查询所有

Query query = new Query();
mongoTemplate.find(new Query(new Criteria()),User.class);

Criteria 的源代码 构造方法

public Criteria() {
    this.isValue = NOT_SET;
    this.criteriaChain = new ArrayList();
}

public Criteria(String key) {
    this.isValue = NOT_SET;
    this.criteriaChain = new ArrayList();
    this.criteriaChain.add(this);
    this.key = key;
}

new Criteria()无参的方法中没有查询条件key，表示查询全部。

大于小于，大于等于，小于等于 , 非空

大于：gt

Criteria.where("age").gt(age)

小于：lt

mongoTemplate.find(Query.query(Criteria.where("age").lt(age)),User.class);

大于等于：gte

Criteria.where("age").gte(age)

小于等于：lte

Criteria.where("age").lte(age)

非空查询 ne(不等于)

mongoTemplate.find(Query.query(Criteria.where("age").ne("").ne(null)),User.class);

排序

单个字段排序

    Query query =  new Query();
    //query.addCriteria(Criteria.where("name").is(name));
    query.with(new Sort(Sort.Direction.ASC, "age"));
    mongoTemplate.find(query,User.class);

多个不同字段排序

  query.with(new Sort(Sort.Direction.ASC, "age").and(new Sort(Sort.Direction.ASC,"xxx")));

多个字段同时升序或降序

多个字段同时升序或降序

    query.with(new Sort(Direction.ASC,"a","b","c"));

in（nin） 在指定范围内查询

in源码方法（nin 同理）

public Criteria in(Object... o) {
    if (o.length > 1 && o[1] instanceof Collection) {
        throw new InvalidMongoDbApiUsageException("You can only pass in one argument of type " + o[1].getClass().getName());
    } else {
        this.criteria.put("$in", Arrays.asList(o));
        return this;
    }
}

public Criteria in(Collection<?> c) {
    this.criteria.put("$in", c);
    return this;
}

可以是一个字符串也可以是一个集合

可以是一个字符串也可以是一个集合mongoTemplate.find(Query.query(Criteria.where("age").in("")),User.class);

分页查询

利用PageRequest对象查询

调用with方法设置分页参数

public Query with(Pageable pageable) {
    if (pageable.isUnpaged()) {
        return this;
    } else {
        this.limit = pageable.getPageSize();
        this.skip = pageable.getOffset();
        return this.with(pageable.getSort());
    }
}

利用Query对象设置查询参数

然后查询总数

public PageModel<User> findUsersByNameLike(String name, int page , int nums) {


    Pageable pageable = new PageRequest(page, page, Sort.Direction.ASC, name);


    //正则
    Pattern  pattern = Pattern.compile("^.*"+name+".*$", Pattern.CASE_INSENSITIVE);
    //创建查询对象
    Query query = new Query();

    //设置模糊查询
    query.addCriteria(Criteria.where("name").regex(pattern));
    //排序
    query.with(new Sort(Sort.Direction.ASC, "age"));
    //设置分页
    query.with(pageable);


    //查询当前页数据集合
    List<User> userList = mongoTemplate.find(query, User.class);

    //查询总记录数
    int count=(int) mongoTemplate.count(query,User.class);

    //创建分页实体对象
    PageModel<User> pageModel =new PageModel<User>();
     
     //pageable.getPageNumber();
     //pageable.getPageSize();
     
    return new PageModel<User>(userList,count,pageable);
}

分页实体

/**
 * 分页
 *
 * @author tizzy
 * @param<T>
 */
public class PageModel<T> {
    //结果集
    private List<T> datas;
    //查询总计记录数
    private Long rowCount;

    //包含页码 , 每页多少条数
    private Pageable pageable;

    public PageModel(List<T> datas, Long rowCount, Pageable pageable) {
        this.datas = datas;
        this.rowCount = rowCount;
        this.pageable = pageable;
    }
}

写文不易，小手动一动，据说长得帅的小哥哥小姐姐都关注我了。