MongoDB学习03（mongodb在java中使用）_mongocredential是在哪个版本-优快云博客

本文链接：https://blog.youkuaiyun.com/baosheng0717/article/details/88891784

本文介绍MongoDB 2.x版本的使用方法，包括非Spring环境下的连接配置及操作、Spring环境下的集成与使用，以及集群配置等内容，并详细展示了查询、更新、插入和删除等常见操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文档密级:公司内部A

Mongodb在2.x和1.x使用差异较大，本文使用2.x以上版本

1、非spring中使用（注意驱动版本）

实战中使用比较少，简单列下几个步骤：

引入

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

链接

public static MongoDatabase getConnect2() {

    List<ServerAddress> adds = new ArrayList<>();

    //ServerAddress()两个参数分别为 服务器地址 和 端口

    ServerAddress serverAddress = new ServerAddress("172.*.*.18", 27017);

    adds.add(serverAddress);

    List<MongoCredential> credentials = new ArrayList<>();

    //MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码

    MongoCredential mongoCredential = MongoCredential.createScramSha1Credential("iflytek", "admin", "iflytek123".toCharArray());

    credentials.add(mongoCredential);

    //通过连接认证获取MongoDB连接

    MongoDatabase mongoDatabase;

    MongoClientOptions.Builder options = new MongoClientOptions.Builder();

    options.connectionsPerHost(300);// 连接池设置为300个连接,默认为100

    options.connectTimeout(15000);// 连接超时，推荐>3000毫秒

    options.maxWaitTime(5000); //

    options.socketTimeout(0);// 套接字超时时间，0无限制

    options.threadsAllowedToBlockForConnectionMultiplier(5000);// 线程队列数，如果连接线程排满了队列就会抛出“Out of semaphores to get db”错误。

    options.writeConcern(WriteConcern.SAFE);//

    options.build();

    try (MongoClient mongoClient = new MongoClient(adds, credentials,options.build())) {

        //连接到数据库

        mongoDatabase = mongoClient.getDatabase("test");

    }

    //返回连接数据库对象

    return mongoDatabase;

}

3、操作(驱动版本不同,增删改查也有很大区别)

public static void main(String[] args) {

    BasicDBObject basicDBObject;

    WriteResult writeResult;

    MongoDatabase db= MongoDBUtil.getConnect2();

    MongoCollection<Document> dbCollection  = db.getCollection("test01");

    FindIterable findIterable = dbCollection.find();

    MongoCursor cursor = findIterable.iterator();

    while (cursor.hasNext()) {

        System.out.println(cursor.next());

    }

    BasicDBObject quary=new BasicDBObject();

}

2、spring版本的使用（版本2.1.3.RELEASE）

引入

<dependency>

   <groupId>org.springframework.boot</groupId>

   <artifactId>spring-boot-starter-data-mongodb</artifactId>

</dependency>

配置

@Bean
public MongoOperations mongoOperations() {
    return getMongoTemplate(applicationConfig.getSourceMongodbHost(),
            applicationConfig.getSourceMongodbPort(),
            applicationConfig.getSourceMongodbDatabase(),
            applicationConfig.getSourceMongodbUsername(),
            applicationConfig.getSourceMongodbPassword(),
            applicationConfig.getSourceMongodbAuthdatabase());
}

private MongoTemplate getMongoTemplate(String mongoHost, int mongoPort, String database, String username, String password, String authDatabase) {
    MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
    //mongo加密
    List<MongoCredential> credentials = new ArrayList<>();
    if (!StringUtils.isEmpty(username)) {
        //支持mongo3.x
        MongoCredential credential = MongoCredential.createCredential(
                username,
                StringUtils.isEmpty(authDatabase) ? database : authDatabase,
                password.toCharArray()
        );
        credentials.add(credential);
    }
    MongoClient mongoClient = new MongoClient(
            new ServerAddress(mongoHost, mongoPort),
            credentials,
            builder.build()
    );
    return new MongoTemplate(mongoClient, database);
}

使用

@Autowired
MongoOperations mongoOperations;
public void getMongoDBtestDemo(){
    MongoCollection<Document> dbCollection = mongoOperations.getCollection("test01");
    //先刷老数据
    // DBCursor dbObjects = dbCollection.find();
    //DBCursor dbObjects = dbCollection.find().sort(new BasicDBObject("$natural", -1)).skip(1).addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    FindIterable findIterable = dbCollection.find();
    MongoCursor cursor = findIterable.iterator();
    while (cursor.hasNext()) {
        System.out.println(cursor.next());
    }
}

3、集群方式

<mongo:mongo-client
        id="mongoClient"
        replica-set="${mongodb.replSet:}"
        credentials="${mongodb.username:}:${mongodb.password:}@${mongodb.authdatabase:}">
    <mongo:client-options
            connections-per-host="100"
            min-connections-per-host="5"
            threads-allowed-to-block-for-connection-multiplier="5"
            connect-timeout="30000"
            max-wait-time="30000"
            socket-keep-alive="true"
            socket-timeout="40000"
            description=" mongodb database"
            max-connection-idle-time="1500"
            max-connection-life-time="0"
            heartbeat-socket-timeout="1000"
            heartbeat-connect-timeout="1500"
            min-heartbeat-frequency="5"
            heartbeat-frequency="10"
    />
</mongo:mongo-client>

<mongo:db-factory id="mongoDbFactory" dbname="${mongodb.database:}" mongo-ref="mongoClient"/>

<mongo:template id="mongoTemplate" db-factory-ref="mongoDbFactory"/>

4、Mongo和MongoClient 两者的关系

、Mongo和MongoClient类均在mongodb驱动中定义的，因此两者都可以作为数据库连接类。

2、 MongoClient作为官方的默认连接类，其继承了mongo

3、mongo与 mongoClient相比，在写性能上较快，读性能上两者相差不大，这个的主要原因在于，两者的写策略不同

官方的建议是使用 MongoClient，如果你对写性能要求特别高，建议使用Mongo

5、查询方法

Query(spring-data-mongo提供)

org.springframework.data.mongodb.core.query

常用方法：

Query addCriteria(CriteriaDefinition criteriaDefinition)

举例：

/**
* 使用 query
*/
Query query = new Query();
query.addCriteria(Criteria.where("name").is("test"));
List<Test> testList = mongoOperations.find(query, Test.class, "test01");
for (Test test : testList) {
System.out.println(test.getName());
}

缺点：无法满足返回指定字段的要求，如果你们都是实体对象全映射返回可以使用。

BasicQuery(spring-data-mongo提供)

Query的继承类，继承了query的全部方法并实现扩展，同时提供了返回指定字段的方法

   /**

 *   BasicQuery

 */

Document dbObject = new Document();

dbObject.put("name", "1");

Document fieldObject = new Document();

fieldObject.put("name", true);

fieldObject.put("_id", true);

Query queryTmp = new BasicQuery(dbObject, fieldObject);

List<Test> testList2 = mongoOperations.find(queryTmp, Test.class, "test01");

for (Test test : testList2) {

    System.out.println(test.getName());

}

此时使用的入参是Document，每个版本的入有很大区别，请注意！

dbObject查询条件，返回字段fieldObject

BasicDBObject(mongodb-driver提供)

使用MongoCollection操作BasicDBObject,就是基本的Json字符串查询

MongoCollection<Document> dbCollection = mongoOperations.getCollection("test01");

   /**

 * 使用BasicDBObject     就是基本的Json字符串查询

 */

BasicDBObject queryObject = new BasicDBObject("name", "test");

FindIterable findIterable = dbCollection.find(queryObject).projection(new BasicDBObject().append("_id", 0).append("obj",0));;

MongoCursor cursor = findIterable.iterator();

while (cursor.hasNext()) {

    System.out.println(cursor.next());

}

projection(new BasicDBObject().append("_id", 0).append("obj",0));;返回指定字段

BasicDBList+ BasicDBObject(mongodb-driver提供)

/**
* 多条件 BasicDBList+ BasicDBObject
*/
BasicDBList basicDBList = new BasicDBList();
basicDBList.add(new BasicDBObject("name", "lfguan"));
basicDBList.add(new BasicDBObject("name", "zcy1"));
BasicDBObject objTmp = new BasicDBObject();
objTmp.put("$or", basicDBList);
FindIterable<Document> orders = dbCollection.find(objTmp);
MongoCursor curTmp = orders.iterator();
while (curTmp.hasNext()) {
System.out.println(curTmp.next());
}

复杂查询

in

query = Query.query(Criteria.where("lfguan").in(“list”));

ne(!=)

没有改字段的数据也是可以查询到的

比如disabled=true/false

可能有的数据没有disabled

query.addCriteria(Criteria.where("disabled").ne(true));

范围查询，大于5小于10

query = Query.query(Criteria.where("age").gt(5).lt(10));

模糊查询，name中包含lfguan的数据

query = Query.query(Criteria.where("name").regex("lfguan"));

数组查询，查询tags里数量为3的数据

query = Query.query(Criteria.where("tags").size(3));

or查询，查询author=jason的或者visitCount=0的数据

query = Query.query(Criteria.where("").orOperator(

Criteria.where("name").is("jason"),

Criteria.where("age").is(10)));

orOperator包含2个Criteria

6、更新

updateFirst（更新第一条）

/**
* updateFirst
*/
Query updateQuery=new Query();
updateQuery.addCriteria(Criteria.where("name").is("lfguan"));
Update updateFiles=new Update();
updateFiles.set("school","school01");
UpdateResult updateResult=mongoOperations.updateFirst(updateQuery,updateFiles,"test01");
System.out.println(updateResult.getModifiedCount());

updateQueryMulti(更新多条)

/**
* updateFilesMulti
*/
Query updateQueryMulti=new Query();
updateQuery.addCriteria(Criteria.where("name").is("lfguan"));
Update updateFilesMulti=new Update();
updateFiles.set("school","school01");
UpdateResult updateResultMulti=mongoOperations.updateMulti(updateQueryMulti,updateFilesMulti,"test01");
System.out.println(updateResultMulti.getModifiedCount());

如果更新没有字段：会添加一条字段

7、Insert（插入）

/**
* insert
*/
Test test=new Test();
test.setName("lfguan02");
Map map=new HashMap<>();
map.put("a","01");
map.put("b","02");
test.setObj(map);
mongoOperations.insert(test,"test01");

8、删除remove

/**
* remove
*/
Query removeQuery=new Query();
updateQueryMulti.addCriteria(Criteria.where("name").is("lfguan"));
DeleteResult deleteResult=mongoOperations.remove(removeQuery,"test01") ;