golang标准模块开发模板插件go-module的使用

Golang标准模块开发模板插件go-module的使用

简介

Go Module是一个用于快速创建新Go模块的模板项目。它不仅能提供新项目的起点，还配备了预配置的CI/CD和工具集。

Go Module

快速开始

使用Makefile

$ make setup
$ make help

$ make find-todos
$ make test lint
$ TIMEOUT=5s make test-with-coverage

使用Taskfile

$ alias run=./Taskfile
$ run refresh
$ run help

$ run docs # === `run docs install -- build -- start`
$ run docs npm ci
$ run docs npm i nextra@latest

$ run tools go generate tools.go
$ run tools golangci-lint --version -- mockgen --version
$ run which goimports golangci-lint govulncheck mockgen

使用工具

$ make tools
$ source bin/activate

$ which goimports
$ goimports -local $(go list -m) -w ./...

使用Docker

$ make go-1.11 # or go-1.12, etc.
/src# make go-env 2>/dev/null | grep GOVERSION
# GOVERSION:   1.11.13
/src# make test

创建自己的模块

  1. 从模板生成新仓库
  2. 本地克隆仓库
  3. 根据需要更新文件，例如：run init my.new/module
  4. 编写代码和测试
  5. 发布

完整示例

以下是一个简单的Go模块示例：

// go.mod
module example.com/my-module

go 1.19

require (
    github.com/stretchr/testify v1.8.0
)

// main.go
package main

import (
    "fmt"
    "example.com/my-module/greeting"
)

func main() {
    fmt.Println(greeting.Hello("World"))
}

// greeting/greeting.go
package greeting

// Hello returns a greeting for the named person.
func Hello(name string) string {
    return "Hello, " + name + "!"
}

// greeting/greeting_test.go
package greeting

import "testing"

func TestHello(t *testing.T) {
    got := Hello("World")
    want := "Hello, World!"

    if got != want {
        t.Errorf("got %q want %q", got, want)
    }
}

配置

预配置项

  1. GitHub Actions
  2. GitHub Pages
  3. Dependabot

包含工具

  1. Nextra (文档)
  2. Makefiles
  3. Taskfiles
  4. Go工具: mockgen, golangci-lint, goimports, govulncheck

集成

项目使用SemVer进行版本控制，建议使用Go Modules管理依赖版本：

$ go get go.octolab.org@latest

这个模板为Go模块开发提供了完整的起点，包含测试、文档和CI/CD流程，可以帮助开发者快速开始新项目。


更多关于golang标准模块开发模板插件go-module的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang标准模块开发模板插件go-module的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Go Module 使用指南

Go Module 是 Go 1.11 版本引入的官方依赖管理系统，取代了旧的 GOPATH 模式。下面我将详细介绍 Go Module 的使用方法，并提供示例代码。

1. 初始化 Module

要创建一个新的 Go Module，首先需要初始化：

# 创建项目目录
mkdir myproject
cd myproject

# 初始化module，module名称通常是仓库路径
go mod init github.com/yourusername/myproject

这会生成一个 go.mod 文件，内容类似：

module github.com/yourusername/myproject

go 1.21

2. 添加依赖

当你的代码中 import 了外部包并运行 go build 或 go test 时，Go 会自动下载依赖并更新 go.mod 和 go.sum 文件。

你也可以手动添加依赖：

go get github.com/gin-gonic/gin@v1.9.1

3. 常用命令

# 下载所有依赖
go mod download

# 整理依赖，移除不需要的
go mod tidy

# 查看依赖关系图
go mod graph

# 验证依赖完整性
go mod verify

# 将依赖复制到vendor目录
go mod vendor

4. 示例项目结构

一个典型的 Go Module 项目结构如下：

myproject/
├── go.mod
├── go.sum
├── main.go
├── internal/
│   └── utils/
│       └── utils.go
├── pkg/
│   └── api/
│       └── api.go
└── cmd/
    └── myapp/
        └── main.go

5. 示例代码

main.go

package main

import (
	"fmt"
	"log"
	
	"github.com/yourusername/myproject/internal/utils"
	"github.com/yourusername/myproject/pkg/api"
)

func main() {
	fmt.Println("Hello, Go Module!")
	
	// 使用内部包
	result := utils.Add(1, 2)
	log.Printf("1 + 2 = %d", result)
	
	// 使用API包
	apiHandler := api.NewAPIHandler()
	apiHandler.SayHello("World")
}

internal/utils/utils.go

package utils

// Add 两个整数相加
func Add(a, b int) int {
	return a + b
}

pkg/api/api.go

package api

import "fmt"

// APIHandler 示例API处理器
type APIHandler struct{}

// NewAPIHandler 创建新的API处理器
func NewAPIHandler() *APIHandler {
	return &APIHandler{}
}

// SayHello 问候方法
func (h *APIHandler) SayHello(name string) {
	fmt.Printf("Hello, %s!\n", name)
}

6. 版本控制

Go Module 支持语义化版本控制：

  • go get github.com/gin-gonic/gin@latest - 获取最新版本
  • go get github.com/gin-gonic/gin@v1.9.1 - 获取指定版本
  • go get github.com/gin-gonic/gin@master - 获取master分支最新代码

7. 替换依赖

在 go.mod 中可以使用 replace 指令替换依赖：

module github.com/yourusername/myproject

go 1.21

require (
	github.com/some/dependency v1.2.3
)

replace github.com/some/dependency => ../local/path/to/dependency

8. 最佳实践

  1. 保持 go.mod 文件整洁，使用 go mod tidy 定期清理
  2. 将 go.sum 文件提交到版本控制
  3. 对于生产环境，使用明确的版本号而非 @latest
  4. 使用 internal 目录保护不想暴露的内部包
  5. 考虑使用 vendor 目录以确保构建可重复性

9. 多版本工作区 (Go 1.18+)

Go 1.18 引入了工作区功能，可以在一个目录下管理多个 module：

# 初始化工作区
go work init

# 向工作区添加module
go work use ./module1
go work use ./module2

这会生成 go.work 文件，用于本地开发时管理多个相关 module。

Go Module 是 Go 语言依赖管理的未来，它简化了依赖管理过程，提供了更好的版本控制和可重复构建能力。

回到顶部