# go-rpc-backnormal

**Repository Path**: go-framework_llllllh/go-rpc-backnormal

## Basic Information

- **Project Name**: go-rpc-backnormal
- **Description**: Go语言后端框架，定制更符合自身开发的go RPC服务框架。
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 1
- **Created**: 2025-07-09
- **Last Updated**: 2025-07-09

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

用Go语言原生实现一个简单的RPC框架，包括服务端和客户端的完整实现。

```
go-rpc-backnormal/src
├── client/          // 客户端实现
├── codec/           // 编解码器
│   ├── json.go
│   ├── protobuf.go
│   └── codec.go
├── conf/         // 配置管理
├── protocol/       // 协议处理
├── registry/       // 服务注册与发现
├── server/         // 服务器核心
├── transport/      // 传输层
├── auth/           // 认证相关
├── middleware/     // 中间件
└── example/        // 示例代码
```

## 一、RPC框架核心设计

### 1. 架构组成

* **通信协议**：TCP协议传输
* **编码协议**：JSON序列化
* **服务注册**：内存注册表
* **核心组件**：
  * 服务端(Server)
  * 客户端(Client)
  * 编解码器(Codec)
  * 服务注册中心(Registry)

### 2. 项目结构

**text**

```
simple-rpc/
├── client/           # 客户端实现
│   └── client.go
├── codec/            # 编解码实现
│   └── json.go
├── example/          # 示例服务
│   ├── service.go
│   └── main.go
├── server/           # 服务端实现
│   └── server.go
└── registry/         # 服务注册
    └── memory.go
```

## 二、核心代码实现

### 1. 编解码器 (codec/json.go)

**go**

```
package codec

import (
	"encoding/json"
	"io"
)

type Codec interface {
	Encode(w io.Writer, body interface{}) error
	Decode(r io.Reader, body interface{}) error
}

type JsonCodec struct{}

func (c *JsonCodec) Encode(w io.Writer, body interface{}) error {
	return json.NewEncoder(w).Encode(body)
}

func (c *JsonCodec) Decode(r io.Reader, body interface{}) error {
	return json.NewDecoder(r).Decode(body)
}
```

### 2. 服务注册中心 (registry/memory.go)

**go**

```
package registry

import "sync"

type MemoryRegistry struct {
	services map[string]interface{}
	mu       sync.RWMutex
}

func NewMemoryRegistry() *MemoryRegistry {
	return &MemoryRegistry{
		services: make(map[string]interface{}),
	}
}

func (r *MemoryRegistry) Register(name string, svc interface{}) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.services[name] = svc
}

func (r *MemoryRegistry) GetService(name string) (interface{}, bool) {
	r.mu.RLock()
	defer r.mu.RUnlock()
	svc, ok := r.services[name]
	return svc, ok
}
```

### 3. 服务端实现 (server/server.go)

**go**

```
package server

import (
	"net"
	"reflect"
	"simple-rpc/codec"
	"simple-rpc/registry"
)

type Server struct {
	registry *registry.MemoryRegistry
	codec    codec.Codec
}

func NewServer() *Server {
	return &Server{
		registry: registry.NewMemoryRegistry(),
		codec:    &codec.JsonCodec{},
	}
}

func (s *Server) Register(name string, svc interface{}) {
	s.registry.Register(name, svc)
}

func (s *Server) Start(addr string) error {
	ln, err := net.Listen("tcp", addr)
	if err != nil {
		return err
	}

	for {
		conn, err := ln.Accept()
		if err != nil {
			continue
		}
		go s.handleConnection(conn)
	}
}

func (s *Server) handleConnection(conn net.Conn) {
	defer conn.Close()

	var req Request
	if err := s.codec.Decode(conn, &req); err != nil {
		return
	}

	svc, ok := s.registry.GetService(req.ServiceName)
	if !ok {
		return
	}

	method := reflect.ValueOf(svc).MethodByName(req.MethodName)
	if !method.IsValid() {
		return
	}

	args := make([]reflect.Value, len(req.Args))
	for i, arg := range req.Args {
		args[i] = reflect.ValueOf(arg)
	}

	result := method.Call(args)
	var response Response
	if len(result) > 0 {
		if err, ok := result[len(result)-1].Interface().(error); ok {
			response.Error = err.Error()
		} else {
			response.Result = result[0].Interface()
		}
	}

	s.codec.Encode(conn, response)
}

type Request struct {
	ServiceName string
	MethodName  string
	Args        []interface{}
}

type Response struct {
	Result interface{}
	Error  string
}
```

### 4. 客户端实现 (client/client.go)

**go**

```
package client

import (
	"net"
	"simple-rpc/codec"
	"reflect"
)

type Client struct {
	conn  net.Conn
	codec codec.Codec
}

func NewClient(addr string) (*Client, error) {
	conn, err := net.Dial("tcp", addr)
	if err != nil {
		return nil, err
	}
	return &Client{
		conn:  conn,
		codec: &codec.JsonCodec{},
	}, nil
}

func (c *Client) Call(serviceName, methodName string, args ...interface{}) (interface{}, error) {
	req := server.Request{
		ServiceName: serviceName,
		MethodName:  methodName,
		Args:        args,
	}

	if err := c.codec.Encode(c.conn, req); err != nil {
		return nil, err
	}

	var resp server.Response
	if err := c.codec.Decode(c.conn, &resp); err != nil {
		return nil, err
	}

	if resp.Error != "" {
		return nil, errors.New(resp.Error)
	}

	return resp.Result, nil
}

func (c *Client) Close() error {
	return c.conn.Close()
}
```

## 三、示例服务实现

### 1. 定义服务 (example/service.go)

**go**

```
package main

type MathService struct{}

func (m *MathService) Add(a, b int) (int, error) {
	return a + b, nil
}

func (m *MathService) Subtract(a, b int) (int, error) {
	return a - b, nil
}
```

### 2. 服务端启动 (example/main.go)

**go**

```
package main

import (
	"log"
	"simple-rpc/server"
)

func main() {
	s := server.NewServer()
	s.Register("MathService", &MathService{})

	log.Println("Server starting on :1234")
	if err := s.Start(":1234"); err != nil {
		log.Fatal("Server error:", err)
	}
}
```

### 3. 客户端调用 (example/client\_test.go)

**go**

```
package main

import (
	"fmt"
	"log"
	"simple-rpc/client"
)

func main() {
	c, err := client.NewClient("localhost:1234")
	if err != nil {
		log.Fatal(err)
	}
	defer c.Close()

	// 调用Add方法
	result, err := c.Call("MathService", "Add", 5, 3)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("5 + 3 =", result.(float64)) // JSON默认解码为float64

	// 调用Subtract方法
	result, err = c.Call("MathService", "Subtract", 5, 3)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("5 - 3 =", result.(float64))
}
```

## 四、运行示例

1. 启动服务端：

**bash**

```
go run example/main.go
```

2. 运行客户端测试：

**bash**

```
go run example/client_test.go
```

## 五、扩展建议

1. **性能优化**：
   * 使用更高效的编解码协议（如Protocol Buffers）
   * 实现连接池管理
   * 添加压缩支持
2. **功能增强**：
   * 服务发现机制
   * 负载均衡
   * 超时控制
   * 熔断机制
3. **生产级改进**：
   * 添加TLS安全传输
   * 实现健康检查
   * 日志和监控集成

这个实现展示了RPC框架的核心原理，虽然简单但包含了服务注册、方法调用、网络通信等关键要素。你可以基于此框架继续扩展完善，或者参考这个实现理解主流RPC框架的工作原理。