SpringBoot集成mongoDB

由于最近做的一个项目中，数据存储时，数据的列或多或少不定，使用传统的数据库，在这种情况下，表的设计就会变的复杂而且不易维护，经过研究决定使用mongoDB这种非结构化的数据库进行数据的存储，后面在使用后发现，mongoDB使用起来还是很爽的，特别是数据存储特别的灵活，查询速度也不慢，下面就是集成mongoDB的过程。

mongoDB学习安装可参照https://www.mongodb.com/

项目是用maven搭建，所以以下集成使用的maven

1、引入mongodb包

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

2、yml文件中加入mongodb的配置

spring：
  data:
    mongodb:
      host: 192.168.100.63
      port: 27017
      username: test
      password: test
      database: test
      #authentication-database: root
      connections-per-host: 20
      min-connections-per-host: 20

3、在项目启动类中加入一下代码，不加入的话启动会报错，这是因为springboot自动配置了支持mongodb。在启动springboot时会自动实例化一个mongo实例，使用自动配置时，不会按照配置的信息来进行数据库链接，所以启动链接不到mongo会异常，有兴趣的话可以跟踪一下代码。

@SpringBootApplication(exclude = {MongoAutoConfiguration.class, MongoDataAutoConfiguration.class})

4、启动项目，启动成功，但是会出现一个问题，在使用

    @Autowired
    private MongoTemplate mongoTemplate;

时，会报找不到mongoTemplate，因为在第三步的时候，我们将自动链接配置排除了，所以没有实例可以使用，这个时候需要自己写配置。

5、添加mongo配置，让mongoclient可以读取我们自己的配置，代码如下

import lombok.Getter;
import lombok.Setter;
import org.hibernate.validator.constraints.NotBlank;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;

import java.util.List;

@Component
@Validated
@Getter
@Setter
public class MongoSettingsProperties {
    @NotBlank
    @Value("${spring.data.mongodb.database}")
    private String database;

    @NotBlank
    @Value("${spring.data.mongodb.host}")
    private String host;

    @NotBlank
    @Value("${spring.data.mongodb.port}")
    private String port;

    @Value("${spring.data.mongodb.username}")
    private String username;

    @Value("${spring.data.mongodb.password}")
    private String password;

    private String replicaSet;
    private String authenticationDatabase;
    private Integer minConnectionsPerHost = 10;
    private Integer connectionsPerHost = 2;
}

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
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.util.StringUtils;

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


@Configuration
public class MongoConfig {
    // 注入配置实体
    @Autowired
    private MongoSettingsProperties mongoSettingsProperties;
    @Bean
    @ConfigurationProperties(
            prefix = "spring.data.mongodb")
    MongoSettingsProperties mongoSettingsProperties() {
        return new MongoSettingsProperties();
    }

    // 覆盖默认的MongoDbFactory
    @Bean
    @Autowired
    MongoDbFactory mongoDbFactory() {
        //客户端配置（连接数、副本集群验证）
        MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
        builder.connectionsPerHost(mongoSettingsProperties.getConnectionsPerHost());
        builder.minConnectionsPerHost(mongoSettingsProperties.getMinConnectionsPerHost());
        if (mongoSettingsProperties.getReplicaSet() != null) {
            builder.requiredReplicaSetName(mongoSettingsProperties.getReplicaSet());
        }
        MongoClientOptions mongoClientOptions = builder.build();

        // MongoDB地址列表
        List<ServerAddress> serverAddresses = new ArrayList<>();
        String host = mongoSettingsProperties.getHost();
        String port = mongoSettingsProperties.getPort();
        ServerAddress serverAddress = new ServerAddress(host, Integer.parseInt(port));
        serverAddresses.add(serverAddress);

        // 连接认证
        ArrayList<MongoCredential> mongoCredentialList = new ArrayList<>();
        if (!StringUtils.isEmpty(mongoSettingsProperties.getUsername())) {
            mongoCredentialList.add(MongoCredential.createScramSha1Credential(
                    mongoSettingsProperties.getUsername(),
                    mongoSettingsProperties.getAuthenticationDatabase() != null ? mongoSettingsProperties.getAuthenticationDatabase() : mongoSettingsProperties.getDatabase(),
                    mongoSettingsProperties.getPassword().toCharArray()));
        }

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

        return mongoDbFactory;
    }

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

    }

6、这个时候，项目中就可以正常使用MongoTemplate了。

7、下面附上我自己写的一些简单的mongodb的增删改查工具类

import com.mongodb.WriteResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.LookupOperation;
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;
import org.springframework.util.StringUtils;

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

@Component
public class MongoDBUtil {

    public static final String MASTER_NAME = "masterTableName";
    public static final String SLAVE_NAME = "slaveTableName";
    public static final String MASTER_FIELD = "fieldForMaster";
    public static final String SLAVE_FIELD = "fieldForSlave";
    public static final String ALIAS_NAME = "resultInfoList";
    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 保存多条数据
     *
     * @param listObj 要保存的数据列表
     * @param objName 保存到数据库中的名称
     */
    public void saveObjListData(List<Map<String, Object>> listObj, String objName) {
        mongoTemplate.insert(listObj, objName);
    }

    /**
     * 保存多条数据
     *
     * @param listObj 要保存的数据列表
     * @param objName 保存到数据库中的名称
     */
    public void saveObjListDataNoType(List<Map> listObj, String objName) {
        for (Map map : listObj) {
            mongoTemplate.save(map, objName);
        }
        //mongoTemplate.insert(listObj, objName);
    }

    /**
     * 保存单条数据
     *
     * @param obj     要存的数据
     * @param objName 数据对象名称
     */
    public void saveObj(Map<String, Object> obj, String objName) {
        mongoTemplate.insert(obj, objName);
    }

    /**
     * 保存或更新
     * @param obj
     * @param objName
     */
    public void saveOrUpdateObj(Map<String, Object> obj, String objName) {
        mongoTemplate.save(obj, objName);
    }

    /**
     * @param obj     要更新的数据 key为字段 value为要更新的数据
     * @param objName 更新的数据对象名称
     * @param conMap  条件 key为字段 value为数据
     * @return
     */
    public int updateObj(Map<String, Object> obj, String objName, Map<String, Object> conMap) {
        Update update = new Update();
        Query query = new Query();
        if (conMap != null && conMap.size() != 0) {
            for (String key : conMap.keySet()) {
                query.addCriteria(Criteria.where(key).is(conMap.get(key)));
            }
        } else {
            return 0;
        }
        for (String key : obj.keySet()) {
            update.set(key, obj.get(key));
        }
        WriteResult wr = mongoTemplate.upsert(query, update, objName);
        return wr.getN();
    }


    /**
     * @param objName 要删除的数据对象名称
     * @param conMap  删除条件 key为字段名称 value为数据
     * @return
     */
    public int deleteObj(String objName, Map<String, Object> conMap) {
        Query query = new Query();
        if (conMap != null && conMap.size() != 0) {
            for (String key : conMap.keySet()) {
                query.addCriteria(Criteria.where(key).is(conMap.get(key)));
            }
        } else {
            return 0;
        }
        WriteResult wr = mongoTemplate.remove(query, objName);
        return wr.getN();
    }


    /**
     * 查询条数
     *
     * @param conMap  要查询的数据条件 key为字段名称，value为值
     * @param sortMap 要排序的字段名称 key为要排序的字段 value为（asc）升序或者（desc）降序
     * @param objName 对象名称
     * @param index   查询开始的条数
     * @param size    取多少条记录
     * @return
     */
    public List<Map> queryData(Map<String, Object> conMap, Map<String, Object> sortMap, String objName, int index, int size) {
        Query query = new Query();
        if (conMap != null) {
            conMap.remove("limit");
            conMap.remove("offset");
            for (String key : conMap.keySet()) {
                if (conMap.get(key) != null && !StringUtils.isEmpty(conMap.get(key).toString())) {
                    // query.addCriteria(Criteria.where(key).is(conMap.get(key)));
                    query.addCriteria(Criteria.where(key).regex(".*?" + conMap.get(key).toString() + ".*"));
                }
            }
        }
        if (sortMap != null) {
            for (String sort : sortMap.keySet()) {
                String value = sortMap.get(sort).toString();
                if (value.equals("desc")) {
                    query.with(new Sort(new Sort.Order(Sort.Direction.DESC, sort)));
                } else {
                    query.with(new Sort(new Sort.Order(Sort.Direction.ASC, sort)));
                }
            }
        }
        if (!(index == 0 && size == 0)) {
            query.skip(index);// 从那条记录开始
            query.limit(size);// 取多少条记录
        }

        List<Map> list = mongoTemplate.find(query, Map.class, objName);
        return list;

    }
}

整个集成过程介绍完毕