/**
* SSE客户端实现（微信小程序专用）
* 功能：
* 1. 支持Server-Sent Events协议
* 2. 自动重连机制
* 3. 心跳检测
* 4. 多设备登录处理
* 5. 二进制数据解码
*/
class SSEClient {
constructor() {
// 基础连接配置
this.baseUrl = 'http://xxxxx:xxxx'; // 服务器地址
this.task = null; // 当前请求任务对象
// 重连相关
this.reconnectTimer = null; // 重连定时器
this.reconnectCount = 0; // 当前重连次数
this.MAX_RECONNECT = 5; // 最大重连次数
// 心跳检测
this.heartbeatTimer = null; // 心跳定时器
this.lastMessageTime = 0; // 最后收到消息时间
this.HEARTBEAT_INTERVAL = 10000; // 心跳间隔(ms)
// 状态控制
this.isForceClosed = false; // 是否被强制关闭（如多设备登录）
this._isConnectionConfirmed = false; // 是否确认连接成功（收到数据）
this._connectionStartTime = 0; // 连接开始时间
this._isClosing = false; // 是否正在关闭中
this._requestLock = false; // 请求锁防止重复连接
this._pendingToken = null; // 等待处理的token
}
/**
* 建立SSE连接（主入口）
* @param {string} token - 身份验证令牌
*/
async connect(token) {
// 验证token有效性
if (!this._validateToken(token)) {
console.warn('[SSE] 无效的token，拒绝连接');
return;
}
// 加锁防止重复请求
if (this._requestLock) {
console.log('[SSE] 已有连接正在进行');
return;
}
this._requestLock = true;
try {
// 第一步：安全关闭旧连接
await this._safeClose();
// 第二步：建立新连接
await this._establishConnection(token);
} catch (error) {
console.error('[SSE] 连接流程异常:', error);
this._scheduleReconnect(token);
} finally {
this._requestLock = false;
}
}
/**
* 安全关闭当前连接
* @return {Promise} 关闭完成的Promise
*/
_safeClose() {
return new Promise((resolve) => {
if (!this.task) {
return resolve();
}
console.log('[SSE] 正在关闭旧连接...');
this._isClosing = true;
const cleanup = () => {
this._clearTimers();
this.task = null;
this._isClosing = false;
this._isConnectionConfirmed = false;
resolve();
};
try {
// 尝试中止请求
if (typeof this.task.abort === 'function') {
this.task.abort();
}
// 给予50ms时间确保abort生效
setTimeout(cleanup, 50);
} catch (e) {
console.warn('[SSE] 关闭异常:', e);
cleanup();
}
});
}
/**
* 实际建立SSE连接
* @param {string} token - 身份验证令牌
*/
async _establishConnection(token) {
// 重置强制关闭状态（如果需要）
if (this.isForceClosed) {
console.warn('[SSE] 重置强制关闭状态');
this.isForceClosed = false;
}
console.log('[SSE] 正在建立新连接...', token);
this._connectionStartTime = Date.now();
return new Promise((resolve, reject) => {
// 创建微信请求任务
this.task = wx.request({
url: `${this.baseUrl}/sseController/connect/${token}`,
method: 'GET',
responseType: 'text',
enableChunked: true, // 启用分块传输
success: (res) => {
if (this._isClosing) {
return reject(new Error('Connection cancelled'));
}
if (res.statusCode !== 200) {
console.error('[SSE] 连接异常，状态码:', res.statusCode);
return reject(new Error(`Invalid status: ${res.statusCode}`));
}
console.log('[SSE] 连接初步建立');
this.reconnectCount = 0; // 重置重连计数器
resolve();
},
fail: (err) => {
if (!this._isClosing) {
console.error('[SSE] 连接失败', err.errMsg);
reject(err);
}
}
});
// 监听响应头
this.task.onHeadersReceived(res => {
this._validateContentType(res.header);
});
// 监听数据流
this.task.onChunkReceived(res => {
this._processIncomingData(res.data);
});
});
}
/**
* 验证token有效性
* @param {string} token - 待验证的token
* @return {boolean} 是否有效
*/
_validateToken(token) {
return token && typeof token === 'string' && token.length > 10;
}
/**
* 验证响应内容类型
* @param {object} headers - 响应头
*/
_validateContentType(headers) {
const contentType = headers['Content-Type'] || headers['content-type'];
if (!contentType || !contentType.includes('text/event-stream')) {
console.error('[SSE] 非SSE协议:', contentType);
this.close();
}
}
/**
* 处理接收到的数据
* @param {ArrayBuffer|string} rawData - 原始数据
*/
async _processIncomingData(rawData) {
// 首次收到数据时确认连接成功
if (!this._isConnectionConfirmed) {
this._isConnectionConfirmed = true;
console.log('[SSE] 连接确认成功',
`耗时:${Date.now() - this._connectionStartTime}ms`);
}
// 更新最后消息时间（用于心跳检测）
this.lastMessageTime = Date.now();
try {
const messageStr = await this._decodeData(rawData);
const validMessages = this._extractValidMessages(messageStr);
for (const msg of validMessages) {
try {
const parsed = JSON.parse(msg);
this._handleMessage(parsed);
} catch (e) {
console.error('[SSE] 单条消息解析失败:', e.message);
}
}
} catch (e) {
console.error('[SSE] 数据处理失败:', e.message);
}
}
/**
* 解码原始数据
* @param {ArrayBuffer|string} rawData - 原始数据
* @return {Promise<string>} 解码后的字符串
*/
async _decodeData(rawData) {
if (rawData instanceof ArrayBuffer) {
return this._decodeArrayBuffer(rawData);
}
return this._forceUTF8Decoding(String(rawData));
}
/**
* 解码ArrayBuffer数据
* @param {ArrayBuffer} buffer - 二进制数据
* @return {Promise<string>} 解码后的字符串
*/
_decodeArrayBuffer(buffer) {
return new Promise((resolve) => {
try {
const uintArray = new Uint8Array(buffer);
let str = '';
const chunkSize = 8192; // 分块处理避免堆栈溢出
for (let i = 0; i < uintArray.length; i += chunkSize) {
const chunk = uintArray.subarray(i, Math.min(i + chunkSize, uintArray.length));
str += String.fromCharCode.apply(null, chunk);
}
resolve(decodeURIComponent(escape(str)));
} catch (e) {
console.error('[SSE] 二进制解码失败:', e);
resolve('[DECODE ERROR]');
}
});
}
/**
* 强制UTF-8解码
* @param {string} str - 待解码字符串
* @return {string} 解码结果
*/
_forceUTF8Decoding(str) {
try {
// 检测是否存在高字节字符
return /[\x80-\xFF]/.test(str) ?
decodeURIComponent(escape(str)) :
str;
} catch (e) {
return str;
}
}
/**
* 从原始字符串提取有效消息
* @param {string} rawStr - 原始字符串
* @return {Array<string>} 有效消息数组
*/
_extractValidMessages(rawStr) {
const messages = [];
// 匹配标准SSE格式：data: {...}\n\n
const sseFormatRegex = /(?:^|\n)data:(\{.*?\})(?:\n\n|$)/g;
let match;
while ((match = sseFormatRegex.exec(rawStr)) !== null) {
messages.push(match[1]);
}
// 兼容非标准JSON格式
if (messages.length === 0) {
const jsonObjRegex = /\{[\s\S]*?\}(?=\\?\n|$)/g;
while ((match = jsonObjRegex.exec(rawStr)) !== null) {
messages.push(match[0]);
}
}
return messages;
}
/**
* 处理解析后的消息
* @param {object} msg - 消息对象
*/
_handleMessage(msg) {
if (!msg || !msg.status) {
console.log('[SSE] 收到无状态消息', msg);
return;
}
console.log('[SSE] 处理状态:', msg.status);
switch(msg.status) {
case '1': // 多设备登录
this._handleForceLogout(msg.message || '您已在其他设备登录');
break;
case '2': // 登录失效
this._handleSessionExpired(msg.message || '登录状态已失效');
break;
case '9': // 心跳消息
this.lastMessageTime = Date.now();
break;
default:
console.log('[SSE] 未知状态消息', msg);
}
}
/**
* 处理强制下线
* @param {string} message - 提示消息
*/
_handleForceLogout(message) {
this.isForceClosed = true;
wx.removeStorageSync('token');
this.close().then(() => {
wx.showModal({
title: '下线通知',
content: message,
showCancel: false,
complete: () => wx.reLaunch({ url: '/pages/login/login' })
});
});
}
/**
* 处理会话过期
* @param {string} message - 提示消息
*/
_handleSessionExpired(message) {
this.isForceClosed = true;
wx.removeStorageSync('token');
this.close().then(() => {
wx.showModal({
title: '登录失效',
content: message,
showCancel: false,
complete: () => wx.reLaunch({ url: '/pages/login/login' })
});
});
}
/**
* 启动心跳检测
*/
_startHeartbeatCheck() {
this._clearHeartbeatTimer();
this.heartbeatTimer = setInterval(() => {
const timeElapsed = Date.now() - this.lastMessageTime;
if (timeElapsed > this.HEARTBEAT_INTERVAL * 1.5) {
console.error('[SSE] 心跳超时', timeElapsed);
if (!this.isForceClosed) {
this.close();
this._scheduleReconnect(this._pendingToken);
}
}
}, this.HEARTBEAT_INTERVAL / 2);
}
/**
* 安排重连
* @param {string} token - 身份验证令牌
*/
_scheduleReconnect(token) {
if (!token || this.isForceClosed) return;
this.reconnectCount++;
// 达到最大重连次数
if (this.reconnectCount > this.MAX_RECONNECT) {
console.error('[SSE] 达到最大重连次数');
wx.showToast({
title: '连接断开，请检查网络',
icon: 'none'
});
return;
}
// 指数退避算法计算延迟
const delay = Math.min(3000 * Math.pow(2, this.reconnectCount - 1), 30000);
console.log(`[SSE] ${delay}ms后第${this.reconnectCount}次重试`);
this.reconnectTimer = setTimeout(() => {
this.connect(token);
}, delay);
}
/**
* 关闭连接（公开方法）
* @return {Promise} 关闭完成的Promise
*/
close() {
if (this._isClosing) return Promise.resolve();
return this._safeClose();
}
/**
* 清理所有定时器
*/
_clearTimers() {
if (this.heartbeatTimer) {
clearInterval(this.heartbeatTimer);
this.heartbeatTimer = null;
}
if (this.reconnectTimer) {
clearTimeout(this.reconnectTimer);
this.reconnectTimer = null;
}
}
}
// 导出单例实例
export const sse = new SSEClient();
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
