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 选择成功

更多操作可以参考：http://mongodb.github.io/mongo-java-driver/3.0/driver/getting-started/quick-tour/

参考文档：http://blog.csdn.net/ererfei/article/details/50857103