在上一篇文章中，我们描述了安装和配置 WebSocket 服务器服务的过程。
该服务提供广泛的功能，在本指南中，我们将介绍其中的一些功能。在上一篇文章中，我们只演示了一个基本配置 - 即我们调用一个脚本并通过 WebSocket 持续发送数据。当涉及到设置生产服务器时，这种方法并不总是高效的。
1. 仅在数据更改时才发送数据
在此代码中，仅当新的 JSON 字符串与前一个字符串不同时，才会将数据发送给客户端。
const newJSON = JSON.stringify(live);
if (newJSON !== previousLiveJSON) {
previousLiveJSON = newJSON;
latestLiveData = live;
broadcast();
console.log(`实时数据已更新 (${live.length} 次访问)`);
}
这种方法可以显著节省客户端资源，尤其是在将数据发送到微控制器时 - 在这种情况下，它可以大大降低负载。
2. 将两个请求合并为一个
您可以构建代码，以便两个请求同时执行并提供所需的数据。 在本例中，我们接收两种不同类型的数据：Live 和 Summary。
/root/websocket-server/server.js
import express from "express";
import { WebSocketServer } from "ws";
import fetch from "node-fetch";
import https from "https";
import fs from "fs";
import url from "url";
import dotenv from "dotenv";
dotenv.config();
const PORT = process.env.PORT || 8080;
const MATOMO_URL = process.env.MATOMO_URL;
const MATOMO_TOKEN = process.env.MATOMO_TOKEN;
const ID_SITE = process.env.MATOMO_SITE_ID || 1;
const FETCH_INTERVAL = parseInt(process.env.FETCH_INTERVAL) || 1000;
const VALID_TOKENS = process.env.VALID_TOKENS.split(",").map(t => t.trim());
const SSL_KEY = process.env.SSL_KEY;
const SSL_CERT = process.env.SSL_CERT;
const TIMEZONE_OFFSET = 3; // 您的 +3 时区
const options = {
key: fs.readFileSync(SSL_KEY),
cert: fs.readFileSync(SSL_CERT)
};
const app = express();
const server = https.createServer(options, app);
const wss = new WebSocketServer({ server });
// === 全局变量 ===
let latestLiveData = [];
let latestSummary = {};
let previousLiveJSON = "";
let previousSummaryJSON = "";
// ===== 获取实时统计数据（最近访问） =====
async function fetchMatomoLive() {
const apiUrl = `${MATOMO_URL}index.php?module=API&method=Live.getLastVisitsDetails&format=JSON&period=day&date=today&idSite=${ID_SITE}`;
const res = await fetch(apiUrl, {
method: "POST",
body: new URLSearchParams({
token_auth: MATOMO_TOKEN,
filter_limit: "5",
expanded: "1"
}),
headers: { "Content-Type": "application/x-www-form-urlencoded" }
});
const data = await res.json();
const visits = [];
if (Array.isArray(data)) {
for (const visit of data) {
if (
visit.latitude &&
visit.longitude &&
!isNaN(visit.latitude) &&
!isNaN(visit.longitude)
) {
let pageTitle = "";
if (Array.isArray(visit.actionDetails)) {
for (const action of visit.actionDetails) {
if (action.pageTitle) {
pageTitle = action.pageTitle;
break;
}
}
}
let localTime = "";
if (visit.lastActionDateTime) {
try {
const date = new Date(visit.lastActionDateTime.replace(" ", "T") + "Z");
const shifted = new Date(date.getTime() + TIMEZONE_OFFSET * 3600000);
localTime = shifted.toISOString().replace("T", " ").substring(0, 19);
} catch {
localTime = visit.lastActionDateTime;
}
}
visits.push({
latitude: parseFloat(visit.latitude),
longitude: parseFloat(visit.longitude),
city: visit.city || "",
countryCode: visit.countryCode || "",
country: visit.country || "",
actions: visit.actions || "",
visitIp: visit.visitIp || "",
operatingSystem: visit.operatingSystem || "",
browserName: visit.browserName || "",
source: visit.referrerName || "",
lastActionDateTime: localTime
});
}
}
}
return visits;
}
// ===== 获取摘要统计数据（VisitsSummary） =====
async function fetchSummaryData() {
async function getMetric(method, date) {
const url = `${MATOMO_URL}index.php?module=API&method=${method}&format=JSON&period=day&date=${date}&idSite=${ID_SITE}`;
const res = await fetch(url, {
method: "POST",
body: new URLSearchParams({ token_auth: MATOMO_TOKEN }),
headers: { "Content-Type": "application/x-www-form-urlencoded" }
});
const data = await res.json();
return data?.value ? parseInt(data.value) : 0;
}
async function getDayData(date) {
const visits = await getMetric("VisitsSummary.getVisits", date);
const timeSec = await getMetric("VisitsSummary.getSumVisitsLength", date);
const h = Math.floor(timeSec / 3600);
const m = Math.floor((timeSec % 3600) / 60);
const s = timeSec % 60;
const formattedTime = `${h.toString().padStart(2, "0")}:${m
.toString()
.padStart(2, "0")}:${s.toString().padStart(2, "0")}`;
return { visits, time_spent: formattedTime };
}
const today = new Date(Date.now() + TIMEZONE_OFFSET * 3600000);
const yesterday = new Date(today.getTime() - 86400000);
const dayBefore = new Date(today.getTime() - 2 * 86400000);
function fmt(d) {
return d.toISOString().substring(0, 10);
}
const [todayStats, yStats, dbStats] = await Promise.all([
getDayData("today"),
getDayData(fmt(yesterday)),
getDayData(fmt(dayBefore))
]);
return {
today: todayStats,
yesterday: yStats,
day_before: dbStats
};
}
// ===== 主要更新功能 =====
async function fetchMatomoData() {
try {
const [live, summary] = await Promise.all([
fetchMatomoLive(),
fetchSummaryData()
]);
// --- 检查更改 ---
const newLiveJSON = JSON.stringify(live);
const newSummaryJSON = JSON.stringify(summary);
const liveChanged = newLiveJSON !== previousLiveJSON;
const summaryChanged = newSummaryJSON !== previousSummaryJSON;
// --- 更新缓存 ---
if (liveChanged) {
previousLiveJSON = newLiveJSON;
latestLiveData = live;
console.log(`实时数据已更新 (${live.length} 次访问)`);
} else {
console.log("⏸ 实时数据未更改");
}
if (summaryChanged) {
previousSummaryJSON = newSummaryJSON;
latestSummary = summary;
console.log("摘要已更新");
} else {
console.log("⏸ 摘要未更改");
}
// --- 仅在数据更改时才向客户端发送更新 ---
if (liveChanged || summaryChanged) {
const combined = JSON.stringify({
visits_live: latestLiveData,
summary: latestSummary
});
wss.clients.forEach(client => {
if (client.readyState === 1) {
client.send(combined);
}
});
console.log("已将更新的数据发送给客户端");
} else {
console.log("没有更改 - 跳过发送");
}
} catch (err) {
console.error("获取数据时出错:", err.message);
}
}
// ===== 启动循环 =====
setInterval(fetchMatomoData, FETCH_INTERVAL);
fetchMatomoData();
// ===== WebSocket =====
wss.on("connection", (ws, req) => {
const query = url.parse(req.url, true).query;
const token = query.token;
if (!VALID_TOKENS.includes(token)) {
console.log(`拒绝了带有令牌的连接：${token}`);
ws.close(4001, "无效令牌");
return;
}
console.log(`客户端已连接 (${token})`);
if (latestLiveData.length > 0 || Object.keys(latestSummary).length > 0) {
ws.send(JSON.stringify({ visits_live: latestLiveData, summary: latestSummary }));
}
ws.on("close", () => {
console.log(`客户端 ${token} 已断开连接`);
});
});
// ===== HTTP 调试 =====
app.get("/debug", (req, res) => {
res.setHeader("Content-Type", "application/json; charset=utf-8");
res.send(
JSON.stringify({ visits_live: latestLiveData, summary: latestSummary }, null, 2)
);
});
server.listen(PORT, () => {
console.log(`HTTPS 服务器在端口 ${PORT} 上运行`);
});
在此示例中，我们直接从两个不同的 API 调用请求数据，并在单个响应中发送它们，从而绕过 PHP 脚本。
3. 安全的身份验证设置
在上面的代码中，使用变量来存储身份验证数据。 要处理此问题，您需要安装以下软件包：
npm install dotenv
配置文件如下所示：
nano /root/websocket-server/.env
# === API 配置 ===
MATOMO_URL=https://domain.tld/path/
MATOMO_TOKEN=YOUR_API_KEY
MATOMO_SITE_ID=1
# === 服务器配置 ===
PORT=8080
FETCH_INTERVAL=1000
# === WebSocket 访问 ===
VALID_TOKENS=WSS_CLIENT_TOKEN_1,WSS_CLIENT_TOKEN_2
# === SSL 路径 ===
SSL_KEY=/etc/letsencrypt/live/wss.domain.tld/privkey.pem
SSL_CERT=/etc/letsencrypt/live/wss.domain.tld/fullchain.pem
如您所见，身份验证既对 API 请求执行，也对连接到 WebSocket 服务器的客户端执行。
要连接到 WSS，请使用带有令牌的地址：
/?token=WSS_CLIENT_TOKEN_1
4. API 数据请求频率
配置在以下行中完成：
const FETCH_INTERVAL = parseInt(process.env.FETCH_INTERVAL) || 1000;
该参数以毫秒为单位指定，其中 1000 = 1 秒。
对于 10 秒，它将如下所示：
const FETCH_INTERVAL = parseInt(process.env.FETCH_INTERVAL) || 10000;
在我们的代码中，如果未在 .env 中定义，则默认设置此参数。
由于它已经在那里指定，因此应直接在 .env 文件中编辑它。
对于 12 小时，请在 .env 中更改参数：
FETCH_INTERVAL=43200000
5. 结论
此配置允许您接收实时统计信息，绕过 PHP 脚本，同时在将数据发送到 WSS 客户端之前考虑数据更改。
要应用新设置，请不要忘记重新启动服务：
cd /root/websocket-server
pm2 restart server.js --name websocket
检查服务状态：
pm2 status server.js --name websocket
No Comments Yet