任务管理系统如何在负责人变更时触发通知,并避免重复发送?

发布人:A5数据发布时间:2026-11-16 13:55阅读量:21

负责人变更通知应由“数据库状态更新”和“待发送事件”共同驱动:事务先确认负责人确实发生变化,再同时更新任务并写入通知事件;后台工作进程读取事件、发送通知,成功后标记完成。这样既不会因任务更新成功、通知入队失败而漏发,也能通过请求幂等键、版本校验和发送端去重,减少重复通知。

下面以 TypeScript、Express 和 PostgreSQL 为例。示例只在负责人真正改变时通知新负责人;如需同时通知原负责人或关注者,可在同一事件中扩展收件人。核心原则是:不要在更新任务的 HTTP 请求里直接发送邮件或调用通知服务。

先确定哪些情况应该发送

可以把一次有效的负责人变更定义为:任务当前负责人是 A,请求指定的新负责人是 B,且 A 与 B 不同。满足条件时更新任务并产生一条事件;否则不产生通知。

还要区分三种容易混淆的重复:

  • 请求重试:客户端未收到响应,重发了同一个请求。用幂等键识别,并返回第一次处理的结果。
  • 并发修改:两个请求同时尝试修改同一任务。用负责人版本号校验,避免后一个请求悄悄覆盖前一个。
  • 发送重试:工作进程发送后崩溃,或暂时无法确认服务端是否已接受通知。用稳定的事件标识请求发送端去重;如果发送渠道不支持幂等,仍需接受极少数重复发送的可能。

最后一点有明确边界:数据库事务无法与邮件服务的发送动作组成一个原子事务。对方已经接收邮件、但本地尚未记录成功时进程崩溃,重试可能再次发送。因此,“可靠重试”不等于对所有外部渠道都能保证严格的一次发送。

用事务发出负责人变更事件

以下结构假定已有 tasks(id, owner_id, title) 和 users(id) 表。负责人版本号只在负责人改变时递增,避免任务标题等其他字段的修改导致负责人更新请求被误判为冲突。

ALTER TABLE tasks
  ADD COLUMN IF NOT EXISTS owner_version integer NOT NULL DEFAULT 0;

CREATE TABLE task_owner_change_requests (
  task_id uuid NOT NULL REFERENCES tasks(id),
  idempotency_key text NOT NULL,
  request_hash text NOT NULL,
  response jsonb NOT NULL,
  created_at timestamptz NOT NULL DEFAULT now(),
  PRIMARY KEY (task_id, idempotency_key)
);

CREATE TABLE task_owner_outbox (
  event_id uuid PRIMARY KEY,
  task_id uuid NOT NULL REFERENCES tasks(id),
  owner_version integer NOT NULL,
  old_owner_id uuid NOT NULL REFERENCES users(id),
  new_owner_id uuid NOT NULL REFERENCES users(id),
  payload jsonb NOT NULL,
  status text NOT NULL DEFAULT 'pending'
    CHECK (status IN ('pending', 'processing', 'sent', 'dead')),
  attempts integer NOT NULL DEFAULT 0,
  available_at timestamptz NOT NULL DEFAULT now(),
  locked_until timestamptz,
  lease_token uuid,
  sent_at timestamptz,
  last_error text,
  created_at timestamptz NOT NULL DEFAULT now(),
  UNIQUE (task_id, owner_version)
);

CREATE INDEX task_owner_outbox_pending_idx
  ON task_owner_outbox (available_at, created_at)
  WHERE status IN ('pending', 'processing');

task_owner_change_requests 保存幂等键和首次响应,包括“负责人没有变化”的结果。task_owner_outbox 保存事务提交后等待发送的事件。两张表的用途不同:前者回答“这个请求是否已经处理”,后者回答“这条通知是否已经发送”。

迁移前应在测试环境核对现有表名、字段类型和外键关系,再按项目的数据库变更流程应用。示例中的外键假定任务负责人和通知接收人都对应 users.id;如果实际系统允许无负责人,应按业务规则调整字段的可空性和通知条件。

在接口中校验版本并写入 Outbox

接口接收目标负责人、客户端读取到的 ownerVersion,以及 Idempotency-Key 请求头。ownerVersion 用来避免覆盖并发修改;幂等键应由调用方在第一次提交时生成,并在该次请求的重试中保持不变。

下面示例使用 pg 的连接池和 Express。assertCanManageTask、assertEligibleOwner 表示接入现有的权限校验和负责人资格校验;生产接口应在读取幂等结果前也完成当前用户的权限验证,不能因为请求键已存在就跳过授权。

import { createHash, randomUUID } from "node:crypto";
import type { Request, Response, NextFunction } from "express";
import { pool } from "./db";

app.patch(
  "/tasks/:taskId/owner",
  async (req: Request, res: Response, next: NextFunction) => {
    const taskId = req.params.taskId;
    const newOwnerId = req.body.ownerId;
    const expectedVersion = req.body.ownerVersion;
    const idempotencyKey = req.header("Idempotency-Key");

    if (
      typeof newOwnerId !== "string" ||
      !Number.isInteger(expectedVersion) ||
      typeof idempotencyKey !== "string" ||
      idempotencyKey.length < 8 ||
      idempotencyKey.length > 200
    ) {
      return res.status(400).json({ error: "请求参数不完整或格式不正确" });
    }

    const requestHash = createHash("sha256")
      .update(JSON.stringify([taskId, newOwnerId, expectedVersion]))
      .digest("hex");

    const client = await pool.connect();

    try {
      await client.query("BEGIN");

      const taskResult = await client.query(
        `SELECT id, title, owner_id, owner_version
         FROM tasks
         WHERE id = $1
         FOR UPDATE`,
        [taskId]
      );

      if (taskResult.rowCount === 0) {
        await client.query("ROLLBACK");
        return res.status(404).json({ error: "任务不存在" });
      }

      const task = taskResult.rows[0];

      // 每次请求都进行权限校验,包括使用原幂等键重试的请求。
      await assertCanManageTask(req, taskId, client);

      const previousRequest = await client.query(
        `SELECT request_hash, response
         FROM task_owner_change_requests
         WHERE task_id = $1 AND idempotency_key = $2`,
        [taskId, idempotencyKey]
      );

      if (previousRequest.rowCount) {
        if (previousRequest.rows[0].request_hash !== requestHash) {
          await client.query("ROLLBACK");
          return res.status(409).json({
            error: "该幂等键已用于不同的请求"
          });
        }

        await client.query("COMMIT");
        return res.status(200).json(previousRequest.rows[0].response);
      }

      if (task.owner_version !== expectedVersion) {
        await client.query("ROLLBACK");
        return res.status(409).json({
          error: "负责人已被其他请求修改,请刷新后重试",
          currentOwnerVersion: task.owner_version
        });
      }

      await assertEligibleOwner(client, newOwnerId);

      if (task.owner_id === newOwnerId) {
        const response = {
          changed: false,
          ownerId: task.owner_id,
          ownerVersion: task.owner_version
        };

        await client.query(
          `INSERT INTO task_owner_change_requests
             (task_id, idempotency_key, request_hash, response)
           VALUES ($1, $2, $3, $4::jsonb)`,
          [taskId, idempotencyKey, requestHash, JSON.stringify(response)]
        );

        await client.query("COMMIT");
        return res.status(200).json(response);
      }

      const updated = await client.query(
        `UPDATE tasks
         SET owner_id = $1,
             owner_version = owner_version + 1,
             updated_at = now()
         WHERE id = $2
         RETURNING owner_version`,
        [newOwnerId, taskId]
      );

      const newVersion = updated.rows[0].owner_version;
      const eventId = randomUUID();
      const payload = {
        taskId,
        taskTitle: task.title,
        oldOwnerId: task.owner_id,
        newOwnerId,
        ownerVersion: newVersion
      };
      const response = {
        changed: true,
        ownerId: newOwnerId,
        ownerVersion: newVersion
      };

      await client.query(
        `INSERT INTO task_owner_outbox
           (event_id, task_id, owner_version,
            old_owner_id, new_owner_id, payload)
         VALUES ($1, $2, $3, $4, $5, $6::jsonb)`,
        [
          eventId,
          taskId,
          newVersion,
          task.owner_id,
          newOwnerId,
          JSON.stringify(payload)
        ]
      );

      await client.query(
        `INSERT INTO task_owner_change_requests
           (task_id, idempotency_key, request_hash, response)
         VALUES ($1, $2, $3, $4::jsonb)`,
        [taskId, idempotencyKey, requestHash, JSON.stringify(response)]
      );

      await client.query("COMMIT");
      return res.status(200).json(response);
    } catch (error) {
      await client.query("ROLLBACK").catch(() => undefined);
      return next(error);
    } finally {
      client.release();
    }
  }
);

任务行使用 FOR UPDATE 锁定,因此针对同一任务的负责人修改会依次处理。版本号不一致时返回 409,让页面刷新负责人状态后再决定是否重新提交。相同幂等键和相同请求内容则返回第一次保存的响应,不会再次创建 Outbox 事件;同一幂等键被用于不同内容时返回冲突,避免误把新操作当作旧请求重放。

任务更新、事件插入和请求结果保存都在同一个事务内。事务提交后,工作进程一定能读到对应事件;事务回滚时,任务负责人和事件也会一起回滚。不要把发送邮件或调用外部通知服务放进这个事务:网络调用可能耗时或失败,也会长时间占用数据库锁。

在接口中校验版本并写入 Outbox配图

前端调用时,为同一次操作生成一个幂等键;网络超时后重试时复用它。新的一次负责人变更则生成新键,并提交页面最新读取到的版本号。例如:

PATCH /tasks/8b87ab67-4360-4de1-b888-0e0d81a6e561/owner
Idempotency-Key: task-owner-8b87ab67-action-019
Content-Type: application/json

{
  "ownerId": "c9384b94-87c2-42e9-a7a8-2f2b124b86a7",
  "ownerVersion": 3
}

用工作进程发送并安全重试

工作进程批量领取待发送事件时,应在一个短事务里锁定记录并设置租约;事务提交后再调用通知服务。SKIP LOCKED 可避免多个工作进程同时领取同一批未处理事件。租约超时后,其他进程可以重新领取崩溃进程留下的记录。

WITH picked AS (
  SELECT event_id
  FROM task_owner_outbox
  WHERE
    (status = 'pending' AND available_at <= now())
    OR
    (status = 'processing' AND locked_until <= now())
  ORDER BY available_at, created_at
  LIMIT 50
  FOR UPDATE SKIP LOCKED
)
UPDATE task_owner_outbox AS o
SET status = 'processing',
    attempts = o.attempts + 1,
    locked_until = now() + interval '90 seconds',
    lease_token = $1
FROM picked
WHERE o.event_id = picked.event_id
RETURNING o.*;

$1 是本次领取批次新生成的 UUID。处理结果更新时同时检查 lease_token,避免租约已过期、事件已被其他进程重新领取后,旧进程覆盖新进程的状态。

import { randomUUID } from "node:crypto";
import { pool } from "./db";

async function claimBatch() {
  const client = await pool.connect();
  const leaseToken = randomUUID();

  try {
    await client.query("BEGIN");
    const result = await client.query(
      `WITH picked AS (
         SELECT event_id
         FROM task_owner_outbox
         WHERE
           (status = 'pending' AND available_at <= now())
           OR
           (status = 'processing' AND locked_until <= now())
         ORDER BY available_at, created_at
         LIMIT 50
         FOR UPDATE SKIP LOCKED
       )
       UPDATE task_owner_outbox AS o
       SET status = 'processing',
           attempts = o.attempts + 1,
           locked_until = now() + interval '90 seconds',
           lease_token = $1
       FROM picked
       WHERE o.event_id = picked.event_id
       RETURNING o.*`,
      [leaseToken]
    );

    await client.query("COMMIT");
    return result.rows.map((row) => ({ ...row, leaseToken }));
  } catch (error) {
    await client.query("ROLLBACK").catch(() => undefined);
    throw error;
  } finally {
    client.release();
  }
}

async function processBatch() {
  const jobs = await claimBatch();

  for (const job of jobs) {
    try {
      await notifier.sendOwnerChanged({
        taskId: job.payload.taskId,
        taskTitle: job.payload.taskTitle,
        recipientUserId: job.new_owner_id,
        idempotencyKey: `owner-change:${job.event_id}:new-owner`
      });

      await pool.query(
        `UPDATE task_owner_outbox
         SET status = 'sent',
             sent_at = now(),
             locked_until = NULL,
             lease_token = NULL,
             last_error = NULL
         WHERE event_id = $1
           AND status = 'processing'
           AND lease_token = $2`,
        [job.event_id, job.leaseToken]
      );
    } catch (error) {
      const delaySeconds = Math.min(900, 2 ** Math.min(job.attempts, 9));
      const retryAt = new Date(Date.now() + delaySeconds * 1000);
      const errorMessage = String(error).slice(0, 1000);

      await pool.query(
        `UPDATE task_owner_outbox
         SET status = CASE WHEN attempts >= 8 THEN 'dead' ELSE 'pending' END,
             available_at = $3,
             locked_until = NULL,
             lease_token = NULL,
             last_error = $4
         WHERE event_id = $1
           AND status = 'processing'
           AND lease_token = $2`,
        [job.event_id, job.leaseToken, retryAt, errorMessage]
      );
    }
  }
}

示例中的退避时间会随失败次数增加,最多约 15 分钟;连续失败 8 次后转入 dead,由运维或业务人员检查后决定是否重新投递。可以按通知服务的超时和限流情况调整重试次数、间隔和租约时长。租约时长应大于通常的发送耗时;如果单次发送可能超过租约,应增加续租机制,而不是让两个进程同时处理一条记录。

用工作进程发送并安全重试配图

notifier.sendOwnerChanged 是与具体邮件、站内信或消息服务对接的适配层。若服务支持幂等键,应将稳定的 event_id 与收件人标识组合后传入;不要使用每次重试都会变化的租约令牌作为发送幂等键。对于站内通知,也可以在通知表上增加唯一约束,例如 (event_id, recipient_id, channel),并使用 ON CONFLICT DO NOTHING,避免同一事件重复插入站内消息。

任务负责人变更流程通常由业务接口、数据库与异步工作进程共同承载。A5idc数据提供香港、美国、日本等地区的物理服务器,涵盖Xeon Gold、AMD EPYC等平台,并提供SSD或NVMe存储及多种网络线路,可为任务管理后台、业务数据库和通知工作进程提供部署资源,也便于结合业务覆盖区域规划服务节点。

用具体操作确认行为

任务当前负责人为 A,ownerVersion 为 3。提交将负责人改为 B 的请求后,预期结果是:

  • 任务负责人变为 B,版本号变为 4。
  • 同一事务中产生一条版本号为 4 的 Outbox 事件。
  • 工作进程发送给 B,并在成功后将事件标记为 sent。

重复测试时,应使用不同场景分别验证:

场景预期结果
同一幂等键、相同请求内容重试返回第一次的响应,不新增事件
同一幂等键、请求内容不同返回 409,不执行第二个变更
新旧负责人相同返回 changed: false,不发送通知
两个请求使用相同版本并发修改一个请求成功,另一个因版本冲突返回 409
通知发送暂时失败事件回到待发送状态,按退避策略重试
发送服务已接收请求,但工作进程未记录成功便退出使用发送端幂等能力避免重复;不支持幂等的外部渠道可能重复发送

排查时可以先检查事件状态和失败次数:

SELECT event_id, task_id, owner_version, status,
       attempts, available_at, sent_at, last_error
FROM task_owner_outbox
WHERE task_id = $1
ORDER BY owner_version;

如果事件停在 processing,查看 locked_until 是否已经过期;如果状态为 dead,先根据 last_error 和通知服务记录确认失败原因,再决定是否重试。不要直接重置全部事件状态,否则可能重复发送已经被外部服务接收的通知。

这套流程将变更判定、并发控制、通知入队和发送重试分开处理:数据库负责准确记录“负责人何时变了”,工作进程负责把事件送达,幂等键与发送端去重负责压低重复风险。实际接入时,再按现有任务表、权限模型和通知渠道调整字段与收件人规则即可。

本文由A5数据原创发布,转载请注明出处:https://www.a5idc.com/helpcontent/9831.html

相关推荐