# gothink

**Repository Path**: wugg/gothink

## Basic Information

- **Project Name**: gothink
- **Description**: 根据thinkphp 框架想法快速搭建项目结构 集成各类简化sql函数，执行方法等
- **Primary Language**: Go
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2025-09-17
- **Last Updated**: 2025-09-18

## Categories & Tags

**Categories**: Uncategorized

**Tags**: First, Go语言, ThinkPHP

## README

# ThinkGo 框架

一个仿照 ThinkPHP 框架思想，使用 Go 语言实现的轻量级快速开发框架。它结合了 Go 语言的高性能特性和 ThinkPHP 的简洁开发理念，为开发者提供高效、快速的 Web 应用开发体验。

## 目录结构

```
think/
├── app/              # 应用目录
│   ├── controller/   # 控制器目录
│   ├── model/        # 模型目录
│   └── view/         # 视图目录
├── common/           # 公共类库
├── config/           # 配置文件目录
├── core/             # 框架核心代码
├── database/         # 数据库操作封装
├── library/          # 第三方库和工具
├── middleware/       # 中间件目录
├── route/            # 路由系统
├── go.mod            # Go模块依赖
├── go.sum            # 依赖版本锁定
├── main.go           # 应用入口文件
├── LICENSE           # 开源许可证
└── README.md         # 项目说明文件
```

## 核心功能

1. **自动路由注册**：基于控制器类自动注册路由，支持 RESTful API 风格
2. **控制器系统**：提供基础控制器类，支持 JSON 响应和参数获取
3. **模型系统**：封装数据库操作，支持链式查询
4. **中间件机制**：支持请求前处理和后处理
5. **配置管理**：集中管理应用配置，支持多种环境配置
6. **日志系统**：内置请求日志和错误日志记录

## 快速开始

### 1. 前提条件

- Go 1.16 或更高版本
- 支持的数据库（默认为 MySQL）

### 2. 安装依赖

```bash
go mod tidy
```

### 3. 配置数据库

编辑 `config/app.go` 文件，配置数据库连接信息：

```go
// DBConfig 数据库配置
var DBConfig = &database.Config{
	Driver:   "mysql",
	Host:     "localhost",
	Port:     "3306",
	Username: "root",
	Password: "password",
	Database: "test",
	Charset:  "utf8mb4",
}
```

### 4. 运行应用

```bash
cd d:\gowork\think
go run main.go
```

### 5. 访问示例接口

框架启动后，可以访问以下示例接口：

- 首页：`http://localhost:8080/`
- Hello 接口：`http://localhost:8080/index/hello`
- 用户列表：`http://localhost:8080/user/list`
- 用户详情：`http://localhost:8080/user/detail?id=1`

## 控制器开发

### 1. 创建基础控制器

在 `app/controller/` 目录下创建新的控制器文件：

```go
package controller

import (
	"net/http"
	"think/common"
)

type UserController struct {
	common.Controller
}

// Index 用户控制器首页
func (c *UserController) Index(w http.ResponseWriter, r *http.Request) {
	c.JSON(w, http.StatusOK, map[string]string{"message": "User controller index"})
}
```

### 2. 自动路由注册

框架会自动扫描控制器目录并注册路由。路由规则如下：

- 控制器名称去掉 `Controller` 后缀，转为小写作为基础路径
- 方法名称根据前缀自动识别 HTTP 方法（GET、POST、PUT、DELETE）
- 方法名称转为下划线命名添加到路由路径中

例如 `UserController` 的 `GetList` 方法会自动注册为 `GET /user/list` 路由。

### 3. 控制器方法示例

```go
// GET 获取用户列表
get /user/list
get /user
func (c *UserController) GetList(w http.ResponseWriter, r *http.Request) {
	// 实现用户列表逻辑
}

// POST 创建用户
post /user/create
func (c *UserController) PostCreateUser(w http.ResponseWriter, r *http.Request) {
	// 实现创建用户逻辑
}

// PUT 更新用户
put /user/update
func (c *UserController) PutUpdateUser(w http.ResponseWriter, r *http.Request) {
	// 实现更新用户逻辑
}

// DELETE 删除用户
delete /user/delete
func (c *UserController) DeleteUser(w http.ResponseWriter, r *http.Request) {
	// 实现删除用户逻辑
}
```

## 模型开发

### 1. 创建模型

在 `app/model/` 目录下创建新的模型文件：

```go
package model

import (
	"think/common"
	"think/database"
)

type UserModel struct {
	common.Model
}

// 表名
func (m *UserModel) TableName() string {
	return "users"
}

// GetUsers 获取用户列表
func (m *UserModel) GetUsers(limit int) []map[string]interface{} {
	var users []map[string]interface{}
	m.Db().Limit(limit).Find(&users)
	return users
}

// GetUserByID 根据ID获取用户
func (m *UserModel) GetUserByID(id int) map[string]interface{} {
	var user map[string]interface{}
	m.Db().Where("id = ?", id).First(&user)
	return user
}
```

### 2. 在控制器中使用模型

```go
func (c *UserController) List(w http.ResponseWriter, r *http.Request) {
	userModel := &model.UserModel{}
	users := userModel.GetUsers(10)
	c.JSON(w, http.StatusOK, map[string]interface{}{
		"code": 0,
		"msg":  "success",
		"data": users,
	})
}
```

## 中间件开发

### 1. 创建中间件

在 `middleware/` 目录下创建新的中间件文件：

```go
package middleware

import (
	"log"
	"net/http"
	"time"
)

// AuthMiddleware 认证中间件
func AuthMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// 实现认证逻辑，例如检查 token
		token := r.Header.Get("Authorization")
		if token == "" {
			http.Error(w, "Unauthorized", http.StatusUnauthorized)
			return
		}
		
		// 验证通过，继续处理请求
		next.ServeHTTP(w, r)
	})
}

// LogMiddleware 日志中间件
func LogMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		startTime := time.Now()
		log.Printf("Started %s %s", r.Method, r.RequestURI)
		
		// 处理请求
		next.ServeHTTP(w, r)
		
		// 记录请求完成时间
		duration := time.Since(startTime)
		log.Printf("Completed %s %s in %v", r.Method, r.RequestURI, duration)
	})
}
```

### 2. 注册中间件

在 `main.go` 文件中注册中间件：

```go
// 添加全局中间件
app := core.NewApp(router)
app.Use(middleware.LogMiddleware)
app.Use(middleware.AuthMiddleware)
```

## 配置管理

### 1. 应用配置

框架的配置文件位于 `config/app.go`，可以在其中添加或修改配置项：

```go
package config

import (
	"think/database"
)

// AppConfig 应用配置
var AppConfig = struct {
	AppName     string
	AppVersion  string
	Env         string // dev, test, prod
	Debug       bool
	Port        string
}{"ThinkGo", "1.0.0", "dev", true, "8080"}

// DBConfig 数据库配置
var DBConfig = &database.Config{
	Driver:   "mysql",
	Host:     "localhost",
	Port:     "3306",
	Username: "root",
	Password: "password",
	Database: "test",
	Charset:  "utf8mb4",
}
```

### 2. 在代码中访问配置

```go
import (
	"fmt"
	"think/config"
)

// 获取应用名称
appName := config.AppConfig.AppName
fmt.Println("App Name:", appName)

// 获取数据库配置
dbConfig := config.DBConfig
fmt.Println("Database:", dbConfig.Database)
```

## 数据库操作

框架提供了简洁的数据库操作接口，支持链式查询：

```go
// 创建模型实例
userModel := &model.UserModel{}

// 查询所有用户
users := userModel.Db().Find(nil)

// 条件查询
users := userModel.Db().
	Where("age > ?", 18).
	Where("status = ?", 1).
	OrderBy("id DESC").
	Limit(10).
	Find(nil)

// 插入数据
insertId := userModel.Db().
	Data(map[string]interface{}{
		"name":  "张三",
		"age":   25,
		"status": 1,
	}).
	Insert()

// 更新数据
affectedRows := userModel.Db().
	Where("id = ?", 1).
	Data(map[string]interface{}{
		"name":  "李四",
		"status": 0,
	}).
	Update()

// 删除数据
affectedRows := userModel.Db().
	Where("id = ?", 1).
	Delete()
```

## 错误处理

### 1. 控制器中返回错误

```go
func (c *UserController) Detail(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")
	if id == "" {
		c.JSON(w, http.StatusBadRequest, map[string]interface{}{
			"code": 400,
			"msg":  "缺少ID参数",
		})
		return
	}
	
	// 其他逻辑...
}
```

### 2. 全局错误处理

在 `main.go` 文件中添加全局错误处理中间件：

```go
// ErrorMiddleware 全局错误处理中间件
func ErrorMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if err := recover(); err != nil {
				log.Printf("Panic error: %v", err)
				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
			}
		}()
		next.ServeHTTP(w, r)
	})
}

// 注册全局错误处理中间件
app.Use(ErrorMiddleware)
```

## 扩展指南

### 1. 添加新的服务

在 `library/` 目录下创建新的服务类，例如缓存服务：

```go
package library

import (
	"sync"
	"time"
)

// Cache 简单内存缓存
type Cache struct {
	items map[string]cacheItem
	mutex sync.RWMutex
}

type cacheItem struct {
	Value      interface{}
	Expiration int64
}

// NewCache 创建缓存实例
func NewCache() *Cache {
	c := &Cache{items: make(map[string]cacheItem)}
	go c.cleanupLoop()
	return c
}

// Set 设置缓存
func (c *Cache) Set(key string, value interface{}, duration time.Duration) {
	// 实现缓存设置逻辑
}

// Get 获取缓存
func (c *Cache) Get(key string) (interface{}, bool) {
	// 实现缓存获取逻辑
	return nil, false
}

// 其他缓存方法...
```

### 2. 自定义路由

除了自动路由，也可以手动注册自定义路由：

```go
// 在 main.go 中添加
router := route.NewRouter()

// 注册自定义路由
router.GET("/api/v1/users", userController.GetList)
router.POST("/api/v1/users", userController.PostCreateUser)
router.GET("/api/v1/users/:id", userController.GetDetail)
router.PUT("/api/v1/users/:id", userController.PutUpdateUser)
router.DELETE("/api/v1/users/:id", userController.DeleteUser)
```

## 最佳实践

1. **项目结构**：遵循框架的目录结构，将业务逻辑分离到控制器和模型中
2. **中间件使用**：将横切关注点（如日志、认证、CORS等）封装为中间件
3. **错误处理**：统一错误处理格式，使用适当的HTTP状态码
4. **安全考虑**：处理用户输入时进行参数验证和过滤，防止SQL注入和XSS攻击
5. **性能优化**：使用连接池、缓存等技术提高应用性能

## 注意事项

1. 本框架是一个轻量级框架，适合中小型项目开发
2. 生产环境使用前请确保进行充分的测试和安全检查
3. 根据实际项目需求，可以扩展框架的功能和组件
4. 框架的自动路由功能依赖于控制器的命名规范，请遵循相关约定
5. 如需使用其他数据库，请修改配置文件并确保对应的驱动已安装

## 许可证

本框架基于 MIT 许可证开源，详情请查看 LICENSE 文件。