一、网络编程与最简 RPC

package main

import (
	"bufio"
	"fmt"
	"net"
)

// TCPServer 是一个简单的 TCP 服务器结构体
// 它只包含一个地址字段，用于指定服务器监听的地址和端口
type TCPServer struct {
	Addr string // 服务器监听地址，例如 ":8080" 表示监听所有网卡的 8080 端口
}

// Start 启动 TCP 服务器
// 这个方法会一直阻塞，直到服务器关闭
func (s *TCPServer) Start() error {
	// 第一步：使用 net.Listen 创建一个监听器
	// 参数1 "tcp" 表示使用 TCP 协议
	// 参数2 是监听地址，例如 ":8080"
	// 返回的 listener 是一个 net.Listener 接口，用于接受客户端连接
	listener, err := net.Listen("tcp", s.Addr)
	if err != nil {
		return fmt.Errorf("监听失败: %w", err) // %w 是 Go 1.13 引入的错误包装语法
	}
	// defer 确保在函数退出时关闭监听器，防止资源泄漏
	defer listener.Close()

	fmt.Printf("服务器启动成功，监听地址: %s\n", s.Addr)

	// 第二步：在一个 for 循环中不断接受新连接
	// listener.Accept() 会阻塞，直到有客户端连接进来
	// 每次有新连接，都会返回一个 net.Conn 对象，代表这个连接
	for {
		conn, err := listener.Accept()
		if err != nil {
			// 如果接受连接出错，打印错误但不要退出服务器
			// 因为可能只是某个连接出问题，服务器应该继续服务其他客户端
			fmt.Printf("接受连接失败: %v\n", err)
			continue
		}
		// 第三步：为每个连接启动一个独立的 goroutine 来处理
		// 这样服务器就可以同时处理多个客户端的连接（并发）
		// 如果不使用 goroutine，服务器只能一次处理一个客户端
		go s.handleConn(conn)
	}
}

// handleConn 处理单个客户端连接
// 基本流程：读数据 -> 处理数据 -> 回写响应
// 这个方法会在一个独立的 goroutine 中运行
func (s *TCPServer) handleConn(conn net.Conn) {
	// defer 确保连接在函数退出时被关闭
	// 无论函数是正常返回还是 panic，defer 都会执行
	defer conn.Close()

	// 远程地址信息，用于日志打印
	remoteAddr := conn.RemoteAddr().String()
	fmt.Printf("客户端 %s 已连接\n", remoteAddr)

	// 使用 bufio.NewReader 包装 conn，方便按行读取数据
	// bufio.Reader 会缓冲数据，减少系统调用次数，提高读取效率
	reader := bufio.NewReader(conn)

	for {
		// ReadString 读取直到遇到分隔符（这里是换行符 \n）
		// 返回的内容包含分隔符本身
		// 如果客户端关闭了连接，会返回 io.EOF 错误
		line, err := reader.ReadString('\n')
		if err != nil {
			// 如果遇到 EOF，说明客户端主动关闭了连接，这是正常情况
			// ErrUnexpectedEOF 表示读取到一半连接断了
			// 这两种情况都应该直接关闭连接
			fmt.Printf("客户端 %s 断开连接: %v\n", remoteAddr, err)
			return // 退出函数，defer 会关闭 conn
		}

		// 去掉末尾的换行符，得到纯净的消息内容
		msg := line[:len(line)-1]
		fmt.Printf("收到来自 %s 的消息: %s\n", remoteAddr, msg)

		// 处理数据：这里简单地把消息转成大写
		// 在真实场景中，这里可能是查数据库、调用其他服务等
		response := fmt.Sprintf("大写: %s\n", toUpper(msg))

		// 回写响应：把处理结果写回给客户端
		// conn.Write 是把字节切片写入连接，通过网络发送给客户端
		// 即便处理数据出错，也要返回一个错误给客户端
		// 不然客户端不知道服务端处理出错了
		_, err = conn.Write([]byte(response))
		if err != nil {
			fmt.Printf("写回响应失败: %v\n", err)
			return
		}
	}
}

// toUpper 将字符串转换为大写
// 这是一个辅助函数，模拟"处理数据"的逻辑
func toUpper(s string) string {
	result := make([]byte, len(s))
	for i := 0; i < len(s); i++ {
		// 如果是小写字母（a-z），转换成大写（A-Z）
		// 小写字母的 ASCII 码比大写字母大 32
		if s[i] >= 'a' && s[i] <= 'z' {
			result[i] = s[i] - 32
		} else {
			result[i] = s[i]
		}
	}
	return string(result)
}

func main() {
	// 创建一个 TCP 服务器，监听 8080 端口
	// ":8080" 表示监听所有网卡的 8080 端口
	// 如果只想监听本机，可以用 "127.0.0.1:8080"
	server := &TCPServer{Addr: ":8080"}

	// 启动服务器，这个调用会一直阻塞
	if err := server.Start(); err != nil {
		fmt.Printf("服务器启动失败: %v\n", err)
	}
}

package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"time"
)

// TCPClient 是一个简单的 TCP 客户端结构体
type TCPClient struct {
	Addr string // 服务器地址，例如 "127.0.0.1:8080"
}

// Connect 连接服务器并发送消息
func (c *TCPClient) Connect() error {
	// 第一步：使用 net.DialTimeout 连接服务器
	// 参数1 "tcp" 表示使用 TCP 协议
	// 参数2 是服务器地址
	// 参数3 是超时时间——超过这个时间还没连上就返回错误
	// 使用 DialTimeout 而不是 Dial，可以避免一直阻塞
	conn, err := net.DialTimeout("tcp", c.Addr, 3*time.Second)
	if err != nil {
		return fmt.Errorf("连接服务器失败: %w", err)
	}
	// 确保函数退出时关闭连接
	defer conn.Close()

	fmt.Printf("已连接到服务器 %s\n", c.Addr)

	// 使用 bufio 读写，方便处理文本数据
	reader := bufio.NewReader(conn)    // 用于读取服务器返回的数据
	stdinReader := bufio.NewReader(os.Stdin) // 用于读取用户从键盘输入的数据

	for {
		// 提示用户输入
		fmt.Print("请输入消息（输入 quit 退出）: ")

		// 从标准输入（键盘）读取一行
		line, err := stdinReader.ReadString('\n')
		if err != nil {
			return fmt.Errorf("读取输入失败: %w", err)
		}

		// 去掉末尾换行符
		msg := line[:len(line)-1]

		// 如果用户输入 quit，退出循环
		if msg == "quit" {
			break
		}

		// 第二步：发送消息到服务器
		// 需要在消息末尾加上换行符，因为服务器用 ReadString('\n') 读取
		_, err = conn.Write([]byte(msg + "\n"))
		if err != nil {
			return fmt.Errorf("发送消息失败: %w", err)
		}

		// 第三步：读取服务器的响应
		// 服务器返回的数据也以换行符结尾
		response, err := reader.ReadString('\n')
		if err != nil {
			return fmt.Errorf("读取响应失败: %w", err)
		}

		fmt.Printf("服务器响应: %s", response)
	}

	return nil
}

func main() {
	// 创建客户端，连接到本机 8080 端口的服务器
	client := &TCPClient{Addr: "127.0.0.1:8080"}

	if err := client.Connect(); err != nil {
		fmt.Printf("客户端出错: %v\n", err)
	}
}

# 终端1：启动服务器
go run server.go

# 终端2：启动客户端
go run client.go

// handleConnV2 使用模式二处理连接
// 读请求和处理请求分离，提高单个连接的吞吐量
func (s *TCPServer) handleConnV2(conn net.Conn) {
	defer conn.Close()
	remoteAddr := conn.RemoteAddr().String()
	reader := bufio.NewReader(conn)

	for {
		// 读取请求（当前 goroutine 负责）
		line, err := reader.ReadString('\n')
		if err != nil {
			fmt.Printf("客户端 %s 断开: %v\n", remoteAddr, err)
			return
		}
		msg := line[:len(line)-1]

		// 将处理和写响应交给新 goroutine
		// 这样当前 goroutine 可以立即回去读下一个请求
		// 注意：这里不能再使用 conn.Write，因为多个 goroutine
		// 同时写同一个 conn 会导致数据交错
		// 需要用 channel 或锁来同步写操作
		go func(message string) {
			response := fmt.Sprintf("大写: %s\n", toUpper(message))
			// 在真实场景中，这里需要加锁或者用专门的写 goroutine
			conn.Write([]byte(response))
		}(msg)
	}
}

package main

import (
	"errors"
	"fmt"
	"net"
	"sync"
	"time"
)

// PoolOption 是连接池的配置参数
type PoolOption struct {
	InitialCap    int           // 初始连接数：启动时预先创建的连接数量
	MaxIdle       int           // 最大空闲连接数：空闲队列最多保存多少个连接
	MaxCap        int           // 最大连接数：同时存在的连接上限
	MaxIdleTime   time.Duration // 最大空闲时间：超过这个时间的空闲连接会被关闭
	Factory       func() (net.Conn, error) // 工厂函数：用于创建新连接
}

// ConnPool 是一个简单的连接池实现
type ConnPool struct {
	mu          sync.Mutex           // 互斥锁，保护并发访问
	conns       chan *idleConn       // 空闲连接队列，用 channel 实现
	factory     func() (net.Conn, error) // 创建新连接的工厂函数
	maxCap      int                  // 最大连接数
	maxIdle     int                  // 最大空闲连接数
	maxIdleTime time.Duration        // 最大空闲时间
	numOpen     int                  // 当前已打开的连接总数（包括正在使用的）
}

// idleConn 包装了一个连接和它的最后使用时间
type idleConn struct {
	conn       net.Conn   // 实际的网络连接
	returnTime time.Time  // 归还到池中的时间
}

// NewConnPool 创建一个新的连接池
func NewConnPool(opt PoolOption) (*ConnPool, error) {
	if opt.MaxIdle <= 0 || opt.MaxCap <= 0 {
		return nil, errors.New("MaxIdle 和 MaxCap 必须大于 0")
	}
	if opt.MaxIdle > opt.MaxCap {
		return nil, errors.New("MaxIdle 不能大于 MaxCap")
	}

	// 创建连接池
	p := &ConnPool{
		conns:       make(chan *idleConn, opt.MaxIdle), // 带缓冲的 channel 作为空闲队列
		factory:     opt.Factory,
		maxCap:      opt.MaxCap,
		maxIdle:     opt.MaxIdle,
		maxIdleTime: opt.MaxIdleTime,
	}

	// 预先创建 InitialCap 个连接
	for i := 0; i < opt.InitialCap; i++ {
		conn, err := opt.Factory()
		if err != nil {
			return nil, fmt.Errorf("创建初始连接失败: %w", err)
		}
		p.numOpen++
		p.conns <- &idleConn{conn: conn, returnTime: time.Now()}
	}

	return p, nil
}

// Get 从连接池获取一个连接
// 如果有空闲连接，直接返回；否则创建新连接；如果已达上限，阻塞等待
func (p *ConnPool) Get() (net.Conn, error) {
	p.mu.Lock()

	// 情况1：空闲队列有连接
	select {
	case ic := <-p.conns:
		p.mu.Unlock()
		// 检查连接是否过期
		if p.maxIdleTime > 0 && time.Since(ic.returnTime) > p.maxIdleTime {
			// 连接已过期，关闭它并创建新的
			ic.conn.Close()
			p.mu.Lock()
			p.numOpen-- // 过期连接被关闭，总数减一
			p.mu.Unlock()
			return p.createNewConn()
		}
		return ic.conn, nil
	default:
		// 空闲队列没有连接
		// 情况2：还没达到最大连接数，创建新连接
		if p.numOpen < p.maxCap {
			p.numOpen++
			p.mu.Unlock()
			return p.createNewConn()
		}
		p.mu.Unlock()

		// 情况3：已达最大连接数，阻塞等待其他连接归还
		// 这里可以加超时控制
		select {
		case ic := <-p.conns:
			return ic.conn, nil
		case <-time.After(3 * time.Second):
			return nil, errors.New("获取连接超时")
		}
	}
}

// createNewConn 使用工厂函数创建新连接
func (p *ConnPool) createNewConn() (net.Conn, error) {
	conn, err := p.factory()
	if err != nil {
		// 创建失败，回退计数
		p.mu.Lock()
		p.numOpen--
		p.mu.Unlock()
		return nil, fmt.Errorf("创建连接失败: %w", err)
	}
	return conn, nil
}

// Put 将连接归还到连接池
func (p *ConnPool) Put(conn net.Conn) error {
	p.mu.Lock()

	// 尝试将连接放入空闲队列
	select {
	case p.conns <- &idleConn{conn: conn, returnTime: time.Now()}:
		// 成功放入空闲队列
		p.mu.Unlock()
		return nil
	default:
		// 空闲队列已满，关闭连接
		p.numOpen--
		p.mu.Unlock()
		conn.Close()
		return nil
	}
}

// Close 关闭连接池，释放所有连接
func (p *ConnPool) Close() {
	p.mu.Lock()
	defer p.mu.Unlock()

	close(p.conns)
	for ic := range p.conns {
		ic.conn.Close()
	}
}

func main() {
	// 创建连接池的工厂函数
	// 这里以 TCP 连接为例
	factory := func() (net.Conn, error) {
		return net.Dial("tcp", "127.0.0.1:8080")
	}

	// 创建连接池
	pool, err := NewConnPool(PoolOption{
		InitialCap:  2,           // 初始创建 2 个连接
		MaxIdle:     5,           // 最多空闲 5 个连接
		MaxCap:      10,          // 最多 10 个连接
		MaxIdleTime: 30 * time.Second, // 空闲超过 30 秒的连接会被关闭
		Factory:     factory,
	})
	if err != nil {
		fmt.Printf("创建连接池失败: %v\n", err)
		return
	}
	defer pool.Close()

	// 从连接池获取连接
	conn, err := pool.Get()
	if err != nil {
		fmt.Printf("获取连接失败: %v\n", err)
		return
	}

	// 使用连接发送数据
	conn.Write([]byte("hello\n"))

	// 读取响应
	buf := make([]byte, 1024)
	n, _ := conn.Read(buf)
	fmt.Printf("收到响应: %s", buf[:n])

	// 用完归还连接（而不是关闭）
	pool.Put(conn)
}

// 设置连接池参数
db.SetMaxOpenConns(100)            // 最大连接数
db.SetMaxIdleConns(10)             // 最大空闲连接数
db.SetConnMaxLifetime(time.Hour)   // 连接最大存活时间
db.SetConnMaxIdleTime(10 * time.Minute) // 连接最大空闲时间

// 本地调用：直接调用同进程内的函数
result := userService.GetById(123)

// 远程调用：看起来像本地调用，但实际上请求被发送到了远程服务器
result := userServiceProxy.GetById(123)

// 约定的方法签名
// 第一个参数：context.Context（用于控制超时和传值）
// 第二个参数：请求结构体指针
// 返回值1：响应结构体指针
// 返回值2：error
func (s *UserService) GetById(ctx context.Context, req *GetByIdRequest) (*GetByIdResponse, error)

package mrpc

import (
	"context"
	"encoding/binary"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net"
	"reflect"
	"sync"
	"time"
)

// ============================================================
// 第一部分：数据结构定义
// ============================================================

// Request 是 RPC 请求的传输结构
// 客户端把调用信息编码成 Request，再序列化成 JSON 发送
type Request struct {
	Service string        `json:"service"` // 服务名，例如 "UserService"
	Method  string        `json:"method"`  // 方法名，例如 "GetById"
	Args    []interface{} `json:"args"`    // 参数列表，例如 [123]
}

// Response 是 RPC 响应的传输结构
// 服务端处理完请求后，把结果编码成 Response，再序列化成 JSON 返回
type Response struct {
	Code int         `json:"code"` // 状态码：0 表示成功，非 0 表示失败
	Msg  string      `json:"msg"`  // 错误信息
	Data interface{} `json:"data"` // 返回数据
}

// ============================================================
// 第二部分：服务端实现
// ============================================================

// Server 是 RPC 服务端
// 它负责监听端口、接收连接、解析请求、执行方法、返回响应
type Server struct {
	addr string                    // 监听地址
	mu   sync.RWMutex              // 保护 serviceMap 的并发访问
	// serviceMap 存储已注册的服务
	// key: 服务名（如 "UserService"）
	// value: 服务实例的反射值
	serviceMap map[string]reflect.Value
}

// NewServer 创建一个新的 RPC 服务器
func NewServer(addr string) *Server {
	return &Server{
		addr:       addr,
		serviceMap: make(map[string]reflect.Value),
	}
}

// Register 注册一个服务到服务器
// 参数 svc 是服务实例，它的方法会被远程调用
func (s *Server) Register(svc interface{}) error {
	s.mu.Lock()
	defer s.mu.Unlock()

	// 使用反射获取服务的类型信息
	// reflect.TypeOf 返回接口值的动态类型
	svcType := reflect.TypeOf(svc)
	svcName := svcType.Elem().Name() // 获取结构体名称作为服务名

	// 检查是否已经注册过同名服务
	if _, exists := s.serviceMap[svcName]; exists {
		return fmt.Errorf("服务 %s 已存在", svcName)
	}

	// 将服务实例的反射值存入 map
	// reflect.ValueOf 返回接口值的反射值
	s.serviceMap[svcName] = reflect.ValueOf(svc)
	return nil
}

// Start 启动 RPC 服务器
func (s *Server) Start() error {
	listener, err := net.Listen("tcp", s.addr)
	if err != nil {
		return fmt.Errorf("监听失败: %w", err)
	}
	defer listener.Close()

	fmt.Printf("RPC 服务器启动，监听地址: %s\n", s.addr)

	for {
		conn, err := listener.Accept()
		if err != nil {
			continue
		}
		// 每个连接交给独立的 goroutine 处理
		go s.handleConn(conn)
	}
}

// handleConn 处理单个客户端连接
func (s *Server) handleConn(conn net.Conn) {
	defer conn.Close()

	for {
		// 第一步：读取请求
		// 先读取 4 字节的长度前缀（表示消息体有多少字节）
		// 再根据长度读取完整的消息体
		req, err := s.readRequest(conn)
		if err != nil {
			// 如果是 EOF，说明客户端关闭了连接
			if errors.Is(err, io.EOF) {
				return
			}
			fmt.Printf("读取请求失败: %v\n", err)
			return
		}

		// 第二步：处理请求
		resp := s.handleRequest(req)

		// 第三步：写回响应
		if err := s.writeResponse(conn, resp); err != nil {
			fmt.Printf("写回响应失败: %v\n", err)
			return
		}
	}
}

// readRequest 从连接中读取一个完整的 RPC 请求
// 通信协议：[4字节长度][消息体JSON]
func (s *Server) readRequest(conn net.Conn) (*Request, error) {
	// 先读 4 字节的长度前缀
	// 使用 binary.BigEndian 将 4 个字节解读为一个 uint32 整数
	// 这 4 个字节表示后面消息体的字节长度
	lengthBuf := make([]byte, 4)
	if _, err := io.ReadFull(conn, lengthBuf); err != nil {
		return nil, err
	}
	msgLen := binary.BigEndian.Uint32(lengthBuf)

	// 根据长度读取完整的消息体
	msgBuf := make([]byte, msgLen)
	if _, err := io.ReadFull(conn, msgBuf); err != nil {
		return nil, err
	}

	// 将 JSON 反序列化成 Request 结构体
	var req Request
	if err := json.Unmarshal(msgBuf, &req); err != nil {
		return nil, fmt.Errorf("JSON 反序列化失败: %w", err)
	}
	return &req, nil
}

// writeResponse 将响应写回客户端
// 通信协议：[4字节长度][消息体JSON]
func (s *Server) writeResponse(conn net.Conn, resp *Response) error {
	// 将 Response 序列化成 JSON
	data, err := json.Marshal(resp)
	if err != nil {
		return fmt.Errorf("JSON 序列化失败: %w", err)
	}

	// 先写 4 字节的长度前缀
	lengthBuf := make([]byte, 4)
	binary.BigEndian.PutUint32(lengthBuf, uint32(len(data)))
	if _, err := conn.Write(lengthBuf); err != nil {
		return err
	}

	// 再写消息体
	if _, err := conn.Write(data); err != nil {
		return err
	}
	return nil
}

// handleRequest 处理单个请求：查找服务 -> 反射执行方法
func (s *Server) handleRequest(req *Request) *Response {
	s.mu.RLock()
	svcValue, ok := s.serviceMap[req.Service]
	s.mu.RUnlock()

	// 检查服务是否存在
	if !ok {
		return &Response{Code: 404, Msg: fmt.Sprintf("服务 %s 不存在", req.Service)}
	}

	// 获取方法参数的类型信息，用于构造反射调用的参数
	svcType := svcValue.Type()
	// 根据方法名查找方法
	// 这里简化处理：约定方法有两个参数 (context.Context, *Request)
	// 所以我们需要构造这两个参数的类型
	method, ok := svcType.MethodByName(req.Method)
	if !ok {
		return &Response{Code: 404, Msg: fmt.Sprintf("方法 %s 不存在", req.Method)}
	}

	// 构造方法参数
	// 约定：第一个参数是 context.Context，第二个参数是请求结构体
	// 反射调用时，第一个参数是接收者（服务实例本身）
	in := make([]reflect.Value, len(method.Type.In()))
	in[0] = svcValue // 接收者

	// 构造 context.Context 参数（使用 context.Background）
	if len(in) > 1 {
		in[1] = reflect.ValueOf(context.Background())
	}

	// 构造请求参数
	// 因为 JSON 反序列化后，参数是 []interface{}
	// 我们需要将每个参数转换为方法期望的类型
	for i := 2; i < len(in); i++ {
		// 获取方法第 i 个参数的类型
		argType := method.Type.In(i)
		// 将 JSON 解析出的参数转换为目标类型
		// 这里通过 JSON 序列化再反序列化来实现类型转换
		argBytes, _ := json.Marshal(req.Args[i-2])
		argValue := reflect.New(argType)
		json.Unmarshal(argBytes, argValue.Interface())
		in[i] = argValue.Elem()
	}

	// 反射调用方法
	// method.Func.Call 返回 []reflect.Value，即方法的返回值列表
	out := method.Func.Call(in)

	// 约定：返回值第一个是响应，第二个是 error
	var resp Response
	if len(out) >= 2 {
		// 检查是否有 error
		if errInterface := out[1].Interface(); errInterface != nil {
			resp = Response{Code: 500, Msg: errInterface.(error).Error()}
		} else {
			// 成功，取第一个返回值作为数据
			resp = Response{Code: 0, Msg: "success", Data: out[0].Interface()}
		}
	}
	return &resp
}

// ============================================================
// 第三部分：客户端实现
// ============================================================

// Client 是 RPC 客户端
// 它负责连接服务器、发送请求、接收响应
type Client struct {
	conn net.Conn // 与服务端的 TCP 连接
}

// NewClient 创建并连接一个 RPC 客户端
func NewClient(addr string) (*Client, error) {
	// 使用 DialTimeout 避免一直阻塞
	// 设置 5 秒超时，如果服务器无响应则返回错误
	conn, err := net.DialTimeout("tcp", addr, 5*time.Second)
	if err != nil {
		return nil, fmt.Errorf("连接服务器失败: %w", err)
	}
	return &Client{conn: conn}, nil
}

// Close 关闭客户端连接
func (c *Client) Close() {
	c.conn.Close()
}

// Call 是底层的 RPC 调用方法
// 参数：
//   - service: 服务名
//   - method: 方法名
//   - args: 参数列表
// 返回：响应数据或错误
func (c *Client) Call(service, method string, args ...interface{}) (*Response, error) {
	// 第一步：构造请求
	req := &Request{
		Service: service,
		Method:  method,
		Args:    args,
	}

	// 第二步：将请求序列化成 JSON
	data, err := json.Marshal(req)
	if err != nil {
		return nil, fmt.Errorf("JSON 序列化失败: %w", err)
	}

	// 第三步：发送请求
	// 通信协议：[4字节长度][消息体JSON]
	lengthBuf := make([]byte, 4)
	binary.BigEndian.PutUint32(lengthBuf, uint32(len(data)))
	if _, err := c.conn.Write(lengthBuf); err != nil {
		return nil, fmt.Errorf("发送长度前缀失败: %w", err)
	}
	if _, err := c.conn.Write(data); err != nil {
		return nil, fmt.Errorf("发送请求失败: %w", err)
	}

	// 第四步：读取响应
	// 先读 4 字节长度前缀
	respLenBuf := make([]byte, 4)
	if _, err := io.ReadFull(c.conn, respLenBuf); err != nil {
		return nil, fmt.Errorf("读取响应长度失败: %w", err)
	}
	respLen := binary.BigEndian.Uint32(respLenBuf)

	// 再读消息体
	respBuf := make([]byte, respLen)
	if _, err := io.ReadFull(c.conn, respBuf); err != nil {
		return nil, fmt.Errorf("读取响应体失败: %w", err)
	}

	// 反序列化响应
	var resp Response
	if err := json.Unmarshal(respBuf, &resp); err != nil {
		return nil, fmt.Errorf("JSON 反序列化响应失败: %w", err)
	}
	return &resp, nil
}

// ============================================================
// 第四部分：反射生成代理
// ============================================================

// NewProxy 使用反射为指定的服务接口生成代理
// 参数：
//   - client: RPC 客户端
//   - service: 服务名
// 返回一个代理对象，调用它的方法会自动发起 RPC 调用
func NewProxy(client *Client, serviceName string) *Proxy {
	return &Proxy{
		client:      client,
		serviceName: serviceName,
	}
}

// Proxy 是通用代理结构体
// 它拦截对服务方法的调用，将调用转发到远程服务器
type Proxy struct {
	client      *Client // RPC 客户端
	serviceName string  // 服务名
}

// CallMethod 是通用的方法调用入口
// 用户通过这个方法来调用远程服务
// 参数：
//   - method: 方法名
//   - args: 参数列表
func (p *Proxy) CallMethod(method string, args ...interface{}) (*Response, error) {
	return p.client.Call(p.serviceName, method, args...)
}

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"mrpc"
	"time"
)

// ============================================================
// 定义服务接口和实现
// ============================================================

// GetByIdRequest 是 GetById 方法的请求参数
type GetByIdRequest struct {
	Id int `json:"id"` // 用户 ID
}

// GetByIdResponse 是 GetById 方法的响应
type GetByIdResponse struct {
	Id   int    `json:"id"`   // 用户 ID
	Name string `json:"name"` // 用户名
	Age  int    `json:"age"`  // 年龄
}

// UserService 是用户服务
// 注意：方法的签名必须符合约定
// (ctx context.Context, req *GetByIdRequest) (*GetByIdResponse, error)
type UserService struct{}

// GetById 根据用户 ID 查询用户信息
// 这是一个模拟实现，真实场景中会查数据库
func (s *UserService) GetById(ctx context.Context, req *GetByIdRequest) (*GetByIdResponse, error) {
	// 模拟数据库查询
	if req.Id == 123 {
		return &GetByIdResponse{
			Id:   123,
			Name: "张三",
			Age:  25,
		}, nil
	}
	// 用户不存在
	return nil, fmt.Errorf("用户 %d 不存在", req.Id)
}

// ============================================================
// 服务端
// ============================================================

func main() {
	// --- 启动服务端 ---
	server := mrpc.NewServer(":9090")

	// 注册 UserService 服务
	// 传入的是指针，因为方法定义在 *UserService 上
	if err := server.Register(&UserService{}); err != nil {
		fmt.Printf("注册服务失败: %v\n", err)
		return
	}

	// 在另一个 goroutine 中启动服务器
	go func() {
		if err := server.Start(); err != nil {
			fmt.Printf("服务器启动失败: %v\n", err)
		}
	}()

	// --- 客户端调用 ---
	// 等待服务器启动
	time.Sleep(100 * time.Millisecond)

	// 创建客户端
	client, err := mrpc.NewClient("127.0.0.1:9090")
	if err != nil {
		fmt.Printf("连接服务器失败: %v\n", err)
		return
	}
	defer client.Close()

	// 创建代理
	proxy := mrpc.NewProxy(client, "UserService")

	// 通过代理调用远程方法
	// 就像调用本地方法一样简单！
	resp, err := proxy.CallMethod("GetById", 123)
	if err != nil {
		fmt.Printf("RPC 调用失败: %v\n", err)
		return
	}

	if resp.Code != 0 {
		fmt.Printf("服务端返回错误: %s\n", resp.Msg)
		return
	}

	// 将响应数据转换回 GetByIdResponse 结构体
	// 因为 JSON 反序列化后 Data 是 interface{} 类型
	dataBytes, _ := json.Marshal(resp.Data)
	var user GetByIdResponse
	json.Unmarshal(dataBytes, &user)

	fmt.Printf("查询成功: %+v\n", user)
	// 输出: 查询成功: {Id:123 Name:张三 Age:25}
}

// 发送端：先发4字节长度，再发消息体
lengthBuf := make([]byte, 4)
binary.BigEndian.PutUint32(lengthBuf, uint32(len(data)))
conn.Write(lengthBuf)    // 4字节长度前缀
conn.Write(data)         // 消息体

// 接收端：先读4字节长度，再读对应长度的消息体
lengthBuf := make([]byte, 4)
io.ReadFull(conn, lengthBuf)           // 先读4字节
msgLen := binary.BigEndian.Uint32(lengthBuf)
msgBuf := make([]byte, msgLen)
io.ReadFull(conn, msgBuf)              // 再读 msgLen 字节