# go-blog

**Repository Path**: chenbool/go-blog

## Basic Information

- **Project Name**: go-blog
- **Description**: go语言 开发的 博客
- **Primary Language**: Go
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-10-09
- **Last Updated**: 2025-10-16

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 📝 Go-Blog 博客服务器

## 1. 项目概述

Go-Blog 是一个基于 Go 语言开发的高性能博客服务器后端系统，提供完整的博客内容管理功能，包括文章发布、用户管理、评论互动、分类管理、收藏点赞等核心功能。

### 1.1 核心价值
提供稳定、高效的博客后端服务，简化博客平台的开发和维护工作，支持个人和小型团队快速搭建专业的内容管理系统。

### 1.2 关键特性
- ⚡ 高性能：基于Go语言开发，具备出色的并发处理能力
- 🧩 模块化：清晰的代码结构，便于功能扩展和维护
- 🛡️ 安全性：完善的用户认证和权限控制机制
- 📱 RESTful API：标准的RESTful接口设计，便于前后端分离开发
- 📊 日志系统：完整的操作日志和访问日志记录
- 🌐 多数据库支持：支持MySQL主从读写分离架构
- 🗄️ 缓存：集成Redis用于会话存储、令牌管理和黑名单
- 🔐 认证：基于JWT的用户认证和授权机制
- 🌍 IP归属地查询：集成ip2region库，支持IP地理位置查询

### 1.3 项目定位
一个功能完整、易于部署和二次开发的博客后端解决方案，适用于个人博客、小型团队内容管理系统等场景。

## 2. 功能特性

| 功能模块 | 描述 | 状态 |
|---------|------|------|
| 文章管理 | 发布、编辑、删除文章，支持富文本内容 | ✅ 已实现 |
| 用户系统 | 用户注册、登录、个人信息管理，支持多种登录方式 | ✅ 已实现 |
| 评论系统 | 文章评论、回复功能 | ✅ 已实现 |
| 分类管理 | 文章分类创建与管理 | ✅ 已实现 |
| 收藏功能 | 用户收藏文章功能，支持收藏夹管理 | ✅ 已实现 |
| 点赞功能 | 文章点赞功能 | ✅ 已实现 |
| 浏览历史 | 记录用户文章浏览历史 | ✅ 已实现 |
| 日志系统 | 操作日志、登录日志记录与管理 | ✅ 已实现 |
| 全局通知 | 系统通知管理 | ✅ 已实现 |
| 图片管理 | 图片上传与管理，支持Web访问 | ✅ 已实现 |
| IP归属地查询 | 支持IP地址归属地查询功能 | ✅ 已实现 |
| 数据库读写分离 | 支持数据库读写分离架构 | ✅ 已实现 |

## 3. 技术栈

| 技术组件 | 版本 | 用途描述 | 官方文档链接 |
|---------|------|---------|------------|
| Go | 1.25.0 | 主要开发语言 | [Go官方文档](https://golang.org/doc/) |
| Gin | 1.11.0 | HTTP Web框架，处理路由和请求 | [Gin文档](https://gin-gonic.com/docs/) |
| GORM | 1.31.0 | ORM框架，简化数据库操作 | [GORM官方文档](https://gorm.io/docs/) |
| MySQL | 5.7+ | 关系型数据库 | [MySQL文档](https://dev.mysql.com/doc/) |
| Redis | 6.0+ | 高性能缓存数据库，用于会话存储、令牌管理和黑名单 | [Redis文档](https://redis.io/documentation) |
| JWT | - | JSON Web Token，用于用户认证和授权 | [JWT官方文档](https://jwt.io/introduction) |
| yaml.v2 | 2.4.0 | 配置文件解析 | [yaml.v2文档](https://github.com/go-yaml/yaml) |
| logrus | 1.9.3 | 结构化日志系统 | [logrus文档](https://github.com/sirupsen/logrus) |
| ip2region | 最新 | IP地址归属地查询库 | [ip2region文档](https://github.com/lionsoul2014/ip2region) |

## 4. 项目依赖详解

| 依赖名称 | 版本 | 用途 | 文档链接 |
|---------|------|------|---------|
| **github.com/sirupsen/logrus** | v1.9.3 | 结构化日志系统，提供丰富的日志记录功能 | [logrus文档](https://github.com/sirupsen/logrus) |
| **gopkg.in/yaml.v2** | v2.4.0 | YAML配置文件解析库，用于读取系统配置 | [yaml.v2文档](https://github.com/go-yaml/yaml) |
| **gorm.io/driver/mysql** | v1.6.0 | GORM的MySQL驱动，用于数据库连接 | [GORM MySQL驱动](https://gorm.io/docs/connecting_to_the_database.html#MySQL) |
| **gorm.io/gorm** | v1.31.0 | 强大的ORM框架，简化数据库操作 | [GORM官方文档](https://gorm.io/docs/) |
| **gorm.io/plugin/dbresolver** | v1.6.2 | GORM的读写分离插件，支持数据库读写分离 | [GORM读写分离](https://gorm.io/docs/dbresolver.html) |
| **github.com/lionsoul2014/ip2region/binding/golang** | 最新 | IP地址归属地查询库，用于获取IP地理位置信息 | [ip2region文档](https://github.com/lionsoul2014/ip2region) |
| **github.com/gin-gonic/gin** | v1.11.0 | 高性能HTTP Web框架，处理路由和请求 | [Gin文档](https://gin-gonic.com/docs/) |
| **github.com/pkg/errors** | 最新 | 错误处理库，提供更好的错误包装和处理功能 | [errors文档](https://github.com/pkg/errors) |
| **github.com/go-redis/redis** | v8.11.5 | Redis客户端，用于连接Redis服务，管理会话和令牌 | [Redis Go客户端文档](https://github.com/go-redis/redis) |
| **github.com/dgrijalva/jwt-go** | v3.2.0+ | JWT库，用于生成和验证JSON Web Token，实现用户认证 | [JWT Go库文档](https://github.com/dgrijalva/jwt-go) |

### 4.1 核心依赖配置示例

#### logrus配置示例
```go
import "github.com/sirupsen/logrus"

func initLogger() {
    // 设置日志格式为JSON
    logrus.SetFormatter(&logrus.JSONFormatter{})
    
    // 设置日志级别
    logrus.SetLevel(logrus.InfoLevel)
    
    // 设置日志输出到文件
    file, _ := os.OpenFile("logs/app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    logrus.SetOutput(file)
}
```

#### GORM配置示例
```go
import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

func initDB() *gorm.DB {
    dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    return db
}
```

#### Gin配置示例
```go
import "github.com/gin-gonic/gin"

func initRouter() *gin.Engine {
    // 设置运行模式
    gin.SetMode(gin.ReleaseMode)
    
    // 创建路由实例
    r := gin.Default()
    
    // 添加中间件
    r.Use(LoggerMiddleware())
    
    return r
}
```

#### Redis配置示例
```go
import "github.com/go-redis/redis"

func initRedis() *redis.Client {
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379", // Redis服务器地址
        Password: "",               // Redis密码
        DB:       0,                // 使用默认DB
    })
    
    // 测试连接
    _, err := client.Ping().Result()
    if err != nil {
        panic("Failed to connect to Redis: " + err.Error())
    }
    
    return client
}
```

#### JWT配置示例
```go
import "github.com/dgrijalva/jwt-go"

// 生成JWT令牌
func GenerateToken(userID int64, secret string) (string, error) {
    claims := jwt.MapClaims{
        "user_id": userID,
        "exp":     time.Now().Add(time.Hour * 24).Unix(), // 24小时过期
    }
    
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString([]byte(secret))
}

// 解析JWT令牌
func ParseToken(tokenString string, secret string) (jwt.MapClaims, error) {
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        return []byte(secret), nil
    })
    
    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        return claims, nil
    }
    
    return nil, err
}
```

### 4.2 依赖关系图
```mermaid
graph TD
    A[main.go] --> B[core/init_conf.go]
    A --> C[core/init_db.go]
    A --> D[core/init_ip_db.go]
    A --> E[core/init_logrus.go]
    A --> F[core/init_redis.go]
    A --> G[router/enter.go]
    B --> H[conf/enter.go]
    C --> I[gorm.io/gorm]
    C --> J[gorm.io/driver/mysql]
    C --> K[gorm.io/plugin/dbresolver]
    D --> L[github.com/lionsoul2014/ip2region]
    E --> M[github.com/sirupsen/logrus]
    F --> N[github.com/go-redis/redis]
    G --> O[github.com/gin-gonic/gin]
    G --> P[api/enter.go]
    P --> Q[api/site_api/enter.go]
    Q --> R[service/log_service/action_log.go]
    Q --> S[service/log_service/login_log.go]
    Q --> T[middleware/auth_middleware.go]
    T --> U[github.com/dgrijalva/jwt-go]
    T --> V[service/redis_service/redis_jwt/enter.go]
    V --> N[github.com/go-redis/redis]
    H --> W[gopkg.in/yaml.v2]
    R --> X[github.com/pkg/errors]
    S --> X[github.com/pkg/errors]
```

## 5. 项目目录结构

```
go-blog/
├── blog_server/         # 博客服务器端代码
│   ├── api/             # API接口定义层
│   │   ├── enter.go     # API包入口文件，聚合所有API模块
│   │   ├── log_api/     # 日志相关API实现
│   │   └── site_api/    # 站点相关API实现
│   ├── common/          # 公共模块
│   │   ├── list_query.go # 列表查询通用逻辑
│   │   └── res/         # 响应结果处理
│   ├── conf/            # 配置结构定义层
│   │   ├── conf_ai.go   # AI功能配置结构体
│   │   ├── conf_db.go   # 数据库配置结构体
│   │   ├── conf_email.go # 邮件服务配置结构体
│   │   ├── conf_jwt.go  # JWT配置结构体
│   │   ├── conf_log.go  # 日志配置结构体
│   │   ├── conf_qiniu.go # 七牛云存储配置结构体
│   │   ├── conf_qq.go   # QQ第三方登录配置结构体
│   │   ├── conf_redis.go # Redis配置结构体
│   │   ├── conf_site.go # 站点配置结构体
│   │   ├── conf_system.go # 系统配置结构体
│   │   ├── enter.go     # 配置包入口文件
│   │   └── site/        # 站点配置子模块
│   ├── core/            # 核心初始化功能层
│   │   ├── init_conf.go # 配置初始化
│   │   ├── init_db.go   # 数据库初始化
│   │   ├── init_ip_db.go # IP数据库初始化
│   │   ├── init_logrus.go # 日志系统初始化
│   │   └── init_redis.go # Redis初始化
│   ├── flags/           # 命令行参数处理层
│   │   ├── enter.go     # flags包入口文件
│   │   └── flags_db.go  # 数据库相关命令行参数
│   ├── global/          # 全局变量定义层
│   │   └── enter.go     # 全局配置和共享变量
│   ├── logs/            # 日志文件存储目录
│   ├── middleware/      # 中间件层
│   │   ├── auth_middleware.go # 认证中间件
│   │   └── log_middleware.go  # 日志中间件
│   ├── models/          # 数据模型层
│   │   ├── article_digg_model.go # 文章点赞模型
│   │   ├── article_model.go      # 文章模型
│   │   ├── banner_model.go       # 横幅模型
│   │   ├── category_model.go     # 分类模型
│   │   ├── collect_model.go      # 收藏夹模型
│   │   ├── comment_model.go      # 评论模型
│   │   ├── enter.go              # models包入口文件
│   │   ├── enum/                 # 枚举定义
│   │   ├── global_notification_model.go # 全局通知模型
│   │   ├── image_model.go        # 图片模型
│   │   ├── log_model.go          # 日志模型
│   │   ├── user_article_collect_model.go # 用户文章收藏模型
│   │   ├── user_article_look_history_model.go # 用户浏览历史模型
│   │   ├── user_login_model.go   # 用户登录记录模型
│   │   ├── user_model.go         # 用户模型
│   │   └── user_top_article_model.go # 用户置顶文章模型
│   ├── router/          # 路由管理层
│   │   ├── enter.go     # 路由包入口文件
│   │   ├── log_router.go # 日志相关路由
│   │   └── site_router.go # 站点相关路由
│   ├── service/         # 业务服务层
│   │   ├── log_service/ # 日志服务
│   │   └── redis_service/ # Redis服务
│   ├── test/            # 测试相关文件
│   ├── uploads/         # 上传文件存储目录
│   ├── utils/           # 工具函数层
│   │   ├── ip/          # IP相关工具
│   │   ├── jwts/        # JWT工具
│   │   └── validate/    # 数据验证工具
│   ├── init/            # 初始化资源目录
│   │   └── ip2region.xdb # IP地址库文件
│   ├── main.go          # 程序入口文件
│   ├── setting.yaml     # 配置文件
│   └── readme.md        # 详细说明文档
├── docs/                # 项目文档
└── README.md            # 项目说明文档
```

### 5.1 目录说明

| 目录路径 | 主要功能 | 重要文件示例 | 备注说明 |
|---------|---------|------------|----------|
| blog_server/api/ | API接口定义层 | api/enter.go, api/site_api/enter.go | 定义系统对外提供的所有API接口 |
| blog_server/common/ | 公共模块 | common/list_query.go, common/res/enter.go | 存放通用的工具类和响应处理逻辑 |
| blog_server/conf/ | 配置结构定义层 | conf/enter.go, conf_db.go | 定义系统配置的结构体 |
| blog_server/core/ | 核心初始化功能层 | core/init_conf.go, core/init_db.go | 系统启动时的核心初始化逻辑 |
| blog_server/flags/ | 命令行参数处理层 | flags/enter.go, flags_db.go | 处理命令行参数的解析和验证 |
| blog_server/global/ | 全局变量定义层 | global/enter.go | 定义全局可访问的配置和共享变量 |
| blog_server/logs/ | 日志文件存储目录 | logs/2025-10-14/2025-10-14_19/blog_server.log | 存放系统运行时生成的日志文件 |
| blog_server/middleware/ | 中间件层 | middleware/log_middleware.go | HTTP请求处理的中间件组件 |
| blog_server/models/ | 数据模型层 | models/user_model.go, models/article_model.go | 定义系统所有的数据模型和枚举类型 |
| blog_server/router/ | 路由管理层 | router/enter.go, router/site_router.go | 定义系统的路由规则和HTTP服务配置 |
| blog_server/service/ | 业务服务层 | service/log_service/action_log.go | 实现系统的业务逻辑 |
| blog_server/test/ | 测试相关文件 | test/err.go, test/ip2region.go | 存放系统测试相关文件 |
| blog_server/uploads/ | 上传文件存储目录 | uploads/a.txt | 存放用户上传的文件 |
| blog_server/utils/ | 工具函数层 | utils/ip/enter.go | 提供通用的工具函数 |
| blog_server/init/ | 初始化资源目录 | init/ip2region.xdb | 存放系统初始化所需的资源文件 |
| docs/ | 项目文档目录 | - | 存放项目相关的各类文档 |

## 6. 系统架构图

```mermaid
flowchart TD
    subgraph 客户端层
        A[浏览器/APP/第三方服务] --> B[HTTP请求]
    end

    subgraph 网关层
        B --> WAF[Web应用防火墙(规划中)]
        WAF --> C[Router路由层]
    end

    subgraph 应用层
        C --> D[中间件层]
        C -- 路由注册与分发 --> C1[HTTP方法映射]
        C -- API分组管理 --> C2[路由前缀控制]
        D -- 日志中间件 --> D1[请求响应记录]
        D -- 认证授权中间件 --> D2[权限验证]
        D -- 限流中间件(规划中) --> D3[访问频率控制]
        D --> E[API接口层]
    end

    subgraph 服务层
        E --> F[Service业务服务层]
        E -- 请求参数解析 --> E1[数据绑定]
        E -- 响应格式化 --> E2[JSON序列化]
        E -- 错误处理 --> E3[统一错误码]
        F -- 业务逻辑处理 --> F1[数据校验]
        F -- 事务管理 --> F2[ACID保证]
    end

    subgraph 数据层
        F --> G[Models数据模型层]
        G --> H[工具函数层]
        G -- 数据库表映射 --> G1[ORM实体定义]
        G -- ORM操作 --> G2[增删改查]
        G -- 数据验证 --> G3[字段校验]
        H -- IP地址解析 --> H1[地理位置查询]
        H -- 加密解密(规划中) --> H2[安全处理]
        H -- 文件处理(规划中) --> H3[存储管理]
        G --> I[配置管理]
        G --> J[日志系统]
        G --> K[数据库]
        G --> L[外部资源]
        I -- YAML配置解析 --> I1[配置文件读取]
        I -- 命令行参数处理 --> I2[参数覆盖]
        J -- 结构化日志 --> J1[JSON格式]
        J -- 多级别日志 --> J2[Debug/Info/Warn/Error/Fatal]
        K -- MySQL主从 --> K1[主库写操作]
        K -- 读写分离 --> K2[从库读操作]
        L -- IP地址库 --> L1[ip2region]
        L -- Redis缓存 --> L2[会话与令牌管理]
        L -- 文件存储(规划中) --> L3[云存储集成]
    end
```

### 6.1 系统架构层级说明

| 层级名称 | 主要职责 | 核心组件 | 数据流向 |
|--------|---------|---------|--------|
| **客户端层** | 用户交互接口 | 浏览器、APP、第三方服务 | 发出HTTP请求 |
| **网关层** | 安全过滤与请求路由 | Web应用防火墙(规划中) | 过滤不安全请求，路由到应用层 |
| **应用层** | 请求处理与API接口 | Router、中间件、API接口 | 接收请求，处理业务逻辑，返回响应 |
| **服务层** | 业务逻辑与流程控制 | Service服务 | 实现核心业务逻辑，管理事务 |
| **数据层** | 数据持久化与资源管理 | Models模型、数据库、工具函数 | 持久化数据，提供各类基础资源支持 |

## 7. 系统架构思维导图

```mermaid
mindmap
    root((Go-Blog博客服务器))
        核心架构
            分层设计
                客户端层
                    浏览器
                    移动端APP
                    第三方服务
                网关层
                    Web应用防火墙(规划中)
                    路由分发
                    负载均衡(规划中)
                应用层
                    路由管理层
                        HTTP方法映射
                        API分组管理
                    中间件层
                        日志中间件
                        认证授权中间件
                        限流中间件(规划中)
                    API接口层
                        站点API
                        用户API
                        文章API
                        评论API
                        日志API
                服务层
                    业务服务层
                        用户服务
                        文章服务
                        评论服务
                        日志服务
                        Redis服务
                    数据校验
                    事务管理
                数据层
                    数据模型层
                        用户模型
                        文章模型
                        评论模型
                        日志模型
                        枚举定义
                    工具函数层
                        IP地址解析
                        加密解密(规划中)
                        文件处理(规划中)
                        JWT工具
                    配置管理
                        YAML配置解析
                        命令行参数处理
                    日志系统
                        结构化日志
                        多级别日志
                    数据库
                        MySQL主从
                        读写分离
                    外部资源
                        Redis缓存
                        IP地址库
                        文件存储(规划中)
            模块化结构
                API接口模块
                数据模型模块
                业务服务模块
                中间件模块
                工具函数模块
                配置管理模块
                核心初始化模块
            设计模式
                工厂模式(服务实例)
                单例模式(全局配置)
                中间件模式(请求处理)
                ORM模式(数据访问)
        核心功能
            用户管理系统
                用户注册/登录
                    多种登录方式
                个人信息管理
                    头像上传
                    资料编辑
                权限控制
                    JWT认证
                    Redis令牌管理
            内容管理系统
                文章发布/编辑
                    富文本编辑
                    封面图片
                    分类管理
                评论互动
                    评论回复
                    评论审核(规划中)
            互动功能
                点赞
                    文章点赞
                    评论点赞(规划中)
                收藏
                    收藏夹管理
                    收藏分类
                浏览历史
                    浏览记录
                    阅读时长统计(规划中)
            系统管理
                日志记录
                    操作日志
                    登录日志
                    运行日志
                通知管理
                    全局通知
                系统配置
                    站点信息
                    邮件配置
                    云存储配置
        技术栈
            开发语言: Go
            Web框架: Gin
            ORM框架: GORM
            数据库: MySQL
            缓存: Redis
            日志系统: logrus
            认证: JWT
            工具库: yaml.v2, ip2region
```

## 8. 启动流程

```mermaid
sequenceDiagram
    participant 用户
    participant 命令行
    participant 主程序
    participant 配置加载
    participant 日志系统
    participant IP数据库
    participant 数据库
    participant Redis
    participant Web服务

    用户->>命令行: 执行程序
    命令行->>主程序: 传递参数
    主程序->>主程序: 解析命令行参数
    主程序->>配置加载: 读取配置文件
    配置加载-->>主程序: 返回配置对象
    主程序->>日志系统: 初始化日志系统
    日志系统-->>主程序: 日志系统就绪
    主程序->>IP数据库: 加载IP地址库
    IP数据库-->>主程序: IP数据库加载完成
    主程序->>数据库: 初始化数据库连接
    数据库-->>主程序: 数据库连接成功
    主程序->>Redis: 初始化Redis连接
    Redis-->>主程序: Redis连接成功
    主程序->>主程序: 执行命令行参数指定的操作
    主程序->>Web服务: 初始化路由
    Web服务-->>主程序: 路由初始化完成
    主程序->>Web服务: 启动HTTP服务
    Web服务-->>用户: 服务就绪
```

## 9. 配置说明

### 9.1 配置文件 (setting.yaml)

项目使用 YAML 格式的配置文件，默认路径为 `setting.yaml`。

```yaml
# 系统配置
system:
  ip:                   # 服务监听IP，空字符串表示监听所有接口
  port: 8080            # 服务监听端口
  env: dev              # 环境标识：dev(开发)/test(测试)/prod(生产)
  gin_mode: release     # Gin框架运行模式：debug/release/test

# 日志配置
log:
  app: blog_server      # 应用名称，用于日志标识
  dir: logs             # 日志文件存储目录

# JWT配置
jwt:
  expire: 3             # Token有效期(小时)
  secret: xxx           # JWT签名密钥
  issuer: fengfeng      # JWT签发者

# Redis配置
redis:
  addr: 127.0.0.1:6379  # Redis服务器地址和端口
  password: "1234"      # Redis密码
  db: 2                 # Redis数据库索引

# 数据库配置(读库)
db:
  user: root            # 数据库用户名
  password: root        # 数据库密码
  host: 127.0.0.1       # 数据库主机地址
  port: 3306            # 数据库端口
  db: blog_db           # 数据库名
  debug: false          # 是否启用调试模式
  source: mysql         # 数据库类型

# 数据库配置(写库)
db1:
  user: root            # 数据库用户名
  password: root        # 数据库密码
  host: 127.0.0.1       # 数据库主机地址
  port: 3306            # 数据库端口
  db: blog_db           # 数据库名
  debug: false          # 是否启用调试模式
  source: mysql         # 数据库类型
```

### 9.2 配置项说明

| 配置项 | 类型 | 默认值 | 说明 |
|--------|------|--------|------|
| system.ip | string | "" | 服务器监听IP地址，空字符串表示监听所有接口 |
| system.port | int | 8080 | 服务器监听端口 |
| system.env | string | dev | 运行环境标识（dev/test/prod） |
| system.gin_mode | string | release | Gin框架运行模式（debug/release/test） |
| log.app | string | blog_server | 应用名称，用于日志标识 |
| log.dir | string | logs | 日志文件存储目录 |
| jwt.expire | int | 3 | JWT令牌有效期，单位小时 |
| jwt.secret | string | xxx | JWT签名密钥，生产环境请修改为强密钥 |
| jwt.issuer | string | fengfeng | JWT签发者标识 |
| redis.addr | string | 127.0.0.1:6379 | Redis服务器地址和端口 |
| redis.password | string | "1234" | Redis密码 |
| redis.db | int | 2 | Redis数据库索引 |
| db.* | object | - | 数据库读库配置 |
| db1.* | object | - | 数据库写库配置 |

## 10. 数据库设计

### 10.1 数据库架构
- **主从架构**: 支持数据库读写分离，提高系统性能和可用性
- **连接池**: 实现数据库连接池管理，优化数据库连接资源
- **ORM映射**: 使用GORM框架实现对象关系映射，简化数据库操作
- **事务支持**: 完整的数据库事务支持，确保数据一致性
- **索引优化**: 合理的索引设计，提高查询性能

### 10.2 数据库实体关系图
```mermaid
erDiagram
    User ||--o{ Article : "发布"
    User ||--o{ Comment : "发表"
    User ||--o{ Collect : "创建"
    User ||--o{ UserLogin : "登录记录"
    User ||--o{ UserArticleCollect : "收藏"
    User ||--o{ UserTopArticle : "置顶"
    User ||--o{ UserArticleLookHistory : "浏览"
    
    Article ||--o{ Comment : "包含"
    Article ||--o{ ArticleDigg : "被点赞"
    Article ||--o{ UserArticleCollect : "被收藏"
    Article ||--o{ UserTopArticle : "被置顶"
    Article ||--o{ UserArticleLookHistory : "被浏览"
    
    Category ||--o{ Article : "分类"
    
    Collect ||--o{ UserArticleCollect : "包含"
    
    User }|--|| UserArticleCollect : "关联"
    Article }|--|| UserArticleCollect : "关联"
    
    Log {
        BIGINT id
        VARCHAR(255) title
        TEXT content
        VARCHAR(50) log_type
        VARCHAR(50) level
        BIGINT user_id
        VARCHAR(50) ip
        BOOLEAN login_status
        VARCHAR(100) service_name
        DATETIME created_at
    }
    
    User {
        BIGINT id
        VARCHAR(50) username
        VARCHAR(255) password
        VARCHAR(100) email
        VARCHAR(255) avatar
        DATETIME created_at
        DATETIME updated_at
    }
    
    Article {
        BIGINT id
        VARCHAR(255) title
        LONGTEXT content
        VARCHAR(255) abstract
        VARCHAR(255) cover
        BIGINT user_id
        BIGINT category_id
        INT view_count
        INT digg_count
        INT comment_count
        DATETIME created_at
        DATETIME updated_at
    }
```

### 10.3 主要实体关系

| 实体 | 描述 | 关联实体 | 关系类型 | 表名 |
|-----|------|----------|---------|------|
| User | 用户 | Article, Comment, Collect, UserLogin | 一对多 | users |
| Article | 文章 | Category, Comment, ArticleDigg, UserArticleCollect | 一对多 | articles |
| Category | 分类 | Article | 一对多 | categories |
| Comment | 评论 | User, Article | 多对一 | comments |
| Collect | 收藏夹 | User, UserArticleCollect | 一对多 | collects |
| ArticleDigg | 文章点赞 | User, Article | 多对一 | article_diggs |
| UserArticleCollect | 用户收藏文章 | User, Article, Collect | 多对多 | user_article_collects |
| UserLogin | 用户登录记录 | User | 多对一 | user_logins |
| Log | 系统日志 | - | - | logs |
| Image | 图片 | - | - | images |
| Banner | 横幅 | - | - | banners |
| GlobalNotification | 全局通知 | - | - | global_notifications |
| UserTopArticle | 用户置顶文章 | User, Article | 多对一 | user_top_articles |
| UserArticleLookHistory | 用户浏览历史 | User, Article | 多对一 | user_article_look_histories |

## 11. API接口设计

### 11.1 API接口规范
- **RESTful风格**: 遵循RESTful API设计规范
- **统一响应格式**: 所有API返回统一的JSON响应结构
- **错误处理**: 使用统一的错误码和错误信息
- **参数验证**: 严格的输入参数验证
- **认证授权**: 基于JWT的认证机制

### 11.2 主要API模块
- 站点管理API
- 用户管理API
- 文章管理API
- 评论管理API
- 分类管理API
- 日志管理API

## 12. 开发指南

### 12.1 环境搭建
1. 安装Go 1.25.0或更高版本
2. 安装MySQL 5.7+和Redis 6.0+
3. 克隆代码仓库
4. 安装依赖：`go mod tidy`
5. 配置setting.yaml文件
6. 启动服务：`go run main.go`

### 12.2 开发规范
- 代码风格遵循Go官方规范
- 使用Go modules进行依赖管理
- 结构体和函数必须添加注释
- 错误处理使用github.com/pkg/errors包
- 日志记录使用logrus包

## 13. 核心功能模块详细说明

### 13.1 用户管理模块
- 用户注册、登录、登出功能
- 个人信息管理
- 密码重置和修改
- JWT令牌生成和验证
- Redis令牌黑名单管理

### 13.2 文章管理模块
- 文章的创建、编辑、删除
- 文章分类管理
- 文章列表查询和详情查看
- 文章点赞和浏览量统计
- 文章收藏功能

### 13.3 评论管理模块
- 文章评论功能
- 评论回复功能
- 评论列表查询
- 评论点赞(规划中)

### 13.4 日志系统模块
- 操作日志记录
- 登录日志记录
- 运行日志记录
- 日志查询和管理

## 14. 未来功能规划

| 功能模块 | 描述 | 状态 |
|---------|------|------|
| Web应用防火墙 | 增强系统安全性，过滤恶意请求 | 📅 规划中 |
| 限流中间件 | 防止API滥用，控制访问频率 | 📅 规划中 |
| 评论点赞 | 支持对评论进行点赞操作 | 📅 规划中 |
| 评论审核 | 评论内容审核和管理 | 📅 规划中 |
| 多级分类 | 支持文章多级分类管理 | 📅 规划中 |
| 文件加密 | 文件上传和存储的加密处理 | 📅 规划中 |
| 云存储集成 | 支持阿里云OSS、七牛云等云存储服务 | 📅 规划中 |
| 阅读时长统计 | 统计用户文章阅读时长 | 📅 规划中 |
| RBAC权限模型 | 基于角色的访问控制 | 📅 规划中 |

## 15. 许可证

本项目采用 MIT 许可证 - 查看 LICENSE 文件了解详情

## 16. 贡献指南

1. Fork 本仓库到个人账号
2. 创建特性分支: `git checkout -b feature/your-feature-name`
3. 提交更改: `git commit -m "feat: 添加xxx功能"`
4. 推送到分支: `git push origin feature/your-feature-name`
5. 提交 Pull Request 到主仓库

## 17. 常见问题

### 17.1 如何修改数据库连接配置？
在setting.yaml文件中修改db和db1部分的配置，包括用户名、密码、主机地址等。

### 17.2 如何更改服务监听端口？
在setting.yaml文件中修改system.port配置项。

### 17.3 如何启用数据库调试模式？
将db.debug配置项设置为true，系统将输出SQL语句。

### 17.4 JWT令牌有效期如何调整？
在setting.yaml文件中修改jwt.expire配置项，单位为小时。

## 18. 联系方式

如有问题或建议，请通过以下方式联系我们：
- Email: admin@example.com
- GitHub Issues: [项目Issues页面](https://github.com/example/go-blog/issues)
- QQ群: 123456789 (Go技术交流群)
- 微信公众号: GoBlogServer

## 19. 附录

### 19.1 命令行参数说明
```
-h, --help           显示帮助信息
--host              服务监听地址
--port              服务监听端口
--config            配置文件路径
```

### 19.2 系统环境变量
```
BLOG_SERVER_CONFIG_PATH  配置文件路径
BLOG_SERVER_HOST         服务监听地址
BLOG_SERVER_PORT         服务监听端口
```