00年，在我家的小房间里第一次邂逅了游戏。从一台红白机和怕磁铁的老式电视机开始，一直到如今，游戏始终在我生活中出现。当然当初我并没玩过这台红白机，当时也没有很大的兴趣，就是在一旁看我爸玩。我爸是个很厉害的人，这个有空我再说说。得益于我爸，在小学家里就用上了电脑，我并没有像一些厉害的人干了一番大事业，而是喜欢上了大家都会喜欢上的游戏。



有时总觉得诧异，游戏是困难的，我们需要努力地去克服各种障碍，有重复的刷等级，金币的枯燥，有不停地探索、学习和利用规则的精神消耗。然而，它却是让我们沉迷的。而生活，类似的体验却让我感到苦闷。

仔细想想，生活是什么时候变成这样苦闷的？

我想，**生活的苦闷大抵是随着岁数与日俱增的**；或许每个时期都有每个时期的烦恼，但是对于我来说下一个时期总比上一个时期更加烦恼。假设每个时期的烦恼都一样多，那么快乐也一样多，烦恼的表达形式比较多，而笑容最能代表快乐，所以我拥有更少的笑容证明了我，拥有更多的烦恼。

我内心以前总特别地悲观地认为，**烦恼是客观存在的，在一定范围内，快乐是恒定的，当你过得格外快乐，总有人替你承担了这份烦恼。** 就像小时候，总那么地开心，因为我父母承担了一切，我就开开心心长大，不用担心吃喝拉撒，不用担心未来什么的，能肆无忌惮地说出理想是当个科学家；慢慢长大了，我开始自己担心自己大学要读什么，能不能考上好学校，担心选的专业有没有前途，担心毕业能不能找到工作，担心能不能养活自己。

我本以为，父母会随着我接过我自己的担子，而减少烦恼。后来我发现，生活总比我想想的更加残酷。这**烦恼原来不是剪切，而是复制** 。我只是默默懂得了父母的烦恼。如果没办法解决这些难题，它就会一直存在我们共同的担子里面。

绝望的不是苦闷的日子总是特别难熬，而是熬过了一个苦难，还有新的苦难。

有一年初春脚烫伤，说起来也是奇葩，我就是脚不舒服，然后拿了个热水袋放在脚下，暖和着比较舒服，在舒服的姿势下睡着了，然后就低温烫伤，烫了个大窟窿，医生听我说后，都笑得不行，怎么会有人睡觉一动不动。连续两个月，每两天我就要请下假，去医院把伤口撕开清理愈合。某一天在去医院的路上，我就在想，要是没烫伤，现在多快活呀。现在距离烫伤都有两年了，日子并不会随着伤口的愈合而变得美好。仍旧会有新的烦恼，会有新的要是不xx，现在多快活的想法。

忽然发现，其实人生和游戏真的很像，人生有不同的苦难，有不同阶段要做的事情，会成长，会学习不同的技能；游戏有不同的关卡，有不同的任务，有经验值会升级，会学习不同的技能；如果**把人生变成游戏**，那么是不是日子会变得像游戏令人沉迷呢？

## 游戏人生

怎么把人生设计成游戏，首先我们要了解，游戏。

《游戏改变世界》这本书中第一章提到，游戏有四个决定性特征，分别是**目标、规则、反馈系统和自愿参与**。

- **目标（goal ）**：指的是玩家努力达成的具体结果；

- **规则（rules）**：为玩家如何实现目标做出限制；

- **反馈系统（feedback system）**：告诉玩家距离实现目标还有多远；

- **自愿参与（voluntary participation）**：要求所有玩游戏的人都了解并愿意接受目标、规则和反馈。

  

**把人生等价设计：**

- **人生目标（life goal）**：等待游戏结束（类似俄罗斯方块，结局只有死亡）；
- **人生规则（life rules）**：需要在游戏过程中不断探索，学习并利用新的规则，现代游戏设计模式大都如此，没有指南，有探索空间；
- **反馈系统（feedback system）**：阶段目标奖励，这个需要自己去建立，**所以没有目标奖励或者只有大目标的会过得很痛苦、迷茫；**
- **自愿参与（voluntary participation）**：这是游戏和人生最大的不同，游戏很多时候都是自愿去参与，接受规则和蓄意设计的高压工作，而生活不是，我们为了活着，活得好，活得有面子，而被迫参与工作，被迫玩这盘游戏。

## 人生四要素
### 目标
人生的结局只有死亡，就像俄罗斯方块，你没法通关，要做的就是在方块碰到最上面前，得到更多的分数。人生呢？在死亡前，我们能做的就是得到更多我们想要得到的东西，所以**人生的结局只有死亡，意义在于走向结局的过程**。

### 规则
人生的规则都是隐性的，需要你自行去探索，他包含万象，就像游戏里面限制，这种限制包含很多，我更愿意说是一种**设定**，比如：角色存在体力条，运动时会消耗，消耗完了就跑不动，需要等待恢复；技能1属木，技能2属火，先用技能1后使用技能2，能加大2技能的伤害，等等。**我们要做的就是去探索规则，归纳总结，运用规则，所以反思和笔记是很重要的**，毕竟我们没有自带系统帮助我们去记录这些。

### 反馈
在游戏中，最为常见的就是我们去完成任务然后获得奖励，这是一种比较传统的反馈机制。我们或多或少也这样给过自己奖励吧，比如：连续几天，吃减肥餐，就奖励自己一顿大餐；孩子只要期末考前几名，就奖励他去旅游，等等。这种是生活中比较常见的反馈系统了。但是，这种反馈其实非常的脆弱，就像《卡片笔记写作法》中写的： 如果不能从长远考虑，建立积极反馈循环，任何试图用外部奖励 （比如在完成一章后做一些喜欢做的事）哄骗自己去工作的尝试都只是短期的解决方案，非常脆弱。只有当工作本身就是激励时，驱动力和奖励才能可持续动态循环，从而推动整个任务前进。 现在的游戏，探索本身已经成为一种反馈了，你要去探索这个游戏世界，游戏世界的设定，风景，人物故事，就一直激励你去探索。回到生活中，比如减肥餐，我们就是单纯地想知道啥味道（频繁更换减肥餐），或者知道怎么做的好（尝试自己创新）。所以呀，**在做事情的过程中，我们渴望得到什么才是我们最好的反馈**。
### 自愿参与
最后是自愿参与，和游戏最大的不同，游戏是想玩就玩，不想玩就不玩，所以自愿参与度很高（tip: 戒网小妙手，逼迫别人去玩游戏，破坏自愿参与度）。而人生呢，生而为人，不是我们能控制的。**我们一定要参与，那就只能提高我们参与的意愿度，说人话就是热爱生活**。

回到这篇文章的标题《起源：游戏人生》，从这篇文章开始，正在边玩边完善我的游戏人生，希望和大家分享，也送我自己一句话：天变不足畏,祖宗不足法,人言不足恤。

起源：游戏人生

## 电脑配置

> 电脑用得是联想小新14 pro
>
> cpu I7-13620H
>
> 16G 内存

![配置.png](/static/img/83631ecb2e9fa40d5aa3a356ef721e0c.%C3%A9%C2%85%C2%8D%C3%A7%C2%BD%C2%AE.webp)



## 操作步骤

1. 安装 ollama

  - 打开 [官网下载页面](https://ollama.com/download)
  - 选择对应的版本下载
  - 我这里下载window版本，也可以到我的网盘下载(失效请联系)

   ```
   链接：https://pan.quark.cn/s/665290f7c0a0
   提取码：M47n
   ```

   - 然后点击安装，就完成了

2. 安装模型

  - 这里默认模型下载位置为：```C:\Users\{userName}\.ollama``` 
  - 添加环境变量 ```OLLAMA_MODELS``` 可以控制下载地址
    - 我的电脑 > 右键 > 属性 > 高级系统设置 > 环境变量 > 新建
  - 打开 ollama [模型下载页面](https://ollama.com/search)
  - 打开 [deepseek-r1模型页面](https://ollama.com/library/deepseek-r1) 
  - 选择需要的模型，复制命令到命令行执行
   
    ![模型.png](/static/img/a4495ef35acc72a1b66be34df40f7063.%C3%A6%C2%A8%C2%A1%C3%A5%C2%9E%C2%8B.webp)

    ![run1.png](/static/img/a7d5782d5428ea38e922723ab626b04d.run1.webp)


    ![run2.png](/static/img/e46d1b4b0e7409b36668b511d1962bac.run2.webp)


3. 使用图形化界面

4. 资源使用情况（7b）

![资源.png](/static/img/6ca917fc9c57a150735335346396e7a9.%C3%A8%C2%B5%C2%84%C3%A6%C2%BA%C2%90.webp)


![执行02.jpg](/static/img/66a6b9e0fde857ed2269562f23e27842.%C3%A6%C2%89%C2%A7%C3%A8%C2%A1%C2%8C02.webp)

DeepSeek-r1 本地部署

最近有点烦，https 的证书到期了，发现免费一次只能续 3 个月，有点麻烦。刚好难道周末有空，开下电脑就搞一下自动获取证书。

## 1. 操作

操作环境为 centos7, 腾讯云服务器

申请域名为 hjl18.com （包含所有二级域名）





1. 下载 cerbot

> yum update -y
>
> yum install certbot -y

2. 申请 RSA 通配符证书命令

> certbot -d hjl18.com -d *.hjl18.com --manual --preferred-challenges dns-01 --server https://acme-v02.api.letsencrypt.org/directory certonly --agree-tos --register-unsafely-without-email

```bash
-------------------------------------------------------------------------
Please deploy a DNS TXT record under the name
_acme-challenge.co1dawn.com whith the following value:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Before continuing, verify the record is deployed.
-------------------------------------------------------------------------
Press Enter to Continue

-------------------------------------------------------------------------
```

- `-d`参数用于指定域名（Domain）。
- `hjl18.com`是主域名。`*.hjl18.com`是通配符域名，表示所有以`hjl18.com`为后缀的子域名，例如`subdomain.hjl18.com`等都包含在内。这意味着该命令将为指定的主域名及其所有子域名（符合通配符规则的）申请证书。
- `--manual`这个参数表示使用手动模式来完成域名验证。需要用户手动配置 DNS 记录
- `--preferred-challenges dns-01` 
  - `--preferred - challenges`参数用于指定首选的验证挑战方式
  - `dns - 01`是一种验证方式。在这种验证方式中，用户需要通过修改 DNS 记录来证明对域名的所有权。Let's Encrypt 会检查 DNS 记录中的特定 TXT 记录来验证域名。这种方式对于一些无法通过 HTTP 验证（例如没有运行 Web 服务器或者 Web 服务器配置复杂）的情况非常有用
- `--server https://acme - v02.api.letsencrypt.org/directory`
  - 这个参数指定了 ACME（Automated Certificate Management Environment）服务器的地址。ACME 是一种协议，用于自动化证书的颁发、更新和撤销。Let's Encrypt 使用 ACME 协议来提供证书服务，`https://acme - v02.api.letsencrypt.org/directory`是 Let's Encrypt 的 ACME v2 服务器的目录端点。Certbot 通过与这个服务器通信来完成证书的申请和管理流程。
- `certonly` 这个参数告诉 Certbot 只获取证书，而不进行其他操作
- `--agree-tos`  表示用户同意 Let's Encrypt 的服务条款
- `--register-unsafely-without-email` 这个参数表示用户不提供电子邮件地址就进行注册


3. 把上述命令输出的 text 文本添加到 dns 解析里面

![dns01.png](/static/img/597f544872f7f6d2424d75c4dae64ce5.dns01.webp)

![dns02.png](/static/img/38b550cd877f2dc1944ead6eda3b8054.dns02.webp)


4. 按下 Enter ，这是就会获取证书了 ( /etc/letsencrypt/live/ 目录下)
5. 在 nginx 上修改证书配置(ssl_certificate, ssl_certificate_key, ssl_trusted_certificate)

```nginx
server {
    listen 443 ssl;
    server_name test.hjl18.com;
    ssl_certificate /etc/letsencrypt/live/hjl18.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/hjl18.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/hjl18.com/chain.pem;
    ssl_session_timeout 5m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2; #按照这个协议配置
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
    ssl_prefer_server_ciphers on;
    access_log /data/logs/main_access_test.log;
    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header Range $http_range;
        proxy_set_header If-Range $http_if_range;
        proxy_redirect off;
        proxy_pass http://0.0.0.0:5700;
        client_max_body_size 20000m;
    }
}
```

6. 重启一下nginx, 查看网站证书刷新成功

7. 定时更新证书: 

   新增脚本 renew_cert.sh

   ```bash
   #!/bin/bash
   
   cerbot renew
   /usr/local/nginx/sbin/nginx -s reload -c /data/nginx-1.17.5/myconf/nginx.conf	
   ```

   授权

   > chmod 777 renew_cert.sh

   设置定时器

   > crontab -e

   ```bash
   0 0 */90 * * /data/nginx-1.17.5/myconf/renew_cert.sh
   ( :wq! 退出)
   ```



**到此完成！！**



## 2. 原理

在域名解析中的 txt 规则

- TXT（Text）记录是域名系统（DNS）中的一种资源记录类型。它主要用于存储文本信息。
- 从功能角度看，TXT 记录就像是给域名添加了一个 “备注标签”，这个标签可以包含各种文本内容，用于特定的目的。例如，在反垃圾邮件设置中，一些邮件服务提供商可能会要求添加 TXT 记录来验证域名所有者的身份，以防止域名被滥用发送垃圾邮件。

时序图：

```mermaid
sequenceDiagram
    participant User as 用户
    participant Certbot as Certbot工具
    participant Let'sEncrypt as Let's Encrypt服务器
    participant DNS_Server as DNS服务器

    User->>Certbot: 执行证书申请命令（含DNS-01挑战）
    Certbot->>Let'sEncrypt: 发起证书申请请求，请求DNS-01验证
    Let'sEncrypt->>Certbot: 返回用于验证的TXT记录令牌
    Certbot->>User: 提示用户将令牌添加到域名DNS的TXT记录
    User->>DNS_Server: 在域名管理处添加TXT记录（含令牌）
    DNS_Server->>Let'sEncrypt: 完成记录更新并等待查询
    Let'sEncrypt->>DNS_Server: 查询域名的TXT记录
    DNS_Server->>Let'sEncrypt: 返回包含令牌的TXT记录内容
    Let'sEncrypt->>Certbot: 根据验证结果告知是否验证通过
    Certbot->>User: 反馈证书申请最终结果（成功/失败）
```

3个月的SSL免费证书有点短？Cerbot 自动"续费"

## 1. 简介

- [官方地址](https://www.mongodb.com/)
- [下载地址](https://www.mongodb.com/try/download/community-edition/releases)
  - 偶数版本(比如 3.2 , 3.4) 为稳定版，奇数为开发版
  - 对32位支持不佳，3.2 版本后不再支持
- [文档](https://www.mongodb.com/developer/) 





### 1.1. 安装

 [手册](https://www.mongodb.com/zh-cn/docs/manual/tutorial/install-mongodb-on-windows/) 

[MongoDb shell 下载](https://www.mongodb.com/try/download/shell)

这里采用压缩包，其实用 msi 安装更好一点，不需要启动

1. 安装, 这里下载了压缩包就直接解压了

2. 把目录下的，bin目录添加到环境变量里面去

   - 例如: I:\Environment\mongodb_7.0.12\bin

   - CMD 执行 ``setx PATH "%PATH%;I:\Environment\mongodb_7.0.12\bin\"``

3. CMD 执行 `` mongod`` , 输出信息即配置完成

4. CMD(管理员权限) 执行启动命令

   ```shell
   PS C:\Windows\system32> mongod --dbpath="I:\cache\db\data"
   {"t":{"$date":"2024-07-27T12:05:32.630+08:00"},"s":"I",  "c":"NETWORK",  "id":4915701, "ctx":"thread1","msg":"Initialized wire specification","attr":{"spec":{"incomingExternalClient":{"minWireVersion":0,"maxWireVersion":21},"incomingInternalClient":{"minWireVersion":0,"maxWireVersion":21},"outgoing":{"minWireVersion":6,"maxWireVersion":21},"isInternalClient":true}}}
   {"t":{"$date":"2024-07-27T12:05:34.126+08:00"},"s":"I",  "c":"CONTROL",  "id":23285,   "ctx":"thread1","msg":"Automatically disabling TLS 1.0, to force-enable TLS 1.0 specify --sslDisabledProtocols 'none'"}
   {"t":{"$date":"2024-07-27T12:05:34.127+08:00"},"s":"I",  "c":"NETWORK",  "id":4648602, "ctx":"thread1","msg":"Implicit TCP FastOpen in use."}
   {"t":{"$date":"2024-07-27T12:05:34.129+08:00"},"s":"I",  "c":"REPL",     "id":5123008, "ctx":"thread1","msg":"Successfully registered PrimaryOnlyService","attr":{"service":"TenantMigrationDonorService","namespace":"config.tenantMigrationDonors"}}
   ```

   - `--dbpath` 指定数据存储目录
   - `--port xxx` 指定端口， 默认 27017

5. 安装 mongodb shell

   - .editor 使用内置编辑器，  `<ctrl> + d` 退出并运行函数

6. 输入指令 mongosh 链接 mongodb 

   ```shell
   PS C:\Windows\system32> mongosh
   Current Mongosh Log ID: 66a47105f645b402a1c4e49a
   Connecting to:          mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.2.12
   Using MongoDB:          7.0.12
   Using Mongosh:          2.2.12
   
   For mongosh info see: https://docs.mongodb.com/mongodb-shell/
   
   ------
      The server generated these startup warnings when booting
      2024-07-27T11:52:46.652+08:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted
      2024-07-27T11:52:46.653+08:00: This server is bound to localhost. Remote systems will be unable to connect to this server. Start the server with --bind_ip <address> to specify which IP addresses it should serve responses from, or with --bind_ip_all to bind to all interfaces. If this behavior is desired, start the server with --bind_ip 127.0.0.1 to disable this warning
   ------
   
   test>
   ```

7. 修改为系统服务(msi安装的不太一样，查看官方文档)

   - 创建配置文件：bin 目录下添加文件 mongod.cfg  [参考官方文档](https://www.mongodb.com/zh-cn/docs/manual/reference/configuration-options/#std-label-configuration-options)

     ```yaml
     #processManagement:
     #   fork: false
     net:
        bindIp: localhost
        port: 27017
     storage:
        # 它指定 MongoDB 将存储其数据文件的位置。
        dbPath: I:\cache\db\data
     systemLog:
        destination: file
        path: I:\cache\db\log\out.log
        logAppend: true
     ```

     

   - 添加配置文件

   - 管理员身份打开命令行窗口

   - 执行命令：

     ```shell
     PS C:\Windows\system32> .\sc.exe create MongoDB binPath="I:\Environment\mongodb_7.0.12\bin\mongod.exe --service --config=I:\Environment\mongodb_7.0.12\bin\mongod.cfg" DisplayName="MongoDB" start="auto"
     [SC] CreateService 成功
     ```

   - 查看任务管理器，随便一个服务右键打开服务，找到 MongoDB 查看(右键启动)
        ![windows_service.png](/static/img/a6bc79ab51bec0ee08c14ed160180d02.windows_service.webp)


   - 删除服务：

     ```shell
     sc.exe delete MongoDB
     ```



### 1.2 Compass 使用

- 下载：[MongoDB Compass Download（GUI）](https://www.mongodb.com/try/download/shell)
- 直接安装打开即可

**创建链接**

![mgdb_compass.png](/static/img/d5556653f13b33ef9144f339e285f438.mgdb_compass.webp)


**主要界面**

![mgdb_compass_main.png](/static/img/72b7063e037da7eeeb0724e5cbc7406c.mgdb_compass_main.webp)


## 2. 基本操作



### 2.1 基本概念

MongoDB 将数据记录存储为**文档**（具体来说是 **BSON** (byte json)文档），并将它的汇集在**集合**中。**数据库**存储一个或多个文档集合。

- **数据库（database）**：数据库是一个仓库，在仓库可以存放集合
- **集合（collection）**: 集合类似于数组，在集合中可以存放文档
- **文档（document）**： 文档数据库中的最小单位，我们存储和操作的内容都是文档

在 MongoDB 中数据库和集合都不需要我们显式地去创建，当我们创建文档时，如果文档所在的数据库或集合不存在，则会自动创建



### 2.2 基本指令

> show dbs

- 显示当前所有数据库

```shell
test> show dbs
admin   40.00 KiB
config  60.00 KiB
local   40.00 KiB
```

----



> use databaseName

- 进入数据库
  - 在进入数据库时，如果数据库不存在，不会有任何影响，退出仍然查询不到abc数据库
  - 当进入到不存在的数据库里面，创建文档则自动创建

```shell
test> show dbs
admin   40.00 KiB
config  92.00 KiB
local   40.00 KiB
test> use test001
switched to db test001
test001> use test
switched to db test
test> show dbs
admin   40.00 KiB
config  92.00 KiB
local   40.00 KiB
test> use test001
switched to db test001
```

---



> db 

- 显示当前数据库

---



> show collections

- 显示数据库中所有的集合

---



> db.<collection>.drop()

- 删除集合

---



> db.dropDatabase()

- 删除数据库



### 2.3 CRUD

[MongoDB CRUD 操作](https://www.mongodb.com/zh-cn/docs/manual/crud/)

#### 插入

> db.<collection>.insertOne(doc)

- 将单个文档插入集合的明细信息嵌入进来。
  - 会自动产生一个 `_id` 属性，这是文档的唯一标识


```shell
test001> db.status.insertOne({name:"test",age:18,gender:"男"})
{
  acknowledged: true,
  insertedId: ObjectId('66a4f439056a8a9e1ac4e49c')
}

test001> show dbs
admin    40.00 KiB
config   92.00 KiB
local    40.00 KiB
test001  72.00 KiB

test001> show collections
status
```

---



>  db.<collection>.insertMany(docs)

- 批量插入

```shell
test001> db.status.insertMany([{name:"孙悟空", age:600},{name:"猪八戒",age:700}])
{
  acknowledged: true,
  insertedIds: {
    '0': ObjectId('66a5ab4bb15d4950bcc4e49f'),
    '1': ObjectId('66a5ab4bb15d4950bcc4e4a0')
  }
}
```





#### 查询

> db.<collection>.find({})<[index]>

查询集合中所有符合条件的文档

---

> db.<collection>.findOne({})

- 查询集合中符合条件的一个文档

---

[查询和操作符](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/query/)

[正则表达式](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/query/regex/#mongodb-query-op.-regex)



##### 查询所有

- {} 或为空，表示查询**所有文档**

```shell
test001> db.status.find()
[
  {
    _id: ObjectId('66a4f41c056a8a9e1ac4e49b'),
    name: 'test',
    age: 18,
    gender: '男'
  },
  {
    _id: ObjectId('66a4f439056a8a9e1ac4e49c'),
    name: 'test',
    age: 18,
    gender: '男'
  },
  {
    _id: ObjectId('66a4f477056a8a9e1ac4e49d'),
    name: 'test02',
    age: 18,
    gender: '男'
  },
  { _id: ObjectId('66a5ab4bb15d4950bcc4e49f'), name: '孙悟空', age: 600 },
  { _id: ObjectId('66a5ab4bb15d4950bcc4e4a0'), name: '猪八戒', age: 700 }
]

```

---

查询行数

> db.<collection>.find({}).count()

---

##### 等于 (=)

`{<key>:<value>,...}` 查询指定字段为指定值的文档

-  `db.status.find({name:"test"})` 查询 name = test 

```shell
test001> db.status.find({name:"test"})
[
  {
    _id: ObjectId('66a4f41c056a8a9e1ac4e49b'),
    name: 'test',
    age: 18,
    gender: '男'
  },
  {
    _id: ObjectId('66a4f439056a8a9e1ac4e49c'),
    name: 'test',
    age: 18,
    gender: '男'
  }
]
```

---



##### 包括（$in）

> {<key>:{$in:[<value>,...]}

```shell
test001> db.status.find({name:{$in:["孙悟空","猪八戒"]}})
[
  { _id: ObjectId('66a5ab4bb15d4950bcc4e49f'), name: '孙悟空', age: 600 },
  { _id: ObjectId('66a5ab4bb15d4950bcc4e4a0'), name: '猪八戒', age: 700 }
]
```

---



##### 或（$or）

> {$or:[{<key>:<value>,...}, {<key>:<value>,...}]}

```shell
test001> db.status.find({$or:[{name:"孙悟空"},{age:700}]})
[
  { _id: ObjectId('66a5ab4bb15d4950bcc4e49f'), name: '孙悟空', age: 600 },
  { _id: ObjectId('66a5ab4bb15d4950bcc4e4a0'), name: '猪八戒', age: 700 }
]
```

---



##### 排序

**查询文档时，默认使用_id的值进行排序(升序)**



> db.<collection>.find().sort({<key>:<value>...})

- sort 指定排序规则
  - `key` 为排序字段
  - `value` 为 1 时升序，为 -1 时降序

---



##### 投影

> db.<collection>.find({}, {<key>:<value>...})

- 查询结果投影，{<key>:<value>...} 为想要显示的字段



#### 修改

[参考文档](https://www.mongodb.com/zh-cn/docs/manual/reference/method/db.collection.updateMany/#mongodb-method-db.collection.updateMany)

> db.<collection>.updateOne(<filter>, <update>, <options>)
>
> db.<collection>.updateMany(<filter>,<update>, <options>)

- 根据 filter条件，修改 update 中的字段

  - `<update>` 需要使用修改操作符号, 参考：[更新操作符](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/update/)

  - ```json
    {
       <operator1>: { <field1>: <value1>, ... },
       <operator2>: { <field2>: <value2>, ... },
       ...
    }
    ```

  - `<options>` 

  - ```json
    {
         upsert: <boolean>, // 
         writeConcern: <document>,
         collation: <document>,
         arrayFilters: [ <filterdocument1>, ... ],
         hint:  <document|string>,
         let: <document>
       }
    ```

    - **upsert**:  可选。当为 `true` 时，`updateMany()`将：1. 如果没有文档与 `filter` 匹配，则创建一个新文档， 2.更新与 `filter` 匹配的文档。要避免多次更新或插入，请确保 `filter` 字段具有唯一索引默认值为 `false`。
    - **writeConcern**: 可选。表达写关注的文档。省略以使用默认写关注。如果是在事务中运行，则请勿显式设置此操作的写关注。要将写关注与事务一起使用，请参阅事务和写关注。

```shell
test001> db.status.find({name:{$in:["孙悟空","test02"]}})
[
  {
    _id: ObjectId('66a4f477056a8a9e1ac4e49d'),
    name: 'test02',
    age: 45,
    gender: '男'
  },
  { _id: ObjectId('66a5ab4bb15d4950bcc4e49f'), name: '孙悟空', age: 45 }
]
test001> db.status.updateMany({name:{$in:["孙悟空","test02"]}},{$set:{gender:"女"}})
{
  acknowledged: true,
  insertedId: null,
  matchedCount: 2,
  modifiedCount: 2,
  upsertedCount: 0
}
test001> db.status.find({name:{$in:["孙悟空","test02"]}})
[
  {
    _id: ObjectId('66a4f477056a8a9e1ac4e49d'),
    name: 'test02',
    age: 45,
    gender: '女'
  },
  {
    _id: ObjectId('66a5ab4bb15d4950bcc4e49f'),
    name: '孙悟空',
    age: 45,
    gender: '女'
  }
]
```

---



> db.<collection>.replaceOne(<filter>, <update>, <options>)

根据 filter条件，替换文档为 update 

```shell
test001> db.status.find({name:{$in:["孙悟空","test02"]}})
[
  {
    _id: ObjectId('66a4f477056a8a9e1ac4e49d'),
    name: 'test02',
    age: 45,
    gender: '女'
  },
  {
    _id: ObjectId('66a5ab4bb15d4950bcc4e49f'),
    name: '孙悟空',
    age: 45,
    gender: '女'
  }
]

test001> db.status.replaceOne({name:{$in:["孙悟空","test02"]}},{age:60})
{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0
}
test001> db.status.find({name:{$in:["孙悟空","test02"]}})
[
  {
    _id: ObjectId('66a5ab4bb15d4950bcc4e49f'),
    name: '孙悟空',
    age: 45,
    gender: '女'
  }
]

test001> db.status.find({_id:{$in:[ObjectId('66a4f477056a8a9e1ac4e49d'),ObjectId('66a5ab4bb15d4950bcc4e49f')]}})
[
  { _id: ObjectId('66a4f477056a8a9e1ac4e49d'), age: 60 },
  {
    _id: ObjectId('66a5ab4bb15d4950bcc4e49f'),
    name: '孙悟空',
    age: 45,
    gender: '女'
  }
]
```

---



**操作符**

| 名称                                                         | 说明                                                         |
| :----------------------------------------------------------- | :----------------------------------------------------------- |
| [`$currentDate`](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/update/currentDate/#mongodb-update-up.-currentDate) | 将字段的值设置为当前日期，可以是日期或时间戳。               |
| [`$inc`](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/update/inc/#mongodb-update-up.-inc) | 将字段的值按指定量递增。                                     |
| [`$min`](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/update/min/#mongodb-update-up.-min) | 仅当指定值小于现有字段值时才更新字段。                       |
| [`$max`](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/update/max/#mongodb-update-up.-max) | 仅当指定值大于现有字段值时才更新字段。                       |
| [`$mul`](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/update/mul/#mongodb-update-up.-mul) | 将字段的值乘以指定量。                                       |
| [`$rename`](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/update/rename/#mongodb-update-up.-rename) | 重命名字段。                                                 |
| [`$set`](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/update/set/#mongodb-update-up.-set) | 设置文档中字段的值。                                         |
| [`$setOnInsert`](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/update/setOnInsert/#mongodb-update-up.-setOnInsert) | 如果某一更新操作导致插入文档，则设置字段的值。对修改现有文档的更新操作没有影响。 |
| [`$unset`](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/update/unset/#mongodb-update-up.-unset) | 从文档中删除指定的字段。                                     |





#### 删除

> db.<collection>.deleteMany({})
>
> db.<collection>.deleteOne({})

- 删除指定文档，传入条件和 find 一样
  - 为空时删除所有文档







## 3. 索引

### 3.1 命令

> db.<collection>.getIndexes()

- 查询文档的所有索引

```shell
test001> db.status.getIndexes()
[ { v: 2, key: { _id: 1 }, name: '_id_' } ]
```

---



> db.<collection>.createIndex({<key>:<value>...}, <options>)

- 创建索引，如果只有对 key value,表示当个索引，这时候value的值不重要
- value 为排序顺序，1升序，-1降序，在聚合索引中，索引字段的排序尤为重要
- options  索引属性
  - **unique** ： 指定 `true` 可创建唯一索引。默认值为 `false`。
  - **name** ： 索引名称。如果未指定，MongoDB 将通过连接索引字段的名称和排序顺序来生成索引名称
  - **partialFilterExpression** ： 部分索引，如果指定，索引只引用与过滤器表达式匹配的文档
    - `{ partialFilterExpression: { rating: { $gt: 5 } } }` 表示部分 rating 字段大于5 的文档进行索引
  - **sparse** ：如果为`true`，则索引仅引用具有指定字段的文档。这些索引使用的空间较少，但在某些情况下（尤其是排序），其行为会有所不同。 默认值为`false` 。

```shell
# 复合索引
test001> db.status.createIndex({age:1, name:-1})
age_1_name_-1

test001> db.status.getIndexes()
[
  { v: 2, key: { _id: 1 }, name: '_id_' },
  { v: 2, key: { age: 1, name: -1 }, name: 'age_1_name_-1' }
]

# 多键索引
test001> db.status.insertOne({name:"index01", doc:{number:10, text:"xxxx"}})
{
  acknowledged: true,
  insertedId: ObjectId('66a613deb15d4950bcc4e4a1')
}
test001> db.status.find({"doc.number":10})
[
  {
    _id: ObjectId('66a613deb15d4950bcc4e4a1'),
    name: 'index01',
    doc: { number: 10, text: 'xxxx' }
  }
]
test001> db.status.createIndex({"doc.number": -1})
doc.number_-1
test001> db.status.getIndexes()
[
  { v: 2, key: { _id: 1 }, name: '_id_' },
  { v: 2, key: { 'doc.number': -1 }, name: 'doc.number_-1' }
]
```

---



> db.<collection>.dropIndex("<indexName>")
>
> db.<collection>.dropIndexes(["<indexName>", ...])
>
> db.<collection>.dropIndexes() 

- 删除指定索引
  - db.<collection>.dropIndexes() 删除所有索引

```shell
test001> db.status.getIndexes()
[
  { v: 2, key: { _id: 1 }, name: '_id_' },
  { v: 2, key: { age: 1, name: -1 }, name: 'age_1_name_-1' }
]
test001> db.status.dropIndex("age_1_name_-1")
{ nIndexesWas: 2, ok: 1 }
test001> db.status.getIndexes()
[ { v: 2, key: { _id: 1 }, name: '_id_' } ]
```



### 3.2 索引的类型

- **单字段索引**： 收集集合内每个文档中单个字段的数据，并对其排序
- **复合索引**：  从集合中每个文档的两个或多个字段收集数据并对其排序。数据先按索引中的第一个字段分组，再按每个后续字段分组。
- **多键索引**： 收集数组中存储的数据并进行排序。

MongoDB 入门

### 1.1 ACID

我们聊到事务，通常会说到 ACID，指**原子性（Atomicity),，一致性（Consistency），隔离性（Isolation），持久性（Durability）**。ACID是事务的特性，也是事务本质的最重要体现。

-  **原子性：all-or-nothing**

我们经常会在多线程中看到原子性这个词，它是指具有原子性的一批指令，能被CPU一次性执行完。

ACID的原子性，也类似。指一次事务请求中的所有语句，要么都成功，要么都不处理。也就是整体提交，或整体回退。




- **一致性：状态一致**

与分布式理论CAP中的一致性不一样，这里的一致性不是说数据一致，而是指规则一致。也就是在用户设置得规则（约束）下，所有语句执行前后数据的状态必须保存一致（都符合规则）。

例如：我们规定字段不能为空，那么不管是insert, update前后，这个字段都不能存在为空的数据。

- **隔离性**

事务之间（按照设置得隔离级别）相互隔离，互不影响。这个在下文会重点讨论

- **持久性**

持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。



### 1.2 隔离性

ACID 对于一个数据库很重要，作为一个开发，我们往往最需要关注的是隔离性

#### 1.2.1 隔离级别

事务的隔离级别分为四个：

- **读未提交（read uncommitted）**

一个事务的修改，即使没有提交，也能被别的事务所看见。

- **读提交（read committed）**

一个事务开始时，只能看见已经提交的事务所做的修改。

- **可重复读（repeatable read）**

同一个事务，在事务期间，看到的数据都是一样的，不会被别的事务所改变。这是 mysql 默认的隔离级别。

- **串行化（serializable ）**

强制事务串行执行，简单说就是对同一行记录，读加读锁，写加写锁，读写出现锁冲突，排队等待锁释放。
这种模式下，事务的锁竞争变得平方，容易出现超时，很少会使用这种模式。



隔离级别示例图如下：

![隔离级别.jpg](/static/img/4380073a5a07de6d995fc2232ec6302a.%C3%A9%C2%9A%C2%94%C3%A7%C2%A6%C2%BB%C3%A7%C2%BA%C2%A7%C3%A5%C2%88%C2%AB.webp)


| 隔离级别 | search1  | search2  |
| -------- | -------- | -------- |
| 读未提交 | age = 5  | age = 5  |
| 读提交   | age = 10 | age = 5  |
| 可重复读 | age = 10 | age = 10 |

而串行化在事务B开启事务时会开启失败，等待事务A commit 后，开始执行。



#### 1.2.2 MVCC

全称：muti-version concurrency control， 即多版本并发控制。

这是 mysql 在 **读提交、可重复读** 隔离级别下，为了保证读写的并发性而设计的方案。

 MVCC 的工作原理基于三个概念，分别是：**行的隐藏列**， **undo log 版本链**， **read view**

- **行的隐藏列**

每一行数据都有两列隐藏数据： trx_id, roll_pointer

**trx_id** 表示当前这行数据的最新事务id，只要任意一个事务对数据进行修改，该事务的id就会被记录到该字段

**roll_pointer** 保存上一个版本数据的指针

- **undo log 版本链**

Undo Log是MySQL的三大日志之一, 当我们对记录做了变更炒作时，就会产生一条 undo 记录，用以在发生异常或手动回滚事务时，回滚到历史版本数据。

如下：
![undo_log.png](/static/img/a16861d12e3b690be8bf4a24a0d625db.undo_log.webp)

- **Read View**

Read View 中存放着一个列表，每一个事务都会创建一条记录，字段如下

| creator_trx_id | m_ids                      | min_trx_id          | max_trx_id           |
| -------------- | -------------------------- | ------------------- | -------------------- |
| 当前事务id     | 所有活跃的事务id（未提交） | m_ids中最小的事务id | 分配给下一个事务的id |

**这个视图决定了事务的可见性**

事务在查询时会建立一条记录，查询数据的流程如下：

![查询流程.png](/static/img/71c771a147186715e978c9dbf61ceef4.%C3%A6%C2%9F%C2%A5%C3%A8%C2%AF%C2%A2%C3%A6%C2%B5%C2%81%C3%A7%C2%A8%C2%8B.webp)



在可重复读隔离级别下，如果事务只是进行查询操作，那么就**「只会在第一次查询的时候生成 ReadView 快照，这一点和读提交隔离级别是最大的区别」**。



### 1.3 并发问题

- read uncommitted - Dirty Read

**读未提交 - 脏读**

读未提交隔离级别的定义是，「一个事务的修改，即使没有提交，也能被别的事务所看见。」

1. 在事务A执行过程中，事务A对数据资源进行了修改，事务B读取了事务A修改后的数据
2. 由于某些原因，事务A并没有完成提交，发生了 Roll Back，则事务B读取的数据就是脏数据。

这种现象就是 脏读， 隔离级别修改为 read committed ，可以解决脏读问题



- read committed  - Nonrepeatable Read

**读提交 - 不可重复读**

对于读提交的隔离级别来讲，在 MVCC 中，生成 Read View 的时机是，每一次查询的时候，这就会有一个现象，当前事务在进行的过程中，**每次查询生成的 Read View 都有可能不同**，所以同一条数据读取到的数据可能不同，这种现象就是**不可重复读**

隔离级别修改为 repeatable read，可以解决该问题



- repeatable read -  Phantom Read

**可重复读 - 幻读**

在可重复读的隔离级别下，我们第一次发生查询时就生成了 Read View ，后续不再生成，这是其他事务区插入一条数据（比如：id=10）,然后提交结束，这时我们海狮看不到 id = 10 的记录，这种情况下，我们也去插入一条 id = 10 的数据，就会出现逐渐冲突。这种情况就是幻读。