当前位置：网站首页>[translation] Introduction to go RPC: Hello World

[translation] Introduction to go RPC: Hello World

2022-07-24 00:08:00 【51CTO】

【 translate 】Go RPC introduction ：Hello World_ Remote procedure call

RPC（Remote Procedure Call） Short for remote procedure call , It is a popular communication mode between different nodes in distributed system . In the age of the Internet ,RPC Has been and IPC Become an indispensable basic component . therefore Go The standard library of language also provides a simple RPC Realization ： net/rpc package .

RPC The purpose of is to become the function call mode of network system . Client execution RPC It's like calling a native function , They just package the function parameters and send them to the server through the network . The server can then unpack these parameters and process the request , Execute the result back to the client .

In computer science , Remote procedure call (RPC) It's a kind of interprocess communication , It allows computer programs to make subroutines or procedures in another address space （ Usually on another computer on a shared network ） perform , There is no need for programmers to explicitly code the details of this remote interaction . in other words , Whether the subroutine is a local program or a remote program that executes the program , Programmers write basically the same code . When the software in question uses object-oriented principles ,RPC It is called remote call or remote method call .

RPC edition Hello World

because net/rpc It provides us with a way for one piece of code to communicate with another piece of code through the network , A natural example is the client - In server architecture “Hello World”.

The code structure ：

       
       .
       
├── Makefile            # instructions for building and running the
       
|                       # example
       
|
       
├── client              # RPC client
       
│   └── client.go       # provides the interface which executes the
       
|                       # command remotely.
       
|
       
├── core                # Shared functionality.
       
│   └── core.go         # - implements the actual handler that gets
       
|                       #   executed in the server;
       
|                       # - provides the go representation of the 
       
|                       #   messages exchanged between client and server.
       
|
       
├── main.go             # CLI
       
|                       #
       
└── server              # RPC server - provides the interface which
       
    |                   # allows a client to communicate with it
       
    └── server.go       # over the wire.
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

server.go

HelloWorld The method needs to meet GO Language RPC The rules , Receive two parameters , The second parameter is the pointer type , Return to one Error type , It must be a public method .HelloWorldService Type objects are registered to RPC service RPC.REGISTER Function call Register object methods in object types to RPC As in the rule RPC function , All registration methods are placed in HelloWorldService Under the service space TCP link , adopt rpc.serverConn Function is provided on this link RPC service :

       
       package 
       
       main
       
       import (
       
       "net"
       
       "net/rpc"
       
)
       
       type 
       
       HelloWorldService 
       
       struct {
       
}
       
       func (
       
       s 
       
       *
       
       HelloWorldService) 
       
       HelloWorld(
       
       request 
       
       string, 
       
       response 
       
       *
       
       string) 
       
       error {
       
       *
       
       response 
       
       = 
       
       "hello" 
       
       + 
       
       request
       
       return 
       
       nil
       
}
       
       func 
       
       main() {
       
       _ 
       
       = 
       
       rpc
       
       .
       
       RegisterName(
       
       "HelloWorldService", 
       
       &
       
       HelloWorldService{})
       
       listener, 
       
       err :
       
       = 
       
       net
       
       .
       
       Listen(
       
       "tcp", 
       
       ":8000")
       
       if 
       
       err 
       
       != 
       
       nil {
       
       panic(
       
       "Monitor port failed!")
       
    }
       
       conn, 
       
       err :
       
       = 
       
       listener
       
       .
       
       Accept()
       
       if 
       
       err 
       
       != 
       
       nil {
       
       panic(
       
       "Establish a connection failure!")
       
    }
       
       rpc
       
       .
       
       ServeConn(
       
       conn)
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

client.go

adopt rpc.dial Of RPC Dial up service through client.call Call the specific method. The first parameter in the method is RPC Service name and method name , The second and third parameters are contained in the method .

       
       package 
       
       main
       
       import (
       
       "fmt"
       
       "log"
       
       "net/rpc"
       
)
       
       func 
       
       main() {
       
       client, 
       
       err :
       
       = 
       
       rpc
       
       .
       
       Dial(
       
       "tcp", 
       
       "127.0.0.1:8000")
       
       if 
       
       err 
       
       != 
       
       nil {
       
       log
       
       .
       
       Fatal(
       
       "dial", 
       
       err)
       
    }
       
       var 
       
       response 
       
       string
       
       err 
       
       = 
       
       client
       
       .
       
       Call(
       
       "HelloWorldService.HelloWorld", 
       
       "world", 
       
       &
       
       response)
       
       if 
       
       err 
       
       != 
       
       nil {
       
       log
       
       .
       
       Fatal(
       
       "caller", 
       
       err)
       
    }
       
       fmt
       
       .
       
       Println(
       
       response)
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.