垦荒学园 - 以垦荒之心，赴成长之约

切换主题

Django静态文件管理 ​

本章将详细介绍Django的静态文件管理系统，包括静态文件配置、媒体文件处理、文件上传、CDN集成等内容，帮助你有效管理Web应用中的各种静态资源。

静态文件概述 ​

什么是静态文件 ​

静态文件是指不会动态生成的文件，包括：

  • CSS样式表 - 页面样式
  • JavaScript文件 - 客户端脚本
  • 图片文件 - 图标、背景图等
  • 字体文件 - Web字体
  • 其他资源 - PDF、音频、视频等

静态文件 vs 媒体文件 ​

python
# 静态文件 (Static Files)
- 开发者创建的文件
- 版本控制管理
- 部署时收集到统一目录
- 例如：CSS、JS、图标

# 媒体文件 (Media Files)  
- 用户上传的文件
- 动态生成的内容
- 存储在媒体目录
- 例如：用户头像、文章图片

静态文件配置 ​

基本配置 ​

python
# settings.py
import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent

# 静态文件URL前缀
STATIC_URL = '/static/'

# 开发环境静态文件目录
STATICFILES_DIRS = [
    BASE_DIR / 'static',           # 项目级静态文件
    BASE_DIR / 'assets',           # 额外的静态文件目录
]

# 生产环境静态文件收集目录
STATIC_ROOT = BASE_DIR / 'staticfiles'

# 媒体文件配置
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'

# 静态文件查找器
STATICFILES_FINDERS = [
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
]

目录结构 ​

myproject/
├── static/                      # 项目级静态文件
│   ├── css/
│   │   ├── bootstrap.min.css
│   │   ├── style.css
│   │   └── admin-custom.css
│   ├── js/
│   │   ├── jquery.min.js
│   │   ├── bootstrap.min.js
│   │   └── main.js
│   ├── images/
│   │   ├── logo.png
│   │   ├── favicon.ico
│   │   └── backgrounds/
│   └── fonts/
│       ├── roboto.woff2
│       └── icons.ttf
├── media/                       # 媒体文件目录
│   ├── uploads/
│   │   ├── avatars/
│   │   ├── articles/
│   │   └── documents/
│   └── cache/
├── blog/
│   └── static/
│       └── blog/               # 应用级静态文件
│           ├── css/
│           │   └── blog.css
│           ├── js/
│           │   └── blog.js
│           └── images/
│               └── blog-icon.png
└── staticfiles/                # 收集后的静态文件（生产环境）

URL配置 ​

python
# urls.py
from django.conf import settings
from django.conf.urls.static import static
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('blog.urls')),
]

# 开发环境下服务静态文件和媒体文件
if settings.DEBUG:
    urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

在模板中使用静态文件 ​

基本用法 ​

html
<!-- 加载静态文件标签 -->
{% load static %}

<!DOCTYPE html>
<html>
<head>
    <title>我的网站</title>
    
    <!-- CSS文件 -->
    <link rel="stylesheet" href="{% static 'css/bootstrap.min.css' %}">
    <link rel="stylesheet" href="{% static 'css/style.css' %}">
    <link rel="stylesheet" href="{% static 'blog/css/blog.css' %}">
    
    <!-- 网站图标 -->
    <link rel="icon" href="{% static 'images/favicon.ico' %}">
    
    <!-- 字体 -->
    <link rel="preload" href="{% static 'fonts/roboto.woff2' %}" as="font" type="font/woff2" crossorigin>
</head>
<body>
    <!-- 图片 -->
    <img src="{% static 'images/logo.png' %}" alt="网站Logo" class="logo">
    
    <!-- 背景图片 -->
    <div class="hero" style="background-image: url('{% static 'images/backgrounds/hero.jpg' %}');">
        <h1>欢迎来到我的网站</h1>
    </div>
    
    <!-- JavaScript文件 -->
    <script src="{% static 'js/jquery.min.js' %}"></script>
    <script src="{% static 'js/bootstrap.min.js' %}"></script>
    <script src="{% static 'js/main.js' %}"></script>
    <script src="{% static 'blog/js/blog.js' %}"></script>
</body>
</html>

动态静态文件路径 ​

html
<!-- 使用变量构建路径 -->
{% load static %}

{% with 'css/'|add:theme|add:'.css' as theme_css %}
    <link rel="stylesheet" href="{% static theme_css %}">
{% endwith %}

<!-- 循环加载多个文件 -->
{% for css_file in css_files %}
    <link rel="stylesheet" href="{% static css_file %}">
{% endfor %}

<!-- 条件加载 -->
{% if user.is_authenticated %}
    <script src="{% static 'js/user-dashboard.js' %}"></script>
{% endif %}

{% if debug %}
    <script src="{% static 'js/debug.js' %}"></script>
{% endif %}

静态文件版本控制 ​

python
# settings.py
# 启用静态文件版本控制
STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'

# 或使用缓存版本
STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.CachedStaticFilesStorage'
html
<!-- 自动添加版本号 -->
{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">
<!-- 输出: /static/css/style.a1b2c3d4.css -->

媒体文件处理 ​

文件上传模型 ​

python
# models.py
from django.db import models
from django.contrib.auth.models import User
import os

def user_avatar_path(instance, filename):
    """用户头像上传路径"""
    ext = filename.split('.')[-1]
    filename = f"{instance.user.id}_avatar.{ext}"
    return os.path.join('avatars', filename)

def article_image_path(instance, filename):
    """文章图片上传路径"""
    ext = filename.split('.')[-1]
    filename = f"{instance.id}_{filename}"
    return os.path.join('articles', str(instance.created_at.year), filename)

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    avatar = models.ImageField(
        upload_to=user_avatar_path,
        default='avatars/default.png',
        help_text='用户头像'
    )
    bio = models.TextField(max_length=500, blank=True)
    
    def __str__(self):
        return f"{self.user.username}的资料"

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    featured_image = models.ImageField(
        upload_to=article_image_path,
        blank=True,
        null=True,
        help_text='文章特色图片'
    )
    attachments = models.FileField(
        upload_to='articles/attachments/',
        blank=True,
        null=True,
        help_text='文章附件'
    )
    created_at = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.title
    
    def get_image_url(self):
        """获取图片URL"""
        if self.featured_image:
            return self.featured_image.url
        return '/static/images/default-article.png'

class Document(models.Model):
    title = models.CharField(max_length=200)
    file = models.FileField(upload_to='documents/%Y/%m/')
    uploaded_at = models.DateTimeField(auto_now_add=True)
    file_size = models.PositiveIntegerField(blank=True, null=True)
    
    def save(self, *args, **kwargs):
        if self.file:
            self.file_size = self.file.size
        super().save(*args, **kwargs)
    
    def get_file_size_display(self):
        """格式化文件大小"""
        if self.file_size:
            if self.file_size < 1024:
                return f"{self.file_size} B"
            elif self.file_size < 1024 * 1024:
                return f"{self.file_size / 1024:.1f} KB"
            else:
                return f"{self.file_size / (1024 * 1024):.1f} MB"
        return "未知大小"

文件上传表单 ​

python
# forms.py
from django import forms
from .models import UserProfile, Article, Document

class UserProfileForm(forms.ModelForm):
    class Meta:
        model = UserProfile
        fields = ['avatar', 'bio']
        widgets = {
            'avatar': forms.FileInput(attrs={
                'class': 'form-control',
                'accept': 'image/*'
            }),
            'bio': forms.Textarea(attrs={
                'class': 'form-control',
                'rows': 4
            })
        }
    
    def clean_avatar(self):
        avatar = self.cleaned_data.get('avatar')
        if avatar:
            # 检查文件大小（2MB限制）
            if avatar.size > 2 * 1024 * 1024:
                raise forms.ValidationError('头像文件不能超过2MB')
            
            # 检查文件类型
            if not avatar.content_type.startswith('image/'):
                raise forms.ValidationError('请上传图片文件')
        
        return avatar

class ArticleForm(forms.ModelForm):
    class Meta:
        model = Article
        fields = ['title', 'content', 'featured_image', 'attachments']
        widgets = {
            'title': forms.TextInput(attrs={'class': 'form-control'}),
            'content': forms.Textarea(attrs={'class': 'form-control', 'rows': 10}),
            'featured_image': forms.FileInput(attrs={
                'class': 'form-control',
                'accept': 'image/*'
            }),
            'attachments': forms.FileInput(attrs={'class': 'form-control'})
        }

class DocumentUploadForm(forms.ModelForm):
    class Meta:
        model = Document
        fields = ['title', 'file']
        widgets = {
            'title': forms.TextInput(attrs={'class': 'form-control'}),
            'file': forms.FileInput(attrs={'class': 'form-control'})
        }
    
    def clean_file(self):
        file = self.cleaned_data.get('file')
        if file:
            # 文件大小限制（10MB）
            if file.size > 10 * 1024 * 1024:
                raise forms.ValidationError('文件不能超过10MB')
            
            # 允许的文件类型
            allowed_types = [
                'application/pdf',
                'application/msword',
                'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
                'text/plain'
            ]
            
            if file.content_type not in allowed_types:
                raise forms.ValidationError('不支持的文件类型')
        
        return file

文件上传视图 ​

python
# views.py
from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from django.http import JsonResponse, HttpResponse, Http404
from django.core.files.storage import default_storage
from django.conf import settings
import os
import mimetypes

@login_required
def upload_avatar(request):
    """上传用户头像"""
    profile, created = UserProfile.objects.get_or_create(user=request.user)
    
    if request.method == 'POST':
        form = UserProfileForm(request.POST, request.FILES, instance=profile)
        if form.is_valid():
            # 删除旧头像
            if profile.avatar and profile.avatar.name != 'avatars/default.png':
                if default_storage.exists(profile.avatar.name):
                    default_storage.delete(profile.avatar.name)
            
            form.save()
            messages.success(request, '头像上传成功！')
            return redirect('profile')
    else:
        form = UserProfileForm(instance=profile)
    
    return render(request, 'accounts/upload_avatar.html', {'form': form})

@login_required
def create_article(request):
    """创建文章"""
    if request.method == 'POST':
        form = ArticleForm(request.POST, request.FILES)
        if form.is_valid():
            article = form.save(commit=False)
            article.author = request.user
            article.save()
            
            messages.success(request, '文章创建成功！')
            return redirect('blog:article_detail', id=article.id)
    else:
        form = ArticleForm()
    
    return render(request, 'blog/create_article.html', {'form': form})

def ajax_upload_image(request):
    """AJAX图片上传"""
    if request.method == 'POST' and request.FILES.get('image'):
        image = request.FILES['image']
        
        # 验证文件
        if not image.content_type.startswith('image/'):
            return JsonResponse({'error': '请上传图片文件'}, status=400)
        
        if image.size > 5 * 1024 * 1024:  # 5MB限制
            return JsonResponse({'error': '图片不能超过5MB'}, status=400)
        
        # 保存文件
        filename = default_storage.save(f'uploads/images/{image.name}', image)
        file_url = default_storage.url(filename)
        
        return JsonResponse({
            'success': True,
            'url': file_url,
            'filename': filename
        })
    
    return JsonResponse({'error': '无效的请求'}, status=400)

def download_file(request, file_id):
    """文件下载"""
    document = get_object_or_404(Document, id=file_id)
    
    if not document.file:
        raise Http404("文件不存在")
    
    # 检查文件是否存在
    if not default_storage.exists(document.file.name):
        raise Http404("文件不存在")
    
    # 获取文件内容
    file_content = default_storage.open(document.file.name).read()
    
    # 确定MIME类型
    content_type, _ = mimetypes.guess_type(document.file.name)
    if not content_type:
        content_type = 'application/octet-stream'
    
    # 创建响应
    response = HttpResponse(file_content, content_type=content_type)
    response['Content-Disposition'] = f'attachment; filename="{document.title}"'
    response['Content-Length'] = len(file_content)
    
    return response

在模板中显示媒体文件 ​

html
<!-- 显示用户头像 -->
{% if user.profile.avatar %}
    <img src="{{ user.profile.avatar.url }}" alt="用户头像" class="avatar">
{% else %}
    <img src="{% static 'images/default-avatar.png' %}" alt="默认头像" class="avatar">
{% endif %}

<!-- 显示文章图片 -->
{% if article.featured_image %}
    <img src="{{ article.featured_image.url }}" alt="{{ article.title }}" class="img-fluid">
{% endif %}

<!-- 文件上传表单 -->
<form method="post" enctype="multipart/form-data">
    {% csrf_token %}
    <div class="mb-3">
        <label for="{{ form.avatar.id_for_label }}" class="form-label">头像</label>
        {{ form.avatar }}
        {% if form.avatar.errors %}
            <div class="text-danger">{{ form.avatar.errors }}</div>
        {% endif %}
    </div>
    
    <div class="mb-3">
        <label for="{{ form.bio.id_for_label }}" class="form-label">个人简介</label>
        {{ form.bio }}
    </div>
    
    <button type="submit" class="btn btn-primary">保存</button>
</form>

<!-- 图片预览 -->
<script>
document.getElementById('id_avatar').addEventListener('change', function(e) {
    const file = e.target.files[0];
    if (file) {
        const reader = new FileReader();
        reader.onload = function(e) {
            document.getElementById('avatar-preview').src = e.target.result;
        };
        reader.readAsDataURL(file);
    }
});
</script>

高级静态文件处理 ​

自定义存储后端 ​

python
# storage.py
from django.core.files.storage import FileSystemStorage
from django.conf import settings
import os

class CustomFileStorage(FileSystemStorage):
    """自定义文件存储"""
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.base_url = settings.MEDIA_URL
    
    def get_available_name(self, name, max_length=None):
        """生成可用的文件名"""
        # 如果文件已存在，添加时间戳
        if self.exists(name):
            import time
            name, ext = os.path.splitext(name)
            name = f"{name}_{int(time.time())}{ext}"
        
        return super().get_available_name(name, max_length)
    
    def save(self, name, content, max_length=None):
        """保存文件时的额外处理"""
        # 可以在这里添加文件处理逻辑
        # 例如：图片压缩、病毒扫描等
        return super().save(name, content, max_length)

class SecureFileStorage(FileSystemStorage):
    """安全文件存储"""
    
    def url(self, name):
        """通过视图提供文件访问"""
        return f"/secure-media/{name}"
    
    def get_accessed_time(self, name):
        """获取文件访问时间"""
        return super().get_accessed_time(name)

图片处理 ​

python
# utils.py
from PIL import Image
from django.core.files.base import ContentFile
from django.core.files.storage import default_storage
import io

def resize_image(image_file, max_width=800, max_height=600, quality=85):
    """调整图片大小"""
    # 打开图片
    image = Image.open(image_file)
    
    # 转换为RGB（如果是RGBA）
    if image.mode in ('RGBA', 'LA', 'P'):
        image = image.convert('RGB')
    
    # 计算新尺寸
    width, height = image.size
    if width > max_width or height > max_height:
        # 保持宽高比
        ratio = min(max_width / width, max_height / height)
        new_width = int(width * ratio)
        new_height = int(height * ratio)
        image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
    
    # 保存到内存
    output = io.BytesIO()
    image.save(output, format='JPEG', quality=quality, optimize=True)
    output.seek(0)
    
    return ContentFile(output.read())

def create_thumbnail(image_file, size=(150, 150)):
    """创建缩略图"""
    image = Image.open(image_file)
    
    # 转换为RGB
    if image.mode in ('RGBA', 'LA', 'P'):
        image = image.convert('RGB')
    
    # 创建缩略图
    image.thumbnail(size, Image.Resampling.LANCZOS)
    
    # 保存到内存
    output = io.BytesIO()
    image.save(output, format='JPEG', quality=90)
    output.seek(0)
    
    return ContentFile(output.read())

# 在模型中使用
class Article(models.Model):
    title = models.CharField(max_length=200)
    featured_image = models.ImageField(upload_to='articles/')
    thumbnail = models.ImageField(upload_to='articles/thumbnails/', blank=True)
    
    def save(self, *args, **kwargs):
        # 处理图片
        if self.featured_image:
            # 调整原图大小
            resized_image = resize_image(self.featured_image)
            self.featured_image.save(
                self.featured_image.name,
                resized_image,
                save=False
            )
            
            # 创建缩略图
            thumbnail = create_thumbnail(self.featured_image)
            thumbnail_name = f"thumb_{self.featured_image.name}"
            self.thumbnail.save(thumbnail_name, thumbnail, save=False)
        
        super().save(*args, **kwargs)

CDN集成 ​

python
# settings.py
# 使用AWS S3作为静态文件存储
if not DEBUG:
    # AWS S3配置
    AWS_ACCESS_KEY_ID = 'your-access-key'
    AWS_SECRET_ACCESS_KEY = 'your-secret-key'
    AWS_STORAGE_BUCKET_NAME = 'your-bucket-name'
    AWS_S3_REGION_NAME = 'us-east-1'
    AWS_S3_CUSTOM_DOMAIN = f'{AWS_STORAGE_BUCKET_NAME}.s3.amazonaws.com'
    
    # 静态文件存储
    STATICFILES_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
    STATIC_URL = f'https://{AWS_S3_CUSTOM_DOMAIN}/static/'
    
    # 媒体文件存储
    DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
    MEDIA_URL = f'https://{AWS_S3_CUSTOM_DOMAIN}/media/'

# 使用CloudFlare CDN
STATIC_URL = 'https://cdn.yourdomain.com/static/'
MEDIA_URL = 'https://cdn.yourdomain.com/media/'

静态文件压缩 ​

python
# settings.py
# 安装: pip install django-compressor

INSTALLED_APPS = [
    # ...
    'compressor',
]

# 压缩器配置
COMPRESS_ENABLED = not DEBUG
COMPRESS_CSS_FILTERS = [
    'compressor.filters.css_default.CssAbsoluteFilter',
    'compressor.filters.cssmin.rCSSMinFilter',
]
COMPRESS_JS_FILTERS = [
    'compressor.filters.jsmin.JSMinFilter',
]

# 压缩文件存储
COMPRESS_STORAGE = 'compressor.storage.CompressorFileStorage'
COMPRESS_URL = STATIC_URL
COMPRESS_ROOT = STATIC_ROOT

# 离线压缩
COMPRESS_OFFLINE = True
html
<!-- 在模板中使用压缩 -->
{% load compress %}

{% compress css %}
    <link rel="stylesheet" href="{% static 'css/bootstrap.css' %}">
    <link rel="stylesheet" href="{% static 'css/style.css' %}">
    <link rel="stylesheet" href="{% static 'blog/css/blog.css' %}">
{% endcompress %}

{% compress js %}
    <script src="{% static 'js/jquery.js' %}"></script>
    <script src="{% static 'js/bootstrap.js' %}"></script>
    <script src="{% static 'js/main.js' %}"></script>
{% endcompress %}

性能优化 ​

静态文件缓存 ​

python
# settings.py
# 静态文件缓存头
STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'

# Nginx配置示例
"""
location /static/ {
    alias /path/to/staticfiles/;
    expires 1y;
    add_header Cache-Control "public, immutable";
    add_header Vary Accept-Encoding;
    gzip_static on;
}

location /media/ {
    alias /path/to/media/;
    expires 30d;
    add_header Cache-Control "public";
}
"""

图片优化 ​

python
# utils.py
from PIL import Image, ImageOptim
import os

def optimize_image(image_path, quality=85):
    """优化图片"""
    with Image.open(image_path) as img:
        # 转换为RGB
        if img.mode in ('RGBA', 'LA', 'P'):
            img = img.convert('RGB')
        
        # 优化并保存
        img.save(image_path, 'JPEG', quality=quality, optimize=True)
        
        # 使用外部工具进一步优化
        if os.system(f'jpegoptim --max={quality} {image_path}') == 0:
            print(f"图片已优化: {image_path}")

def generate_webp(image_path):
    """生成WebP格式图片"""
    webp_path = os.path.splitext(image_path)[0] + '.webp'
    
    with Image.open(image_path) as img:
        img.save(webp_path, 'WebP', quality=85, optimize=True)
    
    return webp_path

响应式图片 ​

html
<!-- 响应式图片 -->
<picture>
    <source media="(min-width: 800px)" srcset="{{ article.featured_image.url }}">
    <source media="(min-width: 400px)" srcset="{{ article.thumbnail.url }}">
    <img src="{{ article.thumbnail.url }}" alt="{{ article.title }}" class="img-fluid">
</picture>

<!-- 使用srcset -->
<img src="{{ article.thumbnail.url }}" 
     srcset="{{ article.thumbnail.url }} 300w, {{ article.featured_image.url }} 800w"
     sizes="(max-width: 600px) 300px, 800px"
     alt="{{ article.title }}" 
     class="img-fluid">

安全考虑 ​

文件上传安全 ​

python
# settings.py
# 文件上传限制
FILE_UPLOAD_MAX_MEMORY_SIZE = 2621440  # 2.5MB
DATA_UPLOAD_MAX_MEMORY_SIZE = 2621440  # 2.5MB
DATA_UPLOAD_MAX_NUMBER_FIELDS = 1000

# 允许的文件类型
ALLOWED_IMAGE_TYPES = ['image/jpeg', 'image/png', 'image/gif', 'image/webp']
ALLOWED_DOCUMENT_TYPES = [
    'application/pdf',
    'application/msword',
    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
    'text/plain'
]

# utils.py
import magic
from django.core.exceptions import ValidationError

def validate_file_type(file):
    """验证文件类型"""
    # 使用python-magic检查真实文件类型
    file_type = magic.from_buffer(file.read(1024), mime=True)
    file.seek(0)  # 重置文件指针
    
    allowed_types = [
        'image/jpeg', 'image/png', 'image/gif',
        'application/pdf', 'text/plain'
    ]
    
    if file_type not in allowed_types:
        raise ValidationError(f'不允许的文件类型: {file_type}')

def scan_file_for_malware(file_path):
    """扫描文件病毒（示例）"""
    # 这里可以集成ClamAV或其他杀毒软件
    # 返回True表示文件安全
    return True

安全的文件访问 ​

python
# views.py
from django.http import HttpResponse, Http404
from django.contrib.auth.decorators import login_required
from django.core.files.storage import default_storage
import os

@login_required
def secure_file_view(request, file_path):
    """安全的文件访问"""
    # 检查用户权限
    if not request.user.has_perm('app.view_file'):
        raise Http404("没有访问权限")
    
    # 防止路径遍历攻击
    file_path = os.path.normpath(file_path)
    if '..' in file_path or file_path.startswith('/'):
        raise Http404("无效的文件路径")
    
    # 检查文件是否存在
    full_path = os.path.join('secure', file_path)
    if not default_storage.exists(full_path):
        raise Http404("文件不存在")
    
    # 返回文件内容
    try:
        with default_storage.open(full_path, 'rb') as f:
            response = HttpResponse(f.read())
            response['Content-Type'] = 'application/octet-stream'
            response['Content-Disposition'] = f'attachment; filename="{os.path.basename(file_path)}"'
            return response
    except Exception:
        raise Http404("文件读取失败")

本章小结 ​

本章详细介绍了Django的静态文件管理系统：

关键要点：

  • 静态文件配置：STATIC_URL、STATICFILES_DIRS、STATIC_ROOT等设置
  • 媒体文件处理：用户上传文件的存储和管理
  • 模板中的使用：{% static %}标签和媒体文件URL
  • 文件上传：表单处理、验证和安全考虑
  • 性能优化：压缩、缓存、CDN集成

重要概念：

  • 静态文件 vs 媒体文件：开发者文件 vs 用户上传文件
  • 文件存储后端：本地存储、云存储等
  • 文件安全：类型验证、权限控制、病毒扫描
  • 性能优化：压缩、缓存、响应式图片

最佳实践：

  • 合理组织静态文件目录结构
  • 使用版本控制管理静态文件变更
  • 实施严格的文件上传验证
  • 配置适当的缓存策略
  • 考虑使用CDN提高访问速度
  • 优化图片大小和格式

在下一章中，我们将学习Django的管理后台系统，了解如何快速构建功能强大的管理界面。

延伸阅读 ​

本站内容仅供学习和研究使用。

Copyright 2025 垦荒教程 kenhuang.com All Rights Reserved. 备案号：粤ICP备17084064号-3 | 免责声明