从零构建电商网站：架构设计篇

电商网站是复杂的系统，涉及用户管理、商品展示、订单处理、支付等多个模块。本文将分享从零开始构建电商网站的架构设计经验。

## 系统架构概览

### 整体架构
```
前端层（Web/App）
↓
负载均衡层（Nginx/HAProxy）
↓
应用层（Django/Flask）
↓
缓存层（Redis/Memcached）
↓
数据库层（MySQL/PostgreSQL）
↓
存储层（文件存储/CDN）
```

### 技术栈选择
- **后端**：Django + Django REST Framework
- **前端**：Vue.js + Element UI
- **数据库**：PostgreSQL（主库）+ Redis（缓存）
- **消息队列**：Celery + Redis
- **搜索**：Elasticsearch
- **部署**：Docker + Kubernetes

## 核心模块设计

### 1. 用户模块
```python
# 用户模型设计
class User(AbstractUser):
phone = models.CharField(max_length=20, unique=True)
avatar = models.ImageField(upload_to='avatars/')
is_verified = models.BooleanField(default=False)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)

class UserProfile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
gender = models.CharField(max_length=10, choices=GENDER_CHOICES)
birthday = models.DateField(null=True, blank=True)
address = models.TextField()
```

### 2. 商品模块
```python
class Category(models.Model):
name = models.CharField(max_length=100)
parent = models.ForeignKey('self', null=True, blank=True)
level = models.IntegerField(default=1)
is_active = models.BooleanField(default=True)

class Product(models.Model):
name = models.CharField(max_length=200)
description = models.TextField()
price = models.DecimalField(max_digits=10, decimal_places=2)
category = models.ForeignKey(Category, on_delete=models.CASCADE)
stock = models.IntegerField(default=0)
is_active = models.BooleanField(default=True)
created_at = models.DateTimeField(auto_now_add=True)

class ProductImage(models.Model):
product = models.ForeignKey(Product, related_name='images')
image = models.ImageField(upload_to='products/')
is_primary = models.BooleanField(default=False)
```

### 3. 订单模块
```python
class Order(models.Model):
ORDER_STATUS = [
('pending', '待支付'),
('paid', '已支付'),
('shipped', '已发货'),
('delivered', '已送达'),
('cancelled', '已取消'),
]

user = models.ForeignKey(User, on_delete=models.CASCADE)
order_number = models.CharField(max_length=50, unique=True)
status = models.CharField(max_length=20, choices=ORDER_STATUS)
total_amount = models.DecimalField(max_digits=10, decimal_places=2)
created_at = models.DateTimeField(auto_now_add=True)

class OrderItem(models.Model):
order = models.ForeignKey(Order, related_name='items')
product = models.ForeignKey(Product)
quantity = models.IntegerField()
price = models.DecimalField(max_digits=10, decimal_places=2)
```

## 性能优化策略

### 1. 数据库优化
```sql
-- 创建索引
CREATE INDEX idx_product_category ON product(category_id);
CREATE INDEX idx_order_user ON order(user_id);
CREATE INDEX idx_order_created ON order(created_at);

-- 分区表（按时间分区）
CREATE TABLE order_2024 PARTITION OF order
FOR VALUES FROM ('2024-01-01') TO ('2025-01-01');
```

### 2. 缓存策略
```python
# Redis 缓存配置
CACHE_CONFIG = {
'product_list': {'timeout': 300}, # 商品列表缓存5分钟
'product_detail': {'timeout': 600}, # 商品详情缓存10分钟
'user_info': {'timeout': 1800}, # 用户信息缓存30分钟
'category_tree': {'timeout': 3600}, # 分类树缓存1小时
}

# 缓存装饰器
def cache_result(key_pattern, timeout=300):
def decorator(func):
def wrapper(*args, **kwargs):
cache_key = key_pattern.format(*args, **kwargs)
result = cache.get(cache_key)
if result is None:
result = func(*args, **kwargs)
cache.set(cache_key, result, timeout)
return result
return wrapper
return decorator
```

### 3. 异步处理
```python
# Celery 异步任务
@celery.task
def send_order_confirmation_email(order_id):
order = Order.objects.get(id=order_id)
send_email(
to=order.user.email,
subject='订单确认',
template='order_confirmation.html',
context={'order': order}
)

@celery.task
def update_product_stock(order_id):
order = Order.objects.get(id=order_id)
for item in order.items.all():
product = item.product
product.stock -= item.quantity
product.save()
```

## 安全考虑

### 1. 支付安全
```python
# 支付签名验证
def verify_payment_signature(data, signature):
secret_key = settings.PAYMENT_SECRET_KEY
expected_signature = hmac.new(
secret_key.encode(),
json.dumps(data).encode(),
hashlib.sha256
).hexdigest()
return hmac.compare_digest(expected_signature, signature)
```

### 2. 数据加密
```python
# 敏感数据加密
from cryptography.fernet import Fernet

class EncryptedField(models.TextField):
def __init__(self, *args, **kwargs):
self.cipher = Fernet(settings.ENCRYPTION_KEY)
super().__init__(*args, **kwargs)

def from_db_value(self, value, expression, connection):
if value is None:
return value
return self.cipher.decrypt(value.encode()).decode()

def to_python(self, value):
if isinstance(value, str):
return value
return self.cipher.encrypt(value.encode()).decode()
```

## 监控和日志

### 1. 性能监控
```python
# 性能监控中间件
class PerformanceMonitoringMiddleware:
def __init__(self, get_response):
self.get_response = get_response

def __call__(self, request):
start_time = time.time()
response = self.get_response(request)
end_time = time.time()

# 记录响应时间
response_time = end_time - start_time
logger.info(f"Request: {request.path} - Time: {response_time:.3f}s")

# 发送到监控系统
metrics.timing('request.duration', response_time)
return response
```

### 2. 错误追踪
```python
# 错误追踪
import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration

sentry_sdk.init(
dsn="your-sentry-dsn",
integrations=[DjangoIntegration()],
traces_sample_rate=1.0,
send_default_pii=True
)
```

## 部署和扩展

### 1. 容器化部署
```yaml
# docker-compose.yml
version: '3.8'
services:
web:
build: .
ports:
- "8000:8000"
environment:
- DEBUG=False
- DATABASE_URL=postgresql://user:pass@db:5432/ecommerce
depends_on:
- db
- redis

db:
image: postgres:13
environment:
- POSTGRES_DB=ecommerce
- POSTGRES_USER=user
- POSTGRES_PASSWORD=pass
volumes:
- postgres_data:/var/lib/postgresql/data

redis:
image: redis:6-alpine
ports:
- "6379:6379"
```

### 2. 自动扩展
```yaml
# Kubernetes HPA
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: web-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: web
minReplicas: 2
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
```

构建电商网站是一个复杂的工程，需要考虑性能、安全、可扩展性等多个方面。通过合理的架构设计和持续优化，可以构建出稳定可靠的电商系统。