Django表单重复提交问题：如何避免多次点击保存生成重复条目？

这确实是Web开发里超常见的头疼问题！当然有成熟的机制能搞定这种重复提交，我来给你拆解几个实用方案，再聊聊你提到的条目哈希方案到底可行不可行。

1. 前端+后端的双重防护（最常用） #

前端：点击后立即禁用按钮 #

这是最简单的防误触手段，用户点击保存后直接把按钮灰掉，避免短时间内重复点击。用几行JS就能实现：

const saveBtn = document.getElementById('save-btn');
saveBtn.addEventListener('click', function() {
    this.disabled = true;
    this.textContent = '保存中...';
    this.form.submit();
});

不过这个只能防前端手滑，要是用户刷新页面或者用工具手动发POST请求，还是得靠后端兜底。

后端：一次性令牌（Nonce）验证 #

给每个表单请求生成一个唯一的随机令牌，存在用户session里，提交时校验令牌——验证通过就删除session里的令牌，重复提交时因为令牌不存在直接拒绝。

举个具体实现例子：
首先给表单加个隐藏的nonce字段：

import secrets
from django import forms
from .models import MyModel

class MyForm(forms.ModelForm):
    nonce = forms.CharField(widget=forms.HiddenInput(), required=True)

    class Meta:
        model = MyModel
        fields = ['title', 'content']

    def __init__(self, *args, **kwargs):
        self.request = kwargs.pop('request')
        super().__init__(*args, **kwargs)
        # 生成随机令牌并存入session
        nonce = secrets.token_hex(16)
        self.request.session['form_nonce'] = nonce
        self.fields['nonce'].initial = nonce

然后在视图里做校验：

from django.contrib import messages
from django.shortcuts import redirect, render
from .forms import MyForm

def create_entry(request):
    if request.method == 'POST':
        form = MyForm(request.POST, request=request)
        if form.is_valid():
            # 校验令牌是否匹配
            submitted_nonce = form.cleaned_data['nonce']
            session_nonce = request.session.get('form_nonce')
            if submitted_nonce != session_nonce:
                messages.error(request, '请勿重复提交表单')
                return redirect('create_entry')
            # 校验通过后删除令牌，避免重复使用
            del request.session['form_nonce']
            # 保存数据
            form.save()
            return redirect('entry_list')
    else:
        form = MyForm(request=request)
    return render(request, 'create_entry.html', {'form': form})

2. 数据库层面的唯一约束 #

如果你的模型有天然的唯一标识（比如用户提交的订单号、邮箱，或者几个字段组合起来唯一），直接在模型里加唯一约束，让数据库帮你兜底。

比如给单个字段加唯一约束：

from django.db import models

class MyModel(models.Model):
    title = models.CharField(max_length=255, unique=True)
    content = models.TextField()

或者多个字段组合唯一：

class MyModel(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    title = models.CharField(max_length=255)
    
    class Meta:
        constraints = [
            models.UniqueConstraint(fields=['user', 'title'], name='unique_user_title')
        ]

然后在视图里捕获数据库抛出的IntegrityError，给用户提示：

from django.db import IntegrityError

def create_entry(request):
    if request.method == 'POST':
        form = MyForm(request.POST)
        if form.is_valid():
            try:
                form.save()
                return redirect('entry_list')
            except IntegrityError:
                messages.error(request, '这个条目已经存在啦，请勿重复提交')
                return redirect('create_entry')
    # ... 其余代码

3. Post/Redirect/Get（PRG）模式 #

这是Web开发的经典最佳实践——表单提交成功后，不要直接渲染页面，而是重定向到一个GET请求的页面（比如成功页或者列表页）。这样用户即使刷新页面，也只会重新加载GET请求，不会重复发送POST数据。

在Django里实现超简单，就是把form.save()后的render换成redirect：

def create_entry(request):
    if request.method == 'POST':
        form = MyForm(request.POST)
        if form.is_valid():
            form.save()
            # 重定向到列表页，而不是直接渲染成功页面
            return redirect('entry_list')
    # ... 其余代码

关于条目哈希方案的可行性 #

你提到的条目哈希方案完全可行，适合那些没有天然唯一字段的场景——核心思路是把用户提交的所有内容生成一个唯一哈希值，存储到数据库里并设为唯一，提交时先检查哈希是否存在，存在就拒绝。

具体实现步骤：

1. 给模型加一个存储哈希的字段：

import hashlib
from django.db import models

class MyModel(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    # 存储内容哈希，设为唯一且不可编辑
    entry_hash = models.CharField(max_length=64, unique=True, editable=False)

    def save(self, *args, **kwargs):
        # 把需要判断重复的字段拼接成字符串，生成SHA256哈希
        content_str = f"{self.title}{self.content}"
        self.entry_hash = hashlib.sha256(content_str.encode('utf-8')).hexdigest()
        super().save(*args, **kwargs)

2. 视图里可以提前校验哈希，或者直接捕获IntegrityError：

def create_entry(request):
    if request.method == 'POST':
        form = MyForm(request.POST)
        if form.is_valid():
            # 提前计算哈希，检查是否已存在
            title = form.cleaned_data['title']
            content = form.cleaned_data['content']
            content_str = f"{title}{content}"
            entry_hash = hashlib.sha256(content_str.encode('utf-8')).hexdigest()
            if MyModel.objects.filter(entry_hash=entry_hash).exists():
                messages.error(request, '该条目已存在，请勿重复提交')
                return redirect('create_entry')
            form.save()
            return redirect('entry_list')
    # ... 其余代码

不过用哈希方案要注意几个点：

• 要确保拼接的字段能完整代表条目的唯一性，不然可能出现误判（比如两个不同内容但哈希碰撞的情况，概率极低但理论存在）。
• 如果允许用户编辑条目，编辑后的内容会生成新的哈希，不会影响原条目。
• 性能上不用担心，因为哈希字段是唯一索引，查询速度很快。

总结一下：优先用PRG模式 + 前端按钮禁用的组合，再加上后端的nonce验证或者数据库唯一约束，基本能覆盖99%的场景。条目哈希方案是很好的补充，适合那些没有天然唯一标识的表单。

内容的提问来源于stack exchange，提问作者kingbrain