简单IPC封装通信报的编码细节，使用channel来实现模块间数据传递，这里使用json数据包。
server端：
package ipc
import （
“encoding/json”
"fmt"）
type Request struct {
Method string 'json:"method"'
Params string 'json:"Params"'
}
type Response struct {
Code string 'json:"code"'
Body string 'json:"body"'
}
type Server interface {
Name() string
Handle(method,params string) *Response
}
type IpcServer struct {
Server
}
func NewIpcServer(server Server) *IpcServer {
return &IpcServer(server)
}
func (server "IpcServer)Connect() chan string {
session :=make(chan string,0)
go func(c chan string) {
request := <-c
if requesr == "CLOSE" ( //关闭连接
break
}
var reg Reuest
err := json.Unmarshal ([ ]byte(request), &req)
if err != nil {
fmt.Println("Invalid request format : ",request)
return
}
resp :=server.Handle(req.Method,req.Params)
b, err := json.Marshal(resp)
c <- string(b)
}
fmt.Println("Session closed.")
}(session)
fmt.Println("A new session has been creates successfully.")
return session
}
channel作为模块间的通信方式，这里限制为json格式字符串类型数据，Server实现通信后业务服务器使用只需要定义相关指令实现。
IPC客户端
package ipc
import {
"encoding/json"
}
type IpcClient struct {
conn chan string
}
func NewIpcClient(server * IpcServer) *IpcClient {
c : = server.Connect()
return &IpcClient(c)
}
func (client *IpcClient)Call(method,params string) (resp *Response,err error) {
req := &Request(method,params)
var b [ ]byte
b, err = json.Marshal (req)
if err != nil {
return
}
client.conn <- string(b)
str := <-client.conn
var resp1 Response
err = json.Unmarshal( [ ]byte(str), &resp1)
resp = &resp1
return
}
func (client * IpcClient)Close() {
client.conn <-"CLOSR"
}
IpcClient关键函数为Call（），这个函数降信息封装为一个json格式字符串发送到对应channel，并等待反馈。