Go实战--go中使用rpc(Thewaytogo)

作者：没有丝袜姑娘 | 来源：互联网 | 2023-07-14 09:05

生命不止，继续gogogo!!!今天聊聊golang中如何使用rpc，各位先稍安勿躁，我们先介绍一些基本的知识。TCP和Http这个stackoverlow上的回答，觉得很好

生命不止，继续 go go go !!!

今天聊聊golang中如何使用rpc，各位先稍安勿躁，我们先介绍一些基本的知识。

TCP和Http
这个stackoverlow上的回答，觉得很好，搬过来：

HTTP is a layer built ontop of the TCP layer to some what standardize data transmission. So naturally using TCP sockets will be less heavy than using HTTP. If performance is the only thing you care about then plain TCP is the best solution for you.

You may want to consider HTTP because of its ease of use and simplicity which ultimately reduces development time. If you are doing something that might be directly consumed by a browser (through an AJAX call) then you should use HTTP. For a non-modern browser to directly consume TCP connections without HTTP you would have to use Flash or Silverlight and this normally happens for rich content such as video and/or audio. However, many modern browsers now (as of 2013) support API’s to access network, audio, and video resources directly via Javascript. The only thing to consider is the usage rate of modern web browsers among your users; see caniuse.com for the latest info regarding browser compatibility.

As for benchmarks, this is the only thing I found. See page 5, it has the performance graph. Note that it doesn’t really compare apples to apples since it compares the TCP/Binary data option with the HTTP/XML data option. Which begs the question: what kind of data are your services outputting? binary (video, audio, files) or text (JSON, XML, HTML)?

In general performance oriented system like those in the military or financial sectors will probably use plain TCP connections. Where as general web focused companies will opt to use HTTP and use IIS or Apache to host their services.

什么是rpc
RPC是Remote Procedure CallProtocol的缩写，即—远程过程调用协议。

RPC是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。如果涉及的软件采用面向对象编程，那么远程过程调用亦可称作远程调用或远程方法调用，信息数据。通过它可以使函数调用模式网络化。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

net/rpc

Go语言标准库能够自带一个rpc框架还是非常给力的，这可以很大程度的降低写后端网络通信服务的门槛，特别是在大规模的分布式系统中，rpc基本是跨机器通信的标配。rpc能够最大程度屏蔽网络细节，让开发者专注在服务功能的开发上面。

Package rpc provides access to the exported methods of an object across a network or other I/O connection. A server registers an object, making it visible as a service with the name of the type of the object. After registration, exported methods of the object will be accessible remotely. A server may register multiple objects (services) of different types but it is an error to register multiple objects of the same type.

Go RPC的函数只有符合下面的条件才能被远程访问，不然会被忽略，详细的要求如下：
1. 函数必须是导出的(首字母大写)
2. 必须有两个导出类型的参数，
3. 第一个参数是接收的参数，第二个参数是返回给客户端的参数，第二个参数必须是指针类型的
4. 函数还要有一个返回值error

下面介绍几个方法：
Register–注册

func Register(rcvr interface{}) error

NewServer

func NewServer() *Server

NewServer returns a new Server.

func (*Server) HandleHTTP

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

HandleHTTP registers an HTTP handler for RPC messages on rpcPath, and a debugging handler on debugPath. It is still necessary to invoke http.Serve(), typically in a go statement.

func Accept

func Accept(lis net.Listener)

Accept accepts connections on the listener and serves requests to DefaultServer for each incoming connection. Accept blocks; the caller typically invokes it in a go statement.

func Dial

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

Dial connects to an RPC server at the specified network address.

RPC可以利用TCP和HTTP进行传递数据，所以这也是为什么最开始介绍了一下tcp vs http.

下面的实现出自于：
https://astaxie.gitbooks.io/build-web-application-with-golang/zh/08.4.html

基于HTTP的RPC
服务端：

package main

    import (
        "errors"
        "fmt"
        "net/http"
        "net/rpc"
    )

    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
    }

    func main() {

        arith := new(Arith)
        rpc.Register(arith)
        rpc.HandleHTTP()

        err := http.ListenAndServe(":1234", nil)
        if err != nil {
            fmt.Println(err.Error())
        }
    }

客户端：

package main

    import (
        "fmt"
        "log"
        "net/rpc"
        "os"
    )

    type Args struct {
        A, B int
    }

    type Quotient struct {
        Quo, Rem int
    }

    func main() {
        if len(os.Args) != 2 {
            fmt.Println("Usage: ", os.Args[0], "server")
            os.Exit(1)
        }
        serverAddress := os.Args[1]

        client, err := rpc.DialHTTP("tcp", serverAddress+":1234")
        if err != nil {
            log.Fatal("dialing:", err)
        }
        // Synchronous call
        args := Args{17, 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\n", args.A, args.B, reply)

        var quot Quotient
        err = client.Call("Arith.Divide", args, ")
        if err != nil {
            log.Fatal("arith error:", err)
        }
        fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

    }

我们已经看到了，上面的两段代码很多的冗余，我们把公共数据部分要提出来。
rpc_objects.go

package rpc_objects
import "net"

type Args struct {
    N, M int
}

func (t *Args) Multiply(args *Args, replu *int) net.error {
    *reply = args.N * args.M
    return nil
}

服务端：

package mian
import (
    "net/http"
    "log"
    "net"
    "net/rpc"
    "time"
    "./rpc_objects"
)

func main() {
    calc := new(rpc_objects.Args)
    rpc.Register(calc)
    rpc.HandleHTTP()
    listener, e := net.Listen("tcp", "localhost:1234")
    if e != nil {
        log.Fatal("Starting RPC-SERVER -listen error:", e)
    }
    go http.Serve(listener, nil)
    time.Sleep(1000e9)
}

客户端：

package mian
import (
    "fmt"
    "log"
    "net/rpc"
    "./rpc_objects"
)

const serverAddress = "localhost"

func main() {
    client, err := rpc.DialHTTP("tcp", serverAddress + ":1234")
    if err != nil {
        log.Fatal("Error dialing:", e)
    }
    args := &rpc_objects.Args{7, 8}
    var reply int
    err = client.Call("Args.Multiply", args, &reply)
    if err != nil {
        log.Fatal("Args error", err)
    }
    fmt.Printf("Args: %d * %d", args.N, args.M, reply)
}

基于TCP的RPC
服务端：

package main

    import (
        "errors"
        "fmt"
        "net"
        "net/rpc"
        "os"
    )

    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
    }

    func main() {

        arith := new(Arith)
        rpc.Register(arith)

        tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
        checkError(err)

        listener, err := net.ListenTCP("tcp", tcpAddr)
        checkError(err)

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

    }

    func checkError(err error) {
        if err != nil {
            fmt.Println("Fatal error ", err.Error())
            os.Exit(1)
        }
    }

客户端：

package main

    import (
        "fmt"
        "log"
        "net/rpc"
        "os"
    )

    type Args struct {
        A, B int
    }

    type Quotient struct {
        Quo, Rem int
    }

    func main() {
        if len(os.Args) != 2 {
            fmt.Println("Usage: ", os.Args[0], "server:port")
            os.Exit(1)
        }
        service := os.Args[1]

        client, err := rpc.Dial("tcp", service)
        if err != nil {
            log.Fatal("dialing:", err)
        }
        // Synchronous call
        args := Args{17, 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\n", args.A, args.B, reply)

        var quot Quotient
        err = client.Call("Arith.Divide", args, ")
        if err != nil {
            log.Fatal("arith error:", err)
        }
        fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

    }

这里写图片描述

推荐阅读

utf-8
javascript分页类支持页码格式

前端时间因为项目需要，要对一个产品下所有的附属图片进行分页显示，没考虑ajax一张张请求，所以干脆一次性全部把图片out，然 ... [详细]

蜡笔小新 2024-11-12 14:58:57
header
技术分享：使用 Flask、AngularJS 和 Jinja2 构建高效前后端交互系统

技术分享：使用 Flask、AngularJS 和 Jinja2 构建高效前后端交互系统 ... [详细]

蜡笔小新 2024-11-11 15:24:24
utf-8
一个Tomcat配置多个端口

一、Tomcat安装后本身提供了一个server，端口配置默认是8080，对应目录为：..\Tomcat8.0\webapps二、Tomcat8.0配置多个端口，其实也就是给T ... [详细]

蜡笔小新 2024-11-14 11:23:53
callback
深入探讨ASP.NET 2.0中的Callback机制及其应用

本文详细解析了ASP.NET 2.0中的Callback机制，不仅介绍了基本的使用方法，还深入探讨了其背后的实现原理。通过对比Atlas框架，帮助读者更好地理解和应用这一机制。 ... [详细]

蜡笔小新 2024-11-14 10:03:15
header
为什么多数程序员难以成为架构师？

探讨80%的程序员为何难以晋升为架构师，涉及技术深度、经验积累和综合能力等方面。本文将详细解析Tomcat的配置和服务组件，帮助读者理解其内部机制。 ... [详细]

蜡笔小新 2024-11-14 03:39:46
header
在PHP中如何正确调用JavaScript变量及定义PHP变量的方法详解

在PHP中如何正确调用JavaScript变量及定义PHP变量的方法详解 ... [详细]

蜡笔小新 2024-11-11 17:28:29
ip
PHP微信开发基础教程（第三篇）：详解消息类型处理

在本文中，我们将详细介绍如何构建一个用于自动回复消息的XML类。当微信服务器接收到用户消息时，该类将生成相应的自动回复消息。以下是具体的代码实现：```phpclass We_Xml { // 代码内容}```通过这个类，开发者可以轻松地处理各种消息类型，并实现高效的自动回复功能。我们将深入探讨类的各个方法和属性，帮助读者更好地理解和应用这一技术。 ... [详细]

蜡笔小新 2024-11-09 15:50:27
ip
Web开发框架概览：Java与JavaScript技术及框架综述

Web开发涉及服务器端和客户端的协同工作。在服务器端，Java是一种优秀的编程语言，适用于构建各种功能模块，如通过Servlet实现特定服务。客户端则主要依赖HTML进行内容展示，同时借助JavaScript增强交互性和动态效果。此外，现代Web开发还广泛使用各种框架和库，如Spring Boot、React和Vue.js，以提高开发效率和应用性能。 ... [详细]

蜡笔小新 2024-11-09 11:59:38
utf-8
使用Python爬取妙笔阁小说信息并保存为TXT和CSV格式

本文介绍了如何使用Python爬取妙笔阁小说网仙侠系列中所有小说的信息，并将其保存为TXT和CSV格式。主要内容包括如何构造请求头以避免被网站封禁，以及如何利用XPath解析HTML并提取所需信息。 ... [详细]

蜡笔小新 2024-11-14 19:54:58
import
Go Echo 框架入门指南【1】

本文介绍了 Go 语言中的高性能、可扩展、轻量级 Web 框架 Echo。Echo 框架简单易用，仅需几行代码即可启动一个高性能 HTTP 服务。 ... [详细]

蜡笔小新 2024-11-14 18:30:58
header
com.sun.javadoc.PackageDoc.exceptions()方法的使用及代码示例

com.sun.javadoc.PackageDoc.exceptions()方法的使用及代码示例 ... [详细]

蜡笔小新 2024-11-13 10:47:33
utf-8
Android 自定义加载对话框 CustomProgressDialog

本文介绍如何在 Android 中自定义加载对话框 CustomProgressDialog，包括自定义 View 类和 XML 布局文件的详细步骤。 ... [详细]

蜡笔小新 2024-11-12 21:51:00
utf-8
网站访问全流程解析

本文详细介绍了从用户在浏览器中输入一个域名（如www.yy.com）到页面完全展示的整个过程，包括DNS解析、TCP连接、请求响应等多个步骤。 ... [详细]

蜡笔小新 2024-11-12 18:13:16
utf-8
使用Python和smtplib实现邮件发送功能

本文详细介绍了如何使用Python中的smtplib库来发送带有附件的邮件，并提供了完整的代码示例。作者：多测师_王sir，时间：2020年5月20日 17:24，微信：15367499889，公司：上海多测师信息有限公司。 ... [详细]

蜡笔小新 2024-11-12 12:21:27
window
C++ 异步编程中获取线程执行结果的方法与技巧及其在前端开发中的应用探讨

本文探讨了C++异步编程中获取线程执行结果的方法与技巧，并深入分析了这些技术在前端开发中的应用。通过对比不同的异步编程模型，本文详细介绍了如何高效地处理多线程任务，确保程序的稳定性和性能。同时，文章还结合实际案例，展示了这些方法在前端异步编程中的具体实现和优化策略。 ... [详细]

蜡笔小新 2024-11-09 15:14:28

没有丝袜姑娘

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章