库，集合<表>，文档<数据>

库

> show databases; | show dbs;

注意:

• **admin**： 从权限的角度来看，这是”root”数据库。要是将一个用户添加到这个数据库，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器。
• **local**: 这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合

• **config**: 当Mongo用于分片设置时，config数据库在内部使用，用于保存分片的相关信息。

  创建数据库

  use 库名

  
  注意: use 代表创建并使用,当库中**没有数据时默认不显示**这个库
  

  删除数据库

• 默认删除当前选中的库

  > db.dropDatabase()

  

  查看当前所在库

  > db;

  

  集合

  查看库中所有集合

  > show collections; | show tables;

  

  创建集合

  > db.createCollection('集合名称', [options])

  
  options可以是如下参数：

注意:当集合不存在时,向集合中插入文档也会自动创建该集合。

删除集合

> db.集合名称.drop();

文档

参考文档: https://docs.mongodb.com/manual/reference/method/

插入文档

• 单条文档

  > db.集合名称.insert({"name":"编程不良人","age":23,"bir":"2012-12-12"});

• 多条文档

  > db.集合名称.insertMany(
   [ <document 1> , <document 2>, ... ],
   {
             writeConcern: 1,//写入策略，默认为 1，即要求确认写操作，0 是不要求。
      ordered: true //指定是否按顺序写入，默认 true，按顺序写入。
   }
  )
  > db.集合名称.insert([
      {"name":"不良人","age":23,"bir":"2012-12-12"},
      {"name":"小黑","age":25,"bir":"2012-12-12"}
  ]);

• 脚本方式

  for(let i=0;i<100;i++){
    db.users.insert({"_id":i,"name":"编程不良人_"+i,"age":23});
  }

  注意:在 mongodb 中每个文档都会有一个_id作为唯一标识,_id默认会自动生成如果手动指定将使用手动指定的值作为_id 的值。

  查询所有

  > db.集合名称.find();

  根据生成ID查询

  db.集合名称.findOne({"_id":ObjectId("62a84c8d724c0a2f70e49a21")})

  删除文档

  ```plsql db.集合名称.remove( , { justOne: , writeConcern: } )

— 删除id为1的 db.user.remove({_id:1} )

**参数说明：**
- **query** :可选删除的文档的条件。
- **justOne** : 可选如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，则删除所有匹配条件的文档。
- **writeConcern** :可选抛出异常的级别
<a name="rNWhH"></a>
### 更新文档
```sql
db.集合名称.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>
   }
);

参数说明：

• query : update的查询条件，类似sql update查询内where后面的。
• update : update的对象和一些更新的操作符（如$,$inc…）等，也可以理解为sql update查询内set后面的
• upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
• multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
• writeConcern :可选，抛出异常的级别。 ```markdown
• db.集合名称.update({“name”:”zhangsan”},{name:”11”,bir:new date()}) 这个更新是将符合条件的全部更新成后面的文档,相当于先删除在更新
• db.集合名称.update({“name”:”xiaohei”},{$set:{name:”mingming”}}) 保留原来数据更新,但是只更新符合条件的第一条数据
• db.集合名称.update({name:”小黑”},{$set:{name:”小明”}},{multi:true})
  保留原来数据更新,更新符合条件的所有数据

• db.集合名称.update({name:”小黑”},{$set:{name:”小明”}},{multi:true,upsert:true}) `保留原来数据更新,更新符合条件的所有数据 没有条件符合时插入数据

  <a name="zd0G7"></a>
  # 文档查询
  **MongoDB 查询文档使用 find() 方法。find() 方法以非结构化的方式来显示所有文档。**
  <a name="lwMFa"></a>
  ## 语法
  ```sql
  > db.集合名称.find(query, projection)

• query ：可选，使用查询操作符指定查询条件

• projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。

如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，语法格式如下：

> db.集合名称.find().pretty()

注意: pretty() 方法以格式化的方式来显示所有文档。

对比语法

如果你熟悉常规的 SQL 数据，通过下表可以更好的理解 MongoDB 的条件语句查询：

AND

> db.集合名称.find({key1:value1, key2:value2,...}).pretty()

类似于 WHERE 语句：WHERE key1=value1 AND key2=value2

OR

MongoDB OR 条件语句使用了关键字 $or,语法格式如下：

> db.集合名称.find(
  {
    $or: [
      {key1: value1}, {key2:value2}
    ]
  }
).pretty()

类似于 WHERE 语句：WHERE key1=value1 or key2=value2

AND 和 OR 联合

类似SQL语句为：'where age >50 AND (name = '编程不良人' OR name = 'MongoDB')'

> db.集合名称.find({"age": {$gt:50}, $or: [{"name": "编程不良人"},{"name": "MongoDB"}]}).pretty();

数组中查询

-- 测试数据
> db.集合名称.insert({ "_id" : 11, "age" : 29, "likes" : [ "看电视", "读书xx", "美女" ], "name" : "不良人_xx_11" })
-- 执行数组查询
> db.users.find({likes:"看电视"})
-- $size 按照数组长度查询
> db.users.find({likes:{$size:3}});

模糊查询

类似 SQL 中为 'where name like '%name%''

> db.users.find({likes:/良/});

注意:在 mongoDB 中使用正则表达式可以是实现近似模糊查询功能

排序

> db.集合名称.find().sort({name:1,age:1}),
- 1 升序  -1 降序

类似 SQL 语句为: 'order by name,age'

分页

db.集合名称.find().sort({条件}).skip(start).limit(rows);

类似于 SQL 语句为: 'limit start,rows'

总条数

> db.集合名称.count();
> db.集合名称.find({"name":"编程不良人"}).count();

类似于 SQL 语句为: 'select count(id) from ....'

去重

> db.集合名称.distinct('字段')

类似于 SQL 语句为: 'select distinct name from ....'

指定返回字段

> db.集合名称.find({条件},{name:1,age:1}) 
- 参数2: 1 返回  0 不返回    `注意:1和0不能同时使用`

$type

说明

$type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果。
MongoDB 中可以使用的类型如下表所示：

使用

> db.col.insert({
    title: 'PHP 教程', 
    description: 'PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。',
    by: '编程不良人',
    url: 'http://www.baizhiedu.xin',
    tags: ['php'],
    likes: 200
});
> db.col.insert({
    title: 'Java 教程', 
    description: 'Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。',
    by: '编程不良人',
    url: 'http://www.baizhiedu.xin',
    tags: ['java'],
    likes: 550
});
> db.col.insert({
    title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '编程不良人',
    url: 'http://www.baizhiedu.xin',
    tags: ['mongodb'],
    likes: 100
});
> db.col.insert({
    title: 2233, 
    description: '2233 是一个 B站的',
    by: '编程不良人',
    url: 'http://www.baizhiedu.xin',
    tags: ['2233'],
    likes: 100
});

• 如果想获取 “col” 集合中 title 为 String 的数据，你可以使用以下命令：

  db.col.find({"title" : {$type : 2}}).pretty();
  或
  db.col.find({"title" : {$type : 'string'}}).pretty();

• 如果想获取 “col” 集合中 tags 为 Array 的数据，你可以使用以下命令：

  dge
  或
  db.col.find({"tags" : {$type : 'array'}}).pretty();

  索引

  https://docs.mongodb.com/manual/indexes/

  说明

  索引通常能够极大的提高查询的效率，如果没有索引，MongoDB在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构。

  原理

  
  从根本上说，MongoDB中的索引与其他数据库系统中的索引类似。MongoDB在集合层面上定义了索引，并支持对MongoDB集合中的任何字段或文档的子字段进行索引。

  操作

  > db.集合名称.createIndex(keys, options)
  > db.集合名称.createIndex({"title":1,"description":-1})

  说明: 语法中 Key 值为你要创建的索引字段，1 为指定按升序创建索引，如果你想按降序来创建索引指定为 -1 即可。
  createIndex() 接收可选参数，可选参数列表如下：

1、查看集合索引

> db.集合名称.getIndexes()

2、查看集合索引大小

> db.集合名称.totalIndexSize()

3、删除集合所有索引

> db.集合名称.dropIndexes()

4、删除集合指定索引

> db.集合名称.dropIndex("索引名称")

复合索引

说明: 一个索引的值是由多个 key 进行维护的索引的称之为复合索引

> db.集合名称.createIndex({"title":1,"description":-1})

注意: mongoDB 中复合索引和传统关系型数据库一致都是左前缀原则

聚合

说明

MongoDB 中聚合(aggregate)主要用于处理数据(诸如统计平均值，求和等)，并返回计算后的数据结果。有点类似 SQL 语句中的 count(*)。

使用

{
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'runoob.com',
   url: 'http://www.runoob.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
},
{
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'runoob.com',
   url: 'http://www.runoob.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
},
{
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
}

现在我们通过以上集合计算每个作者所写的文章数，使用aggregate()计算结果如下：

> db.集合名称.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])

常见聚合表达式

整合应用

说明: 这里主要以 springboot 应用为基础应用进行整合开发。
Spring Data : Spring 数据框架 JPA 、Redis、Elasticsearch、AMQP、MongoDB
JdbcTemplate
RedisTemplate
ElasticTempalte
AmqpTemplate
MongoTemplate
SpringBoot Spring Data MongoDB

环境搭建

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

# mongodb 没有开启任何安全协议
# mongodb(协议)://121.5.167.13(主机):27017(端口)/baizhi(库名)
spring.data.mongodb.uri=mongodb://121.5.167.13:27017/baizhi
# mongodb 存在密码
#spring.data.mongodb.host=tx.chenyn.cn
#spring.data.mongodb.port=27017
#spring.data.mongodb.database=baizhi
#spring.data.mongodb.username=root
#spring.data.mongodb.password=root

集合操作

@Test
    public void testCreateCollection() {
        // 判断集合是否存在
        boolean products = mongoTemplate.collectionExists("products");
        if (!products) {
            // 创建集合 参数: 创建集合名称
            mongoTemplate.createCollection("products");
        }
    }

注意:创建集合不能存在,存在报错

@Test
public void testDeleteCollection(){
  mongoTemplate.dropCollection("users");
}

相关注解

• @Document
  • 修饰范围: 用在类上
  • 作用: 用来映射这个类的一个对象为 mongo 中一条文档数据，相当于把java对象转成bson
  • 属性：(value 、collection )用来指定操作的集合名称
• @Id
  • 修饰范围: 用在成员变量、方法上
  • 作用： 用来将成员变量的值映射为文档的_id 的值
• @Field
  • 修饰范围: 用在成员变量、方法上
  • 作用: 用来将成员变量以及值映射为文档中一个key、value对
  • 属性: ( name,value)用来指定在文档中 key 的名称,默认为成员变量名
• @Transient
  • 修饰范围: 用在成员变量、方法上
  • 作用 : 用来指定改成员变量，不参与文档的序列化

    文档操作

    

    查询操作

    ```java @Autowired private MongoTemplate template;

@Test public void testQuery(){ //基于 id 查询 template.findById(“1”,User.class);

//查询所有 template.findAll(User.class); template.find(new Query(),User.class);

//等值查询 template.find(Query.query(Criteria.where(“name”).is(“编程不良人”)), User.class);

// > gt < lt >= gte <= lte template.find(Query.query(Criteria.where(“age”).lt(25)), User.class); template.find(Query.query(Criteria.where(“age”).gt(25)), User.class); template.find(Query.query(Criteria.where(“age”).lte(25)), User.class); template.find(Query.query(Criteria.where(“age”).gte(25)), User.class);

//and template.find(Query.query(Criteria.where(“name”).is(“编程不良人”) .and(“age”).is(23)),User.class);

//or Criteria criteria = new Criteria() .orOperator(Criteria.where(“name”).is(“编程不良人_1”), Criteria.where(“name”).is(“编程不良人_2”)); template.find(Query.query(criteria), User.class);

//and or Criteria criteria1 = new Criteria() .and(“age”).is(23) .orOperator( Criteria.where(“name”).is(“编程不良人_1”), Criteria.where(“name”).is(“编程不良人_2”)); template.find(Query.query(criteria1), User.class);

//sort 排序 Query query = new Query(); query.with(Sort.by(Sort.Order.desc(“age”)));//desc 降序 asc 升序 template.find(query, User.class);

//skip limit 分页 Query queryPage = new Query(); queryPage.with(Sort.by(Sort.Order.desc(“age”)))//desc 降序 asc 升序 .skip(0) //起始条数 .limit(4); //每页显示记录数 template.find(queryPage, User.class);

//count 总条数 template.count(new Query(), User.class);

//distinct 去重 //参数 1:查询条件 参数 2: 去重字段 参数 3: 操作集合 参数 4: 返回类型 template.findDistinct(new Query(), “name”, User.class, String.class);

//使用 json 字符串方式查询 Query query = new BasicQuery( “{$or:[{name:’编程不良人’},{name:’徐凤年’}]}”, “{name:0}”);

template.find(query, User.class); }

<a name="KLKOF"></a>
### 添加操作
实体类```java
@Document("users")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    @Id
    private Integer id;
    @Field("username")
    private String name;
    @Field
    private Double salary;
    @Field
    private Date birthday;
}

    @Autowired
    private MongoTemplate mongoTemplate;
    @Test
    public void test(){
        User user = new User(1, "张三", 3000.0, new Date());
        mongoTemplate.save(user);
        User userInsert = new User(2, "李四", 3500.0, new Date());
        mongoTemplate.insert(userInsert);
        // 参数：1.批量数据 2.放入哪个集合
        List<User> users = Arrays.asList(new User(4, "李四", 2800.0, new Date()),
                new User(5, "王五", 3800.0, new Date()));
        mongoTemplate.insert(users,User.class);
    }

• insert:插入重复数据时(比如主键重复，或者唯一索引)，insert报DuplicateKeyException提示主键重复；save对已存在的数据更新。

• save:批处理操作时，insert可以一次性插入整个数据，效率较高；save需遍历整个数据，一次插入或更新，效率较低

  更新操作

  @Test
  public void  testUpdate(){
  //1.更新条件
  Query query = Query.query(Criteria.where("age").is(23));
  //2.更新内容
  Update update = new Update();
  update.set("name","编程小陈陈");
  //单条更新
  mongoTemplate.updateFirst(query, update, User.class);
  //多条更新
  mongoTemplate.updateMulti(query, update, User.class);
  //更新插入
  mongoTemplate.upsert(query,update,User.class);
  //返回值均为 updateResult
  //System.out.println("匹配条数:" + updateResult.getMatchedCount());
  //System.out.println("修改条数:" + updateResult.getModifiedCount());
  //System.out.println("插入id_:" + updateResult.getUpsertedId());
  }

  删除操作

  @Test
  public void testDelete(){
  //删除所有
  mongoTemplate.remove(new Query(),User.class);
  //条件删除
  mongoTemplate.remove(
    Query.query(Criteria.where("name").is("编程不良人")),
    User.class
  );
  }