Java使用Bean注入的方式连接Mongodb以及Mongodb的数据库数据操作

关于MongoDB在java中的操作，以及引用的依赖的记录，以便于下次使用能够找到

Maven依赖：

		<dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>mongo-java-driver</artifactId>
			<version>3.10.1</version>
		</dependency>

关于连接的配置文件：

mongo.host1=192.168.4.111
mongo.host2=192.168.4.222
mongo.host3=192.168.4.333
mongo.port=27017
mongo.database=test_mongodb
mongo.user=test
mongo.password=123
mongo.connectionsPerHost=8
mongo.maxConnectionIdleTime=60000
mongo.maxConnectionLifeTime=0
mongo.threadsAllowedToBlockForConnectionMultiplier=4
mongo.connectTimeout=1500
mongo.maxWaitTime=1500
mongo.socketTimeout=1500

使用bean注入的方式连接：

import java.util.Arrays;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.WriteConcern;
import com.mongodb.client.MongoDatabase;
@Configuration
@PropertySource(value = "classpath:mongodb.properties")
@Component
public class MongoConf {
	@Value("${mongo.host1}")
	private String host1;
	@Value("${mongo.host2}")
	private String host2;
	@Value("${mongo.host3}")
	private String host3;
	@Value("${mongo.port}")
	private Integer port;
	@Value("${mongo.database}")
	private String database;
	@Value("${mongo.collections}")
	private String collections;
	@Value("${mongo.user}")
	private String userName;
	@Value("${mongo.password}")
	private String password;
	@Value("${mongo.connectionsPerHost}")
	private Integer connectionsPerHost;
	@Value("${mongo.maxConnectionIdleTime}")
	private Integer maxConnectionIdleTime;
	@Value("${mongo.maxConnectionLifeTime}")
	private Integer maxConnectionLifeTime;
	@Value("${mongo.threadsAllowedToBlockForConnectionMultiplier}")
	private Integer threadsAllowedToBlockForConnectionMultiplier;
	@Value("${mongo.connectTimeout}")
	private Integer connectTimeout;
	@Value("${mongo.maxWaitTime}")
	private Integer maxWaitTime;
	@Value("${mongo.socketTimeout}")
	private Integer socketTimeout;
	
	
		@Bean
	public MongoClient mongoClient() {
			MongoClient mongoClient = new MongoClient(Arrays.asList(new ServerAddress(host1,port), 
													new ServerAddress(host2,port), 
													new ServerAddress(host3,port)),
				 					 MongoCredential.createCredential(userName, database, password.toCharArray()),
				 					 MongoClientOptions.builder()
					 					.connectionsPerHost(connectionsPerHost)
					 					.writeConcern(WriteConcern.ACKNOWLEDGED)
					 					.maxConnectionIdleTime(maxConnectionIdleTime)
					 					.maxConnectionLifeTime(maxConnectionLifeTime)
					 					.threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlockForConnectionMultiplier)
					 					.connectTimeout(connectTimeout)
					 					.maxWaitTime(maxWaitTime)
					 					.socketTimeout(socketTimeout)
					 					.build()
				 					);
			return mongoClient;
	}
	@Bean
	public MongoDatabase mongoDatabase(MongoClient mongoClient) {
		MongoDatabase mongoDatabase = mongoClient.getDatabase("ht_for_web");
		return mongoDatabase;
	}
//-------------------------如果用到多个数据库，可以不写下面两个，根据情况创建
	@Bean
	public MongoCollection<Document> mongoCollection(MongoDatabase mongoDatabase){
		MongoCollection<Document> collection=mongoDatabase.getCollection(collections);
		return collection;
	}
	//关于mongodb的事务
	 @Bean
    public ClientSession clientSession(MongoClient mongoClient) {	
    	ClientSession clientSession = mongoClient.startSession();
 	  	return clientSession;
	}
}

1、插入

		//插入单个
		JSONObject obj = new JSONObject();
		obj.put("id",1);//插入的数据
		Document document = Document.parse(obj.toJSONString());
		collections.insertOne(document);
		//插入多个，将JSON依次遍历转为Document然后依次存入List
		Document document = Document.parse(obj.toJSONString());
		List<Document> list = new ArrayList<>();
		list.add(document)
		collections.insertMany(list);

2、更新

		//---------------更新单个
		JSONObject rootNode = new JSONObject();
		Document update = new Document();
		Document document = Document.parse(rootNode.toJSONString());
		update.append("$set", document);
		UpdateResult result = collections.updateOne(Filters.eq("_id",1))), update);

		//---------------更新多个
        //注意update文档里要包含"$set"字段
        Document update = new Document();
        update.append("$set", new Document("test", "1"));
        //Filters.eq(key, value)是查询条件
        UpdateResult result = collections.updateMany(Filters.eq(key, value), update);
        System.out.println("matchedCount = " + result.getMatchedCount());
	
		//---------------更新整个文档
        //注意：更新文档时，不需要使用"$set"
        Document replacement = new Document();
        replacement.append("value", 123);
        //Filters.eq(key, value)是查询条件
        collections.replace(Filters.eq(key, value), replacement);

3、删除

		//------------根据条件删除一条信息
       collections.deleteOne(Filters.eq(key, value));
		//------------根据条件删除多条信息
        collections.deleteMany(Filters.eq(key, value));

4、查询

		//----------查询所有
		 collections.find();
		//---------查询单个
		 collections.find(Filters.eq(key, value));

除了这些查询，mongodb的管道操作比较复杂，使用Studio 3T的Aggregate的功能，可以得到简单操作mongodb的管道，并且可以生成java等代码。