java 連接mongodb

maven中添加依賴

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

<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代碼如下：

 

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 放在本地目錄下:

 

$ 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 需要驗證用戶名及密碼，可以使用以下代碼：

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()來創建集合

代碼片段如下：

 

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() 方法來獲取一個集合

代碼片段如下：

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() 方法來插入一個文檔

代碼片段如下：

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() );
      }
   }
}

編譯運行以上程序，輸出結果如下:

Connect to database successfully
集合 test 選擇成功
文檔插入成功

檢索所有文檔

我們可以使用 com.mongodb.client.MongoCollection 類中的 find() 方法來獲取集合中的所有文檔。

此方法返回一個游標，所以你需要遍歷這個游標。

代碼片段如下：

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() 方法來更新集合中的文檔。

代碼片段如下：

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 方法刪除。

代碼片段如下：

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進行操作

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 選擇成功