表单并发覆盖怎么防:ETag 条件更新实战

用可运行的 Node.js 接口与浏览器表单实现条件更新,拆解原子比较、冲突保留、手工合并及网络结果未知的边界。

两个人同时打开同一张编辑表单,甲修改标题并保存,乙过了几分钟补充正文再保存。页面都显示成功,但甲的新标题消失了。这个问题不需要高并发才能出现:两个浏览器标签页、一次长时间停留,甚至一个后台脚本和一位编辑,就足以触发。

仅在按钮上加防重复点击解决不了它,因为两个请求来自不同页面。把写入放进数据库事务也不自动知道用户看过哪个版本。真正需要保存的是用户提交修改时的前提:“只有资源仍然是我开始编辑时看到的那一版,才接受这次替换。”

本文使用 ETag 与 If-Match 建立这份契约,给出可运行的 Node.js 服务、浏览器表单和并发测试。演示采用单进程内存状态,便于直接观察冲突;后面再说明如何迁移到数据库原子更新,以及为什么前端收到冲突后不能偷偷重试。

版本必须与用户实际看到的内容对应

一次 GET 同时返回文档和它的 ETag,浏览器将两者一起保存。用户编辑的是这份文档,保存请求就应带回同一个标签。若中间有人更新了资源,服务器拒绝旧标签对应的写入。If-Match 使用强比较,弱标签不能证明表示完全一致;不匹配通常返回 412。本文接口还要求必须携带前提,缺失时返回 428。HTTP 条件请求规范与 428 状态码定义给出了这些语义。

ETag 对客户端应当是不透明字符串。不要在浏览器里拆出版本号、自增后再发回,也不要去掉双引号。标签可以来自内容摘要,也可以来自持久化版本,但无论采用哪种生成方式,只要返回表示发生变化,就必须使强标签相应变化。多语言、压缩或字段裁剪等表示变体需要另外考虑,不能把一种表示的标签随意套给另一种。

本文只返回一种 JSON 表示,每次成功更新生成一个新的随机标签。重启后标签也不同,因此旧页面不会误以为新进程中的初始数据就是原来的版本。内存数据本身会丢失,这是演示的明确限制,标签随机化并没有把内存变成持久化存储。

前提失败与业务冲突分开处理

412 表示客户端给出的版本条件不成立。409 更适合表达另外的业务状态冲突,例如文档已经归档,当前流程不允许编辑。422 用于本例中字段内容不满足规则。三者都可能需要用户处理,但提示和恢复动作不同:旧版本需要重新比较,业务状态冲突需要解释规则,字段错误则应指向具体输入。

如果客户端完全没带版本条件,直接接受请求会留下绕过保护的入口。因此我们选择 428,并告诉调用者先读取资源。这个约束需要覆盖所有写入路径,不只是网页按钮。管理员脚本、移动端和批量导入若仍然无条件覆盖,浏览器做得再精细也保护不了其他人的修改。

可运行服务:比较与写入之间不能插入等待

创建一个空目录,使用 Node.js 24,保存下面的 server.mjs。程序只使用内置模块,不需要安装依赖,也不需要配置外部账号。它仅监听本机地址,供两个本地标签页演示,不应作为公开生产服务部署。Node HTTP 的请求流、响应与服务器选项可查官方文档。

import http from 'node:http';
import {randomUUID} from 'node:crypto';
import {readFile} from 'node:fs/promises';
import {pathToFileURL} from 'node:url';
const fail=(status,error)=>Object.assign(new Error(error),{status});
async function readJSON(req){
  let size=0,tooLarge=false;const chunks=[];
  for await(const chunk of req){
    size+=chunk.length;
    if(size>16384){tooLarge=true;continue;}
    chunks.push(chunk);
  }
  if(tooLarge)throw fail(413,'body_too_large');
  try{return JSON.parse(Buffer.concat(chunks).toString('utf8'));}
  catch{throw fail(400,'invalid_json');}
}
export function makeServer(){
  let doc={title:'初稿',body:'请编辑我'},tag='"'+randomUUID()+'"';
  return http.createServer({requestTimeout:5000},async(req,res)=>{
    const send=(s,v,h={})=>{res.writeHead(s,{'Content-Type':'application/json; charset=utf-8','Cache-Control':'no-store',...h});res.end(v===undefined?undefined:JSON.stringify(v));};
    try{
      const path=new URL(req.url,'http://localhost').pathname;
      if(path==='/'&&req.method==='GET'){
        res.writeHead(200,{'Content-Type':'text/html; charset=utf-8','Cache-Control':'no-store'});
        return res.end(await readFile(new URL('./index.html',import.meta.url)));
      }
      if(path!=='/api/doc')return send(404,{error:'not_found'});
      if(req.method==='GET')return send(200,doc,{ETag:tag});
      if(req.method!=='PUT')return send(405,{error:'method_not_allowed'},{Allow:'GET, PUT'});
      if(req.headers['content-type']?.split(';')[0].trim()!=='application/json')return send(415,{error:'json_required'});
      const match=req.headers['if-match'];
      if(match===undefined)return send(428,{error:'read_then_send_if_match'});
      // This endpoint intentionally accepts one concrete strong tag only.
      if(!/^"[a-zA-Z0-9-]+"$/.test(match))return send(400,{error:'one_strong_etag_required'});
      const input=await readJSON(req);
      if(!input||Array.isArray(input)||typeof input!=='object'||
        Object.keys(input).sort().join(',')!=='body,title'||
        typeof input.title!=='string'||input.title.length<1||input.title.length>120||
        typeof input.body!=='string'||input.body.length>4000)return send(422,{error:'invalid_fields'});
      // No await between comparing and committing this in-memory state.
      if(match!==tag)return send(412,{error:'stale_version'});
      doc={title:input.title,body:input.body};tag='"'+randomUUID()+'"';
      // PUT JSON is reserialized: retrieve the resulting validator with GET.
      return send(204);
    }catch(e){return send(e.status??500,{error:e.status?e.message:'internal_error'});}
  });
}
if(process.argv[1]&&import.meta.url===pathToFileURL(process.argv[1]).href)
  makeServer().listen(3000,'127.0.0.1',()=>console.log('http://127.0.0.1:3000'));

代码在读取完整请求体之后才检查标签,然后立即替换文档和标签。比较与赋值之间没有 await,因此在这个单进程、单事件循环、没有共享外部状态的演示里,另一请求不会插入这一小段同步操作。第二个拿着旧标签的请求即使已经开始上传,也会在真正提交前看到标签变化并返回 412。

一个常见错误是先比较标签,再等待数据库更新或第三方检查。这会重新打开时间窗口:甲、乙都通过比较,然后各自写入。JavaScript 的事件循环不会替异步跨系统操作提供原子性。代码中写“这里原子”只有在存储模型和执行范围确实支持时才成立,换成多个 Node 进程后,内存比较也立即失效。

请求体最多接收十六 KiB 的有效缓存,超过大小后不再保存后续分块,结束时返回 413;请求接收超时用于限制长时间占用。字段约束又单独限制标题和正文长度。两层限制解决不同问题:网络层避免无限缓存,业务层约束可接受的数据。它们不是完整的抗滥用方案,公开服务还需要网关、并发限制和认证。

本接口只接受一个具体强标签,对弱标签、通配符和标签列表返回 400,这是刻意收窄的端点契约,并非完整实现 If-Match 的所有合法语法。通用 HTTP 服务若要接受这些形式,应使用符合规范的解析和比较,而不是把整个请求头字符串直接等于某个 ETag。这里禁止通配符,是为了坚持“比较读过的具体版本”,避免客户端只证明资源存在便覆盖它。

成功 PUT 返回 204,随后由客户端 GET 最新内容和标签。这样多一次请求,但有一个容易遗漏的理由:服务把收到的 JSON 解析后重新序列化,可能改变字节表示。HTTP 规范限制了这种转换后的成功 PUT 直接返回验证器的条件,所以本例不在成功 PUT 响应里附带新 ETag。读取后的标签才明确对应服务器实际返回的表示。PUT 验证器规则

浏览器保存的是草稿、编辑基准和服务器最新版本

发生冲突时,不能立即用服务器内容填满表单,否则用户刚写的段落也会丢失。最少要区分三份数据:开始编辑时的基准、当前本地草稿、冲突后读取的服务器版本。基准解释“我改了哪里”,服务器版本解释“别人改了哪里”,当前草稿则是必须保留下来的用户劳动。

将下面内容保存为 index.html,与 server.mjs 放在同一目录,再运行 node server.mjs,访问 http://127.0.0.1:3000。

<!doctype html><html lang="zh-CN"><meta charset="utf-8"><title>条件更新</title>
<label>标题 <input id="title"></label><p><textarea id="body" rows="8"></textarea></p>
<button id="save">保存</button><button id="adopt" disabled>保留我的编辑,以刚读取版本重新比较</button>
<p id="status" role="status"></p><pre id="remote"></pre>
<script type="module">
const $=s=>document.querySelector(s),title=$('#title'),body=$('#body');
const save=$('#save'),adopt=$('#adopt'),status=$('#status'),remote=$('#remote');
let base=null,etag=null,latest=null,busy=false;
function lock(v){busy=v;save.disabled=v||!etag;title.disabled=v;body.disabled=v;adopt.disabled=v||!latest;}
async function read(){const r=await fetch('/api/doc',{cache:'no-store'});if(!r.ok)throw Error('读取失败');return {doc:await r.json(),etag:r.headers.get('etag')};}
async function init(){lock(true);try{const x=await read();base=x.doc;etag=x.etag;title.value=base.title;body.value=base.body;status.textContent='已读取';}catch(e){status.textContent=e.message;}finally{lock(false);}}
save.onclick=async()=>{
 if(busy||!etag)return;lock(true);latest=null;remote.textContent='';
 try{
  const r=await fetch('/api/doc',{method:'PUT',headers:{'Content-Type':'application/json','If-Match':etag},body:JSON.stringify({title:title.value,body:body.value})});
  if(r.status===412){latest=await read();remote.textContent='服务器当前内容:\n'+JSON.stringify(latest.doc,null,2)+'\n开始编辑时:\n'+JSON.stringify(base,null,2);status.textContent='有其他修改。你的输入仍保留,请比较后再决定。';return;}
  if(!r.ok)throw Error('保存未成功,状态码 '+r.status);
  const x=await read();base=x.doc;etag=x.etag;title.value=base.title;body.value=base.body;status.textContent='保存成功,已读取服务器当前版本';
 }catch(e){status.textContent=e.message+';结果可能未知,先核对服务器,勿盲目重试。';}
 finally{lock(false);}
};
adopt.onclick=()=>{
 if(busy||!latest)return;
 base=latest.doc;etag=latest.etag;latest=null;remote.textContent='';
 status.textContent='已换用刚读取的基准。请完成手工合并,确认后再保存。';lock(false);
};
init();
</script></html>

在两个标签页里读取初稿。甲修改标题后保存;乙保留自己的正文修改并保存,应该看到冲突提示、服务器内容和初始内容,而输入框仍保留乙的编辑。这一步的价值是把无声覆盖变成可见的协作决定。

示例的“保留我的编辑,以刚读取版本重新比较”按钮只更换编辑基准,不自动发送写入。用户仍需手工合并,再按保存。如果服务器期间又变了,保存仍会再次失败。这种保守流程不够华丽,却明确保留了每一次覆盖的决定权。不能在收到 412 后自动 GET 新标签,附上原来的旧表单再提交,那只是在客户端绕过了并发保护。

保存期间输入框被禁用,避免保存请求发出后用户继续输入、随后成功回读覆盖新输入。更成熟的编辑器可以允许继续写,但需要给每次草稿变更编号,只在响应仍对应当前草稿时更新界面。冲突处理不只是请求头问题,异步响应和本地编辑也存在自己的并发关系。

成功保存与随后 GET 之间,其他用户仍可能更新文档。因此回读内容可能包含后来的修改,页面明确显示“已读取服务器当前版本”,没有声称它一定等于刚才提交的版本。若产品必须展示这次提交的不可变结果,应另外提供版本资源或保存记录,而不是把一个不断变化的当前文档接口当成历史凭据。

自动合并只在条件足够清楚时进行

对于标题和正文两个独立字段,可以比较三份内容:本地字段相对基准没变化,就采用服务器字段;服务器字段相对基准没变化,就保留本地字段;两边改成同样的值,可以直接保留;两边都改且不同,交给用户。这个规则适合简单字段,但不能泛化成所有业务都能自动合并。

例如“开始日期”和“结束日期”看似两个字段,实际存在跨字段约束。甲推迟开始日期,乙提前结束日期,分别看都可能合法,合并后却形成倒置区间。结构化字段的独立性需要业务证明,不能由 JSON 的不同键名推断。长文本还涉及段落移动、重复句子和上下文依赖,直接按行拼接可能制造语义错误。

本文没有实现自动三方合并,而是把三份内容展示出来,让机制边界保持清晰。若要加入自动合并,应将合并器作为单独模块测试,保留原始草稿,并在合并后重新执行业务校验。即使界面判断不存在冲突,最终提交仍需携带最新基准标签,因为别人可能在比较完成后继续修改。

自动化测试要真的制造竞争

将以下内容保存为 server.test.mjs,运行 node --test server.test.mjs。测试启动真实本地 HTTP 服务器,通过 fetch 发送请求,不只是直接调用一个比较函数。每项测试使用独立服务状态和随机端口,结束后关闭服务。

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {makeServer} from './server.mjs';
async function setup(t){const s=makeServer();await new Promise(r=>s.listen(0,'127.0.0.1',r));t.after(()=>new Promise(r=>s.close(r)));return `http://127.0.0.1:${s.address().port}/api/doc`;}
const put=(u,tag,v={title:'新版',body:'内容'})=>fetch(u,{method:'PUT',headers:{'Content-Type':'application/json',...(tag?{'If-Match':tag}:{})},body:JSON.stringify(v)});
test('requires a precondition',async t=>{const u=await setup(t);assert.equal((await put(u)).status,428);});
test('only one concurrent writer with the same tag wins',async t=>{const u=await setup(t),r=await fetch(u),tag=r.headers.get('etag');const a=await Promise.all([put(u,tag,{title:'甲',body:'a'}),put(u,tag,{title:'乙',body:'b'})]);assert.deepEqual(a.map(x=>x.status).sort(),[204,412]);const next=await fetch(u);assert.notEqual(next.headers.get('etag'),tag);assert.ok(['甲','乙'].includes((await next.json()).title));});
test('successful transformed PUT sends no validator',async t=>{const u=await setup(t),tag=(await fetch(u)).headers.get('etag'),r=await put(u,tag);assert.equal(r.status,204);assert.equal(r.headers.get('etag'),null);});
test('stale update preserves current content',async t=>{const u=await setup(t),tag=(await fetch(u)).headers.get('etag');await put(u,tag);assert.equal((await put(u,tag,{title:'覆盖',body:'x'})).status,412);assert.equal((await (await fetch(u)).json()).title,'新版');});
test('invalid fields do not advance tag',async t=>{const u=await setup(t),tag=(await fetch(u)).headers.get('etag');assert.equal((await put(u,tag,{title:'',body:'x'})).status,422);assert.equal((await fetch(u)).headers.get('etag'),tag);});
test('weak and wildcard tags rejected by endpoint contract',async t=>{const u=await setup(t);for(const tag of ['W/"abc"','*'])assert.equal((await put(u,tag)).status,400);});
test('oversized payload rejected',async t=>{const u=await setup(t),tag=(await fetch(u)).headers.get('etag');assert.equal((await put(u,tag,{title:'x',body:'a'.repeat(20000)})).status,413);});

本次在 Node.js 24.22.1 中执行,七项测试全部通过:缺少条件、相同标签的并发写入、成功 PUT 不返回验证器、旧版本不覆盖当前内容、无效字段不推进标签、弱标签与通配符拒绝、超大载荷拒绝。并发测试要求两个请求恰好一个成功、一个返回 412,并检查后续标签变化。这是本地演示的实际结果,不是数据库集成或性能测试。

测试不能只判断返回码。一个错误实现可能先写入再返回 412,因此旧版本测试还要回读数据,确认内容没有被覆盖。类似地,字段校验失败后标签不应变化,否则客户端会因为一次没有生效的请求遭遇额外冲突。版本推进和实际状态变化之间的关系值得单独验收。

浏览器界面没有在本次环境中完成自动化端到端测试;双标签页步骤是待人工验证的交互路径。也没有测量多进程、代理缓存、数据库锁竞争或网络中断下的行为。把已经执行的测试和待验证的系统边界分开,才能知道下一轮工作应集中在哪里,而不是让“测试通过”掩盖所有未覆盖部分。

迁移到数据库时,让存储层完成比较并交换

生产服务通常把版本保存在数据库中,并让更新语句同时带上资源身份、租户和旧版本。例如下面的 SQL 展示核心条件,参数由数据库驱动绑定,不能拼接客户端输入。它是迁移示意,尚未在本次环境中执行。

UPDATE documents
SET title = $1, body = $2, revision = revision + 1
WHERE id = $3 AND tenant_id = $4 AND revision = $5
RETURNING revision, title, body;

更新到一行才表示前提成立;零行可能表示版本冲突,也可能表示资源不存在或无访问权限。应用需要在不泄露其他租户信息的前提下决定对外响应。认证和权限检查必须先建立正确的资源范围,ETag 本身没有授权能力。拿到别人的标签不意味着有权编辑别人的文档。

不能先 SELECT revision,在应用里判断后再无条件 UPDATE。即使两句都写在普通事务里,也可能在读取和更新之间发生竞争。将旧版本条件放入 UPDATE,让数据库决定谁有资格修改;PostgreSQL 的 Read Committed 更新会在并发更新后重新检查条件,具体隔离级别与失败处理应按所选数据库验证。PostgreSQL 事务隔离文档

版本列还应覆盖所有能够影响该表示的写入路径。后台修复脚本如果只改正文不增加版本,旧表单仍可覆盖它。删除后重新创建同一资源时也要避免重复使用旧验证器,可以使用持久化世代标识加版本,或使用可靠的内容摘要。数据恢复、导入和迁移同样属于版本设计的一部分。

网络失败不等于保存失败

最棘手的情况是服务器已经提交,成功响应却没有到达浏览器。此时重试旧 If-Match 很可能得到 412,但这并不能证明第一次没成功。界面应保留草稿并提示核对当前内容,不能只显示“保存失败”然后自动换新标签覆盖。

对于需要精确追踪操作结果的系统,可以增加稳定的操作 ID,并在同一事务中记录操作与结果,让客户端查询这次操作是否完成。操作去重解决重复提交,版本条件解决基于旧内容覆盖,两者职责不同。只靠 ETag,无法完整回答“刚才那次请求到底有没有执行”。

安全边界也不能省略。示例没有登录、权限模型和 CSRF 防护,不接受公网部署。上线时要使用经过认证的会话确定租户,限制跨域访问和请求来源策略,并确保代理不会缓存带有编辑内容的响应。页面用文本方式展示服务器内容,避免把普通文档内容解释成 HTML;这只是输出环节的一项防护,不是整站安全保证。

对于低冲突的后台表单,乐观并发控制通常比编辑时长期占锁更合适:用户可以慢慢写,服务器只在提交时判断前提。若多人持续编辑同一段内容,反复冲突会使体验变差,届时应考虑字段级编辑、协作会话或专门的实时合并算法。先把版本与提交关系做对,再决定是否需要更复杂的协作系统,通常比直接堆叠自动保存更稳妥。

相关文章

评论

登录后即可参与讨论

暂无评论。