Arquitectura RPC:
Después de una breve comprensión de la definición y las ventajas y desventajas de los microservicios, antes de aprender formalmente el marco de microservicios, primero debemos comprender la arquitectura RPC. A través de RPC, podemos visualizar el flujo de trabajo de los microservicios.
3.1 El concepto de RPC
RPC (Protocolo de llamada a procedimiento remoto) es la abreviatura de llamada a procedimiento remoto. En términos sencillos, es llamar a una función a distancia. A esto le corresponde la llamada a la función local. Veámosla primero: la llamada a la función local. Cuando escribimos el siguiente código: regla
result := Add(1,2)Sabemos que pasamos dos parámetros de 1 y 2, llamamos a una función Agregar en el código local y obtuvimos el valor de retorno del resultado. En este momento, los parámetros, el valor de retorno y el segmento de código están todos en el espacio de proceso, que es una llamada de función local. ¿Hay alguna forma de llamar a una función entre procesos (llamada "remota", en un caso típico, este proceso se implementa en otro servidor)?
RPC: comunicación remota: un protocolo de capa de aplicación (la misma capa que el protocolo http). La capa inferior se implementa mediante TCP. Es muy sencillo implementar RPC en golang y existen bibliotecas oficiales empaquetadas y algunas bibliotecas de terceros para brindar soporte. Go RPC puede usar tcp o http para transferir datos y puede usar varios tipos de códecs para los datos que se transferirán. La biblioteca oficial net/rpc de Golang utiliza codificación/gob para codificar y decodificar, y admite métodos de transmisión de datos tcp o http. Dado que otros idiomas no admiten los métodos de codificación y decodificación gob, el método RPC se implementa utilizando la biblioteca net/rpc no se puede utilizar para llamadas entre idiomas.
Golang también proporciona oficialmente la biblioteca net/rpc/jsonrpc para implementar el método RPC. JSON RPC utiliza JSON para codificar y decodificar datos, lo que admite llamadas en varios idiomas. Sin embargo, la biblioteca jsonrpc actual se implementa en función del protocolo tcp y por el momento no admite el uso de http para la transmisión de datos. Además de la biblioteca rpc oficial proporcionada por golang, existen muchas bibliotecas de terceros que brindan soporte para la implementación de RPC en golang. La mayoría de las bibliotecas rpc de terceros usan protobuf para codificar y decodificar datos, y generan automáticamente definiciones y métodos de rpc. Código de registro de servicio, es muy conveniente llamar al servicio RPC en golang.
El siguiente es un Holamundo:
1. Cree un proyecto para continuar construyendo el servidor rpc:
package main
import (
"fmt"
"net"
"net/rpc"
)
type Hello struct {
}
/*
1、方法只能有两个可序列化的参数，其中第二个参数是指针类型
req表示获取客户端传过来的数据
res表示给客户端返回数据
2、方法要返回一个error类型，同时必须是公开的方法。
3、req和res的类型不能是: channel (通道)、func (函数)均不能进行序列化
*/
func (this Hello) SayHello(req string, res *string) error {
fmt.Println(req, "=======================.")
*res = req + "你好"
return nil
}
func main() {
//注册RPC服务
err := rpc.RegisterName("hello", new(Hello)) //注册服务 进行创建 一个Hello结构题对象
if err != nil {
fmt.Print(err)
}
//监听端口
listen, err := net.Listen("tcp", "127.0.0.1:8080")
if err != nil {
fmt.Println(err)
}
//3、应用退出的时候关闭监听端口
defer listen.Close()
//放入for循环中使值一直处于建立连接中
for {
fmt.Println("开始建立连接")
//4、建立连接
accept, err := listen.Accept()
if err != nil {
fmt.Println(err)
}
//5、绑定服务
rpc.ServeConn(accept)
}
}
2. Luego cree un proyecto para construir el cliente para acceder:
package main
import (
"fmt"
"net/rpc"
)
func main() {
//1、使用rpc.Dial 和rpc微服务建立远程连接
dial, err := rpc.Dial("tcp", "127.0.0.1:8080")
if err != nil {
fmt.Print(err)
}
//2、当客户端退出的时候关闭连接
defer dial.Close()
//调用远程函数
var reply string
/**
第一个参数表示 我们的远程服务，名称加上要调用的方法名，
第二个参数表示的就是我们传递过去的数据，
第三个参数表示我们接收到的值
*/
//注意： hello 是我们rpc也买进行注册的服务名称
err = dial.Call("hello.SayHello", "我是客户端", &reply)
if err != nil {
fmt.Println(err)
}
//获取返回连接
fmt.Println(reply)
}