如何在Django中生成无竞态条件的唯一Slug？

你的问题核心是应用层的Slug存在性检查和数据库写入不是原子操作，当多个请求同时生成相同Slug并尝试写入时，数据库的unique约束会触发IntegrityError。下面是几种可行的修复方案：

方案1：捕获IntegrityError并重试生成Slug #

直接利用数据库的unique约束作为最终校验，在save方法中捕获错误并重试，这是最直接的原生解决方案：

# models.py
from django.db import IntegrityError
from django.utils.text import slugify
import string
import random
import time
from django.contrib.auth.models import User

class Post(models.Model):
    title = models.CharField(max_length=255)
    slug = models.SlugField(unique=True, blank=True, max_length=255)
    body = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)

    def save(self, *args, **kwargs) -> None:
        if not self.slug:
            base_slug = slugify(self.title)
            self.slug = base_slug
            # 限制重试次数，避免极端场景下的无限循环
            max_retries = 3
            retry_count = 0
            while retry_count < max_retries:
                try:
                    super().save(*args, **kwargs)
                    return
                except IntegrityError:
                    retry_count += 1
                    # 生成带随机后缀的新Slug
                    suffix = '-' + ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
                    self.slug = f"{base_slug}{suffix}"
                    # 短暂休眠降低冲突概率（可选）
                    time.sleep(0.1)
            # 重试多次仍失败，主动抛出错误
            raise IntegrityError("无法生成唯一Slug，请稍后重试")
        else:
            super().save(*args, **kwargs)

这个方案的逻辑是：

• 优先尝试用标题生成的原始Slug保存
• 如果触发IntegrityError（说明Slug已被占用），则生成带随机后缀的新Slug并重试
• 限制重试次数，避免极端情况下的无限循环

方案2：结合事务与原子操作（进阶） #

将Slug检查和写入操作放到同一数据库事务中，确保操作的原子性（需数据库支持事务，如PostgreSQL、MySQL InnoDB）：

# models.py
from django.db import transaction, IntegrityError
from django.utils.text import slugify
import string
import random
import time
from django.contrib.auth.models import User

class Post(models.Model):
    title = models.CharField(max_length=255)
    slug = models.SlugField(unique=True, blank=True, max_length=255)
    body = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)

    def save(self, *args, **kwargs) -> None:
        if not self.slug:
            base_slug = slugify(self.title)
            self.slug = base_slug
            max_retries = 3
            retry_count = 0
            while retry_count < max_retries:
                try:
                    with transaction.atomic():
                        # 检查Slug存在性与保存操作在同一事务内执行
                        if not Post.objects.filter(slug=self.slug).exists():
                            super().save(*args, **kwargs)
                            return
                        # 若Slug已存在，生成新后缀
                        suffix = '-' + ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
                        self.slug = f"{base_slug}{suffix}"
                except IntegrityError:
                    retry_count += 1
                    suffix = '-' + ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
                    self.slug = f"{base_slug}{suffix}"
                    time.sleep(0.1)
            raise IntegrityError("无法生成唯一Slug，请稍后重试")
        else:
            super().save(*args, **kwargs)

这种方式进一步降低了并发冲突的概率，但仍需保留重试逻辑以应对极端场景。

额外优化建议 #

• 将random、string等模块的导入移到文件顶部，避免每次调用save时重复导入
• 可调整随机后缀的长度（如从5位改为6位），进一步降低Slug冲突概率
• 若允许Slug包含时间信息，可在后缀中加入时间戳（如str(int(time.time()))），平衡可读性与唯一性

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