go rpc chan

chain

````
package domain

import "github.com/tiglabs/baudengine/util/log"

type Handler interface {
	Execute(request *Request, response *Response) error
}

type Chain struct {
	panicChain Handler
	chain      []Handler
}

func (this *Chain) Execute(request *Request, response *Response) error {

	defer this.panicChain.Execute(request, response)
	for i := 0; i < len(this.chain); i++ {
		if err := this.chain[i].Execute(request, response); err != nil {
			return err
		}
	}
	return nil
}

func NewChain(paincChain Handler, handlers ...Handler) *Chain {
	return &Chain{panicChain: paincChain, chain: handlers}
}

type PanicChain int

func (PanicChain) Execute(request *Request, response *Response) error {
	if r := recover(); r != nil {
		if response == nil {
			response = new(Response)
		}
		switch r.(type) {
		case error:
			response.Error = "Server internal error :" + r.(error).Error()
		default:
			response.Error = "Server internal error "
		}
		log.Error(response.Error)
	}
	return nil
}

````

````
package main

import (
	"fmt"
	"github.com/ansj/test/test/domain"
	"net"
	"net/rpc"
	"os"
)

func init() {
	fmt.Println("基于TCP协议实现的RPC，服务端的代码如下")
}

type Num int

/*
Go RPC的函数只有符合下面的条件才能够被远程访问，不然会被忽略
1 函数必须是导出的（首字母大写）
2 必须有两个导出类型的参数
3 第一个参数是接受的参数，第二个参数是返回给客户端的参数，第二个参数必须是指正类型的
4 函数还必须有一个返回值error
 */
func (n *Num) Execute(args *domain.Request, reply *domain.Response) error {
	reply.Args = ! args.Args.(bool)
	return nil
}

func main() {
	rpc.RegisterName("testpainc", domain.NewChain(new(domain.PanicChain), new(Num)))
	tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")

	if err != nil {
		fmt.Println("错误了哦")
		os.Exit(1)
	}
	listener, err := net.ListenTCP("tcp", tcpAddr)

	for {
		conn, err := listener.Accept()
		if err != nil {
			continue
		}
		rpc.ServeConn(conn)
	}
}

````

````
package main

import (
	"fmt"
	"github.com/ansj/test/test/domain"
	"net/rpc"
	"sync"
	"time"
)

func main() {


	aa := &domain.Request{}
	aa.Args = false
	var reply *domain.Response
	now := time.Now()
	client, err := rpc.Dial("tcp", "127.0.0.1:1234")
	if err != nil {
		panic(err)
	}
	var wg sync.WaitGroup
	for i:=0 ; i<100000; i++{
		wg.Add(1)
		go func() {
			client.Call("testpainc.Execute", aa, &reply)
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println(time.Now().Sub(now))


}

````