Go语言可扩展应用模块化架构设计与实现

// yourapp/core/application.go
package core

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

// Component 是所有可插拔模块必须实现的接口。
// 它定义了模块的基础URL路径和处理HTTP请求的方法。
type Component interface {
    BaseUrl() string
    ServeHTTP(w http.ResponseWriter, r *http.Request)
}

// Application 是主应用程序的类型，负责管理和路由请求到注册的组件。
type Application struct {
    components map[string]Component // 存储已注册的组件，键为BaseUrl
    mux        *http.ServeMux     // 用于内部路由
}

// NewApplication 创建并返回一个新的Application实例。
func NewApplication() *Application {
    return &Application{
        components: make(map[string]Component),
        mux:        http.NewServeMux(),
    }
}

// Register 方法用于将组件注册到应用程序中。
// 如果BaseUrl冲突，则会发出警告。
func (app *Application) Register(comp Component) {
    baseUrl := comp.BaseUrl()
    if _, exists := app.components[baseUrl]; exists {
        log.Printf("Warning: Component with BaseUrl '%s' already registered. Overwriting.", baseUrl)
    }
    app.components[baseUrl] = comp
    // 为每个组件注册一个处理函数，将请求转发给组件自身的ServeHTTP方法
    app.mux.Handle(baseUrl+"/", http.StripPrefix(baseUrl, comp))
    log.Printf("Component '%s' registered at path '%s'", fmt.Sprintf("%T", comp), baseUrl)
}

// ServeHTTP 实现了http.Handler接口，作为主应用程序的入口点。
// 它根据请求路径将请求路由到相应的组件。
func (app *Application) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 尝试通过内置的ServeMux进行路由
    app.mux.ServeHTTP(w, r)
}

// Run 启动应用程序的HTTP服务器。
func (app *Application) Run(addr string) {
    log.Printf("Application listening on %s", addr)
    log.Fatal(http.ListenAndServe(addr, app))
}

// yourapp/blog/blog.go
package blog

import (
    "fmt"
    "net/http"
)

// Blog 是一个示例组件，代表一个博客模块。
type Blog struct {
    Title string
    // 其他博客相关的配置或数据
}

// BaseUrl 返回此组件的基础URL路径。
func (b Blog) BaseUrl() string {
    return "/blog"
}

// ServeHTTP 处理针对/blog路径的请求。
func (b Blog) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/" {
        fmt.Fprintf(w, "Welcome to the %s Blog Home Page!", b.Title)
    } else {
        fmt.Fprintf(w, "You are viewing a blog post under %s: %s", b.Title, r.URL.Path)
    }
}

// main.go
package main

import (
    "log"

    "your_module_path/App/Modules/Blog" // 替换为你的实际模块路径
    "your_module_path/App/Modules/Core" // 替换为你的实际核心路径
)

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

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

    // 注册其他模块...
    // app.Register(another_module.AnotherModule{})

    log.Println("All components registered.")
    app.Run(":8080")
}

// blog_service/main.go
package main

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

func main() {
    http.HandleFunc("/blog/", func(w http.ResponseWriter, r *http.Request) {
        path := r.URL.Path[len("/blog/"):]
        if path == "" {
            fmt.Fprintf(w, "Welcome to the Blog Service Home Page!")
        } else {
            fmt.Fprintf(w, "You are viewing a blog post from the Blog Service: %s", path)
        }
    })

    log.Println("Blog Service listening on :8081")
    log.Fatal(http.ListenAndServe(":8081", nil))
}

// main.go (使用反向代理)
package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
)

func main() {
    // 注册组件服务及其对应的代理目标
    // 实际应用中，这些映射关系可能从配置文件或服务发现中获取
    componentProxies := map[string]*httputil.ReverseProxy{
        "/blog/": httputil.NewSingleHostReverseProxy(&url.URL{
            Scheme: "http",
            Host:   "localhost:8081", // 博客服务运行的地址
        }),
        // "/users/": httputil.NewSingleHostReverseProxy(&url.URL{
        //  Scheme: "http",
        //  Host:   "localhost:8082", // 用户服务运行的地址
        // }),
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        for prefix, proxy := range componentProxies {
            if strings.HasPrefix(r.URL.Path, prefix) {
                log.Printf("Routing request for %s to %s", r.URL.Path, proxy.Director)
                proxy.ServeHTTP(w, r)
                return
            }
        }
        // 如果没有匹配的组件，返回404
        http.NotFound(w, r)
    })

    log.Println("Main Application (Gateway) listening on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// component_rpc/api.go (示例RPC接口定义)
package component_rpc

type ComponentService interface {
    RegisterComponent(args *RegisterArgs, reply *RegisterReply) error
    UnregisterComponent(args *UnregisterArgs, reply *UnregisterReply) error
    GetGlobalConfig(args *ConfigArgs, reply *ConfigReply) error
}

type RegisterArgs struct {
    ComponentName string
    BaseUrl       string
    Endpoint      string // 组件的服务地址
}
type RegisterReply struct {
    Success bool
    Message string
}
// ... 其他RPC方法和结构