5.9.1 电商微服务架构设计

5.9.1 电商微服务架构设计 #

在构建大型电商系统时，合理的架构设计是成功的关键。本节将从业务需求分析开始，逐步设计出一个完整的电商微服务架构。

业务需求分析 #

核心业务功能 #

电商系统的核心业务功能包括：

用户管理

  • 用户注册、登录、认证
  • 用户信息管理
  • 用户权限控制
  • 用户行为追踪

商品管理

  • 商品信息管理
  • 商品分类管理
  • 库存管理
  • 商品搜索

订单管理

  • 购物车管理
  • 订单创建与支付
  • 订单状态跟踪
  • 退款处理

支付管理

  • 多种支付方式支持
  • 支付状态管理
  • 支付安全保障

非功能性需求 #

性能要求

  • 支持高并发访问（10 万+ QPS）
  • 响应时间 < 200ms
  • 99.9% 可用性

扩展性要求

  • 支持水平扩展
  • 支持多地域部署
  • 支持弹性伸缩

安全性要求

  • 数据加密传输
  • 用户隐私保护
  • 防止恶意攻击

领域驱动设计 #

领域划分 #

基于业务分析，我们可以识别出以下核心领域：

// 用户领域 (User Domain)
type UserDomain struct {
    // 用户聚合根
    UserAggregate *UserAggregate
    // 用户仓储
    UserRepository UserRepository
    // 用户领域服务
    UserDomainService UserDomainService
}

// 商品领域 (Product Domain)
type ProductDomain struct {
    // 商品聚合根
    ProductAggregate *ProductAggregate
    // 库存聚合根
    InventoryAggregate *InventoryAggregate
    // 商品仓储
    ProductRepository ProductRepository
}

// 订单领域 (Order Domain)
type OrderDomain struct {
    // 订单聚合根
    OrderAggregate *OrderAggregate
    // 购物车聚合根
    CartAggregate *CartAggregate
    // 订单仓储
    OrderRepository OrderRepository
}

// 支付领域 (Payment Domain)
type PaymentDomain struct {
    // 支付聚合根
    PaymentAggregate *PaymentAggregate
    // 支付仓储
    PaymentRepository PaymentRepository
}

聚合设计 #

用户聚合

// 用户聚合根
type User struct {
    ID          string    `json:"id"`
    Username    string    `json:"username"`
    Email       string    `json:"email"`
    Phone       string    `json:"phone"`
    Profile     Profile   `json:"profile"`
    Status      UserStatus `json:"status"`
    CreatedAt   time.Time `json:"created_at"`
    UpdatedAt   time.Time `json:"updated_at"`

    // 领域事件
    events []DomainEvent
}

type Profile struct {
    FirstName   string `json:"first_name"`
    LastName    string `json:"last_name"`
    Avatar      string `json:"avatar"`
    Birthday    time.Time `json:"birthday"`
    Gender      Gender `json:"gender"`
}

type UserStatus int

const (
    UserStatusActive UserStatus = iota + 1
    UserStatusInactive
    UserStatusSuspended
)

// 用户行为方法
func (u *User) UpdateProfile(profile Profile) error {
    if u.Status != UserStatusActive {
        return errors.New("inactive user cannot update profile")
    }

    u.Profile = profile
    u.UpdatedAt = time.Now()

    // 发布领域事件
    u.addEvent(NewUserProfileUpdatedEvent(u.ID, profile))
    return nil
}

func (u *User) Suspend() error {
    if u.Status == UserStatusSuspended {
        return errors.New("user already suspended")
    }

    u.Status = UserStatusSuspended
    u.UpdatedAt = time.Now()

    u.addEvent(NewUserSuspendedEvent(u.ID))
    return nil
}

商品聚合

// 商品聚合根
type Product struct {
    ID          string      `json:"id"`
    Name        string      `json:"name"`
    Description string      `json:"description"`
    Price       Money       `json:"price"`
    Category    Category    `json:"category"`
    Images      []string    `json:"images"`
    Attributes  []Attribute `json:"attributes"`
    Status      ProductStatus `json:"status"`
    CreatedAt   time.Time   `json:"created_at"`
    UpdatedAt   time.Time   `json:"updated_at"`

    events []DomainEvent
}

type Money struct {
    Amount   int64  `json:"amount"`   // 以分为单位
    Currency string `json:"currency"` // 货币类型
}

type Category struct {
    ID   string `json:"id"`
    Name string `json:"name"`
    Path string `json:"path"` // 分类路径
}

type Attribute struct {
    Name  string `json:"name"`
    Value string `json:"value"`
}

type ProductStatus int

const (
    ProductStatusDraft ProductStatus = iota + 1
    ProductStatusActive
    ProductStatusInactive
    ProductStatusDeleted
)

// 商品行为方法
func (p *Product) UpdatePrice(newPrice Money) error {
    if p.Status != ProductStatusActive {
        return errors.New("cannot update price for inactive product")
    }

    oldPrice := p.Price
    p.Price = newPrice
    p.UpdatedAt = time.Now()

    p.addEvent(NewProductPriceUpdatedEvent(p.ID, oldPrice, newPrice))
    return nil
}

func (p *Product) Activate() error {
    if p.Status == ProductStatusActive {
        return errors.New("product already active")
    }

    p.Status = ProductStatusActive
    p.UpdatedAt = time.Now()

    p.addEvent(NewProductActivatedEvent(p.ID))
    return nil
}

订单聚合

// 订单聚合根
type Order struct {
    ID          string      `json:"id"`
    UserID      string      `json:"user_id"`
    Items       []OrderItem `json:"items"`
    TotalAmount Money       `json:"total_amount"`
    Status      OrderStatus `json:"status"`
    ShippingAddress Address `json:"shipping_address"`
    CreatedAt   time.Time   `json:"created_at"`
    UpdatedAt   time.Time   `json:"updated_at"`

    events []DomainEvent
}

type OrderItem struct {
    ProductID string `json:"product_id"`
    Quantity  int    `json:"quantity"`
    Price     Money  `json:"price"`
    Amount    Money  `json:"amount"`
}

type Address struct {
    Street   string `json:"street"`
    City     string `json:"city"`
    Province string `json:"province"`
    Country  string `json:"country"`
    ZipCode  string `json:"zip_code"`
}

type OrderStatus int

const (
    OrderStatusPending OrderStatus = iota + 1
    OrderStatusPaid
    OrderStatusShipped
    OrderStatusDelivered
    OrderStatusCancelled
    OrderStatusRefunded
)

// 订单行为方法
func (o *Order) Pay() error {
    if o.Status != OrderStatusPending {
        return errors.New("order cannot be paid")
    }

    o.Status = OrderStatusPaid
    o.UpdatedAt = time.Now()

    o.addEvent(NewOrderPaidEvent(o.ID, o.UserID, o.TotalAmount))
    return nil
}

func (o *Order) Ship() error {
    if o.Status != OrderStatusPaid {
        return errors.New("order must be paid before shipping")
    }

    o.Status = OrderStatusShipped
    o.UpdatedAt = time.Now()

    o.addEvent(NewOrderShippedEvent(o.ID, o.UserID))
    return nil
}

func (o *Order) Cancel() error {
    if o.Status != OrderStatusPending {
        return errors.New("order cannot be cancelled")
    }

    o.Status = OrderStatusCancelled
    o.UpdatedAt = time.Now()

    o.addEvent(NewOrderCancelledEvent(o.ID, o.UserID))
    return nil
}

微服务拆分策略 #

服务边界划分 #

基于领域驱动设计，我们将系统拆分为以下微服务：

核心业务服务

  • 用户服务 (User Service)：负责用户管理、认证授权
  • 商品服务 (Product Service)：负责商品信息管理
  • 库存服务 (Inventory Service)：负责库存管理
  • 订单服务 (Order Service)：负责订单管理
  • 支付服务 (Payment Service)：负责支付处理
  • 购物车服务 (Cart Service)：负责购物车管理

支撑服务

  • 通知服务 (Notification Service)：负责消息通知
  • 搜索服务 (Search Service)：负责商品搜索
  • 推荐服务 (Recommendation Service)：负责商品推荐
  • 文件服务 (File Service)：负责文件上传下载

基础设施服务

  • 网关服务 (Gateway Service)：API 网关
  • 配置服务 (Config Service)：配置管理
  • 监控服务 (Monitoring Service)：系统监控

服务依赖关系 # 

// 服务依赖关系定义
type ServiceDependency struct {
    ServiceName string   `json:"service_name"`
    Dependencies []string `json:"dependencies"`
}

var serviceDependencies = []ServiceDependency{
    {
        ServiceName: "order-service",
        Dependencies: []string{
            "user-service",
            "product-service",
            "inventory-service",
            "payment-service",
        },
    },
    {
        ServiceName: "cart-service",
        Dependencies: []string{
            "user-service",
            "product-service",
        },
    },
    {
        ServiceName: "search-service",
        Dependencies: []string{
            "product-service",
        },
    },
}

系统架构设计 #

整体架构图 # 

┌─────────────────────────────────────────────────────────────┐
│                        Client Layer                         │
├─────────────────────────────────────────────────────────────┤
│                     API Gateway                             │
├─────────────────────────────────────────────────────────────┤
│                   Microservices Layer                       │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐      │
│  │   User   │ │ Product  │ │Inventory │ │  Order   │      │
│  │ Service  │ │ Service  │ │ Service  │ │ Service  │      │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘      │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐      │
│  │ Payment  │ │   Cart   │ │  Search  │ │   File   │      │
│  │ Service  │ │ Service  │ │ Service  │ │ Service  │      │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘      │
├─────────────────────────────────────────────────────────────┤
│                   Infrastructure Layer                      │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐      │
│  │ Service  │ │ Message  │ │  Config  │ │   Log    │      │
│  │Discovery │ │  Queue   │ │ Center   │ │ Center   │      │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘      │
├─────────────────────────────────────────────────────────────┤
│                      Data Layer                             │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐      │
│  │   User   │ │ Product  │ │  Order   │ │  Cache   │      │
│  │    DB    │ │    DB    │ │    DB    │ │  Redis   │      │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘      │
└─────────────────────────────────────────────────────────────┘

技术栈选型 #

开发语言与框架

  • Go 1.21+：主要开发语言
  • Gin：Web 框架
  • gRPC：服务间通信
  • GORM：ORM 框架

数据存储

  • PostgreSQL：主数据库
  • Redis：缓存和会话存储
  • Elasticsearch：搜索引擎
  • MongoDB：日志存储

消息队列

  • Apache Kafka：事件流处理
  • RabbitMQ：任务队列

容器化与编排

  • Docker：容器化
  • Kubernetes：容器编排
  • Helm：包管理

监控与日志

  • Prometheus：监控指标
  • Grafana：监控面板
  • Jaeger：分布式追踪
  • ELK Stack：日志分析

服务治理

  • Consul：服务发现
  • Istio：服务网格
  • Envoy：代理

数据一致性策略 #

最终一致性

对于跨服务的数据操作，采用最终一致性模型：

// 事件驱动的最终一致性
type EventHandler interface {
    Handle(event DomainEvent) error
}

// 订单支付成功事件处理器
type OrderPaidEventHandler struct {
    inventoryService InventoryService
    notificationService NotificationService
}

func (h *OrderPaidEventHandler) Handle(event DomainEvent) error {
    orderPaidEvent, ok := event.(*OrderPaidEvent)
    if !ok {
        return errors.New("invalid event type")
    }

    // 减少库存
    if err := h.inventoryService.DecreaseInventory(
        orderPaidEvent.OrderItems,
    ); err != nil {
        return err
    }

    // 发送通知
    if err := h.notificationService.SendOrderConfirmation(
        orderPaidEvent.UserID,
        orderPaidEvent.OrderID,
    ); err != nil {
        // 通知失败不影响主流程
        log.Error("failed to send notification", err)
    }

    return nil
}

分布式事务

对于强一致性要求的场景，使用 Saga 模式：

// Saga 事务管理器
type SagaManager struct {
    steps []SagaStep
}

type SagaStep struct {
    Name         string
    Execute      func() error
    Compensate   func() error
}

func (sm *SagaManager) Execute() error {
    executedSteps := make([]SagaStep, 0)

    for _, step := range sm.steps {
        if err := step.Execute(); err != nil {
            // 执行补偿操作
            for i := len(executedSteps) - 1; i >= 0; i-- {
                if compErr := executedSteps[i].Compensate(); compErr != nil {
                    log.Error("compensation failed", compErr)
                }
            }
            return err
        }
        executedSteps = append(executedSteps, step)
    }

    return nil
}

// 创建订单的 Saga 事务
func CreateOrderSaga(orderData OrderData) *SagaManager {
    return &SagaManager{
        steps: []SagaStep{
            {
                Name: "create_order",
                Execute: func() error {
                    return orderService.CreateOrder(orderData)
                },
                Compensate: func() error {
                    return orderService.CancelOrder(orderData.ID)
                },
            },
            {
                Name: "reserve_inventory",
                Execute: func() error {
                    return inventoryService.ReserveInventory(orderData.Items)
                },
                Compensate: func() error {
                    return inventoryService.ReleaseInventory(orderData.Items)
                },
            },
            {
                Name: "process_payment",
                Execute: func() error {
                    return paymentService.ProcessPayment(orderData.Payment)
                },
                Compensate: func() error {
                    return paymentService.RefundPayment(orderData.Payment.ID)
                },
            },
        },
    }
}

安全架构设计 #

认证与授权 #

JWT 认证

// JWT 服务
type JWTService struct {
    secretKey []byte
    issuer    string
    expiry    time.Duration
}

type Claims struct {
    UserID   string   `json:"user_id"`
    Username string   `json:"username"`
    Roles    []string `json:"roles"`
    jwt.RegisteredClaims
}

func (j *JWTService) GenerateToken(user *User) (string, error) {
    claims := &Claims{
        UserID:   user.ID,
        Username: user.Username,
        Roles:    user.Roles,
        RegisteredClaims: jwt.RegisteredClaims{
            Issuer:    j.issuer,
            ExpiresAt: jwt.NewNumericDate(time.Now().Add(j.expiry)),
            IssuedAt:  jwt.NewNumericDate(time.Now()),
        },
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString(j.secretKey)
}

func (j *JWTService) ValidateToken(tokenString string) (*Claims, error) {
    token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
        return j.secretKey, nil
    })

    if err != nil {
        return nil, err
    }

    if claims, ok := token.Claims.(*Claims); ok && token.Valid {
        return claims, nil
    }

    return nil, errors.New("invalid token")
}

RBAC 权限控制

// 权限管理
type Permission struct {
    ID       string `json:"id"`
    Resource string `json:"resource"`
    Action   string `json:"action"`
}

type Role struct {
    ID          string       `json:"id"`
    Name        string       `json:"name"`
    Permissions []Permission `json:"permissions"`
}

type RBACService struct {
    roleRepo       RoleRepository
    permissionRepo PermissionRepository
}

func (r *RBACService) CheckPermission(userID, resource, action string) (bool, error) {
    user, err := r.userRepo.GetByID(userID)
    if err != nil {
        return false, err
    }

    for _, roleName := range user.Roles {
        role, err := r.roleRepo.GetByName(roleName)
        if err != nil {
            continue
        }

        for _, permission := range role.Permissions {
            if permission.Resource == resource && permission.Action == action {
                return true, nil
            }
        }
    }

    return false, nil
}

API 安全 #

请求限流

// 限流中间件
func RateLimitMiddleware(limiter *rate.Limiter) gin.HandlerFunc {
    return func(c *gin.Context) {
        if !limiter.Allow() {
            c.JSON(http.StatusTooManyRequests, gin.H{
                "error": "rate limit exceeded",
            })
            c.Abort()
            return
        }
        c.Next()
    }
}

// 基于用户的限流
type UserRateLimiter struct {
    limiters map[string]*rate.Limiter
    mu       sync.RWMutex
    rate     rate.Limit
    burst    int
}

func NewUserRateLimiter(r rate.Limit, b int) *UserRateLimiter {
    return &UserRateLimiter{
        limiters: make(map[string]*rate.Limiter),
        rate:     r,
        burst:    b,
    }
}

func (u *UserRateLimiter) GetLimiter(userID string) *rate.Limiter {
    u.mu.RLock()
    limiter, exists := u.limiters[userID]
    u.mu.RUnlock()

    if !exists {
        u.mu.Lock()
        limiter = rate.NewLimiter(u.rate, u.burst)
        u.limiters[userID] = limiter
        u.mu.Unlock()
    }

    return limiter
}

通过本节的学习，我们完成了电商微服务系统的整体架构设计。下一节将开始具体实现用户服务。