1. 根据上节内容的提示，我们知道如何进行nginx的信号控制和命令行控制了。

2. 这节主要是学习nginx的静态文件、缓存、静态文件压缩等相关内容。

一、 配置并访问nginx静态文件

1.1 root配置nginx静态文件地址

在nginx.conf 配置文件中默认使用root配置了nginx静态界面地址

规则： root配置的路径+location路径为访问的路径。

路径规则：

         ①相对路径： 上图所示的为相对路径，即nginx的prefix路径（/usr/local/nginx）+html路径，也就是nginx启动时的相对路径。

        ②绝对路径： 如果配置和上图中一样的路径，则需要改为： root /usr/local/nginx/html。

注： window系统配置则需要加上双引号 eg： "F:/html/html";

1.2 alias配置静态文件地址

        若使用alias配置上述路径改如何配置呢？改为下述配置即可：

# eg:1

    location /html {
            alias  /usr/local/nginx/html;
            index  index.html index.htm;
        }


# eg:2

    location /html/ {
            alias  /usr/local/nginx/html/;
            index  index.html index.htm;
        }

       

上文中我用了两个例子，首先alias配置和root区别之一便是  location匹配的路径需要和实际路径后面那节一样。  （root是 root路径+location路径）

        第二个区别就是，root会忽视路径最后面的 /    但是alias必须两个同时存在或同时不存在即可

二、 配置并访问vue项目文件

2.1 使用root配置vue项目地址

# 1. 一般使用根路径配置前端

location / {

    root /data/webroot/html/xxx/dist;
    index  index.html index.htm;

}

2.2 使用alias配置vue项目地址

# 1. 一般使用根路径配置前端

location /dist {

    alias /data/webroot/html/xxx/dist;
    index  index.html index.htm;

}

那么我们进行访问的时候会发现报错如下图所示：

此时主要是因为配置vue项目的地址是使用的相对路径，也就是路径没有/dist导致的，故需要在dist目录下的index.html统一添加前缀即可：

下图为正常访问的情况：

三、 nginx静态文件优化配置

http{

    #提高文件的传输效率
    sendfile on;
    #
    tcp_nopush on;
    #
    tcp_nodelay on;
    
}

3.1 sendfile，用来开启高效的文件传输模式

注：① sendfile默认是关闭的。

       ② 在默认情况下，静态文件请求会进行linux内存将文件从磁盘拷贝到缓冲区、然后再将缓冲区的文件通过进程应用拷贝到sokect缓冲区进行返回。

        ③ 开启时，则会直接由linux内核拷贝到sokect缓冲区提供，大大节约了io的次数。

        ④ 在http server location均可以进行开启。

3.2 tcp_nopush：提升网络包的传输'效率（sendfile 开启）

注： 这个开启，则保证了文件不会零散的发送出去（减少了io次数），一次性发送对于整个网络有很大的优化提升。

3.3 tcp_nodelay：提高网络包传输的'实时性（keep-alive连接开启）

注：① 这个开启，会保证数据包（静态文件会分成很多数据包）存在的时候直接进行发送。

        ② 看上去这个和3.2 tcp_nopush 是互斥的，但是在linux内核2.5.9之后处理逻辑是先保证3.2 tcp_nopush填满，当文件

部署

1. STATIC_ROOT 的路径设置为你的静态文件存放地址

   STATICFILES_DIRS = []
   STATIC_URL = '/static/'
   # 线上收集静态文件的目录
   STATIC_ROOT = os.path.join(BASE_DIR,'statics')
   
   

   静态文件相关配置介绍

   官网地址

2. 运行collectstatic管理命令命令

   python manage.py collectstatic
   

   这将会把静态目录下的所有文件拷贝至 STATIC_ROOT 目录。

3. 使用nginx提供静态文件服务
   nginx中静态文件路径

     location /static/{
              root /var/项目目录/;
              try_files $uri @django;
        }
   
   

当静态文件发生变化时

第一次部署项目后发现，admin的页面没有样式，执行collectstatic命令
如果后续静态文件再次发生变化（如：使用接口文档的插件，在线文档无样式），需再次执行collectstatic命令

对于 Go 语言开发者来说，在享受语言便利性的同时，最终编译的单一可执行文件也是我们所热衷的。

但是，Go在编译成二进制文件时并没有把我们的静态资源文件编译进去，如果我们开发的是web应用的话就需要想办法把我们的静态文件也编译进去。

本文收集了一些Go语言中用来在编译过程中将静态文件打包到编译文件的方法。

go-bindata

在 Go 语言的 Awesome 中你可以看到很多静态打包库，但是，你却看不到 go-bindata， go-bindata 明显更受欢迎，更流行。

go-bindata 很简单，设计理念也不难理解。它的任务就是讲静态文件封装在一个 Go 语言的 Source Code 里面，然后提供一个统一的接口，你通过这个接口传入文件路径，它将给你返回对应路径的文件数据。这也就是说它不在乎你的文件是字符型的文件还是字节型的，你自己处理，它只管包装。

简单来说就是它可以把我们的静态文件生成 .go 文件，这样就可以编译成二进制文件，项目启动的时候再把这个 .go 文件再释放成静态文件

下载

go get -u github.com/jteeuwen/go-bindata/...

安装确认

C:\Users\Administrator\Desktop>go-bindata -version
go-bindata 3.1.0 (Go runtime go1.14).
Copyright (c) 2010-2013, Jim Teeuwen.

注意： GOPATH必须在环境变量下

使用

例子一

ConfigTest
├── asset
│   └── asset.go     静态文件编译之后的go文件
├── cli              # 运行目录
├── config           # 配置文件目录
│   ├── config.json 
│   └── config.yaml
└── main            # 程序目录
    └── main.go     # 源码

config.yaml内容

enabled: true
path: aaaaa
id: 10

config.json内容

{
    "enabled": true,
    "path": "xxxx",
    "id": 111
}

执行命令将静态文件打包成go文件

go-bindata -o=./asset/asset.go -pkg=asset config/...

-o 输出文件到 ./asset/asset.go
包名 -pkg=asset
config/… # 指定需要打包的静态文件路径， …包括所有子目录

// 可以参考：https://www.cnblogs.com/landv/p/11577213.html

其路径变为：

ConfigTest
├── asset
│   └── asset.go     静态文件编译之后的go文件
├── cli              # 运行目录
├── config           # 配置文件目录
│   ├── config.json 
│   └── config.yaml
└── main            # 程序目录
    └── main.go     # 源码

main.go

package main

import (
	"configTest/asset"
	"encoding/json"
	"fmt"
	"gopkg.in/yaml.v2"
	"log"
	"os"
	"path/filepath"
)

type conf struct {
	Enabled bool
	Path    string
	ID      int
}

func (c *conf) ReadYaml() {
	data, _ := asset.Asset("config/config.yaml")
	err := yaml.Unmarshal(data, &c)
	if err != nil {
		log.Fatalf("Unmarshal: %v", err)
	}
}

func (c *conf) ReadJson() {
	data, _ := asset.Asset("config/config.json")
	err := json.Unmarshal(data, &c)
	if err != nil {
		log.Fatalf("Unmarshal: %v", err)
	}
}

// 将dir解压到当前目录：根据生成的.go文件，将其解压为当前文件
func restore() {
  // 可以参考：https://www.cnblogs.com/landv/p/11577213.html
	dirs := []string{"config"} // 设置需要释放的目录
	isSuccess := true
	for _, dir := range dirs {
		// 解压dir目录到当前目录
		if err := asset.RestoreAssets("./", dir); err != nil {
			isSuccess = false
			break
		}
	}
	if !isSuccess {
		for _, dir := range dirs {
			os.RemoveAll(filepath.Join("./", dir))
		}
	}
}

func main() {
	var c, j conf
	j.ReadJson()
	fmt.Println("json:", j)
	c.ReadYaml()
	fmt.Println("yaml:", c)
	fmt.Println("释放静态文件")
	restore()
}

• 编译 main.go 执行二进制文件

cd cli && go build ../main/main.go
./main

json: {true xxxx 111}
yaml: {true aaaaa 10}
释放静态文件

执行之后会自动解压出config目录以及下面的静态文件

ConfigTest
├── asset
│   └── asset.go     静态文件编译之后的go文件
├── cli              # 运行目录
│   ├── config       # 调用了restore()会生成这个文件
│   │   ├── config.json
│   │   └── config.yaml
│   └── main        # main.go编译之后生成的二进制执行文件
├── config          # 配置文件目录
│   ├── config.json 
│   └── config.yaml
└── main            # 程序目录
    └── main.go     # 源码

main.go
http.FileSystem是定义HTTP静态文件服务的接口。go-bindata的第三方包，go-bindata-assetfs实现了这个接口，支持http访问静态文件目录的行为。

package main

import (
	"configTest/asset"
	assetfs "github.com/elazarl/go-bindata-assetfs"
	"net/http"
)

func myhttp() {
	fs := assetfs.AssetFS{
		Asset:     asset.Asset,
		AssetDir:  asset.AssetDir,
		AssetInfo: asset.AssetInfo,
	}
	http.Handle("/", http.FileServer(&fs))
	http.ListenAndServe(":12345", nil)
}

func main() {
	myhttp()
}

访问 http://localhost:12345，就可以看到嵌入的静态资源目录的内容了

和 Nginx 查看静态文件目录一样的。

例子二

• 目录

ConfigTest
├── asset
│   └── asset.go     静态文件编译之后的go文件
├── cli              # 运行目录
├── config           # 配置文件目录
│   ├── config.html
└── main            # 程序目录
    └── main.go     # 源码

• config.html内容

<html>
<body>

<h1>My First Heading</h1>

<p>My first paragraph.</p>

</body>
</html>

• 打包命令：生成./asset/asset.go

go-bindata -o=./asset/asset.go -pkg=asset config/...

• main内容：

package main

import (
	"configTest/asset"
	"fmt"
	assetfs "github.com/elazarl/go-bindata-assetfs"
	"github.com/gin-contrib/multitemplate"
	"github.com/gin-gonic/gin"
	"html/template"
)

func main() {
	fs := assetfs.AssetFS{
		Asset:     asset.Asset,
		AssetDir:  asset.AssetDir,
		AssetInfo: asset.AssetInfo,
	}

	router := gin.Default()

	router.StaticFS("/static", &fs)


	r := multitemplate.New()
	bytes, err := asset.Asset("config/config.html")   // 根据地址获取对应内容
	if err != nil {
		fmt.Println(err)
		return
	}


	t, err := template.New("index").Parse(string(bytes))   // 比如用于模板处理
	r.Add("index", t)
	router.HTMLRender = r



	router.GET("/image", func(c *gin.Context) {
		c.HTML(200, "index", gin.H{})
	})

	router.Run(":12345")
}

go.rice【不好用】

go.rice 也支持打包静态文件到 go文件中，但是行为和 go-bindata很不相同。从使用角度，go.rice其实是更便捷的静态文件操作库。打包静态文件反而是顺带的功能。

安装

go get github.com/GeertJohan/go.rice/...

使用一

import (
    "fmt"
    "html/template"

    "github.com/GeertJohan/go.rice"
)

func main() {
    // 这里写相对于的执行文件的地址
    box, err := rice.FindBox("theme/default")
    if err != nil {
        println(err.Error())
        return
    }
    // 从目录 Box 读取文件
    str, err := box.String("post.html")
    if err != nil {
        println(err.Error())
        return
    }
    t, err := template.New("tpl").Parse(str)
    fmt.Println(t, err)
}

使用二

go.rice 是直接支持 http.FileSystem 接口：

package main

import (
	"github.com/GeertJohan/go.rice"
	"net/http"
)

func main() {
	http.Handle("/", http.FileServer(rice.MustFindBox("../config").HTTPBox()))
	http.ListenAndServe(":12345", nil)
}

有点略繁琐的是 rice.FindBox(dir) 只能加载一个目录。因此需要多个目录的场景，会有代码：

func main() {
    http.Handle("/img", http.FileServer(rice.MustFindBox("static/img").HTTPBox()))
    http.Handle("/css", http.FileServer(rice.MustFindBox("static/css").HTTPBox()))
    http.Handle("/js", http.FileServer(rice.MustFindBox("static/js").HTTPBox()))
    http.ListenAndServe(":12345", nil)
}

esc

esc 的作者在研究几款嵌入静态资源的 工具 后，发觉都不好用，就自己写出了 esc。它的需求很简单，就是嵌入静态资源 和 支持 http.FileSystem 。esc 工具也这两个主要功能。

安装

go get github.com/mjibson/esc

使用

使用方法和 go-bindata 类似：

// 注意 esc 不支持 source/... 三个点表示所有子目录
go-bindata -o=asset/asset.go -pkg=asset source theme doc/source doc/theme

import (
    "net/http"
    "asset" // esc 生成 asset/asset.go 
)

func main() {
    fmt.Println(asset.FSString(false, "/theme/default/post.html"))         // 读取单个文件
    http.ListenAndServe(":12345", http.FileServer(asset.FS(false)))     // 支持 http.FileSystem，但是没有做展示目录的支持
}

esc 有个较大的问题是只能一个一个文件操作，不能文件夹操作，没有类似 go-bindata 的 asset.RestoreDir() 方法。并且没有方法可以列出嵌入的文件的列表，导致也无法一个一个文件操作，除非自己写死。这是我不使用他的最大原因。

go generate

嵌入静态资源的工具推荐配合 go generate 使用

参考：https://www.cnblogs.com/landv/p/11577213.html