GVM 脚手架探险记02：那些让我拍大腿的Go技巧彩蛋

// utils/human_duration.go

package utils

import (
	"strconv"
	"strings"
	"time"
)

// ParseDuration 自定义的解析时间的方法
// 支持解析包含天的时长字符串，如 "3d"、"2d6h30m"
func ParseDuration(d string) (time.Duration, error) {
	// 去除字符串首尾空格
	d = strings.TrimSpace(d)
	// 尝试用标准库解析
	dr, err := time.ParseDuration(d)
	if err == nil {
		return dr, nil
	}
	// 当字符串包含 "d" 时，将其视为天单位
	if strings.Contains(d, "d") {
		index := strings.Index(d, "d")

		hour, _ := strconv.Atoi(d[:index])
		dr = time.Hour * 24 * time.Duration(hour)
		ndr, err := time.ParseDuration(d[index+1:])
		if err != nil {
			return dr, nil
		}
		return dr + ndr, nil
	}

	// 尝试将输入解析为整数
	dv, err := strconv.ParseInt(d, 10, 64)
	// 直接转换为 time.Duration 类型（单位为纳秒）
	return time.Duration(dv), err
}

// initialize/other.go

// 尝试打开当前目录下的 go.mod 文件
file, err := os.Open("go.mod")
if err == nil && global.GVA_CONFIG.AutoCode.Module == "" {
	defer file.Close() // 确保文件被关闭
	// bufio.NewScanner(file) 创建一个 Scanner 文件扫描器，用于逐行读取文件内容
	scanner := bufio.NewScanner(file)
	// scanner.Scan() 读取文件的下一行（这里只读取第一行）。
	scanner.Scan()
	// scanner.Text() 返回当前行的内容
	global.GVA_CONFIG.AutoCode.Module = strings.TrimPrefix(scanner.Text(), "module ")
}

// core/server_run.go

package core

import (
	"context"
	"fmt"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

// initServer 启动服务并实现优雅关闭
func initServer(address string, router *gin.Engine, readTimeout, writeTimeout time.Duration) {
	// 创建服务
	srv := &http.Server{
		Addr:           address,
		Handler:        router,
		ReadTimeout:    readTimeout,
		WriteTimeout:   writeTimeout,
		MaxHeaderBytes: 1 << 20, // 限制了单个 HTTP 请求头部分的最大字节数 1MB (1048576 字节)
	}

	/*
		防止恶意客户端发送超大请求头进行攻击
		限制内存消耗，避免单个请求占用过多资源
		是防范 HTTP 头攻击(如 Slowloris 攻击)的措施之一
	*/

	// 在goroutine中启动服务
	go func() {
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			fmt.Printf("listen: %s\n", err)
			zap.L().Error("server启动失败", zap.Error(err))
			os.Exit(1)
		}
	}()

	// 等待中断信号以优雅地关闭服务器
	quit := make(chan os.Signal, 1)
	// kill (无参数) 默认发送 syscall.SIGTERM
	// kill -2 发送 syscall.SIGINT
	// kill -9 发送 syscall.SIGKILL，但是无法被捕获，所以不需要添加
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	zap.L().Info("关闭WEB服务...")

	// 设置5秒的超时时间
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)

	defer cancel()

	if err := srv.Shutdown(ctx); err != nil {
		zap.L().Fatal("WEB服务关闭异常", zap.Error(err))
	}

	zap.L().Info("WEB服务已关闭")
}

// model/common/request/common.go

type PageInfo struct {
	Page     int    `json:"page" form:"page"`         // 页码
	PageSize int    `json:"pageSize" form:"pageSize"` // 每页大小
	Keyword  string `json:"keyword" form:"keyword"`   // 关键字
}

type MyDemoSearch struct {
	Name           *string     `json:"name" form:"name"`
	Age            *int        `json:"age" form:"age"`
	Desc           *string     `json:"desc" form:"desc"`
	request.PageInfo
}

// 定义分页查询方法
func (r *PageInfo) Paginate() func(db *gorm.DB) *gorm.DB {
	return func(db *gorm.DB) *gorm.DB {
		if r.Page <= 0 {
			r.Page = 1
		}
		switch {
		case r.PageSize > 100:
			r.PageSize = 100
		case r.PageSize <= 0:
			r.PageSize = 10
		}
		offset := (r.Page - 1) * r.PageSize
		return db.Offset(offset).Limit(r.PageSize)
	}
}

// 使用分页查询方法
// 例如：
// err = db.Scopes(info.Paginate()).Order("updated_at desc").Find(&entities).Error

package config

import (
	"path/filepath"
	"strings"
)

type Autocode struct {
	Web    string `mapstructure:"web" json:"web" yaml:"web"`
	Root   string `mapstructure:"root" json:"root" yaml:"root"`
	Server string `mapstructure:"server" json:"server" yaml:"server"`
	Module string `mapstructure:"module" json:"module" yaml:"module"`
	AiPath string `mapstructure:"ai-path" json:"ai-path" yaml:"ai-path"`
}

func (a *Autocode) WebRoot() string {
	webs := strings.Split(a.Web, "/")
	if len(webs) == 0 {
		webs = strings.Split(a.Web, "\\")
	}
	return filepath.Join(webs...)
}