「产品矩阵平台」可扩展的服务框架

app/
  modules/
    user/
      module.go
      service.go
      repository.go
      routes.go
      events.go
    commerce/
      module.go
      service.go
      repository.go
      routes.go

type Module interface {
    Name() string
    Register(container Container) error
    Boot(ctx context.Context) error
    Routes(router Router)
    Shutdown(ctx context.Context) error
}

ValidateCart -> CalculatePrice -> LockInventory -> CreateOrder -> EmitEvent

plume make:module content
plume make:service content ArticleService
plume make:event order.created

package kernel

import (
    "context"
    "github.com/goravel/framework/contracts/route"
)

// Module 所有业务模块必须实现的接口
type Module interface {
    Name() string
    // 仅注册依赖，不做网络或 IO 操作
    Register(container Container) error
    // 执行启动逻辑：初始化连接、订阅事件、注册 Worker
    Boot(ctx context.Context) error
    // 注册路由和中间件
    Routes(router route.Route) error
    // 优雅关闭
    Shutdown(ctx context.Context) error
}

// Kernel 内核负责模块的注册与生命周期管理
type Kernel struct {
    modules    []Module
    container  Container
    router     route.Route
}

func (k *Kernel) Register(m Module) error {
    k.modules = append(k.modules, m)
    return m.Register(k.container)
}

func (k *Kernel) Boot(ctx context.Context) error {
    // 解析所有模块依赖
    if err := k.container.ResolveAll(); err != nil {
        return err
    }
    // 按注册顺序启动
    for _, m := range k.modules {
        if err := m.Boot(ctx); err != nil {
            return err
        }
    }
    // 注册路由
    for _, m := range k.modules {
        if err := m.Routes(k.router); err != nil {
            return err
        }
    }
    return nil
}

func (k *Kernel) Shutdown(ctx context.Context) error {
    // 逆序关闭，先注册的模块后关闭
    for i := len(k.modules) - 1; i >= 0; i-- {
        if err := k.modules[i].Shutdown(ctx); err != nil {
            return err
        }
    }
    return nil
}

// app/modules/order/module.go
package order

import (
    "context"
    "github.com/goravel/framework/contracts/route"
)

type Module struct {
    service     *OrderService
    eventBus    EventBus
    config      Config
}

func NewModule(bus EventBus, cfg Config) *Module {
    return &Module{
        eventBus: bus,
        config:   cfg,
    }
}

func (m *Module) Name() string { return "order" }

func (m *Module) Register(c Container) error {
    m.service = NewOrderService(c.Get("inventory.client"),
        c.Get("payment.client"), m.eventBus)
    c.Bind("order.service", m.service)
    c.Bind("order.controller", NewOrderController(m.service))
    return nil
}

func (m *Module) Boot(ctx context.Context) error {
    // 预加载配置
    m.config.Load("order")
    return nil
}

func (m *Module) Routes(r route.Route) error {
    ctrl := m.container.Get("order.controller").(*OrderController)
    r.Group("/api/v1/orders", func(r route.Route) {
        r.Get("/", ctrl.Index)
        r.Post("/", ctrl.Create)
        r.Get("/{id}", ctrl.Show)
        r.Put("/{id}/cancel", ctrl.Cancel)
    })
    return nil
}

func (m *Module) Shutdown(ctx context.Context) error {
    // 关闭持久连接、释放 Worker
    return nil
}

package eventbus

import (
    "context"
    "sync"
)

type EventBus struct {
    handlers map[string][]Handler
    mu       sync.RWMutex
}

type Event struct {
    Name     string
    TenantID string
    AppID    string
    Payload  interface{}
}

type Handler func(ctx context.Context, e Event) error

func (eb *EventBus) On(event string, h Handler) {
    eb.mu.Lock()
    defer eb.mu.Unlock()
    eb.handlers[event] = append(eb.handlers[event], h)
}

func (eb *EventBus) Emit(ctx context.Context, e Event) error {
    eb.mu.RLock()
    hs := eb.handlers[e.Name]
    eb.mu.RUnlock()

    for _, h := range hs {
        // 异步执行，避免阻塞发布方
        go func(handler Handler) {
            if err := handler(ctx, e); err != nil {
                // 写入失败日志/死信队列
            }
        }(h)
    }
    return nil
}

// 使用示例：订单创建后通知分析模块
func (s *OrderService) CreateOrder(ctx context.Context, cmd CreateOrderCommand) (*Order, error) {
    // ... 业务逻辑 ...

    s.eventBus.Emit(ctx, eventbus.Event{
        Name:     "order.created",
        TenantID: cmd.TenantID,
        AppID:    cmd.AppID,
        Payload:  order,
    })
    return order, nil
}

package pipeline

import (
    "context"
    "fmt"
)

// Pipeline 多步骤处理管道
type Pipeline struct {
    steps []Step
}

type Step interface {
    Name() string
    Execute(ctx context.Context, input interface{}) (output interface{}, err error)
}

func (p *Pipeline) Add(s Step) *Pipeline {
    p.steps = append(p.steps, s)
    return p
}

func (p *Pipeline) Run(ctx context.Context, input interface{}) (interface{}, error) {
    data := input
    for _, s := range p.steps {
        out, err := s.Execute(ctx, data)
        if err != nil {
            return nil, fmt.Errorf("step %s failed: %w", s.Name(), err)
        }
        data = out
    }
    return data, nil
}

// 订单创建 Pipeline 步骤
type ValidateCartStep   struct{ /* ... */ }
type CalculatePriceStep struct{
    plugins []PricePlugin // 营销插件扩展点
}
func (c *CalculatePriceStep) Execute(ctx context.Context, input interface{}) (interface{}, error) {
    order := input.(*Order)
    // 基础价格计算
    // 依次执行插件
    for _, plugin := range c.plugins {
        order = plugin.Apply(ctx, order)
    }
    return order, nil
}

type LockInventoryStep  struct{ /* ... */ }
type CreateOrderStep    struct{ /* ... */ }
type EmitEventStep      struct{ eventBus EventBus }

// 组装订单创建 Pipeline
func NewOrderCreatePipeline(eb EventBus, plugins []PricePlugin) *Pipeline {
    return pipeline.NewPipeline().
        Add(&ValidateCartStep{}).
        Add(&CalculatePriceStep{plugins: plugins}).
        Add(&LockInventoryStep{}).
        Add(&CreateOrderStep{}).
        Add(&EmitEventStep{eventBus: eb})
}

package plugin

import (
    "context"
    "fmt"
    "slices"
)

// Manifest 插件清单
type Manifest struct {
    ID          string   `json:"id"`
    Version     string   `json:"version"`
    Requires    []string `json:"requires"`
    Permissions []string `json:"permissions"`
    Entrypoint  string   `json:"entrypoint"`
    Enabled     bool     `json:"enabled"`
    Tenants     []string `json:"tenants"` // 空表示全部租户
}

// Validator 加载插件前校验依赖和权限
func Validate(m *Manifest, loadedModules []string, allowedPerms []string) error {
    // 依赖检查
    for _, req := range m.Requires {
        if !slices.Contains(loadedModules, req) {
            return fmt.Errorf("plugin %s requires module %s, not loaded", m.ID, req)
        }
    }
    // 权限越界检查
    for _, perm := range m.Permissions {
        if !slices.Contains(allowedPerms, perm) {
            return fmt.Errorf("plugin %s requests unauthorized permission: %s", m.ID, perm)
        }
    }
    return nil
}

// CheckTenantAccess 校验租户是否可以使用该插件
func (m *Manifest) CheckTenantAccess(tenantID string) bool {
    if len(m.Tenants) == 0 {
        return true
    }
    return slices.Contains(m.Tenants, tenantID)
}