Gin 项目引入热加载

文章目录

• Gin 项目引入热加载
• • 一、什么是热加载
  • 二、Air
  • • 2.1 介绍
    • 2.2 特性
    • 特性：
    • 2.3 相关文档
    • 2.4 安装
    • • 推荐使用 install.sh
      • 使用 `go install`
      • 2.5 配置环境变量
      • 2.6 使用
      • 三、Fresh
      • • 3.1 介绍
        • 3.2 相关文档
        • 3.3 安装与使用
        • 四、bee
        • • 4.1 介绍
          • 4.2 相关文档
          • 4.3 安装与使用
          • 4.4 基本命令
          • 五、gowatch
          • • 5.1 介绍
            • 5.2 相关文档
            • 5.3 安装与使用
            • 5.4 基本命令与参数
            • 5.5. 生成配置文件
            • 六、gin
            • • 6.1 介绍
              • 6.2 相关文档
              • 6.3 安装与使用
              • 6.4 命令与参数
              • 七、realize（不推荐，已经好久没维护了）
              • • 7.1 介绍
                • 7.2 相关文档
                • 7.3 安装与使用
                • 7.4 命令参数

                  一、什么是热加载

                  热加载（Hot Reloading）是指在应用程序运行时，对代码进行修改后，系统能够自动重新加载这些修改，而无需停止和重新启动整个应用程序。这使得开发者能够在不中断应用程序运行的情况下进行代码的调试和修改。

                  热加载的主要目的是提高开发效率，减少开发过程中的重复操作，以便更快地验证和测试代码的修改。这对于大型项目和复杂框架的开发尤其有益，因为传统的停止-编译-启动的周期会消耗大量时间。

                  在不同的编程语言和框架中，热加载的实现方式可能有所不同。在Python中，像Flask和Django这样的Web框架通常通过监视文件系统的变化，并在检测到变化时重新加载相应的模块。在Java中，一些应用服务器和开发工具提供了热加载的功能，使得在不停止整个应用程序的情况下更新类文件成为可能。

                  总的来说，热加载是一种提高开发效率和用户体验的技术，允许开发者更快速地进行代码调试和修改。

                  二、Air

                  2.1 介绍

                  Air 是一个用于 Go 语言应用程序的快速热加载工具。它能够在代码修改后实时更新应用程序，提高开发效率。以下是对你提供的关于 Air 的信息的简要解释：

                  2.2 特性

                  特性：

                  1. 彩色日志输出： Air 提供了彩色的日志输出，使得日志更加直观和易读。
                  2. 自定义构建或二进制命令： 你可以自定义构建命令，以满足特定项目的需求。
                  3. 支持忽略子目录： 可以配置忽略特定的子目录，使得热加载过程更加灵活。
                  4. 启动后支持监听新目录： 在启动后，Air 支持监听新的目录，方便项目结构的更改。
                  5. 更好的构建过程： Air 提供更灵活的构建过程配置，包括自定义命令、文件扩展名的监听、延迟等。

                  2.3 相关文档

                  • github地址：https://github.com/cosmtrek/air
                  • 中文文档：https://github.com/cosmtrek/air/blob/master/README-zh_cn.md

                    2.4 安装

                    推荐使用 install.sh

                    # binary 文件会是在 $(go env GOPATH)/bin/air
                    curl -sSfL https://raw.githubusercontent.com/cosmtrek/air/master/install.sh | sh -s -- -b $(go env GOPATH)/bin
                    # 或者把它安装在 ./bin/ 路径下
                    curl -sSfL https://raw.githubusercontent.com/cosmtrek/air/master/install.sh | sh -s
                    air -v
                    

                    使用 go install

                    使用 Go 的版本为 1.16 或更高:

                    go install github.com/cosmtrek/air@latest
                    

                    2.5 配置环境变量

                    首先将添加 alias air='~/go/bin/air' 到您的 .bashrc 或 .zshrc 后缀的文件,执行如下命令：

                    echo "alias air='~/go/bin/air'" >> ~/.bashrc
                    

                    或

                    echo "alias air='~/go/bin/air'" >> ~/.zshrc
                    

                    运行以下命令以使更改生效：

                    source ~/.bashrc
                    

                    或

                    source ~/.zshrc
                    

                    现在，您应该能够使用 air 命令了，使用如下命令验证：

                    air -v
                    

                    

                    2.6 使用

                    首先，进入你的项目文件夹

                    cd /path/to/your_project
                    

                    运行以下命令初始化

                    air init
                    

                    生成一个.air.toml 文件，内容解释如下，可以参考 air_example.toml 文件修改.

                    # [Air](https://github.com/cosmtrek/air) 的 TOML 格式配置文件
                    # 工作目录
                    # 可以使用 "." 或绝对路径，但请注意以下目录必须在 root 下。
                    root = "."
                    tmp_dir = "tmp"
                    [build]
                    # 在每次构建之前运行的命令数组
                    pre_cmd = ["echo 'hello air' > pre_cmd.txt"]
                    # 普通的 shell 命令。您也可以使用 `make`。
                    cmd = "go build -o ./tmp/main ."
                    # 在 ^C 后运行的命令数组
                    post_cmd = ["echo 'hello air' > post_cmd.txt"]
                    # 从 `cmd` 产生的二进制文件。
                    bin = "tmp/main"
                    # 自定义二进制文件，可以在运行应用程序时设置环境变量。
                    full_bin = "APP_ENV=dev APP_USER=air ./tmp/main"
                    # 监视这些文件扩展名。
                    include_ext = ["go", "tpl", "tmpl", "html"]
                    # 忽略这些文件扩展名或目录。
                    exclude_dir = ["assets", "tmp", "vendor", "frontend/node_modules"]
                    # 如果指定，监视这些目录。
                    include_dir = []
                    # 监视这些文件。
                    include_file = []
                    # 排除文件。
                    exclude_file = []
                    # 排除特定正则表达式。
                    exclude_regex = ["_test\\.go"]
                    # 排除未更改的文件。
                    exclude_unchanged = true
                    # 对于目录，跟随符号链接。
                    follow_symlink = true
                    # 此日志文件位于 tmp_dir 中。
                    log = "air.log"
                    # 对文件进行轮询以检测更改，而不是使用 fsnotify。
                    poll = false
                    # 轮询间隔（默认为最小间隔 500 毫秒）。
                    poll_interval = 500 # 毫秒
                    # 如果文件更改太频繁，无需每次触发构建。
                    delay = 0 # 毫秒
                    # 在构建错误发生时停止运行旧的二进制文件。
                    stop_on_error = true
                    # 在终止进程之前发送中断信号（Windows 不支持此功能）。
                    send_interrupt = false
                    # 发送中断信号后的延迟。
                    kill_delay = 500 # 纳秒
                    # 是否重新运行二进制文件。
                    rerun = false
                    # 每次执行之后的延迟。
                    rerun_delay = 500
                    # 运行二进制文件（bin/full_bin）时添加附加参数。将运行 './tmp/main hello world'。
                    args_bin = ["hello", "world"]
                    [log]
                    # 显示日志时间
                    time = false
                    # 仅显示主日志（禁用监视器、构建和运行器）
                    main_only = false
                    [color]
                    # 自定义每个部分的颜色。如果找不到颜色，则使用原始应用程序日志。
                    main = "magenta"
                    watcher = "cyan"
                    build = "yellow"
                    runner = "green"
                    [misc]
                    # 在退出时删除 tmp 目录
                    clean_on_exit = true
                    [screen]
                    clear_on_rebuild = true
                    keep_scroll = true
                    

                    现在你只需执行 air 命令启动热加载，无需添加额外的变量，它就能使用 .air.toml 文件中的配置了。

                    air  
                    

                    启动热加载 带打印日志

                     air -d
                    

                    指定配置文件

                    # 优先在当前路径查找 `.air.toml` 后缀的文件，如果没有找到，则使用默认的
                    air -c .air.toml
                    

                    

                    三、Fresh

                    3.1 介绍

                    Fresh 是一个命令行工具，旨在提供对 Go 语言应用程序的热加载支持。每当保存 Go 文件或模板文件时，Fresh 将重新生成并重新启动 Web 应用程序。它监视文件事件，每次创建、修改或删除文件时都会触发重新生成和重启应用程序的过程。如果 go build 返回错误，错误信息将被记录在 tmp 文件夹中。

                    3.2 相关文档

                    • github地址：https://github.com/gravityblast/fresh

                      3.3 安装与使用

                      打开任意一处终端，用 go env 命令查看，如果 GO111MODULE=auto，将这一行改成 GO111MODULE=on。

                      

                      安装配置

                      # 进入你的项目目录
                      cd /your_project
                      # 使用go install 拉取fresh
                      go install github.com/pilu/fresh@latest
                      # 如果你没有go mod ，执行命令初始化
                      go mod init <你的项目名称>
                      # 将依赖添加到你的项目中
                      go get github.com/pilu/fresh
                      

                      最后启动：

                      fresh
                      

                      

                      四、bee

                      4.1 介绍

                      Bee 是一个用于 Go 语言应用程序的开发工具，它提供了一些方便的功能，包括热加载、代码生成、快速开发等。Bee 主要用于支持 Beego 框架的应用程序开发，但它也可以独立使用于其他 Go 项目。

                      4.2 相关文档

                      Bee 的相关文档包括官方文档和其他社区资源。你可以在以下位置找到有关 Bee 的详细信息：

                      • GitHub 仓库：https://github.com/beego/bee

                        4.3 安装与使用

                        1. 进入你的项目目录，注意：使用bee 项目必须要在GOPATH目录下

                        cd /your_project
                        

                        2. 使用以下命令安装 Bee：

                        go install github.com/beego/bee/v2@latest
                        

                        3. 添加到环境变量

                        export PATH=$PATH:/bin
                        

                        4. 安装完成后，你可以使用以下命令检查 Bee 是否正确安装：

                        bee version
                        

                        

                        5. 启动

                        bee run
                        

                        4.4 基本命令

                        Bee 提供了多种命令，这些命令在开发的各个阶段都有帮助。 顶级命令包括：

                        version：显示当前 Bee 工具的版本信息。
                        migrate：运行数据库迁移操作。
                        api：创建一个 Beego API 应用程序。
                        bale：将非 Go 文件转换为 Go 源代码文件。
                        fix：通过使其兼容 Beego 的新版本来修复你的应用程序。
                        pro：源代码生成器。
                        dlv：使用 Delve 启动调试会话。
                        dockerize：为你的 Beego 应用程序生成 Dockerfile 和 docker-compose.yaml。
                        generate：源代码生成器。
                        hprose：基于 Hprose 和 Beego 框架创建一个 RPC 应用程序。
                        new：创建一个 Beego 应用程序。
                        pack：将 Beego 应用程序压缩成一个单一文件。
                        rs：运行定制的脚本。
                        run：通过启动本地开发服务器运行应用程序。
                        server：在指定端口上通过 HTTP 提供静态内容服务。
                        update：更新 Bee 工具。
                        

                        五、gowatch

                        5.1 介绍

                        gowatch 是一个用于 Go 语言应用程序的热加载工具，它能够在代码发生变化时自动重新编译和运行应用程序，从而实现实时的热加载。gowatch 可以用于加速开发过程，避免手动停止和启动应用程序。

                        5.2 相关文档

                        gowatch 的相关文档通常可以在其 GitHub 仓库或其他社区资源中找到。以下是一些常见的文档链接：

                        • GitHub 仓库：https://github.com/silenceper/gowatch

                          5.3 安装与使用

                          1. 进入到你的项目目录

                          cd /path/to/myapp
                          

                          2. 使用以下命令安装 gowatch：

                          go install github.com/silenceper/gowatch@latest
                          go get -u github.com/silenceper/gowatch
                          

                          3. 添加到 ~/.bashrc 或 ~/.bash_profile 文件中的 PATH 环境变量
                          4. 在你的项目目录下执行以下命令启动 gowatch：

                          gowatch
                          

                          

                          5.4 基本命令与参数

                          安装完成后可以直接使用gowatch命令，命令行参数如下：

                          • -o：非必需，指定构建的目标文件路径。
                          • -p：非必需，指定要构建的包（也可以是单个文件）。
                          • -args：非必需，指定程序运行时的参数，例如：-args='-host=:8080, -name=demo'。
                          • -v：非必需，显示 gowatch 版本信息。
                          • -l：非必需，指定日志级别，默认为 debug。
                          • -h：非必需，显示用法信息。

                            5.5. 生成配置文件

                            您可以使用运行以下命令的默认设置将gowatch. yml配置文件初始化到当前目录。运行如下命令：

                            gowatch init
                            

                            大部分情况下，不需要更改配置，直接执行gowatch命令就能满足的大部分的需要，但是也提供了一些配置用于自定义，在执行目录下创建gowatch.yml文件:

                            # gowatch.yml 配置示例
                            # 当前目录执行下生成的可执行文件的名字，默认是当前目录名
                            appname: "test"
                            # 指定编译后的目标文件目录
                            output: /bin/demo
                            # 需要追加监听的文件名后缀，默认只有'.go'文件
                            watch_exts:
                                - .yml
                            # 需要监听的目录，默认只有当前目录
                            watch_paths:
                                - ../pk
                            # 在执行命令时，需要增加的其他参数
                            cmd_args:
                                - arg1=val1
                            # 在构建命令时，需要增加的其他参数
                            build_args:
                                - -race
                            # 需要增加环境变量，默认已加载当前环境变量
                            envs:
                                - a=b
                            # 是否监听 ‘vendor’ 文件夹下的文件改变
                            vendor_watch: false
                            # 不需要监听的目录名字
                            excluded_paths:
                                - path
                            # main 包路径，也可以是单个文件，多个文件使用逗号分隔
                            build_pkg: ""
                            # build tags
                            build_tags: ""
                            # 是否禁止自动运行
                            disable_run: false
                            

                            六、gin

                            6.1 介绍

                            gin是用于实时重新加载Go Web应用程序的简单命令行实用程序。只需gin在您的应用程序目录中运行，您的网络应用程序将 gin作为代理提供。gin检测到更改后，将自动重新编译您的代码。您的应用在下次收到HTTP请求时将重新启动。

                            gin 坚持“沉默就是黄金”的原则，因此，只有在出现编译器错误或在错误发生后成功进行编译时，它才会抱怨。

                            6.2 相关文档

                            • GitHub 地址：https://github.com/codegangsta/gin

                              6.3 安装与使用

                              假设您有一个工作的Go环境并且GOPATH/bin在您的PATH中，gin安装起来轻而易举：

                              go install github.com/codegangsta/gin@latest
                              

                              然后验证gin是否正确安装：

                              gin help
                              

                              使用

                              gin run main.go
                              

                              6.4 命令与参数

                              --laddr value, -l value       代理服务器的监听地址
                              --port value, -p value        代理服务器的端口（默认：3000）
                              --appPort value, -a value     Go web 服务器的端口（默认：3001）
                              --bin value, -b value         生成的二进制文件的名称（默认："gin-bin"）
                              --path value, -t value        监视文件的路径（默认："."）
                              --build value, -d value       构建文件的路径（默认与 --path 相同）
                              --excludeDir value, -x value  要排除的相对目录
                              --immediate, -i               构建后立即运行服务器
                              --all                         每次任何文件更改时重新加载，而不仅仅在 .go 文件更改时重新加载
                              --godep, -g                   在构建时使用 godep
                              --buildArgs value             附加的 go 构建参数
                              --certFile value              TLS 证书
                              --keyFile value               TLS 证书密钥
                              --logPrefix value             设置自定义日志前缀
                              --notifications               启用桌面通知
                              --help, -h                    显示帮助信息
                              --version, -v                 打印版本信息
                              

                              七、realize（不推荐，已经好久没维护了）

                              7.1 介绍

                              Realize 是一个用于 Golang 的实时重载和任务运行器。它具有以下主要功能：

                              • 高性能实时刷新。
                              • 同时管理多个项目。
                              • 通过自定义扩展名和路径观察文件。
                              • 支持所有 Go 命令。
                              • 在不同的 Go 版本之间切换。
                              • 支持项目的自定义环境变量。
                              • 在文件更改前后或全局执行自定义命令。
                              • 将日志和错误导出到外部文件。
                              • 分步项目初始化。
                              • 重新设计的面板，显示构建错误，控制台输出和警告。

                                7.2 相关文档

                                • GitHub 仓库：https://github.com/oxequa/realize

                                  7.3 安装与使用

                                  1. 进入到你的项目目录

                                  cd /path/to/myapp
                                  

                                  2. 使用以下命令安装 gowatch：

                                  go install github.com/oxequa/realize@latest
                                  go get github.com/oxequa/realize
                                  

                                  首先进行初始化，默认配置即可：

                                  realize init
                                  

                                  执行项目：

                                  realize start
                                  

                                  添加命令：

                                  realize add
                                  

                                  删除命令：

                                  realize init
                                  

                                  7.4 命令参数

                                  选项：

                                  --name="name"               -> 根据现有配置的名称运行
                                  --path="realize/server"     -> 自定义路径（如果未指定，将采用工作目录名称）
                                  --generate                  -> 启用 go generate
                                  --fmt                       -> 启用 go fmt
                                  --test                      -> 启用 go test
                                  --vet                       -> 启用 go vet
                                  --install                   -> 启用 go install
                                  --build                     -> 启用 go build
                                  --run                       -> 启用 go run
                                  --server                    -> 启用 Web 服务器
                                  --open                      -> 在默认浏览器中打开 Web UI
                                  --no-config                 -> 忽略现有配置/跳过创建新配置
                                  

                                  示例：

                                  $ realize start
                                  $ realize start --path="mypath"
                                  $ realize start --name="realize" --build
                                  $ realize start --path="realize" --run --no-config
                                  $ realize start --install --test --fmt --no-config
                                  $ realize start --path="/Users/username/go/src/github.com/oxequa/realize-examples/coin/"
                                  

                                   
                                   想建设一个网站  郑州做网站的公司  上海关键词优化外包  企业官网设计公司  微信商城小程序  建站教程网站