临近考试周，又要开始准备复习，顺带总结下自己平常的学习方式与一些感慨。



我个人主要的两种学习方式，**主动学习**与**被动学习**

## 主动学习 ✍

通常来说，主动学习往往是一件痛苦的事情。就如考试周，平常的课该去在课堂上睡觉，该不去的在宿舍睡觉，到考试周，一学期的课没听，但一想到不复习就有可能面临挂科，或多或少都会复习。考试摆烂，挂科惨淡。

除了上面是会导致坏结果而去学习，那么还有一种则是与之相反，也就是所需，所感兴趣的去学习。

例如我想要实现一个酷炫功能，或者是一个需求时，而其中需要的知识点便会去了解与学习。

对于前者而言，其过程并不舒服，甚至可以说是逼自己学习不喜欢的东西，通常我是不如不学的，即便学了在以后也难以记起，除非不学的结果比较严重（如挂科）。而后者情况便不同，兴趣是最好的老师，甚至都不需要借助外界因素去激励，便能有一个很好的学习成果。

如果没有兴趣或需求的情况下，那么主动学习一定要定制一系列的目标，如果没有明确的目标，学习将会显得十分迷茫。我有很多时候便是这样，想去主动去学习诸多技术栈，不知从何下手。

## 被动学习 📘

其实可以说是利用业余时间学习的一个方式，首先我会想我一天主要做的事情（通常是与学习无关），比如刷各个平台（b 站，抖音）的视频，刷知乎，qq 群闲聊等等，这里只是以我一天的大部分日常举例。

此事不妨关注一些与学习类的账号，包括但不限于加入一些技术交流群， up 主，公众号，博主等等，当你每次刷这类平台时，系统很自然就会给你推送相关内容，比方说 b 站，我日常会在上面刷一些鬼畜视频，生活娱乐视频，但也会关注一些技术类的账号，在娱乐的同时，还能不经意间刷到一些编程知识（知乎，微信公众号同理），这送上门的知识不香吗？

再比如 watch 一些开源项目，订阅一些博客文章，定时推送 Hacker News 周刊等等，在他们发布一些重要内容的时候能及时通知到你。虽然这样每天邮箱时常处于未读状态，但如果打开某一条邮箱查看其中的内容，说不定又是一次不错的收获。

当然，这样学习肯定有一定弊端。首先所摄取的知识过于笼统，一般都是由别人推荐的，甚至有可能会浪费你人生中的几分钟，因为这些知识点可能你已经掌握了，或者这些知识确实没什么干货。其次所获取到的知识往往是整个知识面的冰上一角，或者是某些新型技术，但想要深入去学习还是得按上面的主动学习。

被动学习主要的作用能让你在不学习的状态下，还能获取相对应的知识。听起来可能觉得很卷，无时无刻的在学习，但我认为在娱乐中学习往往不会显得像主动学习那般有种疲惫感。

我在被动学习中就间接了解到许多的前沿的技术栈，以及了解到许多之前没使用过的语言、框架特性，而这些都是直接送上门的知识点，而我要做的只是关注一些账号，订阅一些文章或站点，而不用自己去茫茫知识海洋中去寻求。

## 两者的权衡

我时常处于这类被动学习状态，因为我对很多技术点都很感兴趣，但又不知道从何下手，而当我刷到我所感兴趣的东西时，我才会开始转为主动学习。之所以会出现这样的学习状态转型，有很大一部分是因为**兴趣感已经没有一开始所学的那么强烈，甚至可以说有些许乏味**。

在一开始接触时，我是抱着强烈的兴趣感去学的，处于一种非常积极的主动学习状态，当时所获取的知识是无法用现在同等时间所堪比。然而在兴趣感消散，这种状态都为浮云。主动学习的频率减弱，每天都在做着与学习无关的事情，这期间与知识没有任何的往来。

直到将每天所要做的事情，间接的转为被动学习的方式，至少有在学习，而不是在停步，即便是行走 1 厘米，那也是米。

## 总结

最好是对感兴趣的方面学习，这样即有动力去学习，有不会感到厌烦，并且兴趣是能陪伴很久的，也往往能坚持下去。

无论是任何事情在任何时候下都应该保持的是一种不断坚持的状态，打游戏也好，学习也好。

一段时间不打游戏，手感生疏，再次接触就没状态。一段时间不学知识，容易忘记，再次使用就没印象。

大部分人都是如此，可谁又不希望保持一种不断坚持的状态。毕竟不是每个人都有充裕的个人资源与时间资源，很多时候这些资源并不是由自己分配的，有可能是亲朋好友，也有可能是上司老板，最有可能是生活所迫。。。

**唯愿此生，岁月静好**

浅谈个人学习方式

如果尝试过部署 docker 容器应用，并且该应用需要访问宿主机的服务，如 Mysql，Redis。会发现应用可能无法连接，其本质的原因的就是 docker 容器内的 localhost 与宿主机的 localhost 并不是同一个东西。所以连接地址不能用 localhost 和 127.0.0.1。

**宿主机是可以直接访问 docker 容器内的应用。**

## 解决办法

### 使用 host 模式（常用）

docker 运行容器时使用的[桥接](https://so.csdn.net/so/search?q=桥接&spm=1001.2101.3001.7020)模式(默认)，如果使用 host 模式就可以访问，所以需要将 docker 的网络模式设置为 host 模式。

通过`docker run` 启动容器时加入`–net=host` 参数，或在 compose 文件中指定`network_mode: “host”`，便可以 host 模式运行容器

该参数指定该容器使用 host 网络模式，因此也无需映射端口（不然会报警告）。

#### mac 和 windows

需要 env 配置中的 127.0.0.1 替换为**host.docker.internal**

#### linux

在启动 docker 时，加入如下语句

```bash
--add-host=host.docker.internal:host-gateway
```

而在 container 内，可以直接请求 host.docker.internal:PORT，来获取宿主机上提供的各种服务
如果使用了 Docker Compose，则应该将下面的句子加入 container 的声明中：

```yaml
extra_hosts:
  - 'host.docker.internal:host-gateway'
```

### 使用 docker0 网络的默认网关地址

在默认的 bridge 模式下，docker0 网络的默认网关即是宿主机。在 Linux（Windows）下，docker0 网络通常会分配一个 172.17.0.0/16 的网段，其网关通常为**172.17.0.1**；macOS 下的网段则为 192.168.65.0/24，网关为**192.168.65.1**。在容器中使用该 IP 地址即可访问宿主机上的各种服务。

需要注意的是，这种情况下，经由 docker0 网桥而来的流量不经过宿主机的本地回环，因此需要将宿主机上的应用（MySQL，Redis 等）配置为监听 0.0.0.0。

但此 IP 并不一定完全固定，可能会因系统及配置而发生变化，应用也需要更改。

Docker访问宿主机上服务

[把一个 Node.js web 应用程序给 Docker 化 | Node.js (nodejs.org)](https://nodejs.org/zh-cn/docs/guides/nodejs-docker-webapp/)

## 部署 Express 项目

前提：准备一个 Express 项目以及 Docker 环境

在 Express 项目根目录下创建 Dockerfile 文件，内容如下

```dockerfile title="Dockerfile"
FROM node:alpine as builder

WORKDIR /app

COPY . .

RUN npm install

EXPOSE 3000

CMD ["npm", "run", "start"]
```

上述代码的大致意思如下

1. 下载 node 环境
2. 设置 RUN CMD COPY ADD 指令的工作目录
3. 拷贝宿主机（当前运行终端的位置）的文件到容器中的 app 目录中
4. 安装 npm 包
5. 暴露 3000 端口
6. 执行`npm run start`脚本命令

在执行命令前，还需要创建.dockerignore，将一些不必要的文件排除（其作用于.gitignore 一致）

```dockerfile title=".dockerignore"
/dist
/node_modules
package-lock.json
yarn.lock
```

此时打开终端，输入

```bash
docker build -t my-app .
```

将会执行 Dockerfile 命令，待所有命令执行完毕后，将会创建 my-app 的镜像

执行启动容器命令，将服务启动。

```bash
docker run --name my-app -p 3000:3000 my-app
```

此时访问对应机器的 3000 端口即可访问 express 项目。

如果想打开容器内的终端，有以下两种选择

```
docker exec -it 容器ID/名 /bin/bash  # 进入后开启新的终端 可在里面操作(常用) 或者为/bin/sh
docker attach 容器ID/名 # 不会启动新的进程 单单只是进入容器的终端
```

## 部署 Express+MongoDB+Redis

假设我现在要部署 Express + MongoDB+Redis 的服务的话，可以使用 docker-compose.yml 来自动化部署多个容器。

创建 docker-compose.yml 文件，内容如下

```yaml title="docker-compose.yml"
version: '3.9'

services:
  mongodb:
    image: mongo:4.4.6
    restart: always
    ports:
      - 27017:27017
    networks:
      - backend
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: 123
    volumes:
      - db-data:/data/db

  redis:
    image: redis:latest
    command:
      - /bin/bash
      - -c
      - redis-server --appendonly yes
    ports:
      - 6379:6379
    networks:
      - backend

  web:
    build: .
    restart: always
    environment:
      - NODE_ENV=development
      - MYSQL_HOST=mysql
      - REDIS_HOST=redis
    ports:
      - 5000:5000
    networks:
      - backend
    depends_on:
      - mongodb
      - redis

networks:
  backend:

volumes:
  db-data:
```

运行命令，**重新部署的话可以添加--build 参数**

```
docker-compose up -d
```

web 后端项目中涉及到，数据库的连接地址（Host）要以 docker-compose.yml 中的 service 名一致。例如上面所定义的 environment 中

MYSQL_HOST=mysql

REDIS_HOST=redis

而不能为 localhost，因为**docker 容器内的 localhost 与宿主机的 localhost 并不是同一个地址**。

或者是在配置中将 localhost 修改为 docker 网络的 ip，一般为 172.17.0.1，具体根据 docker 实际网络而定。

Docker部署Node项目

## Get 请求

```go
import (
  "fmt"
  "io/ioutil"
  "net/http"
)

func main() {
  resp, err := http.Get("http://127.0.0.1:5000/api/test")

  if err != nil {
    panic(err)

  }
  defer resp.Body.Close()

  s, _ := ioutil.ReadAll(resp.Body)

  fmt.Println(resp.StatusCode)
  fmt.Println(string(s))
}
```

可以发现上面的例子中还需要对**响应体**进行读取，如果每条请求都需要如此操作的话，代码逻辑将会十分臃肿，一般都需要自行封装。而事实上大部分的编程语言的 http 请求库(包)都不会过度封装，一般都需要用户自行封装或使用第三方请求库。

当然这里肯定毫不犹豫的选择第三方库，后文会推荐几个，以及一些使用代码，这里还需要使用原生 http 库发送 Post 请求

## Post 请求

### 发送 querystring

```go
import (
  "fmt"
  "io/ioutil"
  "net/http"
  "strings"
)

func main() {
  payload := strings.NewReader("foo=1&bar=2")

  resp, err := http.Post("http://127.0.0.1:5000/api/test", "application/x-www-form-urlencoded", payload)

  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  s, _ := ioutil.ReadAll(resp.Body)

  fmt.Println(resp.StatusCode)
  fmt.Println(string(s))
}

```

此外还可以使用 http.PostForm（省略读取响应代码）

```go
import (
  "net/http"
  "net/url"
)

func main() {
  payload := url.Values{"foo": {"1"}, "bar": {"2"}}

  resp, err := http.PostForm("http://127.0.0.1:5000/api/test", payload)
}

```

### 发送 json

```go
import (
  "fmt"
  "net/http"
  "strings"
)

func main() {
  payload := strings.NewReader(`{"name":"kuizuo"}`)

  req, _ := http.NewRequest("POST", "http://127.0.0.1:5000/api/test", payload)

  req.Header.Add("Content-Type", "application/json")

  res, _ := http.DefaultClient.Do(req)
  fmt.Println(res)
}

```

至于其他方法就不做演示，不对其封装将十分难用，日常开发主要还是使用第三方 http 请求库。

## HTTP 请求库

[valyala/fasthttp: Fast HTTP package for Go. Tuned for high performance. Zero memory allocations in hot paths. Up to 10x faster than net/http (github.com)](https://github.com/valyala/fasthttp)

[go-resty/resty: Simple HTTP and REST client library for Go (github.com)](https://github.com/go-resty/resty)

[imroc/req: Simple Go HTTP client with Black Magic (github.com)](https://github.com/imroc/req)

[levigross/grequests: A Go "clone" of the great and famous Requests library (github.com)](https://github.com/levigross/grequests)

整合了几个 Github 上所开源的 http 请求库，更多 http 库可在[http-client · GitHub Topics](https://github.com/topics/http-client?l=go)上查看 ，这里对其进行简单优点介绍，以及个人的选择。

- [fasthttp](https://github.com/valyala/fasthttp) 号称比 net/http 快 10 倍的 http 包，并且 star 数最多的。
- [resty](https://github.com/go-resty/resty#usage) 一个链式调用的请求库。
- [Req](https://req.cool/) 与 resty 使用相似，并且提供非常友好的使用文档（有中文）。
- [grequests](https://github.com/levigross/grequests) go 语言版的 python requests。

如果使用过 python requests 库，那么可以毫不犹豫的选择 grequests。很显然，我使用过 requests，所以也就毫不犹豫的选择 grequests。

## grequests

这里写一个模拟登录的例子

```go

import (
  "fmt"

  "github.com/levigross/grequests"
)

type Demo struct {
  Session *grequests.Session
  User    User
}

type User struct {
  Username string
  Password string
}

type Result struct {
  Code int    `json:"code"`
  Msg  string `json:"msg"`
}

func (dm *Demo) login() string {

  resp, err := dm.Session.Post("http://127.0.0.1:5000/api/login",
    &grequests.RequestOptions{
      Data: map[string]string{
        "username": dm.User.Username,
        "password": dm.User.Password,
      },
      Headers: map[string]string{
        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
        "User-Agent":   "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.120 Safari/537.36",
      },
    })

  var result Result
  resp.JSON(&result)

  if err == nil && result.Code == 200 {
    return "登录成功"
  }

  return result.Msg
}

func main() {
  var session = grequests.NewSession(nil)
  dm := Demo{
    Session: session,
    User: User{
      Username: "kuizuo",
      Password: "a123456",
    },
  }
  loginResult := dm.login()
  fmt.Println(loginResult)
  // TODO:
}

```

因为 go 中没有类的概念，所以想要实现“类”，就得在 `func` 和方法名之间添加方法所属的类型声明（有的地方将其称之为接收者声明）

也就是`func (dm *Demo) login() string {` 中的`(dm *Demo)` 其中这里的 Demo 根据实际需求进行更换，并且前面的 dm 无法更名为 this 或 self。

如果想发送 json 请求的话，grequests 写法也挺简单的，只需要将 Data 替换为 JSON（协议头会自动添加 Content-Type: application/json），如下

```go
  resp, err := dm.Session.Post("http://127.0.0.1:5000/api/login",
    &grequests.RequestOptions{
      JSON: map[string]string{
        "username": dm.User.Username,
        "password": dm.User.Password,
      },
    })
```

## 总结

相比 js 和 python 来写 http 请求，由于 go 中没有类的概念（即无 class 关键字），所以只能利用**自定义结构体**来实现这样功能，并且在代码写法上也不算优雅。综合考虑的情况下，还是优选 js 和 python 来复现 http 协议。

Go发送http请求

Go 语言的并发是基于 `goroutine` 的，`goroutine` 类似于线程，但并非线程。可以将 `goroutine` 理解为一种虚拟线程。Go 语言运行时会参与调度 `goroutine`，并将 `goroutine` 合理地分配到每个 CPU 中，最大限度地使用 CPU 性能。开启一个 goroutine 的消耗非常小（大约 2KB 的内存），你可以轻松创建数百万个`goroutine`。



## goroutine

goroutine 语法格式：

```text
go 函数名( 参数列表 )
```

演示代码如下

```go
import (
  "fmt"
  "time"
)

func say(s string) {
  for i := 0; i < 3; i++ {
    time.Sleep(100 * time.Millisecond)
    fmt.Println(s)
  }
}

func main() {
  go say("world")
  say("hello")
  fmt.Println("over!")
}
```

执行上面代码将会输出

```go
hello
world
world
hello
hello
over!
```

其中 hello 与 world 每次执行顺序都不一致，甚至有时候 world 会少输出一遍，或是 world 将会在 over! 后输出。因为此时的`go say("world")` 不在是主线程中执行，而是创建一个 goroutine 去执行。可以认为`go say("world")`就相当于 js 中的`await say("world")` 但 js 是单线程基于事件循环机制来实现的，所以两者还是有着一定的区别。

## 等待 goroutine 执行完成

可以发现 say("hello") 实际上也是在等待执行，如果将 say("hello")注释掉，再次执行，将只会输出 over!。原因很简单，因为主线程已经结束了，程序自然就结束了，goroutine 的执行也就不是程序的重点。

所以有时候需要等待 goroutine 执行完成，最直接的方法就是通过 time.Sleep 函数，或执行时间较长的函数来等待，但实际执行中并不知道应该等待多长时间，很显然这种方式并不是特别好。

## sync 包

Golang 官方在 sync 包中提供了 WaitGroup 类型来解决这个问题，下面是其简单的演示例子。

```go
import (
  "fmt"
  "sync"
  "time"
)

func say(s string, wg *sync.WaitGroup) {
  defer wg.Done()

  for i := 0; i < 3; i++ {
    time.Sleep(100 * time.Millisecond)
    fmt.Println(s)
  }
}

func main() {
  var wg sync.WaitGroup
  wg.Add(2)
  say("hello", &wg)
  say("world", &wg)

  wg.Wait()
  fmt.Println("over!")
}
```

将会像同步输出一样，输出结果

```go
hello
hello
hello
world
world
world
over!
```

使用方法可以总结为下面几点：

1. 创建一个 WaitGroup 实例，比如名称为：wg
2. 调用 wg.Add(n)，其中 n 是等待的 goroutine 的数量
3. 在每个 goroutine 运行的函数中执行 defer wg.Done()
4. 调用 wg.Wait() 阻塞主逻辑

## 通道（channel）

如果说 goroutine 是 Go 语言程序的并发体的话，那么 channels 则是它们之间的通信机制。一个 channel 是一个通信机制，它可以让一个 goroutine 通过它给另一个 goroutine 发送值信息。每个 channel 都有一个特殊的类型，也就是 channels 可发送数据的类型。一个可以发送 int 类型数据的 channel 一般写为 chan int。

使用内置的 make 函数，我们可以创建一个 channel：

```go
ch := make(chan 元素类型, [缓冲大小])
```

先展示一个简单的代码例子

```go
import "fmt"

func sum(s []int, c chan int) {
  sum := 0
  for _, v := range s {
    sum += v
  }
  c <- sum // 把 sum 发送到通道 c
}

func main() {
  s := []int{1, 2, 3, 4, 5}

  c := make(chan int)
  go sum(s[:len(s)/2], c)
  go sum(s[len(s)/2:], c)
  x, y := <-c, <-c // 从通道 c 中接收

  close(c) // 关闭通道

  fmt.Println(x, y, x+y)
}
```

将会输出 12 3 15

关闭通道不是必须的，但关闭后的通道有以下特点：

1.对一个关闭的通道再发送值就会导致 panic。

2.对一个关闭的通道进行接收会一直获取值直到通道为空。

3.对一个关闭的并且没有值的通道执行接收操作会得到对应类型的零值。

4.关闭一个已经关闭的通道会导致 panic。

## 实例

一个深度遍历的代码例子，具体可看 [示例: 并发的 Web 爬虫 · Go 语言圣经 (studygolang.com)](https://books.studygolang.com/gopl-zh/ch8/ch8-06.html)

```go
import (
  "fmt"
  "log"
  "net/http"

  "golang.org/x/net/html"
)

func crawl(url string) []string {
  fmt.Println(url)
  list, err := Extract(url)
  if err != nil {
    log.Print(err)
  }
  return list
}

func Extract(url string) ([]string, error) {
  resp, err := http.Get(url)
  if err != nil {
    return nil, err
  }
  if resp.StatusCode != http.StatusOK {
    resp.Body.Close()
    return nil, fmt.Errorf("getting %s: %s", url, resp.Status)
  }

  doc, err := html.Parse(resp.Body)
  resp.Body.Close()
  if err != nil {
    return nil, fmt.Errorf("parsing %s as HTML: %v", url, err)
  }

  var links []string
  visitNode := func(n *html.Node) {
    if n.Type == html.ElementNode && n.Data == "a" {
      for _, a := range n.Attr {
        if a.Key != "href" {
          continue
        }
        link, err := resp.Request.URL.Parse(a.Val)
        if err != nil {
          continue // ignore bad URLs
        }
        links = append(links, link.String())
      }
    }
  }
  forEachNode(doc, visitNode, nil)
  return links, nil
}

func forEachNode(n *html.Node, pre, post func(n *html.Node)) {
  if pre != nil {
    pre(n)
  }
  for c := n.FirstChild; c != nil; c = c.NextSibling {
    forEachNode(c, pre, post)
  }
  if post != nil {
    post(n)
  }
}

func main() {
  worklist := make(chan []string)

  go func() { worklist <- []string{"http://gopl.io/"} }()

  // Crawl the web concurrently.
  seen := make(map[string]bool)
  for list := range worklist {
    for _, link := range list {
      if !seen[link] {
        seen[link] = true
        go func(link string) {
          worklist <- crawl(link)
        }(link)
      }
    }
  }
}

```

## 参考文章

[Goroutines 和 Channels · Go 语言圣经 (studygolang.com)](https://books.studygolang.com/gopl-zh/ch8/ch8.html)

[https://www.cnblogs.com/sparkdev/p/10917536.html](https://www.cnblogs.com/sparkdev/p/10917536.html)