Golang开发者求职：即时通讯应用开发岗位

// 即时通讯后端核心功能示例 package main

import ( “encoding/json” “log” “net/http” “sync” “time”

"github.com/gorilla/websocket"

)

// 消息结构体 type Message struct { ID string json:"id" Sender string json:"sender" Recipient string json:"recipient" Content string json:"content" Timestamp time.Time json:"timestamp" }

// 连接管理器 type ConnectionManager struct { clients map[*websocket.Conn]bool broadcast chan Message register chan *websocket.Conn unregister chan *websocket.Conn mu sync.RWMutex }

// 消息持久化接口 type MessageStore interface { Save(msg Message) error GetHistory(userID string, limit int) ([]Message, error) }

// Redis消息存储实现示例 type RedisStore struct { // Redis客户端实例 }

func (r *RedisStore) Save(msg Message) error { // 实现Redis存储逻辑 data, _ := json.Marshal(msg) log.Printf(“保存消息到Redis: %s”, string(data)) return nil }

func (r *RedisStore) GetHistory(userID string, limit int) ([]Message, error) { // 实现从Redis获取历史消息 return []Message{}, nil }

// WebSocket处理器 func (cm *ConnectionManager) HandleConnections(w http.ResponseWriter, r *http.Request) { upgrader := websocket.Upgrader{ CheckOrigin: func(r *http.Request) bool { return true }, }

conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
	log.Printf("WebSocket升级失败: %v", err)
	return
}
defer conn.Close()

cm.register <- conn

for {
	var msg Message
	err := conn.ReadJSON(&msg)
	if err != nil {
		cm.unregister <- conn
		break
	}

	msg.Timestamp = time.Now()
	msg.ID = generateMessageID()
	cm.broadcast <- msg
}

}

// 消息广播协程 func (cm *ConnectionManager) BroadcastMessages(store MessageStore) { for { msg := <-cm.broadcast

	cm.mu.RLock()
	for client := range cm.clients {
		err := client.WriteJSON(msg)
		if err != nil {
			client.Close()
			delete(cm.clients, client)
		}
	}
	cm.mu.RUnlock()

	// 异步保存消息
	go store.Save(msg)
}

}

// 生成消息ID func generateMessageID() string { return time.Now().Format(“20060102150405”) + “-” + randomString(8) }

// REST API端点示例 func messageHistoryHandler(store MessageStore) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { userID := r.URL.Query().Get(“user_id”) limit := 50 // 默认值

	messages, err := store.GetHistory(userID, limit)
	if err != nil {
		http.Error(w, "获取历史消息失败", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(messages)
}

}

// 性能监控中间件 func metricsMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { start := time.Now() next.ServeHTTP(w, r) duration := time.Since(start)

	log.Printf("请求 %s 耗时: %v", r.URL.Path, duration)
})

}

func main() { store := &RedisStore{} cm := &ConnectionManager{ clients: make(map[*websocket.Conn]bool), broadcast: make(chan Message), register: make(chan *websocket.Conn), unregister: make(chan *websocket.Conn), }

// 启动消息广播协程
go cm.BroadcastMessages(store)

// 连接管理协程
go func() {
	for {
		select {
		case conn := <-cm.register:
			cm.mu.Lock()
			cm.clients[conn] = true
			cm.mu.Unlock()
			log.Println("新客户端连接")

		case conn := <-cm.unregister:
			cm.mu.Lock()
			delete(cm.clients, conn)
			cm.mu.Unlock()
			log.Println("客户端断开连接")
		}
	}
}()

// 设置路由
mux := http.NewServeMux()
mux.HandleFunc("/ws", cm.HandleConnections)
mux.Handle("/messages/history", metricsMiddleware(messageHistoryHandler(store)))

// 启动服务器
log.Println("即时通讯服务器启动在 :8080")
log.Fatal(http.ListenAndServe(":8080", mux))

}

// 辅助函数 func randomString(n int) string { // 实现随机字符串生成 return “abc123def” }

/* 即时通讯应用Go后端开发要点：

1. 并发处理：使用goroutine处理WebSocket连接和消息广播
2. 连接管理：维护活跃连接映射，支持动态注册/注销
3. 消息序列化：JSON格式的消息编码/解码
4. 持久化存储：Redis存储消息历史，支持快速读写
5. REST API：提供消息历史查询接口
6. 性能监控：中间件记录请求耗时
7. 错误处理：连接异常时的清理和日志记录

该实现展示了：

• WebSocket实时通信
• 并发安全的连接管理
• 消息持久化架构
• 可扩展的服务设计
• 性能监控机制

适用于高并发的即时通讯场景，支持水平扩展。 */