Golang实现Dubbo HTTP代理：基于泛化调用与Nacos服务发现

module dubbo-proxy

go 1.20

require (
	dubbo.apache.org/dubbo-go/v3 v3.0.5
	github.com/apache/dubbo-go-hessian2 v1.12.0
	github.com/gin-gonic/gin v1.9.0
	github.com/nacos-group/nacos-sdk-go/v2 v2.1.2
)

type DataResult struct {
	Env     string `json:"env,omitempty"`  // 当前调用环境
	Code    string `json:"code,omitempty"` // 业务返回结果码
	Data    any    `json:"data,omitempty"` // 实际业务数据
	Message string `json:"message,omitempty"` // 状态描述信息
}

package dubbo

import (
	"fmt"
	"github.com/nacos-group/nacos-sdk-go/v2/clients"
	"github.com/nacos-group/nacos-sdk-go/v2/clients/naming_client"
	"github.com/nacos-group/nacos-sdk-go/v2/common/constant"
	"github.com/nacos-group/nacos-sdk-go/v2/vo"
)

// 存储不同环境对应的 Client 映射
var cliMap = make(map[string]naming_client.INamingClient)

func init() {
	// 假设所有环境共用同一组 Nacos 服务器 IP，仅 Namespace 不同
	serverCfgs := []constant.ServerConfig{
		*constant.NewServerConfig("127.0.0.1", 6801, constant.WithContextPath("/nacos")),
	}
	cliMap["local"] = buildClient("local", serverCfgs)
	cliMap["dev"] = buildClient("develop", serverCfgs)
	cliMap["test"] = buildClient("test", serverCfgs)
}

// 构建命名服务客户端
func buildClient(env string, serverCfgs []constant.ServerConfig) naming_client.INamingClient {
	client, _ := clients.NewNamingClient(
		vo.NacosClientParam{
			ClientConfig: constant.NewClientConfig(
				constant.WithNamespaceId(env),
				constant.WithNotLoadCacheAtStart(true),
			),
			ServerConfigs: serverCfgs,
		},
	)
	return client
}

// 根据服务名和环境获取首个健康的 Dubbo 实例 URL
func SelectInstance(env, servName string) (string, bool) {
	cli, ok := cliMap[env]
	if !ok {
		return "client not found from " + env, false
	}
	// Dubbo 在 Nacos 中的默认 Group 通常遵循 providers:name:version:
	instances, e := cli.SelectInstances(vo.SelectInstancesParam{
		ServiceName: fmt.Sprintf("providers:%s:1.0.0:", servName),
		HealthyOnly: true,
	})
	if e != nil || len(instances) <= 0 {
		msg := "instance not found"
		if e != nil { msg += ", " + e.Error() }
		return msg, false
	}
	
	ip := instances[0].Ip
	port := instances[0].Port
	return fmt.Sprintf("dubbo://%s:%d", ip, port), true
}

package dubbo

import (
	"context"
	"dubbo-proxy/utils"
	cfg "dubbo.apache.org/dubbo-go/v3/config"
	"dubbo.apache.org/dubbo-go/v3/config/generic"
	_ "dubbo.apache.org/dubbo-go/v3/imports"
	"dubbo.apache.org/dubbo-go/v3/protocol/dubbo"
	hessian "github.com/apache/dubbo-go-hessian2"
)

// 全局共享 Dubbo 根配置，避免重复初始化开销
var dubboRoot = cfg.NewRootConfigBuilder().SetProtocols(map[string]*cfg.ProtocolConfig{
	dubbo.DUBBO: {
		Params: map[string]interface{}{
			"getty-session-param": map[string]interface{}{
				"max-msg-len": 1024000,
			},
		},
	},
}).Build()

// GenericInvoke 核心函数：接收字符串格式的输入并返回解析后的结构
func GenericInvoke(iName, method, env string, req []byte) DataResult {
	// 1. 获取目标服务实例地址
	instance, ok := SelectInstance(env, iName)
	if !ok {
		return DataResult{
			Code:    "ERROR",
			Message: instance,
		}
	}

	// 2. 初始化引用配置
	cfg.Load(cfg.WithRootConfig(dubboRoot))
	refConf := cfg.ReferenceConfig{
		InterfaceName: iName,
		Cluster:       "failover",
		Protocol:      dubbo.DUBBO,
		Generic:       "true",  // 启用泛化调用
		Version:       "1.0.0",
		URL:           instance,
	}
	refConf.Init(dubboRoot)
	refConf.GenericLoad("dubbo-proxy")

	// 3. 转换请求参数
	var args = utils.Unmarshal(req, &map[string]hessian.Object{})

	// 4. 发起调用
	raw, err := refConf.GetRPCService().(*generic.GenericService).Invoke(context.Background(), method, nil, []hessian.Object{args})
	if err != nil {
		panic(err)
	}

	// 5. 提取结果 (此处假设业务方返回标准三元组结构)
	rawResult := raw.(map[interface{}]interface{})
	result := DataResult{
		Code:    rawResult["code"].(string),
		Message: rawResult["message"].(string),
		Data:    utils.ConvertAs(rawResult["data"], map[string]interface{}{}),
	}
	return result
}

package web

import (
	"dubbo-proxy/dubbo"
	"github.com/gin-gonic/gin"
	"net/http"
)

func Run() {
	router := gin.Default()
	// 接口匹配规则：/:interfaceName/:methodName
	router.POST("/:intf/:method", func(c *gin.Context) {
		intf := c.Param("intf")
		method := c.Param("method")
		env := c.Query("env") // 通过 query 参数指定环境
		
		body, err := c.GetRawData()
		if err != nil {
		    c.JSON(http.StatusBadRequest, "Failed to get body")
		    return
		}
		
		res := dubbo.GenericInvoke(intf, method, env, body)
		res.Env = env
		c.JSON(http.StatusOK, res)
	})
	
	panic(router.Run(":7788"))
}

package main

import "dubbo-proxy/web"

func main() {
	web.Run()
}