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

重构logger

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

全局变量

var (
    once    sync.Once        // 用于实现单例模式的同步控制
    Logger  *zap.Logger      // 全局日志实例
    String  = zap.String     // 导出常用的 zap.Field 构造方法
    Any     = zap.Any
    Err     = zap.Error
    Int     = zap.Int
    Float32 = 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,    // MB
			MaxBackups: defaultMaxBackups, // 保留的旧日志文件数量
			MaxAge:     defaultMaxAge,     // 保留天数
			Compress:   defaultCompress,   // 是否压缩
		})

		// 编码器配置
		encoderConfig := zap.NewProductionEncoderConfig()
		encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
		encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder // 不带颜色

		// 核心配置
		core := zapcore.NewCore(
			// zapcore.NewJSONEncoder(encoderConfig), // json格式
			zapcore.NewConsoleEncoder(encoderConfig), // 使用 Console 编码器
			writer,
			level,
		)

		// 创建Logger
		Logger = 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 := RunSocket
	
	group := 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.Method
        origin := 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