Mongo入门这一篇就够了（保姆级教程）

MongoDB的入门

1.Docker下载安装MongoDB

浏览器搜索docke hub，在docker hub里面搜索mongo，找到图示中的mongo镜像点进去左边有一串命令，复制到命令提示符运行。



镜像安装好之后使用下面命令启动mongo镜像就行了，docke命令大全稍后就写。

docker start some-mongo

2.MongoDB基本CRUD操作

1. MongoDB的基本概念在MongoDB中数据库database表示一个数据库 。
2. 集合collection相当于关系型数据库的表 。
3. 文档document相当于关系型数据库的一行记录，以二进制json的形式存储在数据库中的,是我们直接操作的对象。

基于Mongo Shell的数据库管理操作

数据库管理语法

操作	语法
查看所有数据库	show dbs;或show databases;
查看当前数据库	db;
切换到某数据库(若数据库不存在则创建数据库)	use <数据库名>;
删除当前数据库	db.dropDatabase();

集合管理语法操作

操作	语法
查看所有集合	show collections;
创建集合	db.createCollection(“集合名”);
删除集合	db.<集合名>.drop();

基于Mongo Shell的CRUD操作

在Mongo Shell中,通过javascript语句,可以与数据库进行交互。

增加操作

使用db.集合名.insertOne()向集合中添加一个文档,参数一个json格式的文档
使用db.集合名.insertMany()向集合中添加多个文档,参数为json文档数组

// 向inventory集合中添加一个文档
db.inventory.insertOne(
   { item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }
)
// 向inventory集合中添加多个文档
db.inventory.insertMany([
   { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } },
   { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } },
   { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }
])

查询操作

基本查询使用db.集合名.find(, )方法对集合进行查询,接收一个json格式的查询条件

db.inventory.find( { status: "D" } )

可以使用$in操作符表示范围查询

db.inventory.find( { status: { $in: [ "A", "D" ] } } )

多个查询条件用逗号分隔,表示AND的关系

db.inventory.find( { status: "A", qty: { $lt: 30 } } )

等价于下面sql语句

SELECT * FROM inventory WHERE status = “A” AND qty < 30

使用$or操作符表示后边数组中的条件是OR的关系

db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )

等价于下面sql语句

SELECT * FROM inventory WHERE status = “A” OR qty < 30

联合使用AND和OR的查询语句

db.inventory.find( {
     status: "A",
     $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ]
} )

对数组进行查询
向集合中添加含有数组属性的文档如下

db.inventory.insertMany([
    { item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] },
    { item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] },
    { item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] },
    { item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] },
    { item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }
]);

匹配整个数组 在查询条件中指定一个数组,表示匹配文档的该数组属性有且只有该条件数组的所有元素，默认情况下匹配会要求顺序.下面查询语句要求匹配文档的tags属性正好有"red","blank"两个元素且按照该顺序排列.

db.inventory.find( { tags: ["red", "blank"] } )

使用$all操作符表示取消匹配顺序.下面查询语句要求匹配文档的tags属性正好有"red","blank"两个元素并可以按任意顺序排列.

db.inventory.find( { tags: { $all: ["red", "blank"] } } )

多条件查询数组
默认情况下,多条件查询一个数组,要求匹配文档对应数组属性中所有元素的任意组合匹配所有条件.既可以数组中一个元素满足所有条件,也可以数组中每个元素只满足一部分条件但加起来满足了所有条件

db.inventory.find( { dim_cm: { $gt: 15, $lt: 20 } } )

使用$elemMatch操作符表示要求数组中至少一个元素满足所有条件

db.inventory.find( { dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } } )       

使用数组属性名.下标指定数组某一位要满足的条件,下标从0开始

db.inventory.find( { "dim_cm.0": { $gt: 25 } } )        

使用.时json的属性名必须用为字符串

使用$size表示根据要求数组长度满足某条件

db.inventory.find( { tags: { $size: 3 } } )

对内联文档数组进行查询
当文档的某属性为文档,则称之为内联文档. 向集合中添加含有内联文档数组属性的文档如下:

db.inventory.insertMany( [
    { item: "journal", instock: [ { warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 } ] },
    { item: "notebook", instock: [ { warehouse: "C", qty: 5 } ] },
    { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 15 } ] },
    { item: "planner", instock: [ { warehouse: "A", qty: 40 }, { warehouse: "B", qty: 5 } ] },
    { item: "postcard", instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);

直接查询一个内联文档
可以通过直接指定查询一个元素的方式对内联文档数组进行查询:

db.inventory.find( { "instock": { warehouse: "A", qty: 5 } } )

该方式需要注意所指定的内联文档的属性及顺序要与数组中的元素完全匹配,更改顺序或缺少属性都不能匹配到数组.

// 属性顺序不匹配
db.inventory.find( { "instock": { qty: 5, warehouse: "A" } } )
// 属性不全
db.inventory.find( { "instock": { warehouse: "A"} } )
通过

内联文档属性进行查询
我们可以通过内联文档属性进行查询,会返回数组中至少有一个元素满足匹配的文档.

db.inventory.find( { 'instock.qty': { $lte: 20 } } )

也可以指定要求数组中某位置的元素属性满足的条件

db.inventory.find( { 'instock.0.qty': { $lte: 20 } } )

指定多条件查询对内联文档数组指定多条件查询时,只要求数组中所有元素的任意匹配满足所有条件,而不必有一个元素满足所有条件.

db.inventory.find( { "instock.qty": { $gt: 10,  $lte: 20 } } )
db.inventory.find( { "instock.qty": 5, "instock.warehouse": "A" } )

可以使用$elemMatch要求数组中至少存在一个元素满足所有条件.

db.inventory.find( { "instock": { $elemMatch: { qty: { $gt: 10, $lte: 20 } } } } )
db.inventory.find( { "instock": { $elemMatch: { qty: 5, warehouse: "A" } } } )

修改操作

使用db.集合名.updateOne(, , )方法修改一个匹配条件的文档
使用db.集合名.updateMany(, , )方法修改所有匹配条件的文档
使用db.集合名.replaceOne(, , )方法替换一个匹配条件的文档
其中参数与查询方法中的条件参数完全一致.
下面演示修改操作:向集合中添加文档如下:

db.inventory.insertMany( [
    { item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" },
    { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
    { item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" },
    { item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" },
    { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
    { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
    { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
    { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
    { item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
    { item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }
] );

db.集合名.updateOne()和db.集合名.updateMany()方法接收的参数的格式如下:

{
	<update operator>: { <field1>: <value1>, ... },
	<update operator>: { <field2>: <value2>, ... },
	...
}

其中最常用的修改操作符即为$set和$unset,分别表示赋值和取消赋值.

db.inventory.updateOne(
    { item: "paper" },
    {
        $set: { "size.uom": "cm", status: "P" },
        $currentDate: { lastModified: true }
    }
)
db.inventory.updateMany(
    { qty: { $lt: 50 } },
    {
        $set: { "size.uom": "in", status: "P" },
        $currentDate: { lastModified: true }
    }
)

db.集合名.replaceOne()方法替换除_id属性外的所有属性,其参数应为一个全新的文档.

db.inventory.replaceOne(
    { item: "paper" },
    { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }
)

删除操作

使用db.collection.deleteMany()方法删除一个匹配的文档.
使用db.collection.deleteOne()方法删除所有匹配的文档.

db.inventory.deleteMany( { qty : { $lt : 50 } } )

3.基于Scala的CRUD操作创建数据库连接

配置文件：

{
  "url":"localhost",
  "port":"27017",
  "loginName":"",
  "dbName":"test",
  "coll": "demo",
  "column": "name",
  "data": "user3",
  "query": "user3",
  "query1": "user1",
  "update": "user1"

}

我这里用的是json格式的配置文件

建立数据库连接

第一种不需要用户名和密码直接获取MongoDB。

def createDatabase(url: String,port:Int,dbName:String):MongoDB={
  /**
   *
   * @Title createDatabase
   * @Description 无权限验证连接
   * @author  Angeline Wong
  * @return com.mongodb.casbah.MongoDB
   */
  MongoClient(url,port).getDB(dbName)
}

第二种：通过权限验证进行连接

def createDatabase(url: String,port: Int,dbName: String,loginName:String,password: String):MongoDB={
/**
 *
 * @Title createDatabase
 * @Description 通过权限验证进行连接
 * @author  Angeline Wong
 * @return com.mongodb.casbah.MongoDB
 */
  val server=new ServerAddress(url,port)
  val credentials=MongoCredential.createCredential(loginName,dbName,password.toCharArray)
  var mongoClient=MongoClient(server,List(credentials))
   val db=mongoClient.getDB(dbName)
  return db
}

添加操作

def insert(): Unit ={
  /**
   *
   * @Title insert
   * @Description 对mongoDB进行数据插入
   * @author  Angeline Wong
   * @return void
   */
  val configName = "mongoDB.json"
  val json123:JSONObject=JSON.parseObject(ClassLoader.getSystemResourceAsStream(configName),classOf[JSONObject])
  val coll=createDatabase(json123.getString("url"),json123.getInteger("port"),json123.getString("dbName")).getCollection(json123.getString("coll"))
  val last = MongoDBObject(json123.getString("column")->json123.getString("data"))
  coll.insert(last)
}

主题代码其实只有
val user= MongoDBObject(“name”-> “user”)
coll.insert(user1)

查询操作

def select(): Unit ={
  /**
   *
   * @Title select
   * @Description 对mongoDB进行数据查询
   * @author  Angeline Wong
   * @return void
   */
  val configName = "mongoDB.json"
  val json123:JSONObject=JSON.parseObject(ClassLoader.getSystemResourceAsStream(configName),classOf[JSONObject])
  val coll=createDatabase(json123.getString("url"),json123.getInteger("port"),json123.getString("dbName")).getCollection(json123.getString("coll"))
  coll.count()
  println(coll.count())
  val query=MongoDBObject(json123.getString("column")->json123.getString("query1"))
    coll.find(query)
  println(coll.find(query))
}

主体代码其实只有：
coll.count() //读取总记录数
也能够使用find读取记录，比方读取全部记录并打印出来：
coll.find().foreach(println)
val query1 =MongoDBObject(“name”->“user1”)
coll.findOne(query1)

删除操作

def delete(boolean: Boolean): Unit ={
    /**
     *
     * @Title delete
     * @Description 对mongoDB进行数据删除
     * @author  Angeline Wong
     * @param boolean 为true时删除集合
     * @return void
     */
    val configName = "mongoDB.json"
    val json123:JSONObject=JSON.parseObject(ClassLoader.getSystemResourceAsStream(configName),classOf[JSONObject])
    val coll=createDatabase(json123.getString("url"),json123.getInteger("port"),json123.getString("dbName")).getCollection(json123.getString("coll"))
    while (boolean ==true) {
      coll.drop()
    }
    val query1 =MongoDBObject(json123.getString("column")->json123.getString("query1"))
    val rm = coll.remove(query1)
}

主体代码只有
val query2 = MongoDBObject(“name”->”user2”)
val result2 = coll.remove(query2)
删除集合
coll.drop()

更新操作

def update(): Unit ={
  /**
   *
   * @Title update
   * @Description 对mongoDb进行数据更新修改
   * @author  Angeline Wong
   * @return void
   */
  val configName = "mongoDB.json"
  val json123:JSONObject=JSON.parseObject(ClassLoader.getSystemResourceAsStream(configName),classOf[JSONObject])
  val coll=createDatabase(json123.getString("url"),json123.getInteger("port"),json123.getString("dbName")).getCollection(json123.getString("coll"))
  val query=MongoDBObject(json123.getString("column")->json123.getString("query"))
  val update=MongoDBObject(json123.getString("column")->json123.getString("update"))
    val last=coll.update(query,update)
}

主体代码：
val update1 =MongoDBObject(“email”->“user1@test.com”)
val result1 = coll.update(query1,update1)
或者val result = coll.update( query, update, upsert=true )//upsert=true,假设不存在就insert
————————————————————————————————————————-

————————————————————————————————————————

本文是学习网上其他博主的文章，并自己练习总结，参考的好多文章，找不到原作了，如果有侵权请联系我，我标明出处或者删掉。