Mongodb的简单介绍和使用

1.简介：引用官方文档的一句话

MongoDB is a document database with the scalability and flexibility that you want with the querying and indexing that you need

也就是说mongoDB 是可扩展的、灵活的、支持索引的文档数据库。

 

 

 

 

2.创建用户

（1）为mongodb穿件系统管理员，改用户可以访问其他的数据库

use admin

db.createUser(
    {
      user: "username",
      pwd: "password",
      roles: [ "root" ]
    }
（2）为xxx数据库创建用户
use xxx
db.createUser(
    {
      user: "username",
      pwd: "password",
      roles: [
         { role: "dbAdmin", db: "xxx" },
         { role: "dbOwner", db: "xxx" },
         { role: "read", db: "xxx" },
         { role: "readWrite", db: "xxx" },
         { role: "userAdmin", db: "xxx" }
      ]
    }
)

3.mongo常见客户端 工具    robot3T 是免费使用的

4.springBoot 整合mongoDB

引入依赖

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

配置类  

@Configuration
public class MongoConfig {


    // 注入配置实体
    @Autowired
    private MongoSettingsProperties mongoSettingsProperties;

    @Bean
    @ConfigurationProperties(
        prefix = "spring.data.mongodb")
    MongoSettingsProperties mongoSettingsProperties() {
        return new MongoSettingsProperties();
    }

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

        // MongoDB地址列表
        List<ServerAddress> serverAddresses = new ArrayList<>();
        for (String host : mongoSettingsProperties.getHosts()) {
            Integer index = mongoSettingsProperties.getHosts().indexOf(host);
            Integer port = mongoSettingsProperties.getPorts().get(index);

            ServerAddress serverAddress = new ServerAddress(host, port);
            serverAddresses.add(serverAddress);
        }

        // 连接认证
        List<MongoCredential> mongoCredentialList = new ArrayList<>();
        if (mongoSettingsProperties.getUsername() != null) {
            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
    public MappingMongoConverter mappingMongoConverter(MongoDbFactory mongoDbFactory, MongoMappingContext context, BeanFactory beanFactory) {
        DbRefResolver dbRefResolver = new DefaultDbRefResolver(mongoDbFactory);
        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));
        mappingConverter.setMapKeyDotReplacement("。");

        return mappingConverter;
    }
}

 读取配置文件的类

Component
@Validated
public class MongoSettingsProperties {

    @NotBlank
    private String database;

    @NotEmpty
    private List<String> hosts;

    @NotEmpty
    private List<Integer> ports;

    private String replicaSet;
    private String username;
    private String password;
    private String authenticationDatabase;
    private Integer minConnectionsPerHost = 10;
    private Integer connectionsPerHost = 20;
    private Integer maxConnectionIdleTime;
    private Integer maxConnectionLifeTime;
    private Integer connectTimeout;
    private Integer socketTimeout;

    public MongoSettingsProperties() {

    }

    public String getDatabase() {
        return database;
    }

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

    public List<String> getHosts() {
        return hosts;
    }

    public void setHosts(List<String> hosts) {
        this.hosts = hosts;
    }

    public List<Integer> getPorts() {
        return ports;
    }

    public void setPorts(List<Integer> ports) {
        this.ports = ports;
    }

    public String getReplicaSet() {
        return replicaSet;
    }

    public void setReplicaSet(String replicaSet) {
        this.replicaSet = replicaSet;
    }

    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 Integer getMinConnectionsPerHost() {
        return minConnectionsPerHost;
    }

    public void setMinConnectionsPerHost(Integer minConnectionsPerHost) {
        this.minConnectionsPerHost = minConnectionsPerHost;
    }

    public Integer getConnectionsPerHost() {
        return connectionsPerHost;
    }

    public void setConnectionsPerHost(Integer connectionsPerHost) {
        this.connectionsPerHost = connectionsPerHost;
    }

	public Integer getMaxConnectionIdleTime() {
		return maxConnectionIdleTime;
	}

	public void setMaxConnectionIdleTime(Integer maxConnectionIdleTime) {
		this.maxConnectionIdleTime = maxConnectionIdleTime;
	}

	public Integer getMaxConnectionLifeTime() {
		return maxConnectionLifeTime;
	}

	public void setMaxConnectionLifeTime(Integer maxConnectionLifeTime) {
		this.maxConnectionLifeTime = maxConnectionLifeTime;
	}

	public Integer getConnectTimeout() {
		return connectTimeout;
	}

	public void setConnectTimeout(Integer connectTimeout) {
		this.connectTimeout = connectTimeout;
	}

	public Integer getSocketTimeout() {
		return socketTimeout;
	}

	public void setSocketTimeout(Integer socketTimeout) {
		this.socketTimeout = socketTimeout;
	}
    
	
    
}

使用mongoTemplate来进行操作mongo相关的增删改查

a.查询

Query query = new Query(Criteria.where("seasonId").is(seasonId).and("sport").is("basketball"));
		//排序
		query.with(new Sort(new Order(Direction.ASC,"rank")));
		List<Map> list = mongoTemplate.find (query, Map.class,"teamseasondata");
		return list;

        //使用DBObject的实现类 
		
		BasicDBObject json1 = new BasicDBObject("seasonId",seasonId);
		BasicDBObject json2 = new BasicDBObject("sport","football");
		
		QueryBuilder queryBuilder = new QueryBuilder();
		queryBuilder.and(json1,json2);
		DBObject dbObject = queryBuilder.get();
		
	    BasicQuery query = new BasicQuery(dbObject);
	    //排序
	    query.with(new Sort(new Order(Direction.DESC,"rank")));
	    List<Map> list = mongoTemplate.find(query, Map.class,"teamseasondata");

 b.增删改

 @Autowired
    MongoTemplate mongoTemplate;

    @Override
    public void save(Object obj, String collectionName) {
        mongoTemplate.save(obj, collectionName);
    }

    @Override
    public void removeById(String id, String collectionName) {
        Query query = Query.query(Criteria.where("_id").is(id));
        mongoTemplate.remove(query, collectionName);
    }

    public void upsertId(String contentId, String collectionName) {
        Query query = Query.query(Criteria.where("_id").is(contentId));
        Update update = new Update();
        update.set("_id", contentId);
        mongoTemplate.upsert(query, update, collectionName);
    }

    @Override
    public void upsertCol(String id, String col, Object jsonStr, String collection) {
        Query query = Query.query(Criteria.where("_id").is(id));
        Update update = new Update();
        update.set(col, jsonStr);
        mongoTemplate.upsert(query, update, collection);
    }


    @Override
    public void insert(Object obj, String collectionName) {
        mongoTemplate.insert(obj, collectionName);
    }