1. Django架构全景解析：从MTV模式到高并发实践

作为Python生态中最负盛名的全栈式Web框架，Django的架构设计体现了"电池全包含"（Batteries included）的哲学理念。我在多个百万级PV的生产环境中验证了其架构的可靠性——从简单的博客系统到复杂的电商平台，Django的MTV模式、ORM层设计和中间件机制构成了其稳固的基石。让我们深入拆解这套架构的运作机理。

1.1 MTV模式：Django的核心设计范式

与传统的MVC架构不同，Django采用MTV（Model-Template-View）模式组织代码结构。这种设计并非简单的概念替换，而是针对Web开发的深度优化：

• Model层：通过继承django.db.models.Model类，开发者可以用Python语法定义数据库schema。例如定义博客文章模型：

from django.db import models class Article(models.Model): title = models.CharField(max_length=200) content = models.TextField() pub_date = models.DateTimeField(auto_now_add=True) def __str__(self): return self.title

Django ORM会自动将其转换为SQL建表语句，同时提供强大的QuerySet API。我曾通过重写模型的save()方法，在数据保存时自动生成SEO友好的URL slug，这种灵活性正是MTV的优势体现。

• Template层：Django模板语言（DTL）刻意保持简单，禁止直接执行Python代码以确保安全。但通过自定义标签和过滤器可以扩展功能。比如实现Markdown渲染过滤器：

from django import template import markdown register = template.Library() @register.filter def markdownify(text): return markdown.markdown(text)

• View层：作为业务逻辑的枢纽，视图函数接收HttpRequest对象并返回HttpResponse。基于类的视图（CBV）通过Mixin机制实现代码复用。例如使用LoginRequiredMixin快速实现访问控制：

from django.views.generic import DetailView from django.contrib.auth.mixins import LoginRequiredMixin class PrivateArticleView(LoginRequiredMixin, DetailView): model = Article template_name = 'articles/private_detail.html'

关键经验：在大型项目中，我习惯将views.py拆分为views/目录，按功能模块组织视图类，配合自定义的ViewMixins实现横切关注点（如缓存控制、权限校验）。

1.2 核心组件协作机制

1.2.1 请求处理管道（Request-Response Cycle）

Django的请求生命周期是一套精密的处理流水线：

1. URL路由解析：urls.py中的path()函数将URL模式映射到视图。我常用include()实现路由模块化：

# 主urls.py from django.urls import include, path urlpatterns = [ path('api/v1/', include('api.urls')), path('blog/', include('blog.urls')), ] # blog/urls.py from django.urls import path from . import views urlpatterns = [ path('<slug:slug>/', views.ArticleDetailView.as_view()), ]

2. 中间件处理：Django的中间件是洋葱式分层处理器。自定义中间件需实现特定钩子方法。例如实现请求耗时统计：

class TimingMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): start_time = time.time() response = self.get_response(request) duration = time.time() - start_time response["X-Response-Time"] = str(duration) return response

3. 视图处理阶段：这里可以组合使用Django内置的通用视图或自定义业务逻辑。我经常在get_context_data()中补充模板上下文：

class ArticleListView(ListView): def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context['featured_articles'] = Article.objects.filter(is_featured=True)[:3] return context

1.2.2 ORM架构解析

Django ORM是典型的"数据映射器"模式实现，其核心架构包含：

• Manager：模型类的默认objects属性就是Manager实例，可通过自定义Manager实现通用查询逻辑：

class PublishedManager(models.Manager): def get_queryset(self): return super().get_queryset().filter(status='published') class Article(models.Model): objects = PublishedManager()

• QuerySet：惰性求值机制是其精髓。以下查询直到print时才会真正执行SQL：

qs = Article.objects.filter(title__contains='Django').order_by('-pub_date')[:5] print(qs) # 此时触发SQL执行

• 迁移系统：makemigrations生成迁移文件，migrate应用变更。我曾通过自定义迁移处理数据转换：

from django.db import migrations def forwards_func(apps, schema_editor): Article = apps.get_model('blog', 'Article') for article in Article.objects.filter(tags__isnull=True): article.tags = "default" article.save() class Migration(migrations.Migration): dependencies = [('blog', '0001_initial')] operations = [migrations.RunPython(forwards_func)]

1.3 高并发场景下的架构调优

1.3.1 缓存策略实施

Django提供多级缓存支持：

• 全页缓存：适用于静态化内容

from django.views.decorators.cache import cache_page @cache_page(60 * 15) def article_detail(request, slug): ...

• 模板片段缓存：细粒度控制

{% load cache %} {% cache 500 sidebar %} <!-- 侧边栏内容 --> {% endcache %}

• 低级API缓存：灵活控制

from django.core.cache import cache def get_popular_articles(): key = 'popular_articles' result = cache.get(key) if not result: result = list(Article.objects.order_by('-views')[:5]) cache.set(key, result, timeout=300) return result

1.3.2 异步任务处理

对于耗时操作，我通常组合使用Celery+Django：

1. 配置Celery：

# proj/celery.py from celery import Celery app = Celery('proj') app.config_from_object('django.conf:settings', namespace='CELERY') app.autodiscover_tasks()

2. 定义异步任务：

# tasks.py from celery import shared_task @shared_task def process_article_metrics(article_id): article = Article.objects.get(id=article_id) # 复杂计算逻辑...

3. 视图调用：

def article_view(request, slug): article = get_object_or_404(Article, slug=slug) process_article_metrics.delay(article.id) return render(...)

1.3.3 数据库优化技巧

• select_related：外键预取

# 优化前：N+1查询问题 articles = Article.objects.all() for a in articles: print(a.author.name) # 每次循环都查询author # 优化后 articles = Article.objects.select_related('author')

• prefetch_related：多对多预取

articles = Article.objects.prefetch_related('tags')

• only/defer：字段延迟加载

# 只获取必要字段 articles = Article.objects.only('title', 'pub_date')

1.4 常见架构误区与解决方案

1.4.1 胖模型瘦视图陷阱

新手常犯的错误是将所有逻辑塞进模型。我的实践方案是：

1. 创建services.py处理复杂业务逻辑

# blog/services.py def publish_article(article_id): article = Article.objects.get(id=article_id) if not article.is_publishable(): raise ValueError("Article not ready") article.status = 'published' article.pub_date = timezone.now() article.save() notify_subscribers(article)

2. 视图中调用服务层

from .services import publish_article def publish_view(request, article_id): publish_article(article_id) return redirect('article_detail', article_id)

1.4.2 信号(Signals)滥用问题

信号虽方便但会降低代码可读性。建议：

• 限制使用场景（如审计日志、通用通知）
• 显式注册信号处理器

# apps.py from django.apps import AppConfig class BlogConfig(AppConfig): def ready(self): from . import signals # 显式导入

1.4.3 静态文件处理最佳实践

生产环境应避免使用Django内置静态服务器：

1. 配置白名单存储路径

STATICFILES_DIRS = [ BASE_DIR / "static", ] STATIC_URL = '/static/' STATIC_ROOT = BASE_DIR / "staticfiles"

2. 使用collectstatic集中文件

python manage.py collectstatic

3. Nginx配置示例：

location /static/ { alias /path/to/staticfiles/; expires 30d; access_log off; }

1.5 现代Django架构演进

1.5.1 Django REST Framework集成

构建API时，DRF是自然选择：

1. 序列化器定义

from rest_framework import serializers class ArticleSerializer(serializers.ModelSerializer): class Meta: model = Article fields = ['id', 'title', 'content', 'pub_date']

2. 视图集配置

from rest_framework import viewsets class ArticleViewSet(viewsets.ModelViewSet): queryset = Article.objects.all() serializer_class = ArticleSerializer permission_classes = [IsAuthenticatedOrReadOnly]

3. 路由注册

from rest_framework.routers import DefaultRouter router = DefaultRouter() router.register(r'articles', ArticleViewSet) urlpatterns = router.urls

1.5.2 异步视图支持

Django 3.1+原生支持异步：

async def article_counter(request, slug): article = await sync_to_async(Article.objects.get)(slug=slug) article.views += 1 await sync_to_async(article.save)() return JsonResponse({'views': article.views})

1.5.3 微服务架构适配

虽然Django是单体友好型框架，但可通过以下方式适应微服务：

1. 服务拆分策略：

   • 按业务域划分（用户服务、内容服务）
   • 共享数据库或API通信

2. 事件驱动架构示例：

# events.py from django_eventstream import send_event def article_published_event(article): send_event( 'article_updates', 'published', { 'id': article.id, 'title': article.title } )

3. API网关集成：

# api_gateway/views.py import requests from django.http import JsonResponse def user_articles(request, user_id): auth_response = requests.get( f"http://auth-service/validate/{request.META['HTTP_AUTHORIZATION']}" ) if not auth_response.ok: return JsonResponse({'error': 'Unauthorized'}, status=401) articles_response = requests.get( f"http://content-service/user/{user_id}/articles" ) return JsonResponse(articles_response.json())

2. Django架构面试深度问答

2.1 高频技术考察点解析

2.1.1 MTV与MVC的本质区别

虽然MTV与MVC在概念上相似，但Django的实现有显著差异：

• 控制器(Controller)的替代：Django的URL配置系统承担了部分控制器职责，而视图层更像是MVC中的控制器
• 模板系统的限制：Django模板系统刻意限制逻辑表达，强制业务逻辑留在视图层
• ORM的深度整合：Django的Model层不仅处理数据访问，还包含业务规则验证

技术对比表：

2.1.2 QuerySet执行机制

QuerySet的惰性求值特性常被误解，其执行过程分为：

1. 构建阶段：链式调用filter()、exclude()等方法只构建查询条件
2. 求值触发点：
   • 迭代（for循环）
   • 切片（[:5]）
   • 序列化（list(qs)）
   • 布尔测试（bool(qs)）
   • repr()调用（打印调试）

缓存行为示例：

qs = Article.objects.all() print(qs) # 第一次求值 print(qs) # 使用缓存结果 new_qs = qs.filter(title__contains='Django') print(new_qs) # 重新执行SQL

2.1.3 中间件执行顺序

中间件的处理顺序对理解请求生命周期至关重要：

1. 请求阶段：从上到下执行process_request()
2. 视图阶段：如果所有process_request()都返回None，则执行视图
3. 响应阶段：从下到上执行process_response()
4. 异常处理：从下到上执行process_exception()

配置示例：

MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', # 最先处理请求 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', # 最后处理请求 # 响应阶段按相反顺序执行 ]

2.2 性能优化实战方案

2.2.1 数据库查询优化

• annotate() vs extra()：优先使用annotate进行标注

from django.db.models import Count # 好：使用ORM标准方法 Article.objects.annotate(comment_count=Count('comments')) # 避免：使用原生SQL片段 Article.objects.extra(select={'comment_count': 'SELECT COUNT(*) FROM comments WHERE comments.article_id=articles.id'})

• 批量操作：减少查询次数

# 差：N次查询+保存 for article in Article.objects.filter(status='draft'): article.status = 'published' article.save() # 优：1次查询+1次更新 Article.objects.filter(status='draft').update(status='published')

2.2.2 缓存策略进阶

• 版本化缓存：处理缓存失效

from django.core.cache import caches def get_article_version_key(article_id): return f'article_{article_id}_v{Article.objects.get(id=article_id).version}' def get_article_with_cache(article_id): cache = caches['default'] key = get_article_version_key(article_id) content = cache.get(key) if not content: article = Article.objects.get(id=article_id) content = render_article(article) cache.set(key, content, timeout=3600) return content

• 分层缓存：组合使用多种后端

CACHES = { 'local': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'unique-snowflake', }, 'redis': { 'BACKEND': 'django_redis.cache.RedisCache', 'LOCATION': 'redis://127.0.0.1:6379/1', 'OPTIONS': { 'CLIENT_CLASS': 'django_redis.client.DefaultClient', } }, }

2.2.3 静态资源优化

• ManifestStaticFilesStorage：添加文件哈希

STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'

• CDN集成：

STATIC_URL = 'https://cdn.example.com/static/'

• 前端资源处理：

# webpack.config.js output: { filename: '[name].[contenthash].js', path: path.resolve(__dirname, '../static/dist'), }

2.3 安全架构设计要点

2.3.1 CSRF防护机制

Django的CSRF中间件提供自动防护：

• 表单中必须包含{% csrf_token %}
• AJAX请求需要设置X-CSRFToken头
• 豁免特定视图使用@csrf_exempt

自定义配置示例：

CSRF_COOKIE_HTTPONLY = True # 防止XSS读取 CSRF_COOKIE_SAMESITE = 'Strict' # 严格同站策略 CSRF_TRUSTED_ORIGINS = ['https://*.example.com'] # 可信域名

2.3.2 XSS防御策略

• 模板自动转义：默认开启，使用|safe显式关闭
• 内容安全策略(CSP)：

MIDDLEWARE = ['csp.middleware.CSPMiddleware'] CSP_DEFAULT_SRC = ["'self'"] CSP_SCRIPT_SRC = ["'self'", "https://cdn.example.com"]

2.3.3 SQL注入防护

Django ORM已提供基本防护，但需注意：

• 避免使用extra()和raw()执行原生SQL
• 必须参数化用户输入：

# 危险 Article.objects.raw(f'SELECT * FROM blog_article WHERE title="{user_input}"') # 安全 Article.objects.raw('SELECT * FROM blog_article WHERE title=%s', [user_input])

2.4 测试驱动开发实践

2.4.1 测试金字塔实施

• 单元测试：测试独立组件

from django.test import TestCase class ArticleModelTest(TestCase): def test_string_representation(self): article = Article(title="Test Article") self.assertEqual(str(article), "Test Article")

• 集成测试：验证组件协作

class ArticleViewTest(TestCase): def test_view_uses_correct_template(self): response = self.client.get(reverse('article_list')) self.assertTemplateUsed(response, 'blog/article_list.html')

• E2E测试：使用Selenium测试完整流程

from selenium.webdriver.common.by import By class ArticleLiveTest(LiveServerTestCase): def test_article_creation(self): self.selenium.get(f"{self.live_server_url}/admin/") # 模拟用户操作流程...

2.4.2 工厂模式创建测试数据

使用factory_boy替代固定fixtures：

import factory class ArticleFactory(factory.django.DjangoModelFactory): class Meta: model = Article title = factory.Sequence(lambda n: f'Article {n}') content = factory.Faker('paragraph') # 测试中使用 article = ArticleFactory()

2.4.3 性能测试集成

使用django-silk分析请求性能：

SILKY_PYTHON_PROFILER = True SILKY_AUTHENTICATION = True SILKY_AUTHORISATION = True

3. Django架构演进与生态整合

3.1 前后端分离架构实践

3.1.1 Django作为API后端

现代前端框架整合方案：

1. DRF序列化优化：

class ArticleSerializer(serializers.ModelSerializer): author = serializers.SerializerMethodField() def get_author(self, obj): return { 'id': obj.author.id, 'name': obj.author.get_full_name() } class Meta: model = Article fields = ['id', 'title', 'content', 'pub_date', 'author']

2. JWT认证集成：

REST_FRAMEWORK = { 'DEFAULT_AUTHENTICATION_CLASSES': [ 'rest_framework_simplejwt.authentication.JWTAuthentication', ], }

3. GraphQL方案：

# schema.py import graphene from graphene_django import DjangoObjectType class ArticleType(DjangoObjectType): class Meta: model = Article class Query(graphene.ObjectType): articles = graphene.List(ArticleType) def resolve_articles(self, info): return Article.objects.all()

3.1.2 静态资源同源部署

配置Django服务前端静态资源：

1. 修改模板基址：

<!-- base.html --> <!DOCTYPE html> <html> <head> <base href="/"> </head> <body> <div id="app"></div> {% block scripts %} <script src="{% static 'dist/main.js' %}"></script> {% endblock %} </body> </html>

2. URL配置兜底：

from django.views.generic import TemplateView urlpatterns = [ # ...API路由 re_path(r'^(?!api|admin|static).*$', TemplateView.as_view(template_name='index.html')), ]

3.2 微服务架构适配方案

3.2.1 服务拆分策略

Django应用微服务化路径：

1. 垂直拆分：按业务功能划分

   • 用户服务（Django + django-allauth）
   • 内容服务（Django + Wagtail CMS）
   • 支付服务（Django + django-payments）

2. 共享库管理：

# shared_libs/db_utils.py from django.conf import settings import psycopg2 def get_conn(): return psycopg2.connect( dbname=settings.DATABASES['default']['NAME'], user=settings.DATABASES['default']['USER'], password=settings.DATABASES['default']['PASSWORD'], host=settings.DATABASES['default']['HOST'] )

3.2.2 服务通信机制

• 同步RPC：使用requests库

import requests from django.http import JsonResponse def user_profile(request): auth_response = requests.get( 'http://auth-service/api/user', headers={'Authorization': request.META.get('HTTP_AUTHORIZATION')} ) if auth_response.status_code != 200: return JsonResponse({'error': 'Unauthorized'}, status=401) return JsonResponse(auth_response.json())

• 异步消息：使用Celery+RabbitMQ

# tasks.py @app.task def async_user_update(user_id, data): try: requests.patch(f'http://user-service/api/users/{user_id}', json=data) except requests.exceptions.RequestException as e: self.retry(exc=e, countdown=60)

3.2.3 分布式事务处理

Saga模式实现示例：

# saga.py class ArticlePublishSaga: def __init__(self, article_id): self.article_id = article_id self.compensations = [] def execute(self): try: # 步骤1：发布文章 publish_article(self.article_id) self.compensations.append(self.unpublish_article) # 步骤2：通知订阅者 notify_subscribers(self.article_id) self.compensations.append(self.retract_notifications) # 步骤3：更新搜索引擎 update_search_index(self.article_id) return True except Exception as e: self.compensate() raise def compensate(self): for cmd in reversed(self.compensations): try: cmd() except Exception: continue

3.3 云原生部署架构

3.3.1 Docker化部署

典型Dockerfile配置：

FROM python:3.9-slim ENV PYTHONUNBUFFERED 1 ENV PYTHONDONTWRITEBYTECODE 1 RUN apt-get update && apt-get install -y \ build-essential \ libpq-dev \ && rm -rf /var/lib/apt/lists/* WORKDIR /app COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY . . RUN python manage.py collectstatic --noinput CMD ["gunicorn", "--bind", "0.0.0.0:8000", "core.wsgi:application"]

3.3.2 Kubernetes编排

典型Deployment配置：

apiVersion: apps/v1 kind: Deployment metadata: name: django-app spec: replicas: 3 selector: matchLabels: app: django template: metadata: labels: app: django spec: containers: - name: web image: my-registry/django-app:latest ports: - containerPort: 8000 envFrom: - configMapRef: name: django-config - secretRef: name: django-secrets readinessProbe: httpGet: path: /health/ port: 8000 initialDelaySeconds: 5 periodSeconds: 5

3.3.3 可观测性建设

• 日志收集：ELK集成

LOGGING = { 'handlers': { 'logstash': { 'level': 'INFO', 'class': 'logstash.TCPLogstashHandler', 'host': 'logstash', 'port': 5959, 'version': 1, 'tags': ['django'], }, } }

• 指标监控：Prometheus配置

INSTALLED_APPS += ['django_prometheus'] MIDDLEWARE = [ 'django_prometheus.middleware.PrometheusBeforeMiddleware', # ...其他中间件 'django_prometheus.middleware.PrometheusAfterMiddleware', ]

• 分布式追踪：OpenTelemetry集成

from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchSpanProcessor from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) span_processor = BatchSpanProcessor(OTLPSpanExporter()) trace.get_tracer_provider().add_span_processor(span_processor)

4. 架构决策与替代方案对比

4.1 Django vs 其他Python框架

4.1.1 Django与Flask架构对比

4.1.2 Django与FastAPI对比

4.2 模块化架构实践

4.2.1 应用拆分原则

• 功能内聚：每个应用应解决特定问题（如users、blog、payments）
• 松耦合：应用间通过定义良好的接口通信
• 可插拔：应用应能独立启用/禁用

4.2.2 项目布局示例

project/ ├── core/ # 核心配置 │ ├── settings/ # 分环境配置 │ │ ├── base.py │ │ ├── dev.py │ │ └── prod.py │ └── asgi.py ├── apps/ │ ├── users/ # 用户管理 │ ├── blog/ # 内容管理 │ └── payments/ # 支付处理 ├── static/ # 公共静态文件 └── templates/ # 全局模板

4.2.3 依赖管理策略

使用requirements分层：

requirements/ ├── base.txt # 公共依赖 ├── dev.txt # 开发环境 ├── test.txt # 测试环境 └── prod.txt # 生产环境

4.3 技术债务管理

4.3.1 常见债务类型

• 模型膨胀：单个models.py超过1000行
• 视图复杂化：单个视图处理过多逻辑
• 模板嵌套过深：多层继承导致维护困难
• 信号滥用：难以追踪的事件触发链

4.3.2 重构策略

• 增量重构：每次修改改进一小部分
• 测试保护：确保重构不破坏现有功能
• 模式应用：
  • 引入Service层处理业务逻辑
  • 使用QuerySet子类封装复杂查询
  • 用自定义Manager实现通用过滤

4.3.3 代码质量工具

• 静态分析：flake8、pylint
• 类型检查：mypy
• 复杂度检测：radon
• 安全扫描：bandit、safety

5. Django架构师成长路径

5.1 核心能力矩阵

5.1.1 技术深度要求

5.1.2 学习资源推荐

• 官方文档：Django官方文档是最好起点
• 源码阅读：重点研究django.db、django.core.handlers等模块
• 技术博客：
  • Django项目官方博客
  • Simple is Better Than Complex
  • Real Python教程
• 书籍推荐：
  • 《Django for Professionals》
  • 《Django Design Patterns》

5.2 典型架构问题解决方案

5.2.1 高并发读场景

• 缓存策略：
  • 使用django-redis作为缓存后端
  • 实现缓存穿透保护

def get_article(slug): cache_key = f'article_{slug}' article = cache.get(cache_key) if article is None: try: article = Article.objects.get(slug=slug) cache.set(cache_key, article, timeout=300) except Article.DoesNotExist: cache.set(cache_key, 'NOT_EXIST', timeout=60) raise elif article == 'NOT_EXIST': raise Article.DoesNotExist return article

• 读写分离：

DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql', 'HOST': 'master.db.example.com', }, 'replica': { 'ENGINE': 'django.db.backends.postgresql', 'HOST': 'replica.db.example.com', } } class ArticleManager(models.Manager): def get_queryset(self): return super().using('replica')

5.2.2 大数据量处理

• 分页优化：使用键集分页替代LIMIT/OFFSET

def get_articles(last_id=None, limit=20): qs = Article.objects.order_by('-id') if last_id: qs = qs.filter(id__lt=last_id) return list(qs[:limit])

• 批量处理：使用django-bulk-update

from django_bulk_update.helper import bulk_update articles = Article.objects.filter(status='draft') for article in articles: article.status = 'published' bulk_update(articles, update_fields=['status'])

5.2.3 多租户架构

• Schema隔离：使用django-tenants

INSTALLED_APPS = [ 'django_tenants', 'customers', 'shared_apps', 'tenant_apps', ] TENANT_MODEL = "customers.Client" TENANT_DOMAIN_MODEL = "customers.Domain" DATABASE_ROUTERS = ( 'django_tenants.routers.TenantSyncRouter', )

• 数据隔离中间件：

class TenantMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): hostname = request.get_host().split(':')[0] try: tenant = Client.objects.get(domains__domain=hostname) request.tenant = tenant connection.set_tenant(request.tenant) except Client.DoesNotExist: return HttpResponseNotFound() return self.get_response(request)

5.3 架构演进案例研究

5.3.1 单体到微服务拆分

原始架构：

• 单个Django项目包含用户、内容、订单等模块
• 共享数据库，模型间外键关联

演进步骤：

1. 垂直拆分：

   • 用户服务：Django + JWT
   • 内容服务：Django + Elasticsearch
   • 订单服务：Django + Celery

2. 数据解耦：

   • 用UUID替代自增主键
   • 事件驱动架构替代直接DB关联

3. 服务治理：

   • 引入API网关
   • 实现服务发现

5.3.2 性能优化实战

问题场景：

• 文章列表页响应时间>2s
• 数据库负载高

优化方案：

1. 查询分析：

from django.db import connection # 原始视图 def article_list(request): articles = Article.objects.select_related('author').prefetch_related('tags') print(len