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

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

项目概述

核心功能与技术目标

本项目旨在构建一个功能完整的企业级电商平台，采用微服务架构，涵盖用户管理、商品管理、订单处理、支付集成等核心业务模块。

核心业务功能：

用户注册/登录/认证
商品浏览/搜索/分类
购物车管理
订单处理
支付集成
物流跟踪

技术架构目标：

微服务架构
高可用性设计
可扩展性保证
安全性保障
性能优化

技术栈选择

后端技术栈：

Django 4.2+ (Web框架)
Django REST Framework (API开发)
PostgreSQL (主数据库)
Redis (缓存/会话)
Celery (异步任务)
RabbitMQ/Kafka (消息队列)

前端技术栈：

Vue.js/React (前端框架)
Axios (HTTP客户端)
Element UI/Ant Design (UI组件)
Webpack (打包工具)

基础设施：

Docker (容器化)
Nginx (反向代理)
Gunicorn (WSGI服务器)
Kubernetes (容器编排)

项目架构设计

微服务架构设计

本项目采用微服务架构，将系统拆分为多个独立的服务模块，包括API网关、用户服务、商品服务、订单服务、支付服务、搜索服务和通知服务等。

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

这种架构的优势在于：

服务独立部署，降低了系统耦合度
数据隔离，提高了系统安全性
异步通信，增强了系统性能
高可用设计，提高了系统可靠性
水平扩展能力，增强了系统可扩展性

项目目录结构

ecommerce-platform/
├── docker-compose.yml
├── services/
│   ├── gateway/
│   ├── user/
│   ├── product/
│   ├── order/
│   ├── payment/
│   ├── cart/
│   ├── search/
│   └── notification/
├── frontend/
├── shared/
├── docs/
├── scripts/
├── tests/
└── README.md

核心服务实现

用户服务模块

用户服务模块负责用户的注册、登录、认证、个人信息管理等功能。

用户模型设计：

# 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)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        db_table = 'users'

用户认证视图：

# services/user/user_service/apps/user_auth/views.py
class UserRegistrationView(APIView):
    """用户注册视图"""
    permission_classes = [AllowAny]
    
    def post(self, request):
        """用户注册"""
        serializer = UserRegistrationSerializer(data=request.data)
        if serializer.is_valid():
            try:
                user = serializer.save()
                send_verification_email(user.email, user.id)
                UserProfile.objects.create(user=user)
                UserSecurity.objects.create(user=user)
                
                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=status.HTTP_201_CREATED)
            except Exception as e:
                logger.error(f"User registration failed: {str(e)}")
                return ErrorResponse('注册失败，请稍后重试', status=status.HTTP_500_INTERNAL_SERVER_ERROR)
        
        return ErrorResponse(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

商品服务模块

商品服务模块负责商品的管理、分类、搜索、库存管理等功能。

商品模型设计：

# services/product/product_service/models.py
class Product(models.Model):
    """商品"""
    PRODUCT_STATUS_CHOICES = [
        ('draft', 'Draft'),
        ('pending_review', 'Pending Review'),
        ('approved', 'Approved'),
        ('rejected', 'Rejected'),
        ('active', 'Active'),
        ('inactive', 'Inactive'),
        ('discontinued', 'Discontinued'),
    ]
    
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    name = models.CharField(max_length=200)
    slug = models.SlugField(unique=True, max_length=250)
    description = models.TextField()
    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)
    price = models.DecimalField(max_digits=10, decimal_places=2, validators=[MinValueValidator(0)])
    status = models.CharField(max_length=20, choices=PRODUCT_STATUS_CHOICES, default='draft')
    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'

订单服务模块

订单服务模块负责购物车管理、订单创建、订单处理、订单状态管理等功能。

购物车视图：

# services/order/order_service/views.py
class ShoppingCartView(APIView):
    """购物车视图"""
    permission_classes = [IsAuthenticated]
    
    def get(self, request):
        """获取购物车"""
        try:
            cart, created = ShoppingCart.objects.get_or_create(
                user_id=request.user.id,
                defaults={
                    'items': [],
                    'total_items': 0,
                    'total_amount': Decimal('0.00')
                }
            )
            
            self.update_cart_totals(cart)
            serializer = ShoppingCartSerializer(cart)
            return SuccessResponse(serializer.data)
        except Exception as e:
            logger.error(f"Error getting shopping cart: {str(e)}")
            return ErrorResponse({'error': '获取购物车失败'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
    
    def post(self, request):
        """添加商品到购物车"""
        try:
            cart, created = ShoppingCart.objects.get_or_create(
                user_id=request.user.id,
                defaults={
                    'items': [],
                    'total_items': 0,
                    'total_amount': Decimal('0.00')
                }
            )
            
            product_id = request.data.get('product_id')
            quantity = int(request.data.get('quantity', 1))
            attributes = request.data.get('attributes', {})
            
            if not product_id:
                return ErrorResponse({'error': '商品ID不能为空'}, status=status.HTTP_400_BAD_REQUEST)
            
            product = self.check_product_availability(product_id, quantity)
            if not product:
                return ErrorResponse({'error': '商品不存在或库存不足'}, status=status.HTTP_400_BAD_REQUEST)
            
            cart.items.append({
                'product_id': str(product_id),
                'quantity': quantity,
                'unit_price': float(product.price),
                'total_price': float(product.price * quantity),
                'attributes': attributes,
                'added_at': timezone.now().isoformat()
            })
            
            cart.save()
            self.update_cart_totals(cart)
            
            serializer = ShoppingCartSerializer(cart)
            return SuccessResponse({
                'cart': serializer.data,
                'message': '商品已添加到购物车'
            })
        except Exception as e:
            logger.error(f"Error adding to cart: {str(e)}")
            return ErrorResponse({'error': '添加到购物车失败'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

支付服务模块

支付服务模块负责支付网关集成、支付处理、退款处理等功能。支持多种支付方式，如Stripe、支付宝、微信支付等。

支付网关基类：

# 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

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()
        self.circuit_breaker = CircuitBreaker()
    
    def dispatch(self, request, *args, **kwargs):
        """请求分发"""
        path = request.path
        method = request.method
        
        try:
            route = APIRoute.objects.get(
                path=path,
                methods__contains=[method],
                is_active=True
            )
        except APIRoute.DoesNotExist:
            return JsonResponse({'error': 'Route not found'}, status=404)
        
        instance = self.service_discovery.get_service_instance(route.target_service.name)
        if not instance:
            return JsonResponse({'error': 'Service unavailable'}, status=503)
        
        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)
            
            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"Gateway error: {e}")
            return JsonResponse({'error': 'Internal Server Error'}, status=500)

部署上线

Docker容器化部署

项目使用Docker进行容器化部署，通过Docker Compose可以快速搭建开发环境。

Docker Compose配置：

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

Kubernetes部署

对于生产环境，项目支持使用Kubernetes进行容器编排，实现高可用性和自动扩缩容。

Kubernetes部署配置：

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

项目总结

本项目通过微服务架构，构建了一个功能完整的电商平台。项目涵盖了用户管理、商品管理、订单处理、支付集成等核心业务模块，并通过API网关实现了请求路由、负载均衡、认证授权等功能。

项目采用了Docker容器化部署，并支持Kubernetes进行容器编排，实现了高可用性和自动扩缩容。同时，项目还实现了搜索服务、通知服务等辅助功能，为用户提供了更好的购物体验。

通过这个项目，你可以学习到如何使用Django构建企业级应用，如何设计微服务架构，如何实现支付集成，以及如何进行容器化部署等技能。

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

#项目概述

#核心功能与技术目标

#技术栈选择

#项目架构设计

#微服务架构设计

#项目目录结构

#核心服务实现

#用户服务模块

#商品服务模块

#订单服务模块

#支付服务模块

#API网关实现

#部署上线

#Docker容器化部署

#Kubernetes部署

#项目总结