# MongoDB入门基础教程

本文主要围绕 MongoDB 的使用，从环境配置、数据库使用，再到客户端工具选用，做了简单的介绍，可能有的地方总结的不到位，还望指正。



## 1.介绍

在介绍 MongoDB 之前，我先介绍一下业务开发的时候遇到的痛点，以便大家对它有一个更加清晰的认识！

最近在用数据库存储数据的时候发现这么一个坑，例如从消息队列中监听消息的时候，原来的做法是将监听的消息json数据存储在数据库，以便好对异常消息数据进行追溯，消息内容使用`text`类型存储，起初因为数据内容很短，没啥毛病，但是当随着业务的扩展，收到的消息内容越来越长，最后发现数据库中的`text`字段类型无法很好的支持查询，于是在这个时候，就开始考虑采用更加合适的数据库来存储这种消息数据！在经过一番讨论之后，对于这种 json 类型的消息数据的存储，大家一致认为采用 MongoDB 是最佳的选择！

据官方介绍，MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富、最像关系数据库的一款高性能的 NoSQL 数据库。

MongoDB 将数据存储为一个文档，数据结构由键值(`key=>value`)对组成。其中的文档类似于 JSON 对象。字段值可以包含其他文档、数组及文档数组，数据结构的支持非常灵活！的确，在使用的过程当中，正如所介绍的，数据的存储和查询，性能极快，而且很好的满足我们的需求！

话不多说，下面我们就一起来了解一下，这款数据库应该如何使用！

## 2.环境配置

在学习它之前，我们需要先搭建好环境，MongoDB 的安装也非常简单！

### 2.1、Windows 平台

如果你是 Windows 平台，MongoDB 提供了可用于 32 位和 64 位系统的预编译二进制，安装基本是傻瓜式的操作，登录 MongoDB 官网并且下载安装包，然后一步一步的操作即可！

![img](https://pic.wjcly.com/my-pic/main/img/202209021039727.jpeg)

### 2.2、Linux 平台

生产环境基本都是 Linux 平台，为了和生产保持一致，小编采用的服务器是`CentOS7`，安装过程也比较简单！

- 创建资源文件

```
sudo vim /etc/yum.repos.d/mongodb-org-4.0.repo
```

- 编辑内容如下

```
[mongodb-org-4.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.0.asc
```

- 运行以下命令安装 mongodb

```
sudo yum install -y mongodb-org
```

- 安装完成之后，配置`mongod.conf`允许远程连接

```
#编辑mongod.conf
vim /etc/mongod.conf
#将net:bindIp: 127.0.0.1 改为 0.0.0.0
net:
   bindIp:0.0.0.0
```

- 最后启动服务

```
#开启服务
systemctl start mongod
#关闭服务
systemctl stop mongod
#重启服务
systemctl restart mongod
#开机自启
systemctl enable mongod
```

至此，环境配置已经完成！

## 3.数据库操作

MongoDB 的数据操作，是开发人员接触最频繁的部分，第一次使用的时候，你会发现它和我们传统使用的 sql 脚本命令完全不同，但是又类似，下面我们就一起来深入的了解下！

### 3.1进入 MongoDB

进入 MongoDB 服务很简单，输入如下命令即可进入！

```
mongo
```

例如，在`CentOS`里面输入命令之后，进入的服务界面如下：

![img](https://pic.wjcly.com/my-pic/main/img/202209021039639.jpeg)

### 3.2创建数据库

MongoDB 创建数据库的语法格式如下：

```
use DATABASE_NAME
```

**如果数据库不存在，则创建数据库，否则切换到指定数据库**。

输入如下命令，可以查询数据库列表

```
#查询数据库列表
show dbs
#命令输出结果：
admin
config
local
```

可以看到，当前 MongoDB 有三个数据库！

输入如下命令，可以切换到`admin`数据库

```
use admin
```

输入`db`命令，还可以查询当前数据库

```
db
```

### 3.3创建用户

默认的情况下，是没有用户的，也无法操作数据库，因此我们需要创建一个用户，同时给他分配权限！

#### 3.3.1、创建一个管理员用户

创建一个用户、密码都是`admin`的用户，同时给这个用户分配`userAdminAnyDatabase`角色，指定的数据库为`admin`！

```
#创建一个admin用户
db.createUser(
{
  user: "admin",
  pwd: "admin",
  roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
})
```

其中字段含义如下：

- user：用户的名字；
- pwd：用户的密码；
- roles：指定用户的角色，可以用一个空数组给新用户设定空角色。
- roles 中的 role：指定角色。
- roles 中的 db：指定的数据库，例如上面中的角色`userAdminAnyDatabase`，只在 admin 数据库中可用。

角色在 MongoDB 中，**代表着某个用户是否有权限访问数据库或者操作数据库**，理解这点非常重要！

MongoDB 角色定义如下：

|    角色类型     |         名称         |                             描述                             |
| :-------------: | :------------------: | :----------------------------------------------------------: |
| admin数据库角色 |   readAnyDatabase    |      只在admin数据库中可用，赋予用户所有数据库的读权限       |
| admin数据库角色 | readWriteAnyDatabase |     只在admin数据库中可用，赋予用户所有数据库的读写权限      |
| admin数据库角色 | userAdminAnyDatabase |   只在admin数据库中可用，赋予用户所有数据库的userAdmin权限   |
| admin数据库角色 |  dbAdminAnyDatabase  |    只在admin数据库中可用，赋予用户所有数据库的dbAdmin权限    |
| admin数据库角色 |     clusterAdmin     | 只在admin数据库中可用，赋予用户所有分片和复制集相关函数的管理权限 |
| admin数据库角色 |         root         |          只在admin数据库中可用，超级账号，超级权限           |
| 数据库管理角色  |       dbAdmin        | 允许用户在指定数据库中执行管理函数，如索引创建、删除，查看统计或访问system.profile |
| 数据库管理角色  |      userAdmin       | 允许用户向system.users集合写入，可以在指定数据库里创建、删除和管理用户 |
| 数据库用户角色  |         read         |                    允许用户读取指定数据库                    |
| 数据库用户角色  |      readWrite       |                    允许用户读写指定数据库                    |

#### 3.3.2创建一个不受访问限制的超级用户

如果你想创建一个不受访问限制的超级用户，赋予`root`角色即可！

```
#创建超级用户
db.createUser(
    {
        user:"root",
        pwd:"root",
        roles:["root"]
    }
)
```

#### 3.3.3创建一个业务数据库普通用户

如果你想创建一个业务数据库普通用户，例如只能访问`test_db`数据库，并且只负责数据的増查改删。

```
# 创建或者切换数据库到test_db
use test_db

# 创建一个test用户，并且只能访问test_db，对表只有读写权限
db.createUser(
{
  user: "test",
  pwd: "test",
  roles: [ { role: "readWrite", db: "test_db" } ]
})
```

#### 3.3.4验证用户是否可以正常登录

对于刚刚创建的用户，我们怎么验证它是否能正常登录呢？命令也很简单！

```
db.auth("test","test")
```

如果返回是`1`表示鉴权正常！

#### 3.3.5查询当前数据库用户信息

查询创建的用户，命令也很简单！

```
# 查看创建的用户
show users
```

#### 3.3.6修改用户密码

有些时候，我们会忘记密码，可通过如下方式进行修改！

```
#修改用户密码
db.changeUserPassword("username", "xxxxx")
```

#### 3.3.7删除用户

如果某个用户需要停用，可通过如下方式进行删除

```
#切换指定数据库
use test_db
#删除用户
db.dropUser('test')
```

#### 3.3.8删除数据库

如果某个数据库需要停用，可通过如下方式进行删除（只有超级管理员有权限删除）

```
#切换指定数据库
use test_db
#删除数据库
db.dropDatabase()
```

### 3.4创建集合

MongoDB 并无**表**这个概念，而对应的定义叫：**集合**，我们在关系型数据库中看到的**表数据**，在 MongoDB 中被定义为：**文档**，MongoDB 也被很多人成为**文档数据库**！

在关系型数据库中，表数据是一行一行的存储，但是在 MongoDB 中，可能不是这样，如果你存储的 json 非常复杂，嵌套很深，那么在 MongoDB 中存储的行数，可能非常深，存储的时候类似我们在页面看到的父子表结构！

#### 3.4.1创建一个集合

MongoDB 中使用 createCollection() 方法来创建集合。

语法格式：

```
db.createCollection(name, options)
```

参数说明：

- name: 要创建的集合名称
- options: 可选参数, 指定有关内存大小及索引的选项

例如，在 test_db 数据库中创建 tb_user 集合：

```
# 切换到test_db数据库
use test_db
# 创建 tb_user 集合
db.createCollection("tb_user")
#输出结果
{ "ok" : 1 }
```

如果要查看已有的集合，可以使用`show collections`命令！

```
show collections
```

下面是带有几个关键参数的`createCollection()`的用法，下面命令表示：创建固定集合`tb_user`，整个集合空间大小`6142800`KB, 文档最大个数为`10000` 个

```
db.createCollection("tb_user", { capped : true, autoIndexId : true, size : 6142800, max : 10000 } )
```

在 MongoDB 中，很多时候不需要手动创建集合。当你插入一个文档时，MongoDB 会自动创建集合！

```
# 向集合tb_user 插入一条文档数据
db.tb_user.insert({"name" : "张三"})
#查询集合
show collections
# 输出结果
tb_user
```

#### 3.4.2删除一个集合

MongoDB 中使用 drop() 方法来删除集合。

语法格式：

```
db.collection.drop()
```

例如，删除在 test_db 数据库中 tb_user 集合：

```
# 切换到test_db数据库
use test_db
# 创建 tb_user 集合
db.tb_user.drop()
#输出结果
true
```

### 3.5、创建文档

创建文档，类似我们在关系型数据库中，将数据插入到数据库，操作也很简单！

#### 3.5.1插入文档

MongoDB 使用 `insert()` 或 `save()` 方法向集合中插入文档。

语法如下：

```
db.COLLECTION_NAME.insert(document)
或
db.COLLECTION_NAME.save(document)
```

- `save()`：如果`_id`主键存在则更新数据，如果不存在就插入数据。
- `insert()`：若插入的数据主键已经存在，则会抛异常，提示主键重复，不保存当前数据。

例如，在`test_db`数据库的`tb_user`集合中，插入一条数据

```
db.tb_user.insert(
{
    name:"张三",
    age:18,
    gender:"男",
    tags: ['宅男', '技术控', '脱发严重']
})
```

如果该集合不在该数据库中， MongoDB 会自动创建该集合并插入文档。

查看已插入文档，命令如下：

```
#查询tb_user集合中的数据
db.tb_user.find()
# 输出结果
{ "_id" : ObjectId("6022310f6b5e964b0a5916e6"), "name" : "张三", "age" : 18, "gender" : "男", "tags" : [ "宅男", "技术控", "脱发严重" ] }
```

当然，你还可以通过`save()`命令进行插入，如果不指定`_id`字段 `save()` 方法类似于 `insert()` 方法。如果指定 `_id` 字段，则会更新该 `_id` 的数据。

例如，将`张三`年龄更新到`30`岁！

```
db.tb_user.save(
{
    _id: ObjectId("6022310f6b5e964b0a5916e6"),
    name:"张三",
    age:30,
    gender:"男",
    tags: ['宅男', '技术控', '脱发严重']
})
```

查看文档

```
db.tb_user.find()
# 输出结果
{ "_id" : ObjectId("6022310f6b5e964b0a5916e6"), "name" : "张三", "age" : 30, "gender" : "男", "tags" : [ "宅男", "技术控", "脱发严重" ] }
```

#### 3.5.2更新文档

MongoDB 提供了 `update()` 和 `save()` 方法来更新集合中的文档。

语法格式如下：

```
db.collection.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 :可选，抛出异常的级别。

例如，将`张三`年龄更新到`22`岁！

```
db.tb_user.update({'name':'张三'},{$set:{'age':22}})
```

查询已更新的数据

```
db.tb_user.find()

# 输出结果
{ "_id" : ObjectId("602235216b5e964b0a5916e8"), "name" : "张三", "age" : 22, "gender" : "男", "tags" : [ "宅男", "技术控", "脱发严重" ] }
```

以上语句只会修改第一条发现的文档，如果你要修改多条相同的文档，则需要设置`multi`参数为`true`。

```
db.tb_user.update({'name':'张三'},{$set:{'age':22}},{multi:true})
```

#### 3.5.3删除文档

MongoDB 中的`remove()`函数是用来移除集合中的数据

语法格式如下：

```
db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)
```

- query :（可选）删除的文档的条件。
- justOne : （可选）如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，则删除所有匹配条件的文档。
- writeConcern :（可选）抛出异常的级别。

例如，删除姓名为`张三`的用户

```
db.tb_user.remove({'name':'张三'})
```

查询数据是否被删除

```
db.col.find()
#结果为空
```

#### 3.5.4查询文档

MongoDB 查询文档使用 find() 方法。

语法格式如下：

```
db.collection.find(query, projection)
```

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

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

```
db.col.find().pretty()
```

首先我们插入几条数据，插入结果如下：

![img](https://pic.wjcly.com/my-pic/main/img/202209021039417.jpeg)

例如，查询一个性别为`男`的用户信息

```
#单个条件查询，类似 sql语句中的 gender = '男'
db.tb_user.find({"gender":"男"})
```

查询一个性别为`男`，姓名为`张三`的用户

```
#多条件查询，类似 sql语句中的 gender = '男' and name = '李四'
db.tb_user.find({"gender":"男","name":"李四"})
```

查询一个性别为`男` 或者 姓名为`张三`的用户

```
#多条件查询，类似 sql语句中的 gender = '男' or name = '李四'
db.tb_user.find({$or:[{"gender":"男"},{"name": "李四"}]})
```

查询一个性别为`男` 或者 姓名为`张三`，同时年龄大于`30`的用户

```
#多条件查询，类似 sql语句中的 age > 30 and ( gender = '男' or name = '李四')
db.tb_user.find({"age": {$gt:30}, $or:[{"gender":"男"},{"name": "李四"}]})
```

#### 3.4.5分页查询文档

如果需要分页查询集合数据，可以使用`limit()`和`skip()`函数，其中`limit()`表示读几条数据，`skip()`表示从第几条数据开始。

```
#从集合中的第三行数据开始，读2条数据返回
db.tb_user.find({}).limit(2).skip(3)
```

#### 3.5.6文档排序

和关系型数据库一样，MongoDB 可以使用`sort()`方法进行排序，通过参数指定排序的字段，并使用 `1` 和 `-1` 来指定排序的方式，其中 `1` 为升序排列，而 `-1` 是用于降序排列。

例如，查询`tb_user`文档，按照`age`进行升序排序！

```
db.tb_user.find({}).sort({"age":1})
```

### 3.6创建索引

索引通常能够极大的提高查询的效率，如果没有索引，MongoDB 在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。

这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。

#### 3.6.1创建索引

MongoDB 使用 `createIndex()` 方法来创建索引，语法格式如下：

```
db.collection.createIndex(keys, options)
```

语法中 Key 值为你要创建的索引字段，`1` 为指定按升序创建索引，如果你想按降序来创建索引指定为 `-1` 即可！

例如，给`tb_user`文档中的`age`创建一个索引！

```
db.tb_user.createIndex({"age":1})
```

创建索引是一个比较耗时的动作，我们还可以通过参数配置，在后台创建索引。

```
db.tb_user.createIndex({"age":1}, {background: true})
```

通过在创建索引时加`background:true`的选项，让创建工作在后台执行！

#### 3.6.2查看索引

MongoDB 提供了`getIndexes()`方法，可以进行查看索引。

例如，查询`tb_user`集合中的索引

```
db.tb_user.getIndexes()
```

#### 3.6.3删除索引

不在需要的索引，我们可以将其删除。删除索引时，可以删除集合中的某一索引，可以删除全部索引。

语法格式：

```
db.COLLECTION_NAME.dropIndex("INDEX-NAME")
```

例如，删除集合`tb_user`集合中的`age`索引：

```
#查询索引
db.tb_user.getIndexes()
#输出结果
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test_db.tb_user"
    },
    {
        "v" : 2,
        "key" : {
            "age" : 1
        },
        "name" : "age_1",
        "ns" : "test_db.tb_user"
    }
]
```

删除对应的`age_1`索引！

```
db.tb_user.dropIndex("age_1")
```

## 4.客户端

对于任何一款数据库，如果没有可视化界面操作，在开发的时候，可以说极其不方便，下面推荐一款小编经常使用的一款客户端。

- Robo 3T(免费、轻量级) ，可以访问官网获取

![img](https://pic.wjcly.com/my-pic/main/img/202209021040062.jpeg)

- Studio 3T(全面，收费)，访问官网地址获取

![img](https://pic.wjcly.com/my-pic/main/img/202209021040560.jpeg)

其中小编采用的是第二款，整体的体验比`Robo 3T`要一点，两者功能都比较齐全！

在使用的时候，可以根据个人喜爱进行选择！

## 5.权限控制

网上发现很多 mongodb 被黑，使大家将目光投向了mongodb 的权限控制。

其实 mongodb 本身有一套完备的 RBAC 权限控制体系，这次被黑基本都是没有遵照 mongodb 的生产环境部署手册部署的结果。

我们平时玩一玩 mongodb 习惯了不设置用户名密码，当我们的数据库放到公网时，由于我们也没有设置用户名密码，任何人都可以随便访问，而且由于我们没有开启授权访问，使得任何登录到 mongodb 服务器的用户都拥有最高权限！

一些居心不良的人发现，就可以把我们的数据拷走，删除我们的数据库，从而勒索赎金！

再次提醒各位同学，别学会所有的技能，大门还一直开着，还抱怨我方防御塔怎么一直被摧毁！

以上文`CentOS7`安装为例，修改`/etc/mongod.conf`，在`security`部分添加如下配置，开启授权访问！

```
security:
    authorization: enabled
```

修改完成之后，重启 mongodb 服务

```
#重启服务
systemctl restart mongod
```

MonogoDB入门基础教程

# IDEA断点调试教程

## 1. 问题总结

> 1.怎么开启断点调试?

> 2.调试界面咋那么多按钮？
>
> - - 1.返回断点位置
>   - 2.步过
>   - 3.步入
>   - 4,5.强制步入，步出
>   - 6.回退断点
>   - 7.断点跳到光标处
>   - 8.表达式计算
>   - 9.恢复程序
>   - 10.停止程序
>   - 11.查看所有断点
>   - 12.禁用断点
>   - 13.其他

> 竟然有那么多调试断点？
>
> - - 1.方法断点
>   - 2.属性断点
>   - 3.异常断点
>   - 4.终止断点
>   - 5.条件断点
>   - 6.流断点
>   - 7.多线程断点
>   - 8.远程断点



## 2.怎么开启断点调试？

随着开发的深入，越来越觉得高效的调试方法是多么的重要了，但我们一般上来就是敲一些代码，谁会去静下心来学一些看似没什么用的调试技巧呢？但这恰恰就是新手和老手之间的区别。

断点调试是很简单的，只需要点击idea上方的小虫子，启动调试即可，如下所示。

![img](https://pic.wjcly.com/my-pic/main/img/202209011101731.png)这当然不是本文的重点，只是开个头。

## 3.调试界面咋那么多按钮？

先来介绍一下界面。

![img](https://pic.wjcly.com/my-pic/main/img/202209011101686.png)我给这些区域都标了号，下面来重点介绍。

### 3.1返回断点位置

1号按钮，这个用的不多，如果你从其他地方想要回到断点位置，就按一下即可，如下图所示。

![img](https://pic.wjcly.com/my-pic/main/img/202209011101716.gif)

### 3.2步过

2号按钮，说人话就是一行行的往下执行，不会进入方法里面，如下所示。

![img](https://pic.wjcly.com/my-pic/main/img/202209011101915.gif)

### 3.3步入

3号按钮，可以进入我们自定义的方法，如果是其他类库的方法不会进入，如下所示。

![img](https://pic.wjcly.com/my-pic/main/img/202209011101559.gif)

### 3.4强制步入|步出

4号5号按钮，前者可以进入深层的方法，包括官方的源码，后者就是从对应的方法中出来，演示如下。

![img](https://pic.wjcly.com/my-pic/main/img/202209011101003.gif)

### 3.5回退断点

6号按钮是很特殊的，如果你的代码中没有调用其他地方的方法，那么是呈灰色的，无法使用，只有进入更深层的方法，才能够使用，其实就是后悔药，我们很多时候调试时不小心按的快了点，很容易错过想看的位置，只能再次重启吗？不，使用这个drop frame 就可以了，演示如下。

可以看到，这里往下执行了add，但是还没有执行完，按这个按钮，再次回到了调用方法之前，但对于数据库插入等操作，其实是无法回退的，这里的回退只是因为记录了栈信息才能够做到的。

![img](https://pic.wjcly.com/my-pic/main/img/202209011101780.gif)但是要注意，如果你某个方法调用完毕了，你想再回去那就没有办法了。

### 3.6断点跳到光标处

7号按钮也用的不多，主要是为了快速跳转到光标指向的那一行，如下所示。

![img](https://pic.wjcly.com/my-pic/main/img/202209011102813.gif)

### 3.7表达式计算

8号按钮是计算表达式的，我们模拟从数据库获取集合，用表达式查询对应的元素，如下所示。

![img](https://pic.wjcly.com/my-pic/main/img/202209011116506.gif)

### 3.8恢复程序

9号按钮称为 `Resume Program`，能够跳转到指定的断点处，我们在10行和第100行各加一个断点，需要点几下该按钮跳转到100行呢？答案是一次即可，第一次断点会在第10行停下，点击改按钮直接飞越90行到第100行，如下所示。

![img](https://pic.wjcly.com/my-pic/main/img/202209011102946.gif)

### 3.9停止程序

10号按钮就是停止调试，但是注意，即便停止了调试，程序也会继续运行下去，如何想让他就在断点处停止呢？后面我会说到。

### 3.10查看所有断点

11号按钮打开又别有乾坤，基本功能如下图所示，主要是设置，查看断点信息，大家看着应吧，实用的方法我会在下面讲的。

![img](https://pic.wjcly.com/my-pic/main/img/202209011102417.png)

### 3.11禁用断点

12号按钮就简单了，暂时禁用掉断点，方便程序继续执行，一般配合 `Resume Program`。

### 3.12其他

13号其实不是按钮，而是一块区域，这里面存放了很多变量的信息，方便我们查看。

14号按钮其实之前被我忽略掉了，这次拿出来讲一下，在watch可以监控变量的变化，有同学说，中间的变量栏也可以看啊，但是单独拉出来，看起来更加的方便，演示如下。

![img](https://pic.wjcly.com/my-pic/main/img/202209011102929.gif)

## 4. 竟然有那么多调试断点？

这里省略了普通的行断点调试，毕竟是最简单的，大家都会。

### 4.1方法断点

方法断点是不是用在普通方法上的，最好的用法是在接口上使用，当我们在调试源码的时候，如果在接口上打了断点，再往下走，可以直接跳转到实现类的实现方法上，而不需要我们一个个的去找。

案例中，有一个接口`DemoInterface`，它有两个实现类，让我们看下效果吧，演示如下。

![img](https://pic.wjcly.com/my-pic/main/img/202209011111531.png)注意：方法断点是一个菱形标志。

![img](https://pic.wjcly.com/my-pic/main/img/202209011111977.gif)

其实可以直接在接口方法上打断点，直接跳转到对应的实现方法的，这里是为了放慢演示速度。

### 4.2属性断点

属性断点是打在属性上的，我们无需再`getter setter`方法上打断点，在属性上打上断点，就会出现一个小眼睛的标志，如下所示。

![img](https://pic.wjcly.com/my-pic/main/img/202209011112502.png)

在眼睛上点击右键可以设置。

我们一般是通过getter，setter方法设值的，所以就会在这两个方法上停留。

![img](https://pic.wjcly.com/my-pic/main/img/202209011112914.png)

看一下GIF演示吧。

![img](https://pic.wjcly.com/my-pic/main/img/202209011113662.gif)

### 4.3异常断点

在线上由于空指针出现了BUG，我们想快速定位到哪里出现了空指针，应该怎么做呢，答案就是，异常断点！演示如下。

注意，异常断点是一个闪电的标志。

![img](https://pic.wjcly.com/my-pic/main/img/202209011113574.gif)

可以看到，我们在全局打了个空指针断点，只要哪里出现了空指针，就会在那里停止，太方便了！

### 4.4终止断点

前面我们说过，即便停止程序，也不会让我们后面运行的代码取消执行，那么我一定要取消执行可以吗？当然是可以的，演示如，在方法栈上点击右键，有一个`Force Return`，然后再点击`Resumer Program`，就可以直接终止返回了。

![img](https://pic.wjcly.com/my-pic/main/img/202209011113627.gif)

### 4.5条件断点

我想要在某个条件满足的时候打上断点，而不想一步步的走下去，有什么办法吗？当然有，在断点处右击，在`condition`里填入相应的条件即可，演示如下。

![img](https://pic.wjcly.com/my-pic/main/img/202209011115237.gif)

### 4.6流断点

我们使用流的时候，很难看到中间做了什么，但其实idea就帮我们解决了，我用断点调试下面代码，给大家演示下。

其实只需要找到这个按钮就行了

![img](https://pic.wjcly.com/my-pic/main/img/202209011113955.png)

```
 List<Integer> list = new ArrayList<>(Arrays.asList(1, 3, 3, 4, 4, 4, 5, 6, 78));
        List<Integer> collect = list.stream()
          //先将偶数筛选，再去重，返回集合
                .filter(s -> s % 2 == 0)
                .distinct()
                .collect(Collectors.toList());
```

![img](https://pic.wjcly.com/my-pic/main/img/202209011113718.gif)

### 4.7多线程断点

给大家演示两种情况，多线程下调试，定时任务下调试。

这个演示比较简单，可能有同学不以为意，你可以去尝试下，如果使用默认All来调试多线程程序会发生什么，可能某条线程就跑掉了，没有停留，而这种方式可以捕获到运行的所有线程。

![img](https://pic.wjcly.com/my-pic/main/img/202209011113144.gif)定时任务这样调试有个好处，即便我们在调试的过程中下一个任务也到时间了，也不会执行，防止多次定时任务执行带来的干扰，我在演示前已经提前一分钟启动了程序，每隔10秒钟打印一次，但是由于暂停了线程的执行，多次点击`Resumer Program`，发现并没有往下执行哦，而是再等了10秒钟之后执行。

![img](https://pic.wjcly.com/my-pic/main/img/202209011113981.gif)

### 4.8远程断点

顾名思义，远程debug就是断点打在你的本地环境, 但是代码是跑在远端的(可以理解为是服务端)。

#### 4.8.1为什么需要远程debug

相信很多人在开发中遇到过这样的问题, 就是明明代码在自己的环境上是好的, 为什么去了测试环境就有问题, 这个时候你可能会质疑测试, 是不是准备的数据有问题?还是不会使用, 导致用错了场景? 还是部署有问题?

在做数据项目的时候, 遇到bug可能会把相应的数据下载到本地开发环境, 然后进行debug, 但如果遇到了如下的问题, 该怎么办呢

- 数据量特别大, 本地无法下载
- 数据比较敏感, 安全原因不让下载
- 本地无法搭建环境, 比如, 需要启动cluster, 需要至少三台物理节点

这个时候远程debug就要上场了, 这样你就能在本地看到远端运行的样子了, 而不用只看输出日志去推断可能哪里出了错误。

#### 4.8.2如何远程debug

##### 4.8.2.1首先看服务器是不是在Debug模式下工作

不是则进行（tomcat/bin/catalina.sh）配置。

```
-Xdebug -Xrunjdwp:transport=dt_socket,address=8787,server=y,suspend=n
```

> 具体解释：
>
> - **-Xdebug ：** 启用调试特性。
> - -**Xrunjdwp**:在目标 VM 中加载 JDWP 实现。它通过传输和 JDWP 协议与独立的调试器应用程序通信。下面介绍一些特定的子选项。
> - **transport**: 这里通常使用套接字传输。但是在 Windows 平台上也可以使用共享内存传输。
> - **address** 这是连接的传输地址。如果服务器为 *n* ，将尝试连接到该地址上的调试器应用程序。否则，将在这个端口监听连接。
> - **server** 如果值为 *y* ，目标应用程序监听将要连接的调试器应用程序。否则，它将连接到特定地址上的调试器应用程序。
> - **suspend** 如果值为 *y* ，目标 VM 将暂停，直到调试器应用程序进行连接。

##### 4.8.2.2本地IDEA进行远程Debug

其实非常简单, 用Intellij IDEA打开你的代码, 点击右上角的“Edit Configurations”

![image-20220901104745631](https://pic.wjcly.com/my-pic/main/img/202209011114216.png)

然后点击左上角的"+“, 添加一个“Remote”, 这个选项就是用来做远程Debug用的, 并且添加远程DEBUG配置项，Host和Port，端口默认给的是5005。配置后，点击`Apply`和`OK`按钮（然后只要把IP和刚才配置的端口号加上就行。

![image-20220901104935150](https://pic.wjcly.com/my-pic/main/img/202209011114467.png)

#### 4.8.3远程debug测试

我们直接在TestController类里的test方法上打断点：

![image-20220901105824672](https://pic.wjcly.com/my-pic/main/img/202209011114854.png)

然后选择远程debug启动项，点击调试按钮启动。

打开postman测试：

![image-20220901105616699](https://pic.wjcly.com/my-pic/main/img/202209011115937.png)
发现成功进入断点

![image-20220901105729273](https://pic.wjcly.com/my-pic/main/img/202209011115278.png)

debug调试教程

在编写 `starter` 之前我们先了解一下什么是 `starter`，一个 `starter` 其实就是对一个功能的集成封装，然后对外提供一个依赖，让业务去使用，像我们熟悉的 `Redis`，`mongo`，`mybatis` 等。另外由于任何人都可以编写自己的 `starter`，那么为了区分官方的 `starter` 和个人的 `starter`，通常在命名上面会有一个规范。所以 `SpringBoot` 官方提出，第三方在建立自己的 `Starter` 的时候命名规则统一用`xxx-spring-boot-starter`，而官方提供的 `Starter` 统一命名方式为`spring-boot-starter-xxx`。

通过我们前面的文章，我们知道自动装配首先要有一个配置类，其次还要有 `spring.factories` 文件，所以这两步是必不可少的。接下来我们就实操一下。




## 1.编写配置类

编写配置类首先要添加一个自动装配的依赖，然后再编写对应的配置类和业务实现类，在 `pom` 中添加如下依赖

```
<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-autoconfigure</artifactId>
      <version>2.7.1</version>
    </dependency>
```

### 1.1装配类

```
package com.example.hash.starter.config;

import com.example.hash.starter.service.MyHashTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnClass({MyHashTemplate.class})
@EnableConfigurationProperties(MyHashProperties.class)
public class MyHashAutoConfiguration {

  @Autowired
  MyHashProperties myHashProperties;

  @Bean
  @ConditionalOnMissingBean(MyHashTemplate.class)
  public MyHashTemplate myJsonService() {
    MyHashTemplate myHashTemplate = new MyHashTemplate();
    myHashTemplate.setPrefix(myHashProperties.getHashPre());
    return myHashTemplate;
  }
}
```

### 1.2属性类

```
package com.example.hash.starter.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "ziyou.hash")
public class MyHashProperties {
  private String hashPre;

  public String getHashPre() {
    return hashPre;
  }

  public void setHashPre(String hashPre) {
    this.hashPre = hashPre;
  }
}
```

### 1.3业务实现类

```
package com.example.hash.starter.service;

import javax.xml.bind.DatatypeConverter;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MyHashTemplate {

  private String prefix;

  public String myHash(String origin) {
    if (null == origin || origin.length() == 0) {
      return null;
    }
    try {
      MessageDigest md = MessageDigest.getInstance("MD5");
      md.update(origin.getBytes());
      byte[] digest = md.digest();
      return this.prefix + ":" + DatatypeConverter.printHexBinary(digest).toUpperCase();
    } catch (NoSuchAlgorithmException e) {
      throw new RuntimeException(e);
    }
  }

  public void setPrefix(String prefix) {
    this.prefix = prefix;
  }
}
```

简单说明一下上面三个类都是干什么的，`MyHashTemplate` 该类是实际业务需要注入的类，用来对入参进行 `MD5` 摘要，然后返回一个拼接了前缀的字符串给业务。这个前缀是通过 `application.properties` 中配置 `ziyou.hash.hashPre=JavaGeekTech666` 配置后传递过来的。`MyHashProperties` 是接受属性值的类，`MyHashAutoConfiguration` 则是自动装配类，这个类会根据条件进行 `MyHashTemplate` `Bean` 的初始化，并将前缀进行赋值。

## 2.增加配置文件

最后还需要在 `resource` 文件中编写一个 `META-INF/spring.factories` 文件，内容如下

```
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.example.hash.starter.config.MyHashAutoConfiguration
```

前面的 `Key` 是固定写法，后面的 `value` 就是配置类的全路径引用地址。

## 3.在项目中使用

编写完了 `starter` 过后，我们再创建一个新的 `web` 应用，在其中增加我们编写的 `starter` 来验证是否成功。第一步在 `pom` 文件中增加依赖

```
<dependency>
   <groupId>com.starter.example</groupId>
   <artifactId>myhash-spring-boot-starter</artifactId>
   <version>0.0.1-SNAPSHOT</version>
</dependency>
```

编写代码并测试

```
package com.example.demo.controller;

import com.example.demo.service.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

  @Autowired
  private HelloService helloService;

  @GetMapping(value = "/hello")
  public String hello(@RequestParam("name") String name) {
    return helloService.sayHello(name);
  }
}
package com.example.demo.service;

import com.example.hash.starter.service.MyHashTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class HelloService {
  @Autowired
  private MyHashTemplate myHashTemplate;

  public String sayHello(String name) {
    return myHashTemplate.myHash(name);
  }
}
```

在 `application.properties` 文件中增加如下配置

```
ziyou.hash.hashPre=JavaGeekTech
```

启动项目，我们访问地址 http://127.0.0.1:8080/hello?name=ziyou 可以看到效果如下。

![img](https://pic.wjcly.com/my-pic/main/img/202209061107767.jpeg)

至此可以看到，我们自己编写的 `starter` 已经成功生效了，只不过功能很简单而已，我们完全可以根据自己需要的实际功能来实现一个复杂一点的 `starter` 来提供开箱即用的效果。

在一些大公司特别是一些中间件或者中台团队，很多时候都是提供各种工具的 `starter` 来给业务团队使用的，毕竟很多重复的功能如果每个业务团队都自己开发的话，完全是浪费资源，通过中台团队统一封装 `starter`，让各个业务团队拿来就用快速搭建业务即可。

Spring Boot 自定义starter

# Docker安装mysql8

> ​	**版本根据自己需求选择：这里是8.0.20**

先看结果

![image-20240227101312723](https://pic.wjcly.com/my-pic/main/img/202402271357222.png)

![image-20240227101417493](https://pic.wjcly.com/my-pic/main/img/202402271357267.png)




> 详细步骤如下

**1.下载mysql8镜像**

```
docker pull mysql:8.0.20
```

**2.启动镜像**

```
docker run -p 3307:3306 --name mysql8 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:8.0.20
```

**3.配置挂载**

```
创建挂载目录（请检查保证创建成功）
mkdir -p /docker/mysql8.0.20/
拷贝配置文件到创建的目录下
docker cp  mysql8:/etc/mysql /docker/mysql8.0.20/
```

**4.删除原有容器**

```
docker stop mysql8
docker rm -f mysql8
```

**5.启动mysql挂载配置文件，数据持久化到宿主主机**

```
新增my.cnf,进入到上面挂载目录下、因为已经做了cp复制。到目录下新增
cd /docker/mysql8.0.20/mysql/conf.d
vim my.cnf
------------------------------------------------手动分割线----------------------------------------------------
复制下面的内容
[mysqld]
user=mysql
character-set-server=utf8
default_authentication_plugin=mysql_native_password
secure_file_priv=/var/lib/mysql
expire_logs_days=7
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
max_connections=1000
 
[client]
default-character-set=utf8
 
[mysql]
```

**6.run**

```
运行命令：
docker run \
-p 3307:3306 \
--name mysql8 \
--privileged=true \
--restart unless-stopped \
-v /docker/mysql8.0.20/mysql:/etc/mysql \
-v /docker/mysql8.0.20/logs:/logs \
-v /docker/mysql8.0.20/data:/var/lib/mysql \
-v /etc/localtime:/etc/localtime \
-e MYSQL_ROOT_PASSWORD=123456 \
-d mysql:8.0.20
------------------------------------------------手动分割线----------------------------------------------------
可编写sh脚本启动
vim docker_mysql8.0.20.sh
脚本代码：
#!/bin/sh
docker run \
-p 3307:3306 \
--name mysql8 \
--privileged=true \
--restart unless-stopped \
-v /docker/mysql8.0.20/mysql:/etc/mysql \
-v /docker/mysql8.0.20/logs:/logs \
-v /docker/mysql8.0.20/data:/var/lib/mysql \
-v /etc/localtime:/etc/localtime \
-e MYSQL_ROOT_PASSWORD=123456 \
-d mysql:8.0.20
------------------------------------------------手动分割线----------------------------------------------------
参数解释:
-p 端口映射 【这里有个特殊的地方是把3306映射给了3307、后续链接数据库的时候用3307链接不用3306】
--name mysql8  名称是mysql8
--privileged=true 挂载文件权限设置
--restart unless-stopped 设置 开机后自动重启容器
-v /docker/mysql8.0.20/mysql:/etc/mysql \ 挂载配置文件【路径是上面创建的挂载路径】
-v /docker/mysql8.0.20/logs:/logs \  挂载日志【路径是上面创建的挂载路径】
-v /docker/mysql8.0.20/data:/var/lib/mysql \ 挂载数据文件 持久化到主机【路径是上面创建的挂载路径】
-v /etc/localtime:/etc/localtime 容器时间与宿主机同步
-e MYSQL_ROOT_PASSWORD=123456 设置密码
-d mysql:8.0.20 后台启动mysql
------------------------------------------------手动分割线----------------------------------------------------
执行脚本:
sh docker_mysql8.0.20.sh
------------------------------------------------手动分割线----------------------------------------------------
检查是否启动成功：
docker ps 
```

**6.配置链接信息**

```
进入mysql8 容器
docker exec -it mysql8 bash
在容器内登录mysql
mysql -u root -p
设置远程连接权限
grant all PRIVILEGES on *.* to root@'%' WITH GRANT OPTION;
使用mysql数据库
use mysql
MySQL5.7设置用户密码命令
ALTER user 'root'@'%' IDENTIFIED BY '123456' PASSWORD EXPIRE NEVER;
MySQL8.0设置用户密码命令
ALTER user 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
```

MongoDB入门基础教程

IDEA断点调试教程

1. 问题总结

Docker安装mysql8

8种架构模式

1.什么是架构