代码结构#
Copy
.
├── client.go
├── coder.go
├── coder_test.go
├── rpc_test.go
├── server.go
├── session.go
└── session_test.go
client.go#
Copy
package rpc
import (
"net"
"reflect"
)
type Client struct {
conn net.Conn
}
func NewClient(conn net.Conn) *Client {
return &Client{conn: conn}
}
func (c *Client) RpcCall(name string, fpr interface{}) {
fn := reflect.ValueOf(fpr).Elem()
f := func(args []reflect.Value) (results []reflect.Value) {
inArgs := make([]interface{}, 0, len(args))
for _, v := range args {
inArgs = append(inArgs, v.Interface())
}
reqData := RpcData{Name: name, Args: inArgs}
reqByteData, err := encode(reqData)
if err != nil {
return
}
session := NewSession(c.conn)
err = session.Write(reqByteData)
if err != nil {
return
}
rspByteData, err := session.Read()
if err != nil {
return
}
rspData, err := decode(rspByteData)
if err != nil {
return
}
outArgs := make([]reflect.Value, 0, len(rspData.Args))
for i, v := range rspData.Args {
if v == nil {
outArgs = append(outArgs, reflect.Zero(fn.Type().Out(i)))
continue
}
outArgs = append(outArgs, reflect.ValueOf(v))
}
return outArgs
}
v := reflect.MakeFunc(fn.Type(), f)
fn.Set(v)
}
coder.go#
Copy
package rpc
import (
"bytes"
"encoding/gob"
"fmt"
)
type RpcData struct {
Name string
Args []interface{}
}
func encode(data RpcData) ([]byte, error) {
var buf bytes.Buffer
encoder := gob.NewEncoder(&buf)
if err := encoder.Encode(data); err != nil {
fmt.Printf("gob encode failed, err: %v\n", err)
return nil, err
}
return buf.Bytes(), nil
}
func decode(data []byte) (RpcData, error) {
buf := bytes.NewBuffer(data)
decoder := gob.NewDecoder(buf)
var rd RpcData
if err := decoder.Decode(&rd); err != nil {
fmt.Printf("gob decode failed, err: %v\n", err)
return rd, err
}
return rd, nil
}
server.go#
Copy
package rpc
import (
"net"
"reflect"
)
type Server struct {
add string
funcs map[string]reflect.Value
}
func NewServer(addr string) *Server {
return &Server{add: addr, funcs: make(map[string]reflect.Value)}
}
func (s *Server) Register(name string, fc interface{}) {
if _, ok := s.funcs[name]; ok {
return
}
s.funcs[name] = reflect.ValueOf(fc)
}
func (s *Server) Run() (err error) {
listener, err := net.Listen("tcp", s.add)
if err != nil {
return
}
for {
conn, err := listener.Accept()
if err != nil {
conn.Close()
continue
}
session := NewSession(conn)
reqData, err := session.Read()
if err != nil {
conn.Close()
continue
}
rpcReqData, err := decode(reqData)
fc, ok := s.funcs[rpcReqData.Name];
if !ok {
conn.Close()
continue
}
args := make([]reflect.Value, 0, len(rpcReqData.Args))
for _, v := range rpcReqData.Args {
args = append(args, reflect.ValueOf(v))
}
callReslut := fc.Call(args)
rargs := make([]interface{}, 0, len(callReslut))
for _, rv := range callReslut {
rargs = append(rargs, rv.Interface())
}
rpcRspData := RpcData{Name: rpcReqData.Name, Args: rargs}
rspData, err := encode(rpcRspData)
if err != nil {
conn.Close()
continue
}
err = session.Write(rspData)
if err != nil {
conn.Close()
continue
}
}
return
}
session.go#
Copy
package rpc
import (
"encoding/binary"
"fmt"
"io"
"net"
)
type Session struct {
conn net.Conn
}
func NewSession(conn net.Conn) *Session {
return &Session{conn: conn}
}
func (s *Session) Read() (data []byte, err error) {
header := make([]byte, 4)
_, err = s.conn.Read(header)
if err != nil {
fmt.Printf("read conn header data failed, err: %v\n", err)
return
}
hlen := binary.BigEndian.Uint32(header)
data = make([]byte, hlen)
_, err = io.ReadFull(s.conn, data)
if err != nil {
fmt.Printf("read conn body data failed, err: %v\n", err)
return
}
return
}
func (s *Session) Write(data []byte) (err error) {
buf := make([]byte, 4+len(data))
binary.BigEndian.PutUint32(buf[:4], uint32(len(data)))
copy(buf[4:], data)
_, err = s.conn.Write(buf)
if err != nil {
fmt.Printf("write conn data failed, err: %v\n", err)
return
}
return
}
coder_test.go#
Copy
package rpc
import (
"testing"
)
func TestCoder(t *testing.T) {
rd := RpcData{
Name: "login",
Args: []interface{}{"zhangsan", "zs123"},
}
eData, err := encode(rd)
if err != nil {
t.Error(err)
return
}
t.Logf("gob 编码后数据长度: %d\n", len(eData))
dData, err := decode(eData)
if err != nil {
t.Error(err)
return
}
t.Logf("%#v\n", dData)
}
session_test.go#
Copy
package rpc
import (
"net"
"sync"
"testing"
)
func TestSession(t *testing.T) {
addr := ":8080"
test_data := "my is test data"
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
listener, err := net.Listen("tcp", addr)
if err != nil {
t.Fatal(err)
return
}
conn, _ := listener.Accept()
s := NewSession(conn)
data, err := s.Read()
if err != nil {
t.Error(err)
return
}
t.Log(string(data))
}()
go func() {
defer wg.Done()
conn, err := net.Dial("tcp", addr)
if err != nil {
t.Fatal(err)
return
}
s := NewSession(conn)
err = s.Write([]byte(test_data))
if err != nil {
return
}
t.Log("写入数据成功")
return
}()
wg.Wait()
}
rpc_test.go#
Copy
package rpc
import (
"encoding/gob"
"fmt"
"net"
"testing"
)
type User struct {
Name string
Age int
}
func queryUser(id int) (User, error) {
users := make(map[int]User)
users[0] = User{"user01", 22}
users[1] = User{"user02", 23}
users[2] = User{"user03", 24}
if u, ok := users[id]; ok {
return u, nil
}
return User{}, fmt.Errorf("%d id not found", id)
}
func TestRpc(t *testing.T) {
gob.Register(User{})
addr := ":8080"
server := NewServer(addr)
server.Register("queryUser", queryUser)
go server.Run()
conn, err := net.Dial("tcp", addr)
if err != nil {
return
}
client := NewClient(conn)
var query func(int) (User, error)
client.RpcCall("queryUser", &query)
user, err := query(1)
if err != nil {
t.Error(err)
return
}
fmt.Printf("%#v\n", user)
}
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 用 C# 插值字符串处理器写一个 sscanf
· Java 中堆内存和栈内存上的数据分布和特点
· 开发中对象命名的一点思考
· .NET Core内存结构体系(Windows环境)底层原理浅谈
· C# 深度学习:对抗生成网络(GAN)训练头像生成模型
· 趁着过年的时候手搓了一个低代码框架
· 本地部署DeepSeek后,没有好看的交互界面怎么行!
· 为什么说在企业级应用开发中,后端往往是效率杀手?
· 用 C# 插值字符串处理器写一个 sscanf
· 乌龟冬眠箱湿度监控系统和AI辅助建议功能的实现