Go 语言实现可插拔组件架构：编译时与运行时扩展

// yourapp/core/application.go
package core

import (
    "fmt"
    "net/http"
    "strings"
)

// Component 接口定义了所有可插插拔模块必须实现的方法
type Component interface {
    BaseUrl() string
    ServeHTTP(w http.ResponseWriter, r *http.Request)
}

// Application 是主应用程序类型
type Application struct {
    components map[string]Component // 存储注册的组件，键为BaseUrl
    // 其他应用配置...
}

// NewApplication 创建一个新的 Application 实例
func NewApplication() *Application {
    return &Application{
        components: make(map[string]Component),
    }
}

// Register 方法用于注册组件
func (app *Application) Register(comp Component) {
    baseURL := comp.BaseUrl()
    if _, exists := app.components[baseURL]; exists {
        panic(fmt.Sprintf("Component with base URL '%s' already registered", baseURL))
    }
    app.components[baseURL] = comp
    fmt.Printf("Registered component: %s at %s\n", comp.BaseUrl(), baseURL)
}

// ServeHTTP 实现 http.Handler 接口，用于处理所有传入请求
func (app *Application) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    for baseURL, comp := range app.components {
        if strings.HasPrefix(r.URL.Path, baseURL) {
            // 将请求路径调整为组件内部路径
            r.URL.Path = strings.TrimPrefix(r.URL.Path, baseURL)
            comp.ServeHTTP(w, r)
            return
        }
    }
    http.NotFound(w, r)
}

// Run 启动应用服务器
func (app *Application) Run(addr string) {
    fmt.Printf("Application running on %s\n", addr)
    http.ListenAndServe(addr, app)
}

// yourapp/blog/blog.go
package blog

import (
    "fmt"
    "net/http"
)

// Blog 是一个组件实现
type Blog struct {
    Title string
    // 其他博客配置或数据...
}

// BaseUrl 实现 Component 接口
func (b Blog) BaseUrl() string {
    return "/blog"
}

// ServeHTTP 实现 Component 接口，处理博客相关请求
func (b Blog) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to %s - Blog Module! Request path: %s\n", b.Title, r.URL.Path)
    // 根据 r.URL.Path 进一步处理博客文章、评论等
}

// main.go
package main

import (
    "yourapp/blog" // 导入博客组件包
    "yourapp/core" // 导入核心应用包
)

func main() {
    app := core.NewApplication()

    // 注册博客组件
    app.Register(blog.Blog{
        Title: "我的个人博客",
    })

    // 注册其他组件...
    // app.Register(anotherModule.AnotherComponent{})

    app.Run(":8080")
}

// blog_service/main.go
package main

import (
    "fmt"
    "log"
    "net"
    "net/http"
    "net/rpc"
)

// BlogRPCService 是博客组件提供的 RPC 服务
type BlogRPCService struct{}

// HandleRequest 是一个 RPC 方法，用于处理博客相关的 HTTP 请求（实际场景中可能更复杂，直接返回HTML或JSON）
func (s *BlogRPCService) HandleRequest(args string, reply *string) error {
    *reply = fmt.Sprintf("Blog service received request: %s", args)
    return nil
}

// RegisterComponent 示例：组件向主应用注册自身
func (s *BlogRPCService) RegisterComponent(args string, reply *string) error {
    *reply = fmt.Sprintf("Blog service registered with name: %s", args)
    return nil
}

func main() {
    blogService := new(BlogRPCService)
    rpc.Register(blogService)

    // 启动 RPC 监听
    listener, err := net.Listen("tcp", ":1234") // 博客服务监听 1234 端口
    if err != nil {
        log.Fatal("listen error:", err)
    }
    defer listener.Close()

    fmt.Println("Blog RPC service listening on :1234")
    rpc.Accept(listener)
}

// main.go
package main

import (
    "fmt"
    "log"
    "net/http"
    "net/http/httputil"
    "net/rpc"
    "net/url"
    "strings"
    "sync"
)

// ComponentInfo 存储组件信息
type ComponentInfo struct {
    BaseURL string
    RPCAddr string // RPC 服务地址
    Proxy   *httputil.ReverseProxy
}

// Application 是主应用程序类型
type Application struct {
    components map[string]*ComponentInfo // 键为 BaseURL
    mu         sync.RWMutex
}

func NewApplication() *Application {
    return &Application{
        components: make(map[string]*ComponentInfo),
    }
}

// RegisterComponentViaRPC 主应用连接到组件RPC并注册
func (app *Application) RegisterComponentViaRPC(baseURL, rpcAddr string) error {
    client, err := rpc.Dial("tcp", rpcAddr)
    if err != nil {
        return fmt.Errorf("dialing rpc service (%s) error: %v", rpcAddr, err)
    }
    defer client.Close()

    var reply string
    err = client.Call("BlogRPCService.RegisterComponent", baseURL, &reply)
    if err != nil {
        return fmt.Errorf("rpc call error: %v", err)
    }
    fmt.Printf("RPC registration response: %s\n", reply)

    // 设置反向代理
    remote, err := url.Parse(fmt.Sprintf("http://%s", rpcAddr)) // 假设组件也提供 HTTP 服务
    if err != nil {
        return fmt.Errorf("parsing remote url error: %v", err)
    }
    proxy := httputil.NewSingleHostReverseProxy(remote)

    app.mu.Lock()
    app.components[baseURL] = &ComponentInfo{
        BaseURL: baseURL,
        RPCAddr: rpcAddr,
        Proxy:   proxy,
    }
    app.mu.Unlock()
    fmt.Printf("Registered component via RPC: %s at %s\n", baseURL, rpcAddr)
    return nil
}

// ServeHTTP 实现 http.Handler 接口
func (app *Application) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    app.mu.RLock()
    defer app.mu.RUnlock()

    for baseURL, compInfo := range app.components {
        if strings.HasPrefix(r.URL.Path, baseURL) {
            // 将请求路径调整为组件内部路径
            r.URL.Path = strings.TrimPrefix(r.URL.Path, baseURL)
            compInfo.Proxy.ServeHTTP(w, r)
            return
        }
    }
    http.NotFound(w, r)
}

func main() {
    app := NewApplication()

    // 假设博客组件服务已经在 :1234 端口运行
    err := app.RegisterComponentViaRPC("/blog", "localhost:1234")
    if err != nil {
        log.Fatalf("Failed to register blog component: %v", err)
    }

    fmt.Println("Main application running on :8080")
    log.Fatal(http.ListenAndServe(":8080", app))
}