痛点：为什么原生Gin不够用？

用Gin写过项目的都知道，它快、小巧、API优雅。但当你做一个真实业务项目时，问题就来了：

• 配置管理：自己写env加载逻辑
• 数据库连接：每项目复制粘贴一套
• JWT认证：中间件手写，Token签发验证逻辑散落各处
• 错误处理：返回格式不统一
• 项目结构：每个人写法都不一样，团队协作头疼

一句话：Gin只解决了"路由"问题，剩下的全靠你自己堆。

AuroraLZDF/go-framework 就是来解决这个问题的——基于Gin，但给你全套基础设施。

它是什么

AuroraLZDF/go-framework 是一个基于 Gin 的高性能、可扩展的 Go Web 开发框架，提供完整的基础设施组件和最佳实践。

MIT 协议，完全开源，核心目标：让Go后端开发从"堆砖头"变成"搭积木"。

核心特性

✅ 分层架构 — Controller → Biz → Store

这是框架最核心的设计思想。

传统Gin项目，所有逻辑往Handler里塞，Controller、Biz、Store混在一起，越写越乱。

AuroraLZDF/go-framework 强制三层分离：

• Controller：HTTP入口，处理请求参数、调用Biz、返回响应
• Biz：业务逻辑层，核心业务规则在这里
• Store：数据访问层，数据库操作封装在这里

依赖注入贯穿全程，单元测试友好。

✅ 开箱即用 — 日志、数据库、认证、中间件

不需要每次从零写：

• 日志系统：基于 Zap，性能优秀，JSON格式输出
• 数据库连接：MySQL + Redis 一行初始化
• JWT认证：签发、验证、黑名单全套
• 中间件：Authn认证、CORS、请求ID自动注入
• 错误码系统：统一的 errno 定义，错误处理规范化

✅ 灵活配置 — 基于 Viper

# config.yaml
app:
  name: my-app
  mode: debug

server:
  http-addr: :8080

database:
  mysql:
    host: 127.0.0.1:3306
    username: root
    password: root
    database: mydb

jwt:
  secret: your-secret-key
  expire: 24

log:
  level: info
  format: json

支持环境变量覆盖、自定义配置项读取、配置验证。

✅ 优雅关闭

服务收到终止信号时，会等待正在处理的请求完成后再退出，避免"断崖式"服务中断。

✅ 统一响应

// 成功响应
response.Success(c, data, "ok")

// 错误响应
response.Error(c, errno.ErrTokenInvalid)

所有接口返回格式统一，前端好处理，日志好追踪。

快速开始

方法一：脚手架工具（推荐）

# 克隆框架仓库
git clone https://github.com/AuroraLZDF/go-framework.git
cd framework

# 构建脚手架工具
make build

# 创建新项目
./bin/scaffold new my-app

# 进入项目目录
cd my-app

# 安装依赖
go mod tidy

# 配置项目
cp config.example.yaml config.yaml
# 编辑 config.yaml，填入你的配置

# 运行应用
go run cmd/app/main.go

脚手架自动生成完整项目结构，5分钟跑起来。

方法二：手动引入

go get go-framework@latest

package main

import (
    "context"
    "github.com/gin-gonic/gin"
    "go-framework/core/config"
    "go-framework/core/response"
    "go-framework/core/server"
)

func main() {
    // 加载配置
    cfg, _ := config.Load("config.yaml")

    // 创建应用
    app, _ := server.NewApplication(cfg)

    // 注册路由
    app.RegisterRoutes(func(engine *gin.Engine, db interface{}) {
        engine.GET("/hello", func(c *gin.Context) {
            response.Success(c, gin.H{"message": "Hello World"}, "ok")
        })
    })

    // 启动服务
    app.Run(context.Background())
}

项目结构

AuroraLZDF/go-framework 的核心结构：

framework/
├── core/                    # 框架核心
│   ├── auth/               # 认证模块
│   │   ├── jwt/            # JWT Token 管理
│   │   └── password/       # 密码加密
│   ├── config/             # 配置管理（基于Viper）
│   ├── context/           # 上下文常量
│   ├── database/          # 数据库连接（MySQL/Redis）
│   ├── errno/             # 错误码定义
│   ├── log/               # 日志系统（基于Zap）
│   ├── middleware/        # Gin 中间件
│   ├── response/          # HTTP 响应封装
│   ├── server/            # 应用服务器
│   ├── service/           # 服务接口定义
│   ├── util/              # 工具函数
│   ├── validator/         # 数据验证
│   └── version/           # 版本管理
├── scaffold/              # 脚手架工具
│   ├── cmd/               # 命令行入口
│   ├── internal/
│   │   └── generator/     # 代码生成器
│   └── templates/         # 项目模板
├── examples/              # 示例项目
└── docs/                  # 文档

最佳实践建议的业务项目结构：

your-project/
├── cmd/app/              # 应用入口
├── internal/
│   ├── biz/              # 业务逻辑层
│   ├── controller/       # 控制器层
│   ├── store/            # 数据访问层
│   ├── model/            # 数据模型
│   └── service/          # 外部服务实现
├── configs/              # 配置文件
├── sql/                  # 数据库脚本
└── assets/              # 静态资源

核心模块详解

1. 配置管理

import "github.com/AuroraLZDF/go-framework/core/config"

cfg, err := config.Load("config.yaml")
if err != nil {
    panic(err)
}

// 验证配置
if err := cfg.Validate(); err != nil {
    panic(err)
}

自定义配置读取（使用Viper）：

import "github.com/spf13/viper"

// config.yaml 添加：
// custom:
//   api-key: abc123
//   timeout: 30

apiKey := viper.GetString("custom.api-key")
timeout := viper.GetInt("custom.timeout")

2. JWT认证

import "go-framework/core/auth/jwt"

// 初始化
jwt.Init(&jwt.Options{
    Secret:  "your-secret",
    Expire:  24,
    TokenID: "X-User-ID",
})

// 签发Token
token, err := jwt.Sign("user-123")

// 验证Token（中间件自动完成）

完整流程：签发 → 携带 → 中间件验证 → 黑名单过期，框架全包。

3. 数据库连接

import "go-framework/core/database/db"

// MySQL
mysqlOpts := &db.MySQLOptions{
    Host:     "127.0.0.1:3306",
    Username: "root",
    Password: "root",
    Database: "mydb",
}
db, err := db.InitMySQL(mysqlOpts)

// Redis
redisOpts := &db.RedisOptions{
    Addr:     "127.0.0.1:6379",
    Password: "",
    DB:       0,
}
redis, err := db.InitRedis(redisOpts)

4. 日志系统

import "go-framework/core/log"

log.Init(&log.Options{
    Level:  "info",
    Format: "json",
    Dir:    "logs",
})

log.Info("Server started", "port", 8080)
log.Error("Something failed", "err", err)

基于Zap，性能远超标准日志库。

5. 中间件

import "go-framework/core/middleware"

// 认证中间件
v1.Use(middleware.Authn())

// 请求ID（自动注册）
// CORS（自动注册）

与其他Go框架对比

AuroraLZDF/go-framework 的优势：Gin的速度 + 完整的基础设施 + 规范的分层架构。

分层架构的真正价值

很多人觉得分层架构是"大项目才需要"。但实际上，分层的好处体现在：

1. 测试：Biz层是纯函数，mock Store，直接单元测试，不需要起数据库。

2. 协作：Controller只管HTTP，Biz只管业务，Store只管DB，团队并行开发不打架。

3. 替换：想换数据库？只改Store层。想换API协议？只改Controller层。改动范围可控。

4. 理解：新人看代码，先看Controller知道"来了什么请求"，再看Biz知道"做了什么处理"，再看Store知道"怎么存数据"，思路清晰。

小结

• AuroraLZDF/go-framework：基于Gin的Go Web开发框架，MIT协议
• 分层架构：Controller→Biz→Store，依赖注入，测试友好
• 开箱即用：JWT、日志、数据库、统一响应、错误码全包
• 脚手架工具：5分钟创建新项目，无需从零配置
• 配置灵活：Viper管理，支持环境变量覆盖
• 项目地址：github.com/AuroraLZDF/go-framework

如果你在用Gin但每次新项目都要从零搭基础设施，这套框架值得一试。