...
;
+ * }
+ * ```
+ */
+
+import { useEffect, useState, useRef } from 'react';
+import { socketService } from '../services/socketService';
+
+export const useEventNotifications = (options = {}) => {
+ const {
+ eventType = 'all',
+ importance = 'all',
+ enabled = true,
+ onNewEvent,
+ } = options;
+
+ const [isConnected, setIsConnected] = useState(false);
+ const [newEvent, setNewEvent] = useState(null);
+ const [error, setError] = useState(null);
+ const unsubscribeRef = useRef(null);
+
+ useEffect(() => {
+ // 如果禁用，则不订阅
+ if (!enabled) {
+ return;
+ }
+
+ // 连接状态监听
+ const handleConnect = () => {
+ setIsConnected(true);
+ setError(null);
+ };
+
+ const handleDisconnect = () => {
+ setIsConnected(false);
+ };
+
+ const handleConnectError = (err) => {
+ setError(err);
+ setIsConnected(false);
+ };
+
+ // 连接 WebSocket
+ socketService.connect();
+
+ // 监听连接事件
+ socketService.on('connect', handleConnect);
+ socketService.on('disconnect', handleDisconnect);
+ socketService.on('connect_error', handleConnectError);
+
+ // 新事件处理函数
+ const handleNewEvent = (eventData) => {
+ setNewEvent(eventData);
+
+ // 调用外部回调
+ if (onNewEvent) {
+ onNewEvent(eventData);
+ }
+ };
+
+ // 订阅事件推送
+ socketService.subscribeToEvents({
+ eventType,
+ importance,
+ onNewEvent: handleNewEvent,
+ onSubscribed: (data) => {
+ console.log('订阅成功:', data);
+ },
+ });
+
+ // 保存取消订阅函数
+ unsubscribeRef.current = () => {
+ socketService.unsubscribeFromEvents({ eventType });
+ };
+
+ // 组件卸载时清理
+ return () => {
+ console.log('清理 WebSocket 订阅');
+
+ // 取消订阅
+ if (unsubscribeRef.current) {
+ unsubscribeRef.current();
+ }
+
+ // 移除监听器
+ socketService.off('connect', handleConnect);
+ socketService.off('disconnect', handleDisconnect);
+ socketService.off('connect_error', handleConnectError);
+
+ // 断开连接
+ socketService.disconnect();
+ };
+ }, [eventType, importance, enabled, onNewEvent]);
+
+ return {
+ newEvent, // 最新收到的事件
+ isConnected, // WebSocket 连接状态
+ error, // 错误信息
+ clearNewEvent: () => setNewEvent(null), // 清除新事件状态
+ };
+};
+
+/**
+ * 简化版 Hook：只订阅所有事件
+ */
+export const useAllEventNotifications = (onNewEvent) => {
+ return useEventNotifications({
+ eventType: 'all',
+ importance: 'all',
+ onNewEvent,
+ });
+};
+
+/**
+ * Hook：订阅重要事件（S 和 A 级）
+ */
+export const useImportantEventNotifications = (onNewEvent) => {
+ const [importantEvents, setImportantEvents] = useState([]);
+
+ const handleEvent = (event) => {
+ // 只处理 S 和 A 级事件
+ if (event.importance === 'S' || event.importance === 'A') {
+ setImportantEvents(prev => [event, ...prev].slice(0, 10)); // 最多保留 10 个
+ if (onNewEvent) {
+ onNewEvent(event);
+ }
+ }
+ };
+
+ const result = useEventNotifications({
+ eventType: 'all',
+ importance: 'all',
+ onNewEvent: handleEvent,
+ });
+
+ return {
+ ...result,
+ importantEvents,
+ clearImportantEvents: () => setImportantEvents([]),
+ };
+};
+
+export default useEventNotifications;
diff --git a/src/services/socketService.js b/src/services/socketService.js
index 32e129f0..f3be42b0 100644
--- a/src/services/socketService.js
+++ b/src/services/socketService.js
@@ -186,6 +186,169 @@ class SocketService {
getSocketId() {
return this.socket?.id || null;
}
+
+ // ==================== 事件推送专用方法 ====================
+
+ /**
+ * 订阅事件推送
+ * @param {object} options - 订阅选项
+ * @param {string} options.eventType - 事件类型 ('all' | 'policy' | 'market' | 'tech' | ...)
+ * @param {string} options.importance - 重要性 ('all' | 'S' | 'A' | 'B' | 'C')
+ * @param {Function} options.onNewEvent - 收到新事件时的回调函数
+ * @param {Function} options.onSubscribed - 订阅成功的回调函数（可选）
+ */
+ subscribeToEvents(options = {}) {
+ const {
+ eventType = 'all',
+ importance = 'all',
+ onNewEvent,
+ onSubscribed,
+ } = options;
+
+ if (!this.socket || !this.connected) {
+ logger.warn('socketService', 'Cannot subscribe: socket not connected');
+ // 自动连接
+ this.connect();
+ // 等待连接成功后再订阅
+ this.socket.once('connect', () => {
+ this._doSubscribe(eventType, importance, onNewEvent, onSubscribed);
+ });
+ return;
+ }
+
+ this._doSubscribe(eventType, importance, onNewEvent, onSubscribed);
+ }
+
+ /**
+ * 执行订阅操作（内部方法）
+ */
+ _doSubscribe(eventType, importance, onNewEvent, onSubscribed) {
+ // 发送订阅请求
+ this.emit('subscribe_events', {
+ event_type: eventType,
+ importance: importance,
+ });
+
+ // 监听订阅确认
+ this.socket.once('subscription_confirmed', (data) => {
+ logger.info('socketService', 'Subscription confirmed', data);
+ if (onSubscribed) {
+ onSubscribed(data);
+ }
+ });
+
+ // 监听订阅错误
+ this.socket.once('subscription_error', (error) => {
+ logger.error('socketService', 'Subscription error', error);
+ });
+
+ // 监听新事件推送
+ if (onNewEvent) {
+ // 先移除之前的监听器（避免重复）
+ this.socket.off('new_event');
+ // 添加新的监听器
+ this.socket.on('new_event', (eventData) => {
+ logger.info('socketService', 'New event received', eventData);
+ onNewEvent(eventData);
+ });
+ }
+ }
+
+ /**
+ * 取消订阅事件推送
+ * @param {object} options - 取消订阅选项
+ * @param {string} options.eventType - 事件类型
+ * @param {Function} options.onUnsubscribed - 取消订阅成功的回调函数（可选）
+ */
+ unsubscribeFromEvents(options = {}) {
+ const {
+ eventType = 'all',
+ onUnsubscribed,
+ } = options;
+
+ if (!this.socket || !this.connected) {
+ logger.warn('socketService', 'Cannot unsubscribe: socket not connected');
+ return;
+ }
+
+ // 发送取消订阅请求
+ this.emit('unsubscribe_events', {
+ event_type: eventType,
+ });
+
+ // 监听取消订阅确认
+ this.socket.once('unsubscription_confirmed', (data) => {
+ logger.info('socketService', 'Unsubscription confirmed', data);
+
+ // 移除新事件监听器
+ this.socket.off('new_event');
+
+ if (onUnsubscribed) {
+ onUnsubscribed(data);
+ }
+ });
+
+ // 监听取消订阅错误
+ this.socket.once('unsubscription_error', (error) => {
+ logger.error('socketService', 'Unsubscription error', error);
+ });
+ }
+
+ /**
+ * 快捷方法：订阅所有类型的事件
+ * @param {Function} onNewEvent - 收到新事件时的回调函数
+ * @returns {Function} 取消订阅的函数
+ */
+ subscribeToAllEvents(onNewEvent) {
+ this.subscribeToEvents({
+ eventType: 'all',
+ importance: 'all',
+ onNewEvent,
+ });
+
+ // 返回取消订阅的清理函数
+ return () => {
+ this.unsubscribeFromEvents({ eventType: 'all' });
+ };
+ }
+
+ /**
+ * 快捷方法：订阅特定重要性的事件
+ * @param {string} importance - 重要性级别 ('S' | 'A' | 'B' | 'C')
+ * @param {Function} onNewEvent - 收到新事件时的回调函数
+ * @returns {Function} 取消订阅的函数
+ */
+ subscribeToImportantEvents(importance, onNewEvent) {
+ this.subscribeToEvents({
+ eventType: 'all',
+ importance,
+ onNewEvent,
+ });
+
+ // 返回取消订阅的清理函数
+ return () => {
+ this.unsubscribeFromEvents({ eventType: 'all' });
+ };
+ }
+
+ /**
+ * 快捷方法：订阅特定类型的事件
+ * @param {string} eventType - 事件类型
+ * @param {Function} onNewEvent - 收到新事件时的回调函数
+ * @returns {Function} 取消订阅的函数
+ */
+ subscribeToEventType(eventType, onNewEvent) {
+ this.subscribeToEvents({
+ eventType,
+ importance: 'all',
+ onNewEvent,
+ });
+
+ // 返回取消订阅的清理函数
+ return () => {
+ this.unsubscribeFromEvents({ eventType });
+ };
+ }
}
// 导出单例
diff --git a/test_create_event.py b/test_create_event.py
new file mode 100644
index 00000000..5a475cc9
--- /dev/null
+++ b/test_create_event.py
@@ -0,0 +1,109 @@
+"""
+测试脚本：手动创建事件到数据库
+用于测试 WebSocket 实时推送功能
+"""
+
+import sys
+from datetime import datetime
+from sqlalchemy import create_engine, Column, Integer, String, Text, Float, DateTime
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+# 数据库连接（从 app.py 复制）
+DATABASE_URI = 'mysql+pymysql://root:Zzl5588161!@111.198.58.126:33060/stock?charset=utf8mb4'
+
+engine = create_engine(DATABASE_URI, echo=False)
+Session = sessionmaker(bind=engine)
+session = Session()
+
+Base = declarative_base()
+
+# Event 模型（简化版，只包含必要字段）
+class Event(Base):
+ __tablename__ = 'events'
+
+ id = Column(Integer, primary_key=True)
+ title = Column(String(500), nullable=False)
+ description = Column(Text)
+ event_type = Column(String(100))
+ importance = Column(String(10))
+ status = Column(String(50), default='active')
+ hot_score = Column(Float, default=0)
+ view_count = Column(Integer, default=0)
+ created_at = Column(DateTime, default=datetime.now)
+ updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+
+
+def create_test_event():
+ """创建一个测试事件"""
+
+ import random
+
+ event_types = ['policy', 'market', 'tech', 'industry', 'finance']
+ importances = ['S', 'A', 'B', 'C']
+
+ test_event = Event(
+ title=f'测试事件 - {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}',
+ description=f'这是一个用于测试 WebSocket 实时推送的事件，创建于 {datetime.now()}',
+ event_type=random.choice(event_types),
+ importance=random.choice(importances),
+ status='active',
+ hot_score=round(random.uniform(50, 100), 2),
+ view_count=random.randint(100, 1000)
+ )
+
+ try:
+ session.add(test_event)
+ session.commit()
+
+ print("✅ 测试事件创建成功!")
+ print(f" ID: {test_event.id}")
+ print(f" 标题: {test_event.title}")
+ print(f" 类型: {test_event.event_type}")
+ print(f" 重要性: {test_event.importance}")
+ print(f" 热度: {test_event.hot_score}")
+ print(f"\n💡 提示: 轮询将在 2 分钟内检测到此事件并推送到前端")
+ print(f" （如果需要立即推送，请将轮询间隔改为更短）")
+
+ return test_event.id
+
+ except Exception as e:
+ session.rollback()
+ print(f"❌ 创建事件失败: {e}")
+ return None
+ finally:
+ session.close()
+
+
+def create_multiple_events(count=3):
+ """创建多个测试事件"""
+ print(f"正在创建 {count} 个测试事件...\n")
+
+ for i in range(count):
+ event_id = create_test_event()
+ if event_id:
+ print(f"[{i+1}/{count}] 事件 #{event_id} 创建成功\n")
+ else:
+ print(f"[{i+1}/{count}] 创建失败\n")
+
+ print(f"\n✅ 完成！共创建 {count} 个事件")
+
+
+if __name__ == '__main__':
+ print("=" * 60)
+ print("WebSocket 事件推送测试 - 手动创建事件")
+ print("=" * 60)
+ print()
+
+ if len(sys.argv) > 1:
+ try:
+ count = int(sys.argv[1])
+ create_multiple_events(count)
+ except ValueError:
+ print("❌ 参数必须是数字")
+ print("用法: python test_create_event.py [数量]")
+ else:
+ # 默认创建 1 个事件
+ create_test_event()
+
+ print("\n" + "=" * 60)
diff --git a/test_websocket.html b/test_websocket.html
new file mode 100644
index 00000000..a11c5b1c
--- /dev/null
+++ b/test_websocket.html
@@ -0,0 +1,289 @@
+
+
+
+
+
🔌 WebSocket 事件推送测试页面
+
+
+ 状态: 未连接
+
+
+
+
+
+
+
+
+
+
+
+
+
📋 日志
+
+