java 连接mongodb

 

java mongo 驱动API   http://mongodb.github.io/mongo-java-driver/

 

maven中添加依赖

http://mongodb.github.io/mongo-java-driver/

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<dependencies>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongodb-driver</artifactId>
        <version>3.4.1</version>
    </dependency>
</dependencies>
<dependencies>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>bson</artifactId>
        <version>3.4.1</version>
    </dependency>
</dependencies>

　　

JavaProject

连接数据库

连接数据库，你需要指定数据库名称，如果指定的数据库不存在，mongo会自动创建数据库。

连接数据库的Java代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
 
public class MongoDBJDBC{
   public static void main( String args[] ){
      try{  
       // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
        
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol"); 
       System.out.println("Connect to database successfully");
         
      }catch(Exception e){
        System.err.println( e.getClass().getName() + ": " + e.getMessage() );
     }
   }
}

　　

现在，让我们来编译运行程序并连接到数据库 mycol。

你可以根据你的实际环境改变 MongoDB JDBC 驱动的路径。

本实例将 MongoDB JDBC 启动包 mongo-java-driver-3.2.2.jar 放在本地目录下:

?
1
2
3
4
$ javac -cp .:mongo-java-driver-3.2.2.jar MongoDBJDBC.java
$ java -cp .:mongo-java-driver-3.2.2.jar MongoDBJDBC
Connect to database successfully
Authentication: true

　　

本实例中 Mongo 数据库无需用户名密码验证。如果你的 Mongo 需要验证用户名及密码，可以使用以下代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
package com.iwhere.rongyun.config;
 
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
 
import java.util.ArrayList;
import java.util.List;
 
import org.apache.commons.lang3.StringUtils;
import org.bson.Document;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
 
@Configuration
public class MongoConfig {
    private static Logger LOGGER = LoggerFactory.getLogger(MongoConfig.class);
     
    @Value("${mongodb.hostports}")
    private String hostports;
     
    @Value("${mongodb.maxConnect}")
    private String maxConnect;
    @Value("${mongodb.maxWaitThread}")
    private String maxWaitThread;
    @Value("${mongodb.maxTimeOut}")
    private String maxTimeOut;
    @Value("${mongodb.maxWaitTime}")
    private String maxWaitTime;
     
    @Value("${mongodb.username}")
    private String username;
    @Value("${mongodb.password}")
    private String password;
    @Value("${mongodb.database}")
    private String database;
    @Value("${mongodb.collection")
    private String collection;
     
     
    @Bean
    public MongoClient mongoClient() {
        MongoClient mongoClient = null;
         
        MongoClientOptions.Builder build = new MongoClientOptions.Builder(); 
        build.connectionsPerHost(Integer.valueOf(maxConnect)); 
        build.threadsAllowedToBlockForConnectionMultiplier(Integer.valueOf(maxWaitThread)); 
        build.connectTimeout(Integer.valueOf(maxTimeOut) * 1000); 
        build.maxWaitTime(Integer.valueOf(maxWaitTime) * 1000); 
        MongoClientOptions options = build.build(); 
         
        try {
            List<ServerAddress> addrs = new ArrayList<ServerAddress>(); 
            for (String hostport : hostports.split(", *")) {
                if (StringUtils.isBlank(hostport)) {
                    continue;
                }
                hostport = hostport.trim();
                 
                ServerAddress serverAddress = new ServerAddress(hostport.split(":")[0],Integer.valueOf(hostport.split(":")[1]));
                addrs.add(serverAddress); 
            }
               
            MongoCredential credential = MongoCredential.createScramSha1Credential(username, database, password.toCharArray()); 
            List<MongoCredential> credentials = new ArrayList<MongoCredential>(); 
            credentials.add(credential);
             
            mongoClient = new MongoClient(addrs,credentials, options);
             
            LOGGER.info("【mongodb client】: mongodb客户端创建成功");
        } catch (Exception e) {
            LOGGER.error("【mongodb client】: mongodb客户端创建成功");
            e.printStackTrace();
        }
        return mongoClient;
    }
     
    @Bean
    public MongoDatabase mongoDatabase(MongoClient mongoClient) {
         MongoDatabase mongoDatabase = mongoClient.getDatabase(database);
         return mongoDatabase;
    }
     
    @Bean
    public MongoCollection<Document> mongoCollection(MongoDatabase mongoDatabase) {
        MongoCollection<Document> mongoCollection = mongoDatabase.getCollection(collection);
        return mongoCollection;
    }
     
}

　　通过spring配置文件注入所需的值即可, mondb.properties为: 

mongodb.hostports=192.168.51.100:2,192.168.51.101:533,192.168.51.102:21
mongodb.maxConnect=50
mongodb.maxWaitThread=50
mongodb.maxTimeOut=60
mongodb.maxWaitTime=60
mongodb.username=name
mongodb.password=pass
mongodb.database=data
mongodb.collection=user_rongyun

 

 

创建集合

我们可以使用 com.mongodb.client.MongoDatabase 类中的createCollection()来创建集合

代码片段如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
 
public class MongoDBJDBC{
   public static void main( String args[] ){
      try{  
      // 连接到 mongodb 服务
      MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
          
        
      // 连接到数据库
      MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol"); 
      System.out.println("Connect to database successfully");
      mongoDatabase.createCollection("test");
      System.out.println("集合创建成功");
         
      }catch(Exception e){
        System.err.println( e.getClass().getName() + ": " + e.getMessage() );
     }
   }
}

　　

获取集合

我们可以使用com.mongodb.client.MongoDatabase类的 getCollection() 方法来获取一个集合

代码片段如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
 
public class MongoDBJDBC{
   public static void main( String args[] ){
      try{  
       // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
        
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol"); 
       System.out.println("Connect to database successfully");
       
       MongoCollection<Document> collection = mongoDatabase.getCollection("test");
       System.out.println("集合 test 选择成功");
      }catch(Exception e){
        System.err.println( e.getClass().getName() + ": " + e.getMessage() );
     }
   }
}

　　

插入文档

我们可以使用com.mongodb.client.MongoCollection类的 insertMany() 方法来插入一个文档

代码片段如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.util.ArrayList;
import java.util.List;
import org.bson.Document;
 
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
 
public class MongoDBJDBC{
   public static void main( String args[] ){
      try{  
         // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
          
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol"); 
         System.out.println("Connect to database successfully");
          
         MongoCollection<Document> collection = mongoDatabase.getCollection("test");
         System.out.println("集合 test 选择成功");
         //插入文档 
         /**
         * 1. 创建文档 org.bson.Document 参数为key-value的格式
         * 2. 创建文档集合List<Document>
         * 3. 将文档集合插入数据库集合中 mongoCollection.insertMany(List<Document>) 插入单个文档可以用 mongoCollection.insertOne(Document)
         * */
         Document document = new Document("title", "MongoDB"). 
         append("description", "database"). 
         append("likes", 100). 
         append("by", "Fly"); 
         List<Document> documents = new ArrayList<Document>(); 
         documents.add(document); 
         collection.insertMany(documents); 
         System.out.println("文档插入成功"); 
      }catch(Exception e){
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      }
   }
}

　　编译运行以上程序，输出结果如下:

?
1
2
3
Connect to database successfully
集合 test 选择成功
文档插入成功

　　

检索所有文档

我们可以使用 com.mongodb.client.MongoCollection 类中的 find() 方法来获取集合中的所有文档。

此方法返回一个游标，所以你需要遍历这个游标。

代码片段如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
 
public class MongoDBJDBC{
   public static void main( String args[] ){
      try{  
         // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
          
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol"); 
         System.out.println("Connect to database successfully");
          
         MongoCollection<Document> collection = mongoDatabase.getCollection("test");
         System.out.println("集合 test 选择成功");
          
         //检索所有文档 
         /**
         * 1. 获取迭代器FindIterable<Document>
         * 2. 获取游标MongoCursor<Document>
         * 3. 通过游标遍历检索出的文档集合
         * */ 
         FindIterable<Document> findIterable = collection.find(); 
         MongoCursor<Document> mongoCursor = findIterable.iterator(); 
         while(mongoCursor.hasNext()){ 
            System.out.println(mongoCursor.next()); 
         } 
       
      }catch(Exception e){
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      }
   }
}

　　

更新文档

你可以使用 com.mongodb.client.MongoCollection 类中的 updateMany() 方法来更新集合中的文档。

代码片段如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
 
public class MongoDBJDBC{
   public static void main( String args[] ){
      try{  
         // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
          
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol"); 
         System.out.println("Connect to database successfully");
          
         MongoCollection<Document> collection = mongoDatabase.getCollection("test");
         System.out.println("集合 test 选择成功");
          
         //更新文档   将文档中likes=100的文档修改为likes=200  
         collection.updateMany(Filters.eq("likes", 100), new Document("$set",new Document("likes",200))); 
         //检索查看结果 
         FindIterable<Document> findIterable = collection.find(); 
         MongoCursor<Document> mongoCursor = findIterable.iterator(); 
         while(mongoCursor.hasNext()){ 
            System.out.println(mongoCursor.next()); 
         } 
       
      }catch(Exception e){
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      }
   }
}

　　

删除第一个文档

要删除集合中的第一个文档，首先你需要使用com.mongodb.DBCollection类中的 findOne()方法来获取第一个文档，然后使用remove 方法删除。

代码片段如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
 
public class MongoDBJDBC{
   public static void main( String args[] ){
      try{  
         // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
 
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol"); 
         System.out.println("Connect to database successfully");
 
         MongoCollection<Document> collection = mongoDatabase.getCollection("test");
         System.out.println("集合 test 选择成功");
 
         //删除符合条件的第一个文档 
         collection.deleteOne(Filters.eq("likes", 200)); 
         //删除所有符合条件的文档 
         collection.deleteMany (Filters.eq("likes", 200)); 
         //检索查看结果 
         FindIterable<Document> findIterable = collection.find(); 
         MongoCursor<Document> mongoCursor = findIterable.iterator(); 
         while(mongoCursor.hasNext()){ 
           System.out.println(mongoCursor.next()); 
         } 
            
      }catch(Exception e){
        System.err.println( e.getClass().getName() + ": " + e.getMessage() );
     }
   }
}

　　

使用dbCollection进行操作

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
package com.iwhere.test2;
 
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;
 
import org.bson.types.ObjectId;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.mongodb.core.MongoTemplate;
 
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.QueryBuilder;
import com.mongodb.QueryOperators;
 
public class MongoDBTest {
    Mongo mongo = null;
    DB db = null;
    DBCollection userCollection = null;
 
    private MongoTemplate mongoTemplate;
 
    @Before
    public void setUp() throws Exception {
        // 创建一个MongoDB的数据库连接对象，无参数的话它默认连接到当前机器的localhost地址，端口是27017。
//        mongo = new Mongo("192.168.225.101", 27017);
        // 得到一个test的数据库，如果mongoDB中没有这个数据库，当向此库中添加数据的时候会自动创建
//        db = mongo.getDB("test");
//        db.authenticate("test", "test".toCharArray());
        // 获取到一个叫做"user"的集合，相当于关系型数据库中的"表"
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-mvc-servlet.xml");
        mongoTemplate = (MongoTemplate) context.getBean("mongoTemplate");
        userCollection = mongoTemplate.getCollection("user");
    }
 
    /**
     * 查询所有的集合名称
     */
    public void testGetAllCollections() {
        Set<String> collectionNames = db.getCollectionNames();
        for (String name : collectionNames) {
            System.out.println("collectionName:" + name);
        }
    }
 
    /**
     * 查询所有的用户信息
     */
    @Test
    public void testFind() {
        testInitTestData();
        // find方法查询所有的数据并返回一个游标对象
        DBCursor cursor = userCollection.find();
 
        while (cursor.hasNext()) {
            print(cursor.next());
        }
        // 获取数据总条数
        int sum = cursor.count();
        System.out.println("sum===" + sum);
    }
 
    /**
     * 查询第一条数据
     */
    public void testFindOne() {
        testInitTestData();
        // 只查询第一条数据
        DBObject oneUser = userCollection.findOne();
        print(oneUser);
    }
 
    /**
     * 条件查询
     */
    public void testConditionQuery() {
        testInitTestData();
        // 查询id=50a1ed9965f413fa025166db
        DBObject oneUser = userCollection.findOne(new BasicDBObject("_id", new ObjectId("50a1ed9965f413fa025166db")));
        print(oneUser);
 
        // 查询age=24
        List<DBObject> userList1 = userCollection.find(new BasicDBObject("age", 24)).toArray();
        print("        find age=24: ");
        printList(userList1);
 
        // 查询age>=23
        List<DBObject> userList2 = userCollection.find(new BasicDBObject("age", new BasicDBObject("$gte", 23))).toArray();
        print("        find age>=23: ");
        printList(userList2);
 
        // 查询age<=20
        List<DBObject> userList3 = userCollection.find(new BasicDBObject("age", new BasicDBObject("$lte", 20))).toArray();
        print("        find age<=20: ");
        printList(userList3);
 
        // 查询age!=25
        List<DBObject> userList4 = userCollection.find(new BasicDBObject("age", new BasicDBObject("$ne", 25))).toArray();
        print("        find age!=25: ");
        printList(userList4);
 
        // 查询age in[23,24,27]
        List<DBObject> userList5 = userCollection
                .find(new BasicDBObject("age", new BasicDBObject(QueryOperators.IN, new int[] { 23, 24, 27 })))
                .toArray();
        print("        find agein[23,24,27]: ");
        printList(userList5);
 
        // 查询age not in[23,24,27]
        List<DBObject> userList6 = userCollection
                .find(new BasicDBObject("age", new BasicDBObject(QueryOperators.NIN, new int[] { 23, 24, 27 })))
                .toArray();
        print("        find age not in[23,24,27]: ");
        printList(userList6);
 
        // 查询29>age>=20
        List<DBObject> userList7 = userCollection.find(new BasicDBObject("age", new BasicDBObject("$gte", 20).append("$lt", 29)))
                .toArray();
        print("        find 29>age>=20: ");
        printList(userList7);
 
        // 查询age>24 and name="zhangguochen"
        BasicDBObject query = new BasicDBObject();
        query.put("age", new BasicDBObject("$gt", 24));
        query.put("name", "zhangguochen");
        List<DBObject> userList8 = userCollection.find(query).toArray();
        print("        find age>24 and name='zhangguochen':");
        printList(userList8);
 
        // 和上面的查询一样,用的是QueryBuilder对象
        QueryBuilder queryBuilder = new QueryBuilder();
        queryBuilder.and("age").greaterThan(24);
        queryBuilder.and("name").equals("zhangguochen");
        List<DBObject> userList82 = userCollection.find(queryBuilder.get()).toArray();
        print("        QueryBuilder find age>24 and name='zhangguochen':");
        printList(userList82);
 
        // 查询所有的用户，并按照年龄升序排列
        List<DBObject> userList9 = userCollection.find().sort(new BasicDBObject("age", 1)).toArray();
        print("        find all sort age asc: ");
        printList(userList9);
 
        // 查询特定字段
        DBObject query1 = new BasicDBObject();// 要查的条件
        query.put("age", new BasicDBObject("$gt", 20));
        DBObject field = new BasicDBObject();// 要查的哪些字段
        field.put("name", true);
        field.put("age", true);
        List<DBObject> userList10 = userCollection.find(query1, field).toArray();
        print("        select name,age where age>20");
        printList(userList10);
 
        // 查询部分数据
        DBObject query2 = new BasicDBObject();// 查询条件
        query2.put("age", new BasicDBObject("$lt", 27));
        DBObject fields = new BasicDBObject();// 查询字段
        fields.put("name", true);
        fields.put("age", true);
        List<DBObject> userList11 = userCollection.find(query2, fields, 1, 1).toArray();
        print("        select age,name from user skip 1 limit 1:");
        printList(userList11);
 
        // 模糊查询
        DBObject fuzzy_query = new BasicDBObject();
        String keyWord = "zhang";
        Pattern pattern = Pattern.compile("^" + keyWord + ".*$", Pattern.CASE_INSENSITIVE);
        fuzzy_query.put("name", pattern);
        // 根据name like zhang%查询
        List<DBObject> userList12 = userCollection.find(fuzzy_query).toArray();
        print("        select * from user where name like 'zhang*'");
        printList(userList12);
 
    }
 
    /**
     * 删除用户数据
     */
    public void testRemoveUser() {
        testInitTestData();
        DBObject query = new BasicDBObject();
        // 删除age>24的数据
        query.put("age", new BasicDBObject("$gt", 24));
        userCollection.remove(query);
        printList(userCollection.find().toArray());
    }
 
    /**
     * 修改用户数据
     */
    public void testUpdateUser() {
 
        // update(query,set,false,true);
        // query:需要修改的数据查询条件,相当于关系型数据库where后的语句
        // set:需要设的值,相当于关系型数据库的set语句
        // false:需要修改的数据如果不存在,是否插入新数据,false不插入,true插入
        // true:如果查询出多条则不进行修改,false:只修改第一条
 
        testInitTestData();
 
        // 整体更新
        DBObject query = new BasicDBObject();
        query.put("age", new BasicDBObject("$gt", 15));
        DBObject set = userCollection.findOne(query);// 一定是查询出来的DBObject,否则会丢掉一些列,整体更新
        set.put("name", "Abc");
        set.put("age", 19);
        set.put("interest", new String[] { "hadoop", "study", "mongodb" });
        DBObject zhangguochenAddress = new BasicDBObject();
        zhangguochenAddress.put("address", "henan");
        set.put("home", zhangguochenAddress);
        userCollection.update(query, // 需要修改的数据条件
                set, // 需要赋的值
                false, // 数据如果不存在,是否新建
                false);// false只修改第一条,true如果有多条就不修改
        printList(userCollection.find().toArray());
 
        // 局部更新,只更改某些列
        // 加上$set会是局部更新,不会丢掉某些列,只把name更新为"jindazhong",年龄更新为123
        BasicDBObject set1 = new BasicDBObject("$set", new BasicDBObject("name", "jindazhong").append("age", 123));
        userCollection.update(query, // 需要修改的数据条件
                set1, // 需要赋的值
                false, // 数据如果不存在,是否新建
                false);// false只修改第一条,true如果有多条就不修改
        printList(userCollection.find().toArray());
 
        // 批量更新
        // user.updateMulti(new BasicDBObject("age",new
        // BasicDBObject("$gt",16)),
        // new BasicDBObject("$set", new
        // BasicDBObject("name","jindazhong").append("age", 123)));
        // printList(user.find().toArray());
 
    }
 
    /**
     * 初始化测试数据
     */
    public void testInitTestData() {
        userCollection.drop();
        DBObject zhangguochen = new BasicDBObject();
        zhangguochen.put("name", "zhangguochen");
        zhangguochen.put("age", 25);
        zhangguochen.put("interest", new String[] { "hadoop", "study", "mongodb" });
        DBObject zhangguochenAddress = new BasicDBObject();
        zhangguochenAddress.put("address", "henan");
        zhangguochen.put("home", zhangguochenAddress);
 
        DBObject jindazhong = new BasicDBObject();
        jindazhong.put("name", "jindazhong");
        jindazhong.put("age", 21);
        jindazhong.put("interest", new String[] { "hadoop", "mongodb" });
        jindazhong.put("wife", "小龙女");
        DBObject jindazhongAddress = new BasicDBObject();
        jindazhongAddress.put("address", "shanghai");
        jindazhong.put("home", jindazhongAddress);
 
        DBObject yangzhi = new BasicDBObject();
        yangzhi.put("name", "yangzhi");
        yangzhi.put("age", 22);
        yangzhi.put("interest", new String[] { "shopping", "sing", "hadoop" });
        DBObject yangzhiAddress = new BasicDBObject();
        yangzhiAddress.put("address", "hubei");
        yangzhi.put("home", yangzhiAddress);
 
        DBObject diaoyouwei = new BasicDBObject();
        diaoyouwei.put("name", "diaoyouwei");
        diaoyouwei.put("age", 23);
        diaoyouwei.put("interest", new String[] { "notejs", "sqoop" });
        DBObject diaoyouweiAddress = new BasicDBObject();
        diaoyouweiAddress.put("address", "shandong");
        diaoyouwei.put("home", diaoyouweiAddress);
 
        DBObject cuichongfei = new BasicDBObject();
        cuichongfei.put("name", "cuichongfei");
        cuichongfei.put("age", 24);
        cuichongfei.put("interest", new String[] { "ebsdi", "dq" });
        cuichongfei.put("wife", "凤姐");
        DBObject cuichongfeiAddress = new BasicDBObject();
        cuichongfeiAddress.put("address", "shanxi");
        cuichongfei.put("home", cuichongfeiAddress);
 
        DBObject huanghu = new BasicDBObject();
        huanghu.put("name", "huanghu");
        huanghu.put("age", 25);
        huanghu.put("interest", new String[] { "shopping", "study" });
        huanghu.put("wife", "黄蓉");
        DBObject huanghuAddress = new BasicDBObject();
        huanghuAddress.put("address", "guangdong");
        huanghu.put("home", huanghuAddress);
 
        DBObject houchangren = new BasicDBObject();
        houchangren.put("name", "houchangren");
        houchangren.put("age", 26);
        houchangren.put("interest", new String[] { "dota", "dq" });
        DBObject houchangrenAddress = new BasicDBObject();
        houchangrenAddress.put("address", "shandong");
        houchangren.put("home", houchangrenAddress);
 
        DBObject wangjuntao = new BasicDBObject();
        wangjuntao.put("name", "wangjuntao");
        wangjuntao.put("age", 27);
        wangjuntao.put("interest", new String[] { "sport", "study" });
        wangjuntao.put("wife", "王语嫣");
        DBObject wangjuntaoAddress = new BasicDBObject();
        wangjuntaoAddress.put("address", "hebei");
        wangjuntao.put("home", wangjuntaoAddress);
 
        DBObject miaojiagui = new BasicDBObject();
        miaojiagui.put("name", "miaojiagui");
        miaojiagui.put("age", 28);
        miaojiagui.put("interest", new String[] { "hadoop", "study", "linux" });
        miaojiagui.put("wife", null);
        DBObject miaojiaguiAddress = new BasicDBObject();
        miaojiaguiAddress.put("address", "未知");
        miaojiagui.put("home", miaojiaguiAddress);
 
        DBObject longzhen = new BasicDBObject();
        longzhen.put("name", "longzhen");
        longzhen.put("age", 29);
        longzhen.put("interest", new String[] { "study", "cook" });
        longzhen.put("wife", null);
        DBObject longzhenAddress = new BasicDBObject();
        longzhenAddress.put("address", "sichuan");
        longzhen.put("home", longzhenAddress);
 
        userCollection.insert(zhangguochen);
        userCollection.insert(jindazhong);
        userCollection.insert(yangzhi);
        userCollection.insert(diaoyouwei);
        userCollection.insert(cuichongfei);
        userCollection.insert(huanghu);
        userCollection.insert(houchangren);
        userCollection.insert(wangjuntao);
        userCollection.insert(miaojiagui);
        userCollection.insert(longzhen);
    }
 
    public void testRemove() {
        userCollection.drop();
    }
 
    /**
     * 打印数据
     *
     * @param object
     */
    public void print(Object object) {
        System.out.println(object);
    }
 
    /**
     * 打印列表
     *
     * @param objectList
     */
    public void printList(List<DBObject> objectList) {
        for (Object object : objectList) {
            print(object);
        }
    }
}

　　

 

编译运行以上程序，输出结果如下:

Connect to database successfully
集合 test 选择成功

 

 

 

 

 

posted @   割肉机  阅读(778)  评论(0)  编辑  收藏  举报
编辑推荐：
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
阅读排行：
· winform 绘制太阳，地球，月球 运作规律
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· AI与.NET技术实操系列（五）：向量存储与相似性搜索在 .NET 中的实现
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
历史上的今天：
2018-09-04 react+echarts/g2/bizcharts可视化图表
点击右上角即可分享
微信分享提示
AI IDE Trae