XRPC 是一个基于 Go 语言开发的高性能、企业级分布式 RPC 框架，提供了完整的微服务开发解决方案。

• 高性能消息传输：基于高效的消息队列机制实现RPC调用
• 并发安全：全面的并发安全保护，支持高并发场景
• 分布式追踪：内置OpenTelemetry兼容的分布式追踪系统
• 性能监控：丰富的性能指标收集和监控功能
• 多协议支持：支持HTTP、gRPC、WebSocket等多种协议

• TLS加密：完整的TLS支持，确保传输安全
• 身份认证：支持JWT、API Key、HMAC等多种认证方式
• 访问控制：IP白名单/黑名单、流量限制
• CORS支持：完善的跨域资源共享配置
• CSRF防护：内置CSRF攻击防护机制

• 分布式追踪：完整的请求链路追踪
• 指标监控：计数器、仪表盘、直方图等监控指标
• 健康检查：HTTP、TCP、gRPC多种健康检查机制
• 实时仪表板：提供Web界面的实时监控面板

• 负载均衡：轮询、加权轮询、最少连接、一致性哈希算法
• 服务发现：自动服务注册与发现机制
• 故障转移：智能故障检测和自动恢复
• 熔断器：防雪崩的熔断保护机制

• 认证中间件：多种认证策略支持
• 限流中间件：令牌桶、滑动窗口等限流算法
• 缓存中间件：LRU、LFU、FIFO等多种缓存策略
• 安全中间件：综合安全检查和防护

go get github.com/darkit/xrpc

package main

import (
    "context"
    "log"
    
    "github.com/darkit/xrpc"
)

func main() {
    // 创建XRPC实例
    rpcServer := xrpc.NewXRPC()
    
    // 配置选项
    opts := &xrpc.Options{
        EnableTracing:    true,
        EnableMetrics:    true,
        MetricsInterval: 10,
    }
    rpcServer.SetOptions(opts)
    
    // 注册服务方法
    rpcServer.RegisterMethod("hello", func(ctx context.Context, args []interface{}) (interface{}, error) {
        if len(args) > 0 {
            name := args[0].(string)
            return "Hello, " + name, nil
        }
        return "Hello, World!", nil
    })
    
    // 启动服务器
    if err := rpcServer.Serve(":8080"); err != nil {
        log.Fatal(err)
    }
}

package main

import (
    "context"
    "fmt"
    "log"
    
    "github.com/darkit/xrpc"
)

func main() {
    // 创建客户端
    client := xrpc.NewXRPC()
    
    // 连接服务器
    if err := client.Connect("localhost:8080"); err != nil {
        log.Fatal(err)
    }
    defer client.Close()
    
    // 调用远程方法
    result, err := client.Call(context.Background(), "hello", []interface{}{"World"})
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println(result) // 输出: Hello, World
}

// 创建安全管理器
securityConfig := &xrpc.SecurityConfig{
    EnableTLS:       true,
    CertFile:        "/path/to/cert.pem",
    KeyFile:         "/path/to/key.pem",
    EnableAuth:      true,
    AuthType:        "jwt",
    SecretKey:       "your-secret-key",
    EnableRateLimit: true,
    RateLimitPerIP:  100,
}

securityManager, err := xrpc.NewSecurityManager(securityConfig)
if err != nil {
    log.Fatal(err)
}

// 应用安全配置
rpcServer.SetSecurityManager(securityManager)

// 创建负载均衡器
lbConfig := &xrpc.LoadBalancerConfig{
    Algorithm: "round_robin", // round_robin, weighted_round_robin, least_connections, consistent_hash
    HealthCheckInterval: 30 * time.Second,
    MaxRetries: 3,
}

loadBalancer := xrpc.NewLoadBalancer(lbConfig)

// 添加服务节点
nodes := []*xrpc.ServiceNode{
    {ID: "node1", Address: "192.168.1.10", Port: 8080, Weight: 100},
    {ID: "node2", Address: "192.168.1.11", Port: 8080, Weight: 100},
    {ID: "node3", Address: "192.168.1.12", Port: 8080, Weight: 50},
}

loadBalancer.UpdateNodes("my-service", nodes)

// 创建健康监控器
healthConfig := &xrpc.HealthMonitorConfig{
    DefaultInterval: 30 * time.Second,
    DefaultTimeout:  5 * time.Second,
    MaxWorkers:      10,
    EnableMetrics:   true,
}

healthMonitor := xrpc.NewHealthMonitor(healthConfig)

// 添加健康检查目标
target := &xrpc.HealthTarget{
    ID:       "service-node-1",
    Type:     "http",
    Address:  "192.168.1.10",
    Port:     8080,
    Path:     "/health",
    Interval: 15 * time.Second,
    Timeout:  3 * time.Second,
}

healthMonitor.AddTarget(target)

// 创建追踪器配置
tracerConfig := &xrpc.TracerConfig{
    ServiceName:    "my-rpc-service",
    ServiceVersion: "1.0.0",
    ExporterType:   "jaeger", // jaeger, console, file
    ExporterConfig: map[string]string{
        "endpoint": "http://jaeger:14268/api/traces",
    },
    SamplingRate: 1.0, // 100% 采样
}

tracer := xrpc.NewTracer(tracerConfig)
rpcServer.SetTracer(tracer)

// 认证中间件
authConfig := &xrpc.AuthConfig{
    Type:      "jwt",
    SecretKey: "your-secret-key",
    TokenTTL:  time.Hour,
}
authMiddleware := xrpc.NewAuthMiddleware(authConfig)

// 限流中间件
rateLimitConfig := &xrpc.RateLimitConfig{
    Algorithm:    "token_bucket",
    Rate:         100,
    BurstSize:    200,
    WindowSize:   time.Minute,
}
rateLimitMiddleware := xrpc.NewRateLimitMiddleware(rateLimitConfig)

// 缓存中间件
cacheConfig := &xrpc.CacheConfig{
    Algorithm:  "lru",
    MaxSize:    1000,
    DefaultTTL: 10 * time.Minute,
}
cacheMiddleware := xrpc.NewCacheMiddleware(cacheConfig)

// 注册中间件
rpcServer.Use(authMiddleware)
rpcServer.Use(rateLimitMiddleware)
rpcServer.Use(cacheMiddleware)

XRPC 提供了完整的开发者工具链，提升开发效率：

# 编译工具
cd cmd/xrpc && go build -o ../../bin/xrpc

# 生成RPC客户端代码
./bin/xrpc generate -input service.go -output client.go -format client

# 生成服务端代码
./bin/xrpc generate -input service.go -output server.go -format server

# 生成接口定义
./bin/xrpc generate -input service.go -output interface.go -format interface

# 编译调试工具
cd cmd/xrpc-debug && go build -o ../../bin/xrpc-debug

# 调试RPC连接
./bin/xrpc-debug -target localhost:8080 -method ping

# 性能测试
./bin/xrpc-debug -target localhost:8080 -method hello -concurrent 100 -requests 1000

# 编译格式化工具
cd cmd/xrpc-fmt && go build -o ../../bin/xrpc-fmt

# 格式化代码
./bin/xrpc-fmt -input service.go -output formatted.go

# 编译文档生成器
cd cmd/xrpc-docs && go build -o ../../bin/xrpc-docs

# 生成文档
./bin/xrpc-docs -input service.go -output docs/ -format html

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   客户端应用     │    │   负载均衡器     │    │   服务端应用     │
│                │    │                │    │                │
│  ┌───────────┐  │    │  ┌───────────┐  │    │  ┌───────────┐  │
│  │ RPC Client│──┼────┼──│LoadBalancer│──┼────┼──│RPC Server │  │
│  └───────────┘  │    │  └───────────┘  │    │  └───────────┘  │
│                │    │                │    │                │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         └───────────────────────┼───────────────────────┘
                                │
                    ┌─────────────────┐
                    │   基础设施层     │
                    │                │
                    │ ┌─────┐ ┌─────┐ │
                    │ │追踪│ │监控│ │
                    │ └─────┘ └─────┘ │
                    │ ┌─────┐ ┌─────┐ │
                    │ │缓存│ │安全│ │
                    │ └─────┘ └─────┘ │
                    └─────────────────┘

• 并发处理：支持万级并发连接
• 响应延迟：平均延迟 < 1ms（本地测试）
• 吞吐量：> 100K RPS（8核16GB测试环境）
• 内存使用：优化的内存管理，避免内存泄漏
• CPU利用率：高效的协程调度，CPU使用率优化

项目提供了丰富的示例代码，展示各种功能的使用方法：

• examples/basic_example.go - 基础RPC调用示例
• examples/middleware_example.go - 中间件使用示例
• examples/load_balancer_example.go - 负载均衡示例
• examples/health_check_example.go - 健康检查示例
• examples/security_demo.go - 安全功能演示
• examples/tracing_example.go - 分布式追踪示例

我们欢迎社区贡献！请遵循以下步骤：

1. Fork 项目仓库
2. 创建功能分支 (git checkout -b feature/amazing-feature)
3. 提交变更 (git commit -m '✨feat: 添加某个功能')
4. 推送分支 (git push origin feature/amazing-feature)
5. 创建 Pull Request

• 遵循 Go 编程规范
• 编写单元测试
• 更新相关文档
• 确保代码通过 lint 检查

• v2.0 - gRPC原生支持
• v2.1 - 服务网格集成
• v2.2 - 云原生部署支持
• v2.3 - 图形化配置界面
• v3.0 - 跨语言SDK支持

本项目采用 MIT 许可证 - 查看 LICENSE 文件了解详情。

• 文档：访问 项目文档 获取详细信息
• 问题反馈：通过 GitHub Issues 报告问题
• 讨论：加入我们的 GitHub Discussions
• 邮件：技术支持邮箱 support@darkit.io

感谢所有为 XRPC 项目做出贡献的开发者和社区成员！

---

XRPC - 让分布式RPC开发更简单、更高效、更安全！