MongoDB 入门专栏

http://blog.csdn.net/column/details/19681.html

Java 连接 MongoDB

MongoDB 提供了一系列的驱动用于支持各种语言连接 mongodb 数据库，包括：Java，Python，C++，Scala，PHP 等，完整的驱动列表： https://docs.mongodb.com/manual/applications/drivers/index.html

其中对于 Java 提供了 mongo-java-driver 库支持 Mongo JDBC 驱动，使用该驱动只要在项目依赖中导入： org.mongodb:mongo-java-driver

如在使用 gradle 构建的项目中，如下导入：

compile 'org.mongodb:mongo-java-driver:3.6.3'

Mongo JDBC 驱动文档主页： http://mongodb.github.io/mongo-java-driver/；

可以在驱动主页查询该驱动的详细用法，一下示例基本使用，包括：数据库连接、CURD 操作，使用版本为：mongodb 3.6，mongo-java-driver 3.6，不同版本的驱动的 API 由一些差异，详细请查询驱动文档；

示例用的数据库集合 testdb.blog 文档示例如下：

             
          { 
         
              "_id" : ObjectId("5a8d519a07c9086ee823f15d"), 
         
              "title" : "Mysql Overview", 
         
              "description" : "Musql is a RDBMS", 
         
              "author" : "assad", 
         
              "url" : "http://blog.assad.article/233", 
         
              "tages" : [ "mysql", "RDBMS", "sql" ], 
         
              "likes" : 200 
         
          }

数据库连接

1）无验证连接

             
          MongoClient mongoClient = new MongoClient("127.0.0.1",27017); 
         
          //或者使用 mongo uri 
         
          MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://127.0.0.1:27017"));

2）验证连接

             
          String user = "assad";                   //用户名 
         
          String database = "testdb";              //数据库 
         
          char[] password = "123".toCharArray();   //密码 
         
          ​ 
         
          MongoCredential credential = MongoCredential.createCredential(user,database,password);   //验证对象 
         
          MongoClientOptions options = MongoClientOptions.builder().sslEnabled(false).build();     //连接操作对象 
         
          MongoClient mongoClient = new MongoClient(new ServerAddress("127.0.0.1",27017),credential,options);   //连接对象 
         
          ​ 
         
          //或者使用 mongo uri 
         
          MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://assad:[email protected]:27017/?authSource=testdb&ssl=false"));

其中 mongo uri 的验证连接格式如下：

mongodb://userName:password@host/?authSource=databaseName&ssh=true;

获取数据库 & 集合

             
          //获取指定数据库对象 
         
          MongoDatabase db = mongoClient.getDatabase("testdb"); 
         
          //获取指定集合对象 
         
          MongoCollection<Document> blogs = db.getCollection("blog"); 
         
          ​ 
         
          //列举所有数据库名称 
         
          for(String dbName : blogs.listDatabaseNames() 
         
              System.out.println(dbName); 
         
          //列举指定数据库中所有集合名称 
         
          for(String colName: db.listCollectionNames()) 
         
              System.out.println(colName);

以下示例中，对于文档结果的输出都使用 Log4j2 进行标准输出；

select 查询操作

1）查询结果遍历

在 MongoDB JDBC 中，会对查询结果生成一个 FindIterable<Document> 对象，可以通过获取其迭代器对其进行迭代，同时该对象也提供了 foreach 方法，通过传入一个 Block 对象，可以对结果进行阻塞迭代；

             
          //数据库连接 
         
          MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://assad:[email protected]:27017/?authSource=testdb&ssl=false")); 
         
          MongoCollection<Document> blogs = mongoClient.getDatabase("testdb").getCollection("blog"); 
         
          ​ 
         
          //查询所有文档，遍历输出结果 
         
          for (Document document1 : blogs.find()) 
         
              log.debug(document1.toJson()); 
         
          ​ 
         
          //查询所有文档，使用遍历器遍历结果 
         
          MongoCursor<Document> cursor = blogs.find().iterator(); 
         
          while(cursor.hasNext()) 
         
              log.debug(cursor.next().toJson()); 
         
          ​ 
         
          //查询所有文档，对所有结果使用阻塞回调方法 
         
          blogs.find().forEach((Block<Document>) document -> { 
         
              log.debug(document.toJson()); 
         
          }); 
         
          ​ 
         
          //查询所有文档，获取结果文档中的 title 字段（string）、likes 字段（int32）、tags 字段（array） 
         
          blogs.find().forEach((Block<Document>) document ->{ 
         
              String title = document.getString("title"); 
         
              int likes = document.getInteger("likes"); 
         
              List<String> tags = (List<String>) document.get("tags"); 
         
              log.debug(title + " - " + likes + " - " + tags); 
         
          });

2）条件查询

对于条件查询，可以通过构造一个个嵌套的 Document 对象，产生类似 mongodb 查询语法的 Document 链来进行查询；或者使用 Filters 中的各种静态方法（如 eq，lte等）来进行函数式地查询，MongoDB JDBC 已经将绝大部分的 mongodb 查询条件操作符封装为函数式调用；

             
          //条件查询: db.blog.find({"author":"assad"}) 
         
          blogs.find(new Document("author","assad")).forEach((Block<Document>) document -> { 
         
              log.debug(document.toJson()); 
         
          }); 
         
          ​ 
         
          blogs.find(eq("author","assad")).forEach((Block<Document>) document -> { 
         
              log.debug(document.toJson()); 
         
          }); 
         
          ​ 
         
          ​ 
         
          //条件查询: db.blog.find({"likes":{$gte:200,$lte:500}}) 
         
          blogs.find(new Document("likes",new Document("$gte",200).append("$lte",500))) 
         
                  .forEach((Block<Document>) document -> { 
         
              log.debug(document.toJson()); 
         
          }); 
         
          blogs.find(and(gte("likes",200), lte("likes",500))) 
         
                  .forEach((Block<Document>) document -> { 
         
              log.debug(document.toJson()); 
         
          }); 
         
          ​ 
         
          //条件查询：db.blog.find({"author":"assad","title":/mongodb*/i }) 
         
          blogs.find(new Document("author","assad").append("title",new Document("$regex","mongodb*").append("$options","i"))) 
         
                  .forEach((Block<Document>) document -> { 
         
              log.debug(document.toJson()); 
         
          }); 
         
          blogs.find(and(eq("author","assad"), regex("title","mongodb*","i"))) 
         
                  .forEach((Block<Document>) document -> { 
         
              log.debug(document.toJson()); 
         
          });

3）查询结果映射，排序，限制

             
          //映射操作, db.blog.find({"author:"assad""},{"title":1,"url":1,"likes":1,"_id":0}) 
         
          blogs.find(new Document("author","assad")) 
         
                  .projection(new Document("title",1).append("url",1).append("likes",1).append("_id",0)) 
         
                  .forEach((Block<Document>) document -> { 
         
                      log.debug(document.toJson()); 
         
                  }); 
         
          blogs.find(eq("author","assad")) 
         
                  .projection(fields(include("title","url","likes"),excludeId())) 
         
                  .forEach((Block<Document>) document -> { 
         
                      log.debug(document.toJson()); 
         
                  }); 
         
          ​ 
         
          //查询排序、限制： db.blog.find().sort({"likes":1,"title":-1}).limit(5) 
         
          blogs.find() 
         
                  .sort(and(ascending("likes"),descending("title"))) 
         
                  .limit(5) 
         
                  .forEach((Block<Document>) document -> { 
         
                      log.debug(document.toJson()); 
         
                  }); 
         
          ​ 
         
          blogs.find() 
         
                  .sort(new Document("likes",1).append("title",-1)) 
         
                  .limit(5) 
         
                  .forEach((Block<Document>) document -> { 
         
                      log.debug(document.toJson()); 
         
                  });

4）aggregate 数据聚合操作

             
          //数据聚合: db.blog.aggregate([ {$group:{_id:"$author",likes_count:{$sum:"$likes"}}} ]) 
         
          blogs.aggregate(asList( group("$author",sum("likes_count","$likes")) )) 
         
                  .forEach((Block<Document>) document -> { 
         
                      log.debug(document.toJson()); 
         
                  }); 
         
          ​ 
         
          //数据聚合: db.blog.aggregate([ {$group:{_id:"$author",likes_avg:{$avg:"$likes"}}}, {$match:{_id:"assad"}} ]) 
         
          blogs.aggregate(asList( 
         
                      group("$author",avg("likes_avg","$likes")), 
         
                      match(eq("_id","assad")) )) 
         
                  .forEach((Block<Document>) document -> { 
         
                      log.debug(document.toJson()); 
         
                  });

insert 插入操作

             
          //数据库连接 
         
          MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://assad:[email protected]:27017/?authSource=testdb&ssl=false")); 
         
          MongoCollection<Document> blogs = mongoClient.getDatabase("testdb").getCollection("blog"); 
         
          ​ 
         
          //插入一个文档 
         
          Document doc = new Document("title","Mysql Overview") 
         
                  .append("description","Musql is a RDBMS") 
         
                  .append("author","assad") 
         
                  .append("url","http://blog.assad.article/233") 
         
                  .append("tages", Arrays.asList("mysql","RDBMS","sql")) 
         
                  .append("likes",100); 
         
          blogs.insertOne(doc); 
         
          ​ 
         
          //插入多个文档 
         
          Document doc1 = new Document("title","DB2 Overview") 
         
                          .append("author","Alex"); 
         
          Document doc2 = new Document("title","Redis Overview") 
         
                          .append("author","Orlda"); 
         
          List<Document> docList = new ArrayList<>(); 
         
          docList.add(doc1); 
         
          docList.add(doc2); 
         
          blogs.insertMany(docList); 
         
          ​

update 操作

             
          //数据库连接 
         
          MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://assad:[email protected]:27017/?authSource=testdb&ssl=false")); 
         
          MongoCollection<Document> blogs = mongoClient.getDatabase("testdb").getCollection("blog"); 
         
          ​ 
         
          //更改第一条匹配条件的文档记录,对应 update(<query>,{muti:false}) 方法 
         
          blogs.updateOne(and(eq("author","assad"),eq("title","SqlLite Overview")) 
         
                  ,combine(set("author","assad_1"),set("likes",0))); 
         
          ​ 
         
          //更改所有匹配条件的文档记录,对应 update(<query>,{muti:true}) 方法 
         
          blogs.updateMany(lte("likes",300) 
         
                  , inc("likes",100)); 
         
          ​ 
         
          ​ 
         
          //完全替换一条文档记录，对应 save() 方法 
         
          Document doc = new Document("title","Mysql Overview") 
         
                  .append("description","Musql is a RDBMS") 
         
                  .append("author","assad") 
         
                  .append("url","http://blog.assad.article/233") 
         
                  .append("tages", Arrays.asList("mysql","RDBMS","sql")) 
         
                  .append("likes",100); 
         
          blogs.replaceOne(eq("author","Alex"),doc); 
         
          ​

delete 操作

             
          //数据库连接 
         
          MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://assad:[email protected]:27017/?authSource=testdb&ssl=false")); 
         
          MongoCollection<Document> blogs = mongoClient.getDatabase("testdb").getCollection("blog"); 
         
          ​ 
         
          //删除第一条满足查询条件的文档记录，对应 delete(<query>,{justOne:true}) 方法 
         
          blogs.deleteOne(eq("author","Alex")); 
         
          ​ 
         
          //删除所有满足查询条件的文档记录，对应 delete(<query>,{justOne:false}) 方法 
         
          blogs.deleteMany(gte("likes",900));

MongoDB JDBC 基本使用