Django中接收含多图的Zip包并关联存储至同一模型实例

Hey there! Let's break down how to handle this Django scenario where you need to unpack an uploaded ZIP file and link all the images inside to the same X instance. Here's a solid, production-ready approach that covers all the key best practices:

First, you'll need a dedicated model to store the individual images, each linked back to its parent X object. This keeps your data normalized and makes it easy to query all images for a given X instance later:

from django.db import models

class X(models.Model):
    zip_file = models.FileField(upload_to='zips/')  # Store ZIPs in a dedicated directory for organization

class XImage(models.Model):
    x_instance = models.ForeignKey(X, on_delete=models.CASCADE, related_name='images')
    image_file = models.ImageField(upload_to='x_images/')  # Separate directory for unpacked images

The related_name='images' lets you do things like my_x_instance.images.all() to fetch all linked images in one go—super handy.

You’ve got two main options for when to trigger the ZIP unpacking, depending on your workflow:

Option A: Automatic Handling with Django Signals #

If you want unpacking to happen automatically whenever an X instance is created (or its ZIP file is updated), use a post_save signal. Just make sure to add checks to avoid redundant processing:

import zipfile
import os
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.conf import settings
from PIL import Image  # Optional, but great for validating image files
from django.db import transaction

@receiver(post_save, sender=X)
@transaction.atomic()  # Wrap in a transaction to avoid partial saves
def unpack_zip_to_images(sender, instance, created, **kwargs):
    # Skip if we're updating an X instance and didn't change the ZIP file
    if not created and not instance.zip_file.changed:
        return

    # Bail out if no ZIP file was uploaded
    if not instance.zip_file:
        return

    # Create a temp directory if it doesn't exist
    temp_dir = os.path.join(settings.MEDIA_ROOT, 'temp')
    os.makedirs(temp_dir, exist_ok=True)

    with zipfile.ZipFile(instance.zip_file.path, 'r') as zip_ref:
        for file_info in zip_ref.infolist():
            # Skip directories and hidden files (like .DS_Store on macOS)
            if file_info.is_dir() or file_info.filename.startswith('.'):
                continue

            # Only process valid image extensions—adjust this list to match your needs
            allowed_extensions = ('.jpg', '.jpeg', '.png', '.gif', '.webp')
            if not file_info.filename.lower().endswith(allowed_extensions):
                continue

            # Extract the file to temp storage
            temp_file_path = zip_ref.extract(file_info, temp_dir)
            
            try:
                # Optional but critical: Validate that the file is actually a valid image
                with Image.open(temp_file_path) as img:
                    img.verify()  # Throws an error if the file isn't a valid image

                # Create the XImage instance—Django will handle moving the file to the XImage's upload path
                XImage.objects.create(
                    x_instance=instance,
                    image_file=os.path.relpath(temp_file_path, settings.MEDIA_ROOT)
                )
            except (IOError, SyntaxError, zipfile.BadZipFile) as e:
                # Skip invalid files and clean up
                os.remove(temp_file_path)
                continue
            finally:
                # Always clean up the temp file, even if something went wrong
                if os.path.exists(temp_file_path):
                    os.remove(temp_file_path)

Don’t forget to register this signal in your app’s apps.py file (or import it somewhere Django will pick it up, like your models.py).

Option B: Manual Handling in a View/Form #

If you need more control over when unpacking happens (e.g., only after user confirmation), handle the logic directly in a view or form. Here’s an example using a CreateView:

from django.views.generic.edit import CreateView
from .models import X, XImage
import zipfile
import os
from django.conf import settings
from django.db import transaction
from PIL import Image

class XCreateView(CreateView):
    model = X
    fields = ['zip_file']

    def form_valid(self, form):
        # Wrap everything in a transaction to ensure atomicity
        with transaction.atomic():
            # Save the parent X instance first
            self.object = form.save()

            if self.object.zip_file:
                temp_dir = os.path.join(settings.MEDIA_ROOT, 'temp')
                os.makedirs(temp_dir, exist_ok=True)

                with zipfile.ZipFile(self.object.zip_file.path, 'r') as zip_ref:
                    for file_info in zip_ref.infolist():
                        if file_info.is_dir() or file_info.filename.startswith('.'):
                            continue
                        if not file_info.filename.lower().endswith(('.jpg', '.jpeg', '.png', '.gif')):
                            continue

                        temp_file_path = zip_ref.extract(file_info, temp_dir)
                        try:
                            with Image.open(temp_file_path) as img:
                                img.verify()
                            XImage.objects.create(
                                x_instance=self.object,
                                image_file=os.path.relpath(temp_file_path, settings.MEDIA_ROOT)
                            )
                        except Exception as e:
                            os.remove(temp_file_path)
                            continue
                        finally:
                            if os.path.exists(temp_file_path):
                                os.remove(temp_file_path)
        return super().form_valid(form)

• Atomic Transactions: Always wrap unpacking and saving logic in transaction.atomic()—this ensures that if something goes wrong mid-process, you don’t end up with an X instance linked to only half its images.
• Validate Everything: Check file extensions AND use PIL to verify image validity—this blocks malicious or corrupted files from cluttering your database/storage.
• Clean Up Temp Files: Never leave extracted files lying around—disk space adds up fast, and it’s a security risk too.
• Handle Large ZIPs: If users might upload big ZIPs, offload the unpacking to an asynchronous task (like Celery). Running heavy processing in a request can timeout and frustrate users.
• Avoid Duplicate Work: The instance.zip_file.changed check in the signal ensures you don’t re-unpack the same ZIP every time you save the X instance.

• Test edge cases: empty ZIPs, ZIPs with non-image files, corrupted ZIPs, and ZIPs with hidden system files (like .DS_Store).
• Verify transaction rollback: Force an error mid-unpack and check that no partial data is saved.
• Check storage: Ensure temp files are deleted and images are stored in the correct directories.

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