Go 即时通讯系统：日志模块重构，并从main函数开始

重构logger

上次写的logger.go过于繁琐，有很多没用到的功能；重构后只提供了简洁的日志接口，支持日志轮转、多级别日志记录等功能，并采用单例模式确保全局只有一个日志实例

全局变量

var (once    sync.Once        // 用于实现单例模式的同步控制Logger  *zap.Logger      // 全局日志实例String  = zap.String     // 导出常用的 zap.Field 构造方法Any     = zap.AnyErr     = zap.ErrorInt     = zap.IntFloat32 = zap.Float32
)

默认配置常量

const (defaultLogPath    = "./logs"      // 默认日志存储目录defaultLogLevel   = "debug"        // 默认日志级别defaultMaxSize    = 100           // 单个日志文件最大大小(MB)defaultMaxBackups = 30            // 保留的旧日志文件数量defaultMaxAge     = 7             // 日志保留天数defaultCompress   = true          // 是否压缩旧日志
)

初始化日志记录器

// Init 初始化日志记录器(单例模式)
func Init() *zap.Logger {once.Do(func() {// 确保日志目录存在if err := os.MkdirAll(defaultLogPath, 0755); err != nil {panic(err)}// 设置日志级别level := getLogLevel(defaultLogLevel)// 日志文件路径logFile := getDatedLogFilename(defaultLogPath)// 设置日志轮转writer := zapcore.AddSync(&lumberjack.Logger{Filename:   logFile,MaxSize:    defaultMaxSize,    // MBMaxBackups: defaultMaxBackups, // 保留的旧日志文件数量MaxAge:     defaultMaxAge,     // 保留天数Compress:   defaultCompress,   // 是否压缩})// 编码器配置encoderConfig := zap.NewProductionEncoderConfig()encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoderencoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder // 不带颜色// 核心配置core := zapcore.NewCore(// zapcore.NewJSONEncoder(encoderConfig), // json格式zapcore.NewConsoleEncoder(encoderConfig), // 使用 Console 编码器writer,level,)// 创建LoggerLogger = zap.New(core)})return Logger
}

获取日志实例

func GetLogger() *zap.Logger {if Logger == nil {Init() // 自动初始化}return Logger
}

直接可用的日志方法

func Debug(msg string, fields ...zap.Field) {GetLogger().Debug(msg, fields...)
}func Info(msg string, fields ...zap.Field) {GetLogger().Info(msg, fields...)
}func Warn(msg string, fields ...zap.Field) {GetLogger().Warn(msg, fields...)
}func Error(msg string, fields ...zap.Field) {GetLogger().Error(msg, fields...)
}func Fatal(msg string, fields ...zap.Field) {GetLogger().Fatal(msg, fields...)
}func Sync() error {return GetLogger().Sync()
}

代码地址：logger.go

从main函数开始

func main() {defer log.Sync() // 记录日志log.Info("start chat server...")newRouter := router.NewRouter()go chat.MyServer.Start()s := &http.Server{Addr:           ":8080",Handler:        newRouter,ReadTimeout:    10 * time.Second,WriteTimeout:   10 * time.Second,MaxHeaderBytes: 1 << 20,}err := s.ListenAndServe()if err != nil {log.Error("server start error", log.Err(err))}
}

1. 初始化路由
   • 创建 HTTP 请求路由器。
   • 会在这里定义所有的 API 端点（endpoints）和对应的处理函数。
   • 返回一个实现了 http.Handler 接口的路由器对象。
2. 启动后台服务
   • 使用 go 关键字启动一个 goroutine，异步运行 chat.MyServer.Start() 方法。
   • 这通常用于启动需要长期运行的 WebSocket 服务。
3. 配置 HTTP 服务器
4. 启动 HTTP 服务器：开始监听指定端口（8080）的 HTTP 请求。

自定义Gin路由

NewRouter 函数解析

func NewRouter() *gin.Engine {gin.SetMode(gin.ReleaseMode)server := gin.Default()server.Use(Cors())server.Use(Recovery)socket := RunSocketgroup := server.Group(""){// 用户管理功能group.GET("/user", api.GetUserList)group.GET("/user/:uuid", api.GetUserDetails)group.GET("/user/name", api.GetUserOrGroupByName)group.POST("/user/register", api.Register)group.POST("/user/login", api.Login)group.PUT("/user", api.ModifyUserInfo)group.POST("/friend", api.AddFriend)group.GET("/message", api.GetMessage)group.GET("/file/:fileName", api.GetFile)group.POST("/file", api.SaveFile)group.GET("/group/:uuid", api.GetGroup)group.POST("/group/:uuid", api.SaveGroup)group.POST("/group/join/:userUuid/:groupUuid", api.JoinGroup)group.GET("/group/user/:uuid", api.GetGroupUsers)group.GET("/socket.io", socket)}return server
}

1. Gin 模式设置：gin.SetMode(gin.ReleaseMode) 将 Gin 设置为发布模式，减少调试信息输出。
2. 中间件使用：Cors() 中间件处理跨域请求，Recovery 中间件捕获并处理 panic。
3. 路由分组：所有路由都定义在根分组 ("") 下，清晰的 RESTful 风格路由设计。
4. 路由类型：用户管理：GET/POST/PUT 操作；文件管理：文件上传/下载；WebSocket：实时通信端点。

跨域处理中间件 (Cors)

func Cors() gin.HandlerFunc {return func(c *gin.Context) {method := c.Request.Methodorigin := c.Request.Header.Get("Origin")if origin != "" {// 设置跨域响应头c.Header("Access-Control-Allow-Origin", "*")c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, UPDATE")c.Header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization")c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Cache-Control, Content-Language, Content-Type")c.Header("Access-Control-Allow-Credentials", "true")}// 处理 OPTIONS 预检请求if method == "OPTIONS" {c.JSON(http.StatusOK, "ok!")return}// 异常捕获defer func() {if err := recover(); err != nil {log.Error("HttpError", log.Any("HttpError", err))}}()c.Next() // 处理请求}
}

1. 跨域头设置：
   • 允许所有来源 (*)，生产环境应替换为具体域名
   • 允许的 HTTP 方法
   • 允许的请求头
   • 允许客户端访问的响应头
   • 允许携带凭证
2. OPTIONS 请求处理：直接返回 200 状态码，满足浏览器的预检请求。
3. 异常捕获：使用 defer+recover 捕获处理过程中的 panic，记录错误日志。

恢复中间件 (Recovery)

func Recovery(c *gin.Context) {defer func() {if r := recover(); r != nil {log.Error("gin catch error", log.Any("error", r))c.JSON(http.StatusOK, response.FailMsg("系统内部错误"))}}()c.Next()
}

panic 恢复：捕获路由处理函数中可能发生的 panic，记录错误日志

WebSocket 实现 (RunSocket)

var upGrader = websocket.Upgrader{CheckOrigin: func(r *http.Request) bool {return true // 允许所有跨域 WebSocket 连接},
}func RunSocket(c *gin.Context) {user := c.Query("user") // 获取用户标识if user == "" {return // 无用户标识则拒绝连接}log.Info("newUser", log.String("newUser", user))// 升级 HTTP 连接为 WebSocket 连接ws, err := upGrader.Upgrade(c.Writer, c.Request, nil)if err != nil {return}// 创建客户端对象client := &server.Client{Name: user,Conn: ws,Send: make(chan []byte),}// 注册客户端到服务器server.MyServer.Register <- client// 启动读写协程go client.Read()go client.Write()
}

1. WebSocket 升级：
   • 使用 gorilla/websocket 包的 Upgrader 将 HTTP 连接升级为 WebSocket 连接
   • CheckOrigin 返回 true 允许所有跨域连接（生产环境应做限制）
2. 客户端管理：
   • 通过 user 查询参数识别用户，创建客户端对象，包含 WebSocket 连接和消息通道
   • 通过注册通道将客户端注册到中央服务器。
3. 并发处理：为每个客户端启动独立的读 (client.Read()) 和写 (client.Write()) 协程，实现全双工通信。

代码地址：IM-Go