django综合实战项目 —— 电商平台开发完整指南

📂 所属阶段：第四部分 — 实战项目
🎯 难度等级：专家级
⏰ 预计学习时间：12-15小时
🎒 前置知识：完成前三部分所有章节

项目概述

本教程将带你从零开始，构建一个功能完整的企业级电商平台。项目采用微服务架构，涵盖用户管理、商品管理、订单处理、支付集成等核心业务模块。通过这个实战项目，你将综合运用 django 的各类advanced-features，并掌握微服务、容器化部署等现代工程实践。

核心业务功能

用户注册 / 登录 / 身份认证
商品浏览 / 搜索 / 分类展示
购物车管理（增删改查）
订单全生命周期处理（创建 → 支付 → 发货 → 完成）
多种支付方式集成（Stripe、支付宝、微信等）
物流状态跟踪与通知

技术架构目标

微服务架构：各业务模块独立开发、部署、扩展
高可用性：服务冗余、熔断降级、负载均衡
可扩展性：支持水平扩展，适应业务增长
安全性：多层认证鉴权、数据加密、防攻击措施
性能优化：缓存、异步任务、数据库索引优化

技术栈选择

本项目的技术选型兼顾了开发效率和长期维护性，充分考虑了开源社区的活跃度与生态完整性。

后端技术栈：

django 4.2+ —— 全功能 Web 框架，提供 ORM、认证、管理后台等开箱即用的能力
django REST Framework —— 构建 RESTful API 的利器
PostgreSQL —— 主数据库，性能稳定，支持 JSON 字段和全文搜索
Redis —— 缓存热点数据、存储会话、实现分布式锁
Celery —— 异步任务处理，如发送邮件、生成报表
RabbitMQ / Kafka —— 消息队列，用于服务间解耦与削峰

前端技术栈：

Vue.js / React —— 现代前端框架，构建单页应用
Axios —— HTTP 客户端，与后端 API 交互
Element UI / Ant Design —— 企业级 UI 组件库，快速搭建后台管理界面
Webpack —— 模块打包工具

基础设施：

Docker —— 容器化运行，保证环境一致性
Nginx —— 反向代理与静态资源服务
Gunicorn —— WSGI 应用服务器
Kubernetes —— 生产环境容器编排，实现自动伸缩与零停机部署

项目架构设计

微服务架构全景

我们将整个电商系统拆分为多个微服务，每个服务拥有独立的数据库，并通过 API 网关对外统一暴露接口。各个服务之间通过 REST 或消息队列进行异步通信。

┌─────────────────────┐      ┌─────────────────────┐      ┌─────────────────────┐
│    API Gateway      │────▶ │    Gateway Route    │────▶ │      Frontend       │
└─────────────────────┘      └─────────────────────┘      └─────────────────────┘
          │
          ▼
┌─────────────────────┐      ┌─────────────────────┐      ┌─────────────────────┐
│    Auth Service     │      │    User Service     │      │   Product Service   │
└─────────────────────┘      └─────────────────────┘      └─────────────────────┘
          │                            │                            │
          ▼                            ▼                            ▼
┌─────────────────────┐      ┌─────────────────────┐      ┌─────────────────────┐
│    Cart Service     │      │    Order Service    │      │   Payment Service   │
└─────────────────────┘      └─────────────────────┘      └─────────────────────┘

这种架构带来了以下核心优势：

独立部署与迭代：每个服务可以独立发布，不会互相影响
数据隔离：服务拥有独立数据库，避免单点故障
异步解耦：通过消息队列将耗时操作异步化，提升整体吞吐量
高可用与弹性伸缩：无状态服务可以轻松水平扩展，配合负载均衡实现高可用
技术多样性：不同服务可以根据需求选用最合适的语言或存储方案（本文统一使用 django）

项目目录结构

ecommerce-platform/
├── docker-compose.yml          # 本地开发环境编排
├── services/                   # 微服务目录
│   ├── gateway/                # API 网关
│   ├── user/                   # 用户服务
│   ├── product/                # 商品服务
│   ├── order/                  # 订单与购物车服务
│   ├── payment/                # 支付服务
│   ├── cart/                   # 购物车独立服务（可选项）
│   ├── search/                 # 搜索服务
│   └── notification/           # 通知服务
├── frontend/                   # 前端项目
├── shared/                     # 共享工具库、中间件
├── docs/                       # 项目文档
├── scripts/                    # 运维脚本
├── tests/                      # 集成测试用例
└── README.md

核心服务实现

接下来，我们将逐一深入各个微服务的核心实现。每个服务都将展示关键的模型设计、视图逻辑以及最佳实践。

1. 用户服务模块

用户服务是整个平台的基础，负责注册、登录、个人信息管理等。

用户模型设计

我们继承 django 的 AbstractUser，并扩展手机号、邮箱验证、头像等字段，使用 UUID 作为主键以提升安全性。

# services/user/user_service/apps/user_auth/models.py
from django.db import models
from django.contrib.auth.models import AbstractUser
import uuid

class User(AbstractUser):
    """扩展的用户模型"""
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    phone = models.CharField(max_length=20, blank=True, unique=True)
    avatar = models.URLField(blank=True)
    email_verified = models.BooleanField(default=False)
    phone_verified = models.BooleanField(default=False)
    is_premium = models.BooleanField(default=False, verbose_name="是否高级会员")
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        db_table = 'users'

用户注册接口

注册接口会同时创建用户、个人资料和安全设置，并发送验证邮件。通过 RefreshToken 直接返回 JWT 令牌，减少登录步骤。

# services/user/user_service/apps/user_auth/views.py
from rest_framework.views import APIView
from rest_framework.permissions import AllowAny
from rest_framework_simplejwt.tokens import RefreshToken
from .serializers import UserRegistrationSerializer
from .utils import send_verification_email

class UserRegistrationView(APIView):
    """用户注册"""
    permission_classes = [AllowAny]

    def post(self, request):
        serializer = UserRegistrationSerializer(data=request.data)
        if not serializer.is_valid():
            return ErrorResponse(serializer.errors, status=400)

        try:
            user = serializer.save()
            # 发送验证邮件（异步调用 Celery 任务更佳，此处为演示省略）
            send_verification_email(user.email, user.id)

            # 生成 JWT 令牌
            refresh = RefreshToken.for_user(user)

            return SuccessResponse({
                'user': {
                    'id': str(user.id),
                    'username': user.username,
                    'email': user.email,
                    'phone': user.phone,
                },
                'tokens': {
                    'refresh': str(refresh),
                    'access': str(refresh.access_token),
                },
                'message': '注册成功，请检查邮箱完成验证'
            }, status=201)
        except Exception as e:
            logger.error(f"用户注册失败: {str(e)}")
            return ErrorResponse({'detail': '注册失败，请稍后重试'}, status=500)

2. 商品服务模块

商品服务负责维护商品数据、分类、品牌、库存等信息。

商品模型示例

商品模型包含状态流转、评分、销量统计等，并通过外键关联分类与品牌。

# services/product/product_service/models.py
class Product(models.Model):
    """商品"""
    PRODUCT_STATUS_CHOICES = [
        ('draft', '草稿'),
        ('pending_review', '待审核'),
        ('approved', '已审核'),
        ('active', '已上架'),
        ('inactive', '已下架'),
        ('discontinued', '停止销售'),
    ]

    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    name = models.CharField(max_length=200, verbose_name="商品名称")
    slug = models.SlugField(unique=True, max_length=250)
    description = models.TextField(verbose_name="商品描述")
    category = models.ForeignKey(Category, on_delete=models.SET_NULL,
                                 null=True, related_name='products')
    brand = models.ForeignKey(Brand, on_delete=models.SET_NULL,
                              null=True, related_name='products')
    sku = models.CharField(max_length=100, unique=True, verbose_name="SKU")
    price = models.DecimalField(max_digits=10, decimal_places=2,
                                validators=[MinValueValidator(0)])
    status = models.CharField(max_length=20, choices=PRODUCT_STATUS_CHOICES,
                              default='draft', verbose_name="商品状态")
    rating = models.DecimalField(max_digits=3, decimal_places=2,
                                 default=0, validators=[MinValueValidator(0),
                                                        MaxValueValidator(5.0)])
    review_count = models.PositiveIntegerField(default=0)
    view_count = models.PositiveIntegerField(default=0)
    sales_count = models.PositiveIntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        db_table = 'products'

3. 订单与购物车服务

订单服务中包含了购物车的逻辑，购物车数据通常存储在 Redis 或数据库中（本例存储在数据库），便于持久化。

购物车视图

# services/order/order_service/views.py
class ShoppingCartView(APIView):
    """购物车管理"""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        """获取当前用户的购物车"""
        cart, _ = ShoppingCart.objects.get_or_create(
            user_id=request.user.id,
            defaults={'items': [], 'total_items': 0, 'total_amount': 0.00}
        )
        self.update_cart_totals(cart)
        serializer = ShoppingCartSerializer(cart)
        return SuccessResponse(serializer.data)

    def post(self, request):
        """添加商品到购物车"""
        product_id = request.data.get('product_id')
        quantity = int(request.data.get('quantity', 1))

        if not product_id:
            return ErrorResponse({'error': '商品ID不能为空'}, status=400)

        # 检查商品是否存在且库存充足
        product = self.check_product_availability(product_id, quantity)
        if not product:
            return ErrorResponse({'error': '商品不存在或库存不足'}, status=400)

        cart, _ = ShoppingCart.objects.get_or_create(
            user_id=request.user.id,
            defaults={'items': [], 'total_items': 0, 'total_amount': 0.00}
        )

        # 更新购物车商品项
        cart.items.append({
            'product_id': str(product_id),
            'quantity': quantity,
            'unit_price': float(product.price),
            'total_price': float(product.price * quantity),
            'added_at': timezone.now().isoformat()
        })
        cart.save()
        self.update_cart_totals(cart)

        serializer = ShoppingCartSerializer(cart)
        return SuccessResponse({
            'cart': serializer.data,
            'message': '已加入购物车'
        })

4. 支付服务模块

支付服务通过策略模式封装不同的支付网关，方便扩展支付宝、微信等渠道。

支付网关基类

# services/payment/payment_service/gateways/base.py
from abc import ABC, abstractmethod
from decimal import Decimal
from typing import Dict, Any

class BasePaymentGateway(ABC):
    """支付网关抽象基类"""

    def __init__(self, config: Dict[str, Any]):
        self.config = config

    @abstractmethod
    def create_payment(self, amount: Decimal, currency: str,
                       order_info: Dict[str, Any]) -> Dict[str, Any]:
        """发起支付请求"""
        pass

    @abstractmethod
    def verify_payment(self, transaction_id: str) -> Dict[str, Any]:
        """验证支付结果"""
        pass

    @abstractmethod
    def refund_payment(self, transaction_id: str,
                       amount: Decimal = None) -> Dict[str, Any]:
        """执行退款"""
        pass

实际项目中，你会分别实现 StripeGateway、AlipayGateway 等子类，通过配置动态选择。

API 网关实现

API 网关是整个系统的统一入口，负责请求路由、认证授权、流量控制和熔断保护。

# services/gateway/gateway_app/views.py
class GatewayView(View):
    """API 网关主视图"""

    def __init__(self):
        super().__init__()
        self.service_discovery = ServiceDiscovery()  # 服务发现
        self.load_balancer = LoadBalancer()          # 负载均衡
        self.api_client = APIClient()                # HTTP 客户端
        self.circuit_breaker = CircuitBreaker()      # 熔断器

    def dispatch(self, request, *args, **kwargs):
        """请求分发"""
        path = request.path
        method = request.method

        # 1. 根据路由表找到对应的微服务
        try:
            route = APIRoute.objects.get(
                path=path,
                methods__contains=[method],
                is_active=True
            )
        except APIRoute.DoesNotExist:
            return JsonResponse({'error': '路由未找到'}, status=404)

        # 2. 从服务发现获取一个可用实例
        instance = self.service_discovery.get_instance(route.target_service.name)
        if not instance:
            return JsonResponse({'error': '服务暂不可用'}, status=503)

        # 3. 转发请求，并启用熔断保护
        headers = self._build_headers(request)
        body = request.body.decode('utf-8') if request.body else None
        query_params = dict(request.GET)

        try:
            response_data = self.circuit_breaker.call(
                route.target_service.name,
                self.api_client.forward_request,
                instance, path, method, headers, body, query_params
            )
            # 记录访问日志
            self._log_request(route, request, response_data)

            # 4. 构造响应返回客户端
            response = HttpResponse(
                content=response_data['body'],
                status=response_data['status_code'],
                content_type='application/json'
            )
            for key, value in response_data['headers'].items():
                response[key] = value
            return response

        except Exception as e:
            logger.error(f"网关转发异常: {e}")
            return JsonResponse({'error': '内部服务器错误'}, status=500)

网关层还可以嵌入 JWT 校验、IP 黑白名单、Rate Limiting 等安全策略，有效保护后端服务。

部署上线

使用 Docker Compose 快速启动

本地开发和测试环境可以通过 docker-compose.yml 一键搭建所有依赖服务。

version: '3.8'

services:
  postgres:
    image: postgres:15
    container_name: ecommerce_postgres
    environment:
      POSTGRES_DB: ecommerce
      POSTGRES_USER: ecommerce_user
      POSTGRES_PASSWORD: ${DB_PASSWORD:-password}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    networks:
      - ecommerce_network

  redis:
    image: redis:7-alpine
    container_name: ecommerce_redis
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - ecommerce_network

  gateway:
    build: ./services/gateway
    container_name: ecommerce_gateway
    depends_on:
      - postgres
      - redis
    environment:
      - DEBUG=${DEBUG:-False}
      - DB_HOST=postgres
      - REDIS_URL=redis://redis:6379/0
    ports:
      - "8000:8000"
    networks:
      - ecommerce_network
    restart: unless-stopped

  user-service:
    build: ./services/user
    container_name: ecommerce_user_service
    depends_on:
      - postgres
      - redis
    ports:
      - "8001:8001"
    networks:
      - ecommerce_network
    restart: unless-stopped

volumes:
  postgres_data:
  redis_data:

networks:
  ecommerce_network:
    driver: bridge

只需执行 docker-compose up -d 即可启动整个开发环境。

生产环境：Kubernetes 部署

对于高可用生产环境，我们使用 Kubernetes 进行容器编排。以下是一个典型的 Deployment 配置，用于部署 Gateway 服务，并配置了健康检查和资源限制。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gateway
  namespace: ecommerce-platform
  labels:
    app: gateway
spec:
  replicas: 3                                    # 多个副本保证高可用
  selector:
    matchLabels:
      app: gateway
  template:
    metadata:
      labels:
        app: gateway
    spec:
      containers:
      - name: gateway
        image: ecommerce/gateway:latest
        ports:
        - containerPort: 8000
        env:
        - name: DB_HOST
          value: postgres-service
        - name: REDIS_URL
          value: redis://redis-service:6379/0
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:                           # 存活探针
          httpGet:
            path: /health/
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:                          # 就绪探针
          httpGet:
            path: /health/
            port: 8000
          initialDelaySeconds: 5
          periodSeconds: 5

单个服务的伸缩只需要调整 replicas 数；结合 Service 和 Ingress，外部流量可以平滑地分发到各个 Pod。

项目总结

通过本教程，我们从零开始搭建了一个生产级电商平台。你不仅学会了如何用 django 构建 RESTful API，还深入了解了：

如何按照业务边界拆分为独立的微服务
如何设计用户认证、商品管理、订单、支付等核心模块
如何通过 API 网关实现统一入口和流量治理
如何利用 Docker 和 Kubernetes 实现一键部署和弹性伸缩
如何结合 Redis、Celery、消息队列优化性能和解耦服务

这个项目既是 django 技术栈的综合练习，也是通往企业级微服务架构的实战桥梁。希望你能在此基础上进一步扩展功能，比如加入推荐系统、智能搜索、数据看板等，打造属于你自己的全栈电商应用！

提示：你可以在 GitHub 仓库找到完整的项目源码，配合本文食用效果更佳。

#django综合实战项目 —— 电商平台开发完整指南

#项目概述

#核心业务功能

#技术架构目标

#技术栈选择

#项目架构设计

#微服务架构全景

#项目目录结构

#核心服务实现

#1. 用户服务模块

#用户模型设计

#用户注册接口

#2. 商品服务模块

#商品模型示例

#3. 订单与购物车服务

#购物车视图

#4. 支付服务模块

#支付网关基类

#API 网关实现

#部署上线

#使用 Docker Compose 快速启动

#生产环境：Kubernetes 部署

#项目总结