flowchart TD A[2007年 Google开始设计Go语言] --> B[解决现代软件开发痛点] B --> C[编译速度慢] B --> D[依赖管理复杂] B --> E[并发编程困难] B --> F[代码维护成本高] C --> G[2009年 Go语言正式发布] D --> G E --> G F --> G G --> H[静态强类型、编译型语言]
# 1. 查看可用版本
go list -m -versions github.com/gin-gonic/gin
# 2. 升级到最新版本
go get github.com/gin-gonic/gin@latest
# 3. 升级到特定版本
go get github.com/gin-gonic/[email protected]# 4. 升级到最新的次版本
go get github.com/gin-gonic/gin@v1
# 5. 升级到预发布版本
go get github.com/gin-gonic/[email protected]# 6. 回退到之前版本
go get github.com/gin-gonic/[email protected]# 7. 查看依赖图
go mod graph
# 8. 解释为什么需要某个依赖
go mod why github.com/gin-gonic/gin
# 发布预发布版本
git tag v2.0.0-alpha
git tag v2.0.0-beta.1
git tag v2.0.0-rc.1
# 使用预发布版本
go get github.com/example/[email protected]# 预发布版本不会被@latest选择
go get github.com/example/lib@latest # 不会选择预发布版本
// 使用go mod tidy检查兼容性
// go mod tidy会：
// 1. 添加缺失的依赖
// 2. 移除未使用的依赖
// 3. 更新go.sum文件
// 检查模块兼容性
go mod verify // 验证依赖完整性
go mod download // 下载依赖到本地缓存
// 查看过时的依赖
go list -u -m all
#!/bin/bash
# 版本发布脚本示例
# 1. 确保工作目录干净
if [[ -n $(git status --porcelain) ]]; then
echo "工作目录不干净，请先提交更改"
exit 1
fi
# 2. 运行测试
go test ./...
if [[ $? -ne 0 ]]; then
echo "测试失败"
exit 1
fi
# 3. 更新版本号
VERSION=$1
if [[ -z $VERSION ]]; then
echo "请提供版本号，如: ./release.sh v1.2.3"
exit 1
fi
# 4. 创建标签并推送
git tag $VERSION
git push origin $VERSION
echo "版本 $VERSION 发布成功"
// 静态类型示例
var name string = "Go语言" // 编译时确定为string类型
var age int = 10 // 编译时确定为int类型
// name = age // 编译错误：不能将int赋值给string
flowchart LR
A[Go源代码.go] --> B[Go编译器]
B --> C[机器码可执行文件]
C --> D[直接运行]
style A fill:#e8f5e8
style B fill:#e3f2fd
style C fill:#fff3e0
style D fill:#fce4ec
flowchart TD
A[主Goroutine] --> B[创建Channel]
B --> C[启动Worker Goroutines]
C --> D[Goroutine 1]
C --> E[Goroutine 2]
C --> F[Goroutine 3]
D --> G[Channel通信]
E --> G
F --> G
G --> H[结果汇总]
H --> I[程序结束]
style A fill:#e8f5e8
style G fill:#e3f2fd
style H fill:#fff3e0
// New-API项目中的并发示例
func main() {
// 启动多个后台goroutine
go model.SyncChannelCache(common.SyncFrequency)
go model.SyncOptions(common.SyncFrequency)
go model.UpdateQuotaData()
go controller.AutomaticallyTestChannels()
// 使用gopool管理goroutine
if common.IsMasterNode && constant.UpdateTask {
gopool.Go(func() {
controller.UpdateMidjourneyTaskBulk()
})
gopool.Go(func() {
controller.UpdateTaskBulk()
})
}
}
// 生产者-消费者模式示例
func producerConsumerExample() {
jobs := make(chan int, 100)
results := make(chan int, 100)
// 启动3个worker goroutine
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}
// 发送9个任务
for j := 1; j <= 9; j++ {
jobs <- j
}
close(jobs)
// 收集结果
for a := 1; a <= 9; a++ {
<-results
}
}
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
fmt.Printf("worker %d started job %d\n", id, j)
time.Sleep(time.Second)
fmt.Printf("worker %d finished job %d\n", id, j)
results <- j * 2
}
}
flowchart TD
A[程序运行] --> B[内存分配]
B --> C{内存使用率达到阈值?}
C -->|否| B
C -->|是| D[触发GC]
D --> E[标记阶段]
E --> F[清除阶段]
F --> G[内存整理]
G --> B
E --> E1[白色对象：未访问]
E --> E2[灰色对象：已访问，子对象未访问]
E --> E3[黑色对象：已访问，子对象已访问]
style E1 fill:#ffffff,stroke:#000000
style E2 fill:#cccccc,stroke:#000000
style E3 fill:#000000,color:#ffffff
// GC触发示例
func gcExample() {
// 分配大量内存
data := make([][]byte, 1000)
for i := 0; i < 1000; i++ {
data[i] = make([]byte, 1024*1024) // 1MB
}
// 手动触发GC（通常不需要）
runtime.GC()
// 查看内存统计
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("分配的内存: %d KB\n", m.Alloc/1024)
fmt.Printf("GC次数: %d\n", m.NumGC)
}
flowchart LR
A[环境变量配置] --> B[GOROOT]
A --> C[GOPATH]
A --> D[PATH]
A --> E[GOPROXY]
A --> F[GO111MODULE]
B --> B1[Go安装目录]
C --> C1[Go工作空间]
D --> D1[可执行文件路径]
E --> E1[模块代理地址]
F --> F1[启用Go Modules]
# 设置多个代理
export GOPROXY=https://goproxy.cn,https://goproxy.io,direct
# 查看当前代理设置
go env GOPROXY
# 临时使用不同代理
GOPROXY=direct go get github.com/example/package
# 检查Go版本
go version
# 输出：go version go1.23.4 linux/amd64
# 查看Go环境信息
go env
# 输出Go相关的环境变量
# 查看具体的环境变量
go env GOROOT
go env GOPATH
go env GOPROXY
flowchart TD
A[VS Code安装] --> B[安装Go扩展]
B --> C[配置Go工具]
C --> D[设置优化]
D --> E[调试配置]
C --> C1[gopls语言服务器]
C --> C2[go-outline代码大纲]
C --> C3[gotests测试生成]
C --> C4[delve调试器]
D --> D1[自动格式化]
D --> D2[代码检查]
D --> D3[自动导入]
E --> E1[Launch配置]
E --> E2[Attach配置]
style A fill:#e3f2fd
style B fill:#f3e5f5
style C fill:#e8f5e8
style D fill:#fff3e0
style E fill:#fce4ec
# 手动安装Go工具
go install -v golang.org/x/tools/gopls@latest
go install -v github.com/ramya-rao-a/go-outline@latest
go install -v github.com/cweill/gotests/...@latest
go install -v github.com/fatih/gomodifytags@latest
go install -v github.com/josharian/impl@latest
go install -v github.com/haya14busa/goplay/cmd/goplay@latest
go install -v github.com/go-delve/delve/cmd/dlv@latest
go install -v honnef.co/go/tools/cmd/staticcheck@latest
sequenceDiagram
participant Dev as 开发者
participant GoMod as Go Modules
participant Proxy as 模块代理
participant Repo as 代码仓库
Dev->>GoMod: go mod init
GoMod->>GoMod: 创建go.mod文件
Dev->>GoMod: go get package
GoMod->>Proxy: 查询模块信息
Proxy->>Repo: 获取源码
Repo->>Proxy: 返回模块
Proxy->>GoMod: 返回模块
GoMod->>GoMod: 更新go.mod和go.sum
Dev->>GoMod: go build
GoMod->>GoMod: 验证依赖完整性
GoMod->>Dev: 构建成功
flowchart LR
A[Go Modules命令] --> B[初始化]
A --> C[依赖管理]
A --> D[依赖查询]
A --> E[维护操作]
B --> B1[go mod init]
C --> C1[go get 添加依赖]
C --> C2[go get -u 更新依赖]
C --> C3[go mod tidy 整理依赖]
C --> C4[go mod download 下载依赖]
D --> D1[go list -m all]
D --> D2[go mod graph]
D --> D3[go mod why]
E --> E1[go mod verify]
E --> E2[go clean -modcache]
style B fill:#e8f5e8
style C fill:#e3f2fd
style D fill:#fff3e0
style E fill:#fce4ec
# 在项目根目录执行
go mod init module-name
# 例如：
go mod init one-api
# 添加依赖
go get github.com/gin-gonic/gin@latest
go get github.com/gin-gonic/[email protected] # 指定版本
# 更新依赖
go get -u github.com/gin-gonic/gin # 更新到最新版本
go get -u all # 更新所有依赖
# 移除未使用的依赖
go mod tidy
# 下载依赖到本地缓存
go mod download
# 验证依赖
go mod verify
# 查看依赖图
go mod graph
# 查看可用版本
go list -m -versions github.com/gin-gonic/gin
# 查看当前依赖
go list -m all
# 查看依赖原因
go mod why github.com/gin-gonic/gin
flowchart LR
A[HTTP请求] --> B[中间件1]
B --> C[中间件2]
C --> D[中间件3]
D --> E[业务处理器]
E --> F[中间件3]
F --> G[中间件2]
G --> H[中间件1]
H --> I[HTTP响应]
style A fill:#e3f2fd
style I fill:#e8f5e8
style B fill:#fff3e0
style C fill:#fff3e0
style D fill:#fff3e0
style F fill:#fff3e0
style G fill:#fff3e0
style H fill:#fff3e0
style E fill:#f3e5f5
### 1.5.2 目录结构设计原则
#### 1. 分层架构原则
```mermaid
flowchart TD
A[HTTP请求] --> B[Router路由层]
B --> C[Middleware中间件]
C --> D[Controller控制器层]
D --> E[Service业务服务层]
E --> F[Model数据模型层]
F --> G[Database数据库]
D --> H[DTO数据传输对象]
E --> I[Common公共工具]
style B fill:#e1f5fe
style D fill:#f3e5f5
style E fill:#e8f5e8
style F fill:#fff3e0
flowchart TD
A[表示层 Presentation Layer] --> B[业务逻辑层 Business Logic Layer]
B --> C[数据访问层 Data Access Layer]
C --> D[数据存储层 Data Storage Layer]
A1[HTTP处理器<br/>路由<br/>中间件] --> A
B1[业务规则<br/>业务流程<br/>领域逻辑] --> B
C1[数据库操作<br/>缓存操作<br/>外部API调用] --> C
D1[MySQL<br/>Redis<br/>文件系统] --> D
style A fill:#e1f5fe
style B fill:#f3e5f5
style C fill:#e8f5e8
style D fill:#fff3e0
flowchart LR
V[View 视图层] --> C[Controller 控制器层]
C --> M[Model 模型层]
M --> V
V1[模板引擎<br/>JSON响应<br/>HTML页面] --> V
C1[HTTP处理器<br/>路由处理<br/>请求验证] --> C
M1[数据模型<br/>业务逻辑<br/>数据访问] --> M
style V fill:#ffebee
style C fill:#e3f2fd
style M fill:#e8f5e8
# 设置Go代理（加速依赖下载）
go env -w GOPROXY=https://goproxy.cn,direct
# 下载依赖
go mod download
# 整理依赖（移除未使用的依赖）
go mod tidy
# 验证依赖
go mod verify
# 查看所有依赖
go list -m all
# 查看依赖图
go mod graph
# 查看特定依赖的信息
go list -m -versions github.com/gin-gonic/gin
flowchart TD
A[数据库选择] --> B{环境类型}
B --> C[开发环境]
B --> D[生产环境]
C --> C1[SQLite]
C1 --> C2[无需安装]
C1 --> C3[文件数据库]
C1 --> C4[快速启动]
D --> D1[MySQL]
D --> D2[PostgreSQL]
D1 --> D3[高性能]
D1 --> D4[广泛支持]
D2 --> D5[功能丰富]
D2 --> D6[标准兼容]
C1 --> E[New-API支持]
D1 --> E
D2 --> E
style C1 fill:#e8f5e8
style D1 fill:#e3f2fd
style D2 fill:#fff3e0
# 创建数据目录
mkdir -p data
# SQLite无需额外安装，Go程序会自动创建数据库文件
# 安装MySQL（Ubuntu/Debian）
sudo apt update
sudo apt install mysql-server
# 启动MySQL服务
sudo systemctl start mysql
sudo systemctl enable mysql
# 创建数据库
mysql -u root -p
CREATE DATABASE new_api CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'newapi'@'localhost' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON new_api.* TO 'newapi'@'localhost';
FLUSH PRIVILEGES;
# 安装PostgreSQL（Ubuntu/Debian）
sudo apt update
sudo apt install postgresql postgresql-contrib
# 创建数据库和用户
sudo -u postgres psql
CREATE DATABASE new_api;
CREATE USER newapi WITH PASSWORD 'password';
GRANT ALL PRIVILEGES ON DATABASE new_api TO newapi;
# 进入前端目录
cd web
# 安装依赖
bun install
# 或使用npm：npm install
# 构建前端
bun run build
# 或使用npm：npm run build
flowchart TD
A[项目启动] --> B{选择启动方式}
B --> C[Makefile方式]
B --> D[手动启动]
B --> E[开发模式]
C --> C1[make all]
C --> C2[make build-frontend]
C --> C3[make start-backend]
D --> D1[构建前端]
D1 --> D2[启动后端]
E --> E1[前端开发服务器]
E --> E2[后端调试模式]
C1 --> F[服务运行]
D2 --> F
E1 --> F
E2 --> F
F --> G[功能验证]
G --> H[健康检查]
G --> I[Web界面]
G --> J[数据库连接]
# 查看可用的make命令
make help
# 构建前端并启动后端
make all
# 仅构建前端
make build-frontend
# 仅启动后端
make start-backend
# 构建前端（一次性）
cd web && bun run build && cd ..
# 启动后端服务
go run main.go
# 终端1：启动前端开发服务器
cd web
bun run dev
# 终端2：启动后端服务
GIN_MODE=debug go run main.go
# 查看日志确认数据库连接正常
tail -f logs/oneapi-*.log
# 预期看到类似日志
[SYS] database migration started
[SYS] database migrated
[SYS] New API v0.0.0 started
flowchart TD
A[常见问题] --> B[端口占用]
A --> C[权限问题]
A --> D[依赖下载失败]
A --> E[前端构建失败]
B --> B1[lsof -i :3000]
B --> B2[netstat检查]
B --> B3[kill进程]
C --> C1[目录权限]
C --> C2[文件所有者]
C --> C3[systemd服务]
D --> D1[清理模块缓存]
D --> D2[更换代理]
D --> D3[直接访问源码]
E --> E1[清理node_modules]
E --> E2[重新安装依赖]
E --> E3[检查Node版本]
style B fill:#ffebee
style C fill:#fff3e0
style D fill:#e8f5e8
style E fill:#e3f2fd
