func (s *Skeleton) Init() {
if s.GoLen <= 0 {
s.GoLen = 0
}
if s.TimerDispatcherLen <= 0 {
s.TimerDispatcherLen = 0
}
s.g = g.New(s.GoLen)
s.dispatcher = timer.NewDispatcher(s.TimerDispatcherLen)
s.server = s.ChanRPCServer
if s.server == nil {
s.server = chanrpc.NewServer(0)
}
s.commandServer = chanrpc.NewServer(0)
}
//创建骨架
func NewSkeleton() *module.Skeleton {
skeleton := &module.Skeleton{ //创建骨架
GoLen: conf.GoLen,
TimerDispatcherLen: conf.TimerDispatcherLen,
ChanRPCServer: chanrpc.NewServer(conf.ChanRPCLen),
}
skeleton.Init() //初始化骨架
return skeleton //返回骨架
}
func NewSkeleton() *module.Skeleton {
skeleton := &module.Skeleton{
GoLen: conf.GoLen,
TimerDispatcherLen: conf.TimerDispatcherLen,
ChanRPCServer: chanrpc.NewServer(conf.ChanRPCLen),
}
skeleton.Init()
return skeleton
}
//初始化
func (s *Skeleton) Init() {
//检查Go管道长度
if s.GoLen <= 0 {
s.GoLen = 0
}
//检查定时器分发器管道长度
if s.TimerDispatcherLen <= 0 {
s.TimerDispatcherLen = 0
}
s.g = g.New(s.GoLen) //创建Go
s.dispatcher = timer.NewDispatcher(s.TimerDispatcherLen) //创建分发器
s.server = s.ChanRPCServer //外部传入的，内部引用
if s.server == nil { //外部传入的为空
s.server = chanrpc.NewServer(0) //内部创建一个
}
s.commandServer = chanrpc.NewServer(0) //创建命令RPC服务器
}
func Example() {
s := chanrpc.NewServer(10) //创建一个RPC服务器,调用管道的长度为10
//调用管道：用于传输调用信息
//一个rpc服务器可以对应多个rpc客户端，rpc客户端将调用信息传输到RPC服务器的管道（共用一个），rpc服务器再将响应消息返回到rpc客户端各自的管道内
var wg sync.WaitGroup //声明等待组
wg.Add(1) //等待组+1
// goroutine 1
go func() {
//注册函数:id->function
s.Register("f0", func(args []interface{}) {
})
s.Register("f1", func(args []interface{}) interface{} {
return 1
})
s.Register("fn", func(args []interface{}) []interface{} {
return []interface{}{1, 2, 3}
})
s.Register("add", func(args []interface{}) interface{} {
n1 := args[0].(int)
n2 := args[1].(int)
return n1 + n2
})
//注册完成，释放等待组
wg.Done()
//死循环，处理rpc服务器调用
for {
err := s.Exec(<-s.ChanCall) //从管道里读取一个调用信息并执行
if err != nil {
fmt.Println(err)
}
}
}()
wg.Wait() //等待等待组，阻塞在这里，等待注册函数完成
wg.Add(1) //注册函数完成，等待组再+1
// goroutine 2
go func() {
c := s.Open(10) //打开一个rpc客户端
// sync 同步调用
//同步调用0，无返回值（0个返回值）
err := c.Call0("f0")
if err != nil {
fmt.Println(err)
}
//同步调用1，1个返回值
r1, err := c.Call1("f1")
if err != nil {
fmt.Println(err)
} else {
fmt.Println(r1)
}
//同步调用N，N个返回值
rn, err := c.CallN("fn")
if err != nil {
fmt.Println(err)
} else {
fmt.Println(rn[0], rn[1], rn[2])
}
//同步调用1，1个返回值
ra, err := c.Call1("add", 1, 2)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(ra)
}
// asyn 异步调用
c.AsynCall("f0", func(err error) {
if err != nil {
fmt.Println(err)
}
})
c.AsynCall("f1", func(ret interface{}, err error) {
if err != nil {
fmt.Println(err)
} else {
fmt.Println(ret)
}
})
c.AsynCall("fn", func(ret []interface{}, err error) {
if err != nil {
fmt.Println(err)
} else {
fmt.Println(ret[0], ret[1], ret[2])
}
})
c.AsynCall("add", 1, 2, func(ret interface{}, err error) {
if err != nil {
fmt.Println(err)
} else {
fmt.Println(ret)
}
})
c.Cb(<-c.ChanAsynRet)
c.Cb(<-c.ChanAsynRet)
c.Cb(<-c.ChanAsynRet)
c.Cb(<-c.ChanAsynRet)
// go Go调用
s.Go("f0")
wg.Done() //goroutine2完成
}()
wg.Wait() //等待goroutine2完成
// Output:
// 1
// 1 2 3
// 3
// 1
// 1 2 3
// 3
}
func Example() {
s := chanrpc.NewServer(10)
var wg sync.WaitGroup
wg.Add(1)
// goroutine 1
go func() {
s.Register("f0", func(args []interface{}) {
})
s.Register("f1", func(args []interface{}) interface{} {
return 1
})
s.Register("fn", func(args []interface{}) []interface{} {
return []interface{}{1, 2, 3}
})
s.Register("add", func(args []interface{}) interface{} {
n1 := args[0].(int)
n2 := args[1].(int)
return n1 + n2
})
wg.Done()
for {
s.Exec(<-s.ChanCall)
}
}()
wg.Wait()
wg.Add(1)
// goroutine 2
go func() {
c := s.Open(10)
// sync
err := c.Call0("f0")
if err != nil {
fmt.Println(err)
}
r1, err := c.Call1("f1")
if err != nil {
fmt.Println(err)
} else {
fmt.Println(r1)
}
rn, err := c.CallN("fn")
if err != nil {
fmt.Println(err)
} else {
fmt.Println(rn[0], rn[1], rn[2])
}
ra, err := c.Call1("add", 1, 2)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(ra)
}
// asyn
c.AsynCall("f0", func(err error) {
if err != nil {
fmt.Println(err)
}
})
c.AsynCall("f1", func(ret interface{}, err error) {
if err != nil {
fmt.Println(err)
} else {
fmt.Println(ret)
}
})
c.AsynCall("fn", func(ret []interface{}, err error) {
if err != nil {
fmt.Println(err)
} else {
fmt.Println(ret[0], ret[1], ret[2])
}
})
c.AsynCall("add", 1, 2, func(ret interface{}, err error) {
if err != nil {
fmt.Println(err)
} else {
fmt.Println(ret)
}
})
c.Cb(<-c.ChanAsynRet)
c.Cb(<-c.ChanAsynRet)
c.Cb(<-c.ChanAsynRet)
c.Cb(<-c.ChanAsynRet)
// go
s.Go("f0")
wg.Done()
}()
wg.Wait()
// Output:
// 1
// 1 2 3
// 3
// 1
// 1 2 3
// 3
}
package login import ( "github.com/name5566/leaf/chanrpc" "server/conf" ) var ChanRPC = chanrpc.NewServer(conf.ChanRPCLen)