Package rpc

import "net/rpc"
Overview
Index
Subdirectories

Overview ▾

软件包rpc可以通过网络或其他I / O连接访问对象的导出方法. 服务器注册一个对象,使其以对象类型的名称显示为服务. 注册后,将可以远程访问对象的导出方法. 服务器可以注册不同类型的多个对象(服务),但是注册相同类型的多个对象是错误的.

只有满足这些条件的方法才可用于远程访问. 其他方法将被忽略:

- the method's type is exported.
- the method is exported.
- the method has two arguments, both exported (or builtin) types.
- the method's second argument is a pointer.
- the method has return type error.

实际上,该方法必须看起来像

func (t *T) MethodName(argType T1, replyType *T2) error

T1和T2可以通过编码/抓取来封送. 即使使用其他编解码器,这些要求也适用. (将来,对于自定义编解码器,这些要求可能会变软.)

方法的第一个参数表示调用者提供的参数; 第二个参数表示要返回给调用方的结果参数. 该方法的返回值(如果非零)作为一个字符串传递回客户端,客户端认为该字符串是由errors.New创建的. 如果返回错误,则reply参数将不会发送回客户端.

服务器可以通过调用ServeConn处理单个连接上的请求. 通常,它将创建一个网络侦听器并调用Accept,或者对于HTTP侦听器,调用HandleHTTP和http.Serve.

希望使用该服务的客户端建立连接,然后在该连接上调用NewClient. 便捷功能拨号(DialHTTP)对原始网络连接(HTTP连接)执行两个步骤. 生成的Client对象具有两个方法Call和Go,它们指定要调用的服务和方法,一个包含参数的指针和一个用于接收结果参数的指针.

Call方法等待远程调用完成,而Go方法异步启动调用,并使用Call结构的Done通道发出完成信号.

除非设置了显式编解码器,否则将使用包编码/目标来传输数据.

这是一个简单的例子. 服务器希望导出Arith类型的对象:

package server

import "errors"

type Args struct {
	A, B int
}

type Quotient struct {
	Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
	*reply = args.A * args.B
	return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
	if args.B == 0 {
		return errors.New("divide by zero")
	}
	quo.Quo = args.A / args.B
	quo.Rem = args.A % args.B
	return nil
}

服务器调用(用于HTTP服务):

arith := new(Arith)
rpc.Register(arith)
rpc.HandleHTTP()
l, e := net.Listen("tcp", ":1234")
if e != nil {
	log.Fatal("listen error:", e)
}
go http.Serve(l, nil)

此时,客户端可以使用方法" Arith.Multiply"和" Arith.Divide"看到服务" Arith". 要调用一个,客户端首先拨打服务器:

client, err := rpc.DialHTTP("tcp", serverAddress + ":1234")
if err != nil {
	log.Fatal("dialing:", err)
}

然后可以进行远程呼叫:

// Synchronous call
args := &server.Args{7,8}
var reply int
err = client.Call("Arith.Multiply", args, &reply)
if err != nil {
	log.Fatal("arith error:", err)
}
fmt.Printf("Arith: %d*%d=%d", args.A, args.B, reply)

or

// Asynchronous call
quotient := new(Quotient)
divCall := client.Go("Arith.Divide", args, quotient, nil)
replyCall := <-divCall.Done	// will be equal to divCall
// check errors, print, etc.

服务器实现通常会为客户端提供一个简单的类型安全的包装器.

net / rpc软件包被冻结,并且不接受新功能.

Index ▾

Constants
Variables
func Accept(lis net.Listener)
func HandleHTTP()
func Register(rcvr interface{}) error
func RegisterName(name string, rcvr interface{}) error
func ServeCodec(codec ServerCodec)
func ServeConn(conn io.ReadWriteCloser)
func ServeRequest(codec ServerCodec) error
type Call
type Client
    func Dial(network, address string) (*Client, error)
    func DialHTTP(network, address string) (*Client, error)
    func DialHTTPPath(network, address, path string) (*Client, error)
    func NewClient(conn io.ReadWriteCloser) *Client
    func NewClientWithCodec(codec ClientCodec) *Client
    func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error
    func (client *Client) Close() error
    func (client *Client) Go(serviceMethod string, args interface{}, reply interface{}, done chan *Call) *Call
type ClientCodec
type Request
type Response
type Server
    func NewServer() *Server
    func (server *Server) Accept(lis net.Listener)
    func (server *Server) HandleHTTP(rpcPath, debugPath string)
    func (server *Server) Register(rcvr interface{}) error
    func (server *Server) RegisterName(name string, rcvr interface{}) error
    func (server *Server) ServeCodec(codec ServerCodec)
    func (server *Server) ServeConn(conn io.ReadWriteCloser)
    func (server *Server) ServeHTTP(w http.ResponseWriter, req *http.Request)
    func (server *Server) ServeRequest(codec ServerCodec) error
type ServerCodec
type ServerError
    func (e ServerError) Error() string

Package files

client.go debug.go server.go

Constants

const (
    // Defaults used by HandleHTTP
    DefaultRPCPath   = "/_goRPC_"
    DefaultDebugPath = "/debug/rpc"
)

Variables

DefaultServer是* Server的默认实例.

var DefaultServer = NewServer()
var ErrShutdown = errors.New("connection is shut down")

func Accept

func Accept(lis net.Listener)

Accept接受侦听器上的连接,并为每个传入的连接向DefaultServer提供请求. 接受块; 调用方通常在go语句中调用它.

func HandleHTTP

func HandleHTTP()

HandleHTTP在DefaultRPCPath上注册用于RPC消息到DefaultServer的HTTP处理程序,并在DefaultDebugPath上注册调试处理程序. 通常仍然需要在go语句中调用http.Serve().

func Register

func Register(rcvr interface{}) error

注册将在DefaultServer中发布接收者的方法.

func RegisterName

func RegisterName(name string, rcvr interface{}) error

RegisterName类似于Register,但是使用提供的名称作为类型,而不是接收者的具体类型.

func ServeCodec

func ServeCodec(codec ServerCodec)

ServeCodec类似于ServeConn,但是使用指定的编解码器解码请求和编码响应.

func ServeConn

func ServeConn(conn io.ReadWriteCloser)

ServeConn在单个连接上运行DefaultServer. ServeConn阻塞,为连接提供服务,直到客户端挂断. 调用方通常在go语句中调用ServeConn. ServeConn在连接上使用gob导线格式(请参阅软件包gob). 要使用备用编解码器,请使用ServeCodec. 有关并发访问的信息,请参见NewClient的注释.

func ServeRequest

func ServeRequest(codec ServerCodec) error

ServeRequest类似于ServeCodec,但是同步处理单个请求. 完成后不会关闭编解码器.

type Call

呼叫代表有效的RPC.

type Call struct {
    ServiceMethod string      // The name of the service and method to call.
    Args          interface{} // The argument to the function (*struct).
    Reply         interface{} // The reply from the function (*struct).
    Error         error       // After completion, the error status.
    Done          chan *Call  // Strobes when call is complete.
}

type Client

客户端代表RPC客户端. 单个客户端可能有多个未完成的调用,并且一个客户端可能同时被多个goroutine使用.

type Client struct {
    // contains filtered or unexported fields
}

func Dial

func Dial(network, address string) (*Client, error)

拨号连接到指定网络地址的RPC服务器.

func DialHTTP

func DialHTTP(network, address string) (*Client, error)

DialHTTP在默认的HTTP RPC路径上侦听的指定网络地址处连接到HTTP RPC服务器.

func DialHTTPPath

func DialHTTPPath(network, address, path string) (*Client, error)

DialHTTPPath通过指定的网络地址和路径连接到HTTP RPC服务器.

func NewClient

func NewClient(conn io.ReadWriteCloser) *Client

NewClient返回一个新的Client,以处理对连接另一端的服务集的请求. 它在连接的写端添加了一个缓冲区,因此标头和有效负载作为一个单元发送.

连接的读写部分独立地序列化,因此不需要互锁. 但是,每个部分都可以同时访问,因此conn的实现应防止并发读取或并发写入.

func NewClientWithCodec

func NewClientWithCodec(codec ClientCodec) *Client

NewClientWithCodec类似于NewClient,但是使用指定的编解码器来编码请求和解码响应.

func (*Client) Call

func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error

Call invokes the named function, waits for it to complete, and returns its error status.

func (*Client) Close

func (client *Client) Close() error

Close调用基础编解码器的Close方法. 如果连接已经关闭,则返回ErrShutdown.

func (*Client) Go

func (client *Client) Go(serviceMethod string, args interface{}, reply interface{}, done chan *Call) *Call

Go异步调用该函数. 它返回表示调用的Call结构. 完成的通道将通过返回相同的Call对象来通知何时完成呼叫. 如果完成为零,Go将分配一个新通道. 如果非零,则必须缓冲done,否则Go会故意崩溃.

type ClientCodec

ClientCodec为RPC会话的客户端实现RPC请求的写入和RPC响应的读取. 客户端调用WriteRequest将请求写入连接,并成对调用ReadResponseHeader和ReadResponseBody以读取响应. 连接完成后,客户端将调用"关闭". 可以使用nil参数调用ReadResponseBody,以强制读取响应的主体,然后将其丢弃. 有关并发访问的信息,请参见NewClient的注释.

type ClientCodec interface {
    WriteRequest(*Request, interface{}) error
    ReadResponseHeader(*Response) error
    ReadResponseBody(interface{}) error

    Close() error
}

type Request

请求是在每个RPC调用之前编写的标头. 它在内部使用,但在此处记录为调试的辅助工具,例如在分析网络流量时.

type Request struct {
    ServiceMethod string // format: "Service.Method"
    Seq           uint64 // sequence number chosen by client
    // contains filtered or unexported fields
}

type Response

响应是在每次RPC返回之前编写的标头. 它在内部使用,但在此处记录为调试的辅助工具,例如在分析网络流量时.

type Response struct {
    ServiceMethod string // echoes that of the Request
    Seq           uint64 // echoes that of the request
    Error         string // error, if any.
    // contains filtered or unexported fields
}

type Server

服务器代表RPC服务器.

type Server struct {
    // contains filtered or unexported fields
}

func NewServer

func NewServer() *Server

NewServer返回一个新的服务器.

func (*Server) Accept

func (server *Server) Accept(lis net.Listener)

接受在侦听器上接受连接,并为每个传入的连接提供请求. 接受块,直到侦听器返回非nil错误. 调用方通常在go语句中调用Accept.

func (*Server) HandleHTTP

func (server *Server) HandleHTTP(rpcPath, debugPath string)

HandleHTTP在rpcPath上注册用于RPC消息的HTTP处理程序,并在debugPath上注册调试处理程序. 通常仍然需要在go语句中调用http.Serve().

func (*Server) Register

func (server *Server) Register(rcvr interface{}) error

寄存器在服务器中发布满足以下条件的接收者值的方法集:

- exported method of exported type
- two arguments, both of exported type
- the second argument is a pointer
- one return value, of type error

如果接收器不是导出类型或没有合适的方法,则返回错误. 它还使用程序包日志记录错误. 客户端使用形式为" Type.Method"的字符串访问每个方法,其中Type是接收者的具体类型.

func (*Server) RegisterName

func (server *Server) RegisterName(name string, rcvr interface{}) error

RegisterName类似于Register,但是使用提供的名称作为类型,而不是接收者的具体类型.

func (*Server) ServeCodec

func (server *Server) ServeCodec(codec ServerCodec)

ServeCodec类似于ServeConn,但是使用指定的编解码器解码请求和编码响应.

func (*Server) ServeConn

func (server *Server) ServeConn(conn io.ReadWriteCloser)

ServeConn在单个连接上运行服务器. ServeConn阻塞,为连接提供服务,直到客户端挂断. 调用方通常在go语句中调用ServeConn. ServeConn在连接上使用gob导线格式(请参阅软件包gob). 要使用备用编解码器,请使用ServeCodec. 有关并发访问的信息,请参见NewClient的注释.

func (*Server) ServeHTTP

func (server *Server) ServeHTTP(w http.ResponseWriter, req *http.Request)

ServeHTTP实现了一个响应RPC请求的http.Handler.

func (*Server) ServeRequest

func (server *Server) ServeRequest(codec ServerCodec) error

ServeRequest类似于ServeCodec,但是同步处理单个请求. 完成后不会关闭编解码器.

type ServerCodec

ServerCodec为RPC会话的服务器端实现RPC请求的读取和RPC响应的写入. 服务器成对调用ReadRequestHeader和ReadRequestBody以从连接中读取请求,并调用WriteResponse以写回响应. 连接完成后,服务器将调用"关闭". 可以使用nil参数调用ReadRequestBody,以强制读取和丢弃请求的正文. 有关并发访问的信息,请参见NewClient的注释.

type ServerCodec interface {
    ReadRequestHeader(*Request) error
    ReadRequestBody(interface{}) error
    WriteResponse(*Response, interface{}) error

    // Close can be called multiple times and must be idempotent.
    Close() error
}

type ServerError

ServerError表示已从RPC连接的远程端返回的错误.

type ServerError string

func (ServerError) Error

func (e ServerError) Error() string

Subdirectories

Name Synopsis
..
jsonrpc 包jsonrpc为rpc包实现了JSON-RPC 1.0 ClientCodec和ServerCodec.

by  ICOPY.SITE