Golang项目初始化指南：从零开始搭建项目

Go项目初始化指南

1. 项目结构初始化

首先创建标准的Go项目结构：

# 创建项目目录
mkdir myproject && cd myproject

# 初始化Go模块（替换为你的模块路径）
go mod init github.com/yourusername/myproject

# 创建标准目录结构
mkdir -p cmd/ internal/ pkg/ api/ configs/ scripts/ build/ deployments/
mkdir -p test/ web/ static/ docs/ examples/

2. 基础文件配置

创建main.go入口文件：

// cmd/myproject/main.go
package main

import (
    "context"
    "log"
    "os"
    "os/signal"
    "syscall"
    "time"
    
    "github.com/yourusername/myproject/internal/app"
    "github.com/yourusername/myproject/internal/config"
)

func main() {
    // 加载配置
    cfg, err := config.Load()
    if err != nil {
        log.Fatalf("Failed to load config: %v", err)
    }
    
    // 创建应用
    application, err := app.New(cfg)
    if err != nil {
        log.Fatalf("Failed to create app: %v", err)
    }
    
    // 优雅关闭
    ctx, stop := signal.NotifyContext(context.Background(), 
        os.Interrupt, syscall.SIGTERM)
    defer stop()
    
    // 启动应用
    if err := application.Run(ctx); err != nil {
        log.Fatalf("Application error: %v", err)
    }
}

3. 配置文件示例

创建配置结构：

// internal/config/config.go
package config

import (
    "github.com/spf13/viper"
)

type Config struct {
    Server   ServerConfig   `mapstructure:"server"`
    Database DatabaseConfig `mapstructure:"database"`
    Log      LogConfig      `mapstructure:"log"`
}

type ServerConfig struct {
    Port         int           `mapstructure:"port"`
    ReadTimeout  time.Duration `mapstructure:"read_timeout"`
    WriteTimeout time.Duration `mapstructure:"write_timeout"`
}

type DatabaseConfig struct {
    Host     string `mapstructure:"host"`
    Port     int    `mapstructure:"port"`
    User     string `mapstructure:"user"`
    Password string `mapstructure:"password"`
    DBName   string `mapstructure:"dbname"`
}

type LogConfig struct {
    Level  string `mapstructure:"level"`
    Format string `mapstructure:"format"`
}

func Load() (*Config, error) {
    viper.SetConfigName("config")
    viper.SetConfigType("yaml")
    viper.AddConfigPath(".")
    viper.AddConfigPath("./configs")
    
    viper.SetDefault("server.port", 8080)
    viper.SetDefault("server.read_timeout", "30s")
    viper.SetDefault("server.write_timeout", "30s")
    
    if err := viper.ReadInConfig(); err != nil {
        return nil, err
    }
    
    var cfg Config
    if err := viper.Unmarshal(&cfg); err != nil {
        return nil, err
    }
    
    return &cfg, nil
}

4. Makefile构建脚本

创建Makefile：

# Makefile
.PHONY: build run test clean lint

BINARY_NAME=myproject
VERSION=$(shell git describe --tags --always --dirty)

# 构建
build:
    @echo "Building $(BINARY_NAME)..."
    CGO_ENABLED=0 go build -ldflags="-s -w -X main.version=$(VERSION)" \
        -o bin/$(BINARY_NAME) ./cmd/myproject

# 开发运行
run:
    go run ./cmd/myproject

# 测试
test:
    go test -v -race ./...

# 代码检查
lint:
    golangci-lint run ./...

# 清理
clean:
    rm -rf bin/ coverage.out

# Docker构建
docker-build:
    docker build -t $(BINARY_NAME):$(VERSION) .

# 生成Swagger文档
swagger:
    swag init -g cmd/myproject/main.go -o docs/swagger

5. Docker配置

创建Dockerfile：

# Dockerfile
# 构建阶段
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" \
    -o /app/bin/myproject ./cmd/myproject

# 运行阶段
FROM alpine:latest
RUN apk --no-cache add ca-certificates tzdata
WORKDIR /root/
COPY --from=builder /app/bin/myproject .
COPY --from=builder /app/configs ./configs
EXPOSE 8080
CMD ["./myproject"]

6. 依赖管理

更新go.mod并添加常用依赖：

# 添加常用开发依赖
go get -u github.com/spf13/viper
go get -u github.com/gin-gonic/gin
go get -u go.uber.org/zap
go get -u github.com/stretchr/testify
go get -u golang.org/x/tools/cmd/goimports

# 添加开发工具
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
go install github.com/swaggo/swag/cmd/swag@latest

7. 测试结构

创建基础测试示例：

// internal/app/app_test.go
package app_test

import (
    "context"
    "testing"
    "time"
    
    "github.com/stretchr/testify/assert"
    "github.com/yourusername/myproject/internal/app"
    "github.com/yourusername/myproject/internal/config"
)

func TestApp(t *testing.T) {
    cfg := &config.Config{
        Server: config.ServerConfig{
            Port:         8080,
            ReadTimeout:  30 * time.Second,
            WriteTimeout: 30 * time.Second,
        },
    }
    
    app, err := app.New(cfg)
    assert.NoError(t, err)
    assert.NotNil(t, app)
    
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    // 测试应用启动
    go func() {
        err := app.Run(ctx)
        assert.ErrorIs(t, err, context.DeadlineExceeded)
    }()
    
    time.Sleep(100 * time.Millisecond)
}

8. Git忽略文件

创建.gitignore：

# .gitignore
# 二进制文件
bin/
dist/

# 依赖目录
vendor/

# 环境文件
.env
.env.local

# IDE文件
.vscode/
.idea/
*.swp
*.swo

# 测试输出
coverage.out
profile.out

# 临时文件
tmp/
*.log

# Go工作区
go.work

9. 代码质量工具

创建.golangci.yml：

# .golangci.yml
run:
  timeout: 5m
  modules-download-mode: readonly

linters:
  enable:
    - gofmt
    - goimports
    - revive
    - govet
    - staticcheck
    - gosimple
    - unused
    - errcheck
    - goconst
    - gocyclo
    - ineffassign

issues:
  max-issues-per-linter: 0
  max-same-issues: 0

这个初始化结构包含了生产级Go项目所需的基础组件，包括配置管理、构建脚本、容器化支持、测试框架和代码质量工具。