基于Sequelize与Node.js实现SQL Server表插入事件通知

针对你的需求——替代轮询机制，让SQL Server在目标表被第三方应用插入数据时主动通知Node.js应用，这里提供三种可行方案，按原生性和复杂度排序：

方案一：SQL Server Service Broker（原生实时推送） #

这是SQL Server内置的消息队列机制，能在表发生插入操作时直接推送通知到Node.js，完全摆脱轮询。

步骤1：配置SQL Server端Service Broker #

在目标数据库和表上完成以下配置：

-- 1. 启用数据库的Service Broker
ALTER DATABASE YourDatabaseName SET ENABLE_BROKER;

-- 2. 定义通知消息类型
CREATE MESSAGE TYPE [NewMessageNotification] VALIDATION = NONE;

-- 3. 创建消息交互契约
CREATE CONTRACT [MessageInsertContract] ([NewMessageNotification] SENT BY INITIATOR);

-- 4. 创建接收通知的队列与服务
CREATE QUEUE [MessageNotificationQueue];
CREATE SERVICE [NotificationReceiverService] ON QUEUE [MessageNotificationQueue] ([MessageInsertContract]);

-- 5. 创建发起通知的队列与服务
CREATE QUEUE [NotificationInitiatorQueue];
CREATE SERVICE [NotificationInitiatorService] ON QUEUE [NotificationInitiatorQueue] ([MessageInsertContract]);

-- 6. 新增触发器：表插入数据时发送通知
CREATE TRIGGER trg_NotifyNewMessage ON YourMessagesTable
AFTER INSERT
AS
BEGIN
    SET NOCOUNT ON;
    DECLARE @conversationHandle UNIQUEIDENTIFIER;

    -- 开启对话连接
    BEGIN DIALOG @conversationHandle
        FROM SERVICE [NotificationInitiatorService]
        TO SERVICE 'NotificationReceiverService'
        ON CONTRACT [MessageInsertContract]
        WITH ENCRYPTION = OFF;

    -- 发送通知消息
    SEND ON CONVERSATION @conversationHandle
        MESSAGE TYPE [NewMessageNotification] (N'New record inserted');

    -- 结束对话
    END CONVERSATION @conversationHandle;
END;

步骤2：Node.js（Sequelize）端监听队列 #

利用Sequelize底层的mssql连接编写监听逻辑：

const { Sequelize } = require('sequelize');

// 初始化Sequelize连接
const sequelize = new Sequelize('YourDatabaseName', 'Username', 'Password', {
    dialect: 'mssql',
    dialectOptions: {
        options: {
            encrypt: true,
            trustServerCertificate: true
        }
    }
});

// 监听Service Broker队列的函数
async function listenForNotifications() {
    let connection;
    try {
        // 获取Sequelize底层的mssql连接
        connection = await sequelize.connectionManager.getConnection();
        
        while (true) {
            // 从队列接收通知
            const result = await connection.request().query(`
                RECEIVE TOP(1) * FROM MessageNotificationQueue;
            `);

            if (result.recordset.length > 0) {
                console.log('收到插入通知，开始处理待发送消息');
                // 查询所有未发送的消息
                const pendingMessages = await sequelize.models.Message.findAll({
                    where: { status: 'unsent' }
                });
                // 执行你的消息发送逻辑...
                console.log(`处理了 ${pendingMessages.length} 条待发送消息`);
            } else {
                // 无消息时短暂等待，避免占用过多资源
                await new Promise(resolve => setTimeout(resolve, 1000));
            }
        }
    } catch (err) {
        console.error('监听队列出错:', err);
        // 出错后5秒重试
        setTimeout(listenForNotifications, 5000);
    } finally {
        if (connection) await connection.release();
    }
}

// 启动监听
listenForNotifications();

优缺点 #

• ✅ 原生SQL Server支持，无需第三方组件，实时性高
• ❌ 配置相对复杂，需要了解Service Broker基础概念
• ❌ 需确保SQL Server用户拥有足够权限（如ALTER ANY SERVICE、CREATE QUEUE等）

方案二：SQL Server Change Tracking（轻量级变更追踪） #

如果不需要严格实时推送，Change Tracking是更简单的选择——它会记录表的变更记录，你可按需查询，资源占用远低于10秒轮询。

步骤1：启用Change Tracking #

-- 启用数据库的Change Tracking
ALTER DATABASE YourDatabaseName SET CHANGE_TRACKING = ON (CHANGE_RETENTION = 2 DAYS, AUTO_CLEANUP = ON);

-- 启用目标表的Change Tracking
ALTER TABLE YourMessagesTable ENABLE CHANGE_TRACKING WITH (TRACK_COLUMNS_UPDATED = OFF);

步骤2：Node.js（Sequelize）端查询变更 #

let lastSyncVersion = 0;

async function checkForChanges() {
    try {
        // 获取当前数据库的变更版本
        const versionResult = await sequelize.query(
            'SELECT CHANGE_TRACKING_CURRENT_VERSION() AS currentVersion;',
            { type: sequelize.QueryTypes.SELECT }
        );
        const currentVersion = versionResult[0].currentVersion;

        if (currentVersion > lastSyncVersion) {
            // 查询自上次同步以来的变更记录
            const changes = await sequelize.query(`
                SELECT CT.*, M.*
                FROM CHANGETABLE(CHANGES YourMessagesTable, ${lastSyncVersion}) AS CT
                JOIN YourMessagesTable AS M ON CT.[SYS_CHANGE_ID] = M.Id;
            `, { type: sequelize.QueryTypes.SELECT });

            if (changes.length > 0) {
                console.log(`发现 ${changes.length} 条新插入的消息`);
                // 处理消息发送逻辑...
            }
            // 更新上次同步版本
            lastSyncVersion = currentVersion;
        }
    } catch (err) {
        console.error('查询变更记录出错:', err);
    } finally {
        // 每30秒查询一次（可根据需求调整，比10秒轮询高效很多）
        setTimeout(checkForChanges, 30000);
    }
}

// 启动查询
checkForChanges();

优缺点 #

• ✅ 配置简单，学习成本低
• ✅ 资源占用远低于轮询
• ❌ 不是主动推送，需定期查询（但间隔可大幅拉长）
• ❌ 需保留变更记录版本号，避免丢失数据

方案三：Redis Pub/Sub（跨应用协同） #

如果插入数据的第三方应用可以修改代码，这是实现成本最低的方案：让第三方应用插入数据后，同时向Redis发布通知，你的Node.js应用订阅该频道，收到通知后查询待发送消息。

步骤1：Node.js端订阅Redis频道 #

const redis = require('redis');
const subscriber = redis.createClient();

subscriber.on('message', async (channel, message) => {
    if (channel === 'new-message-inserted') {
        console.log('收到Redis通知，处理待发送消息');
        const pendingMessages = await sequelize.models.Message.findAll({
            where: { status: 'unsent' }
        });
        // 执行发送逻辑...
    }
});

subscriber.subscribe('new-message-inserted');

步骤2：第三方应用插入后发布通知 #

（以Node.js为例，其他语言逻辑一致）

const publisher = redis.createClient();

// 插入数据后发布通知
async function insertMessage(data) {
    await thirdPartySequelize.models.Message.create(data);
    await publisher.publish('new-message-inserted', 'new record');
}

优缺点 #

• ✅ 实现最简单，跨语言跨应用友好
• ✅ 实时性高
• ❌ 依赖第三方应用配合修改，若对方无法调整代码则不可用
• ❌ 需要额外部署Redis服务

内容的提问来源于stack exchange，提问作者Felipi Estevão