网络通信编程 海量用户通信 注册功能的实现 对客户端进行分析

最新推荐文章于 2024-10-04 21:49:15 发布
最新推荐文章于 2024-10-04 21:49:15 发布
阅读量218 收藏
点赞数
文章标签： 开发语言 golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45193103/article/details/123883904
版权 
package main

import (
	"chartroom/client/process"
	"fmt"
	"os"
)

//定义两个全局变量，一个表示用户的id一个表示用户的密码
var userId int
var userPwd string
var userName string

func main() {
	//接受用户的选择
	var key int
	//判断是否继续显示菜单
	//var loop = true
	for true {
		fmt.Println("-----欢迎登录多人聊天系统-----")
		fmt.Println("\t\t\t 1 登录聊天室")
		fmt.Println("\t\t\t 2 注册用户")
		fmt.Println("\t\t\t 3 退出系统")
		fmt.Println("\t\t\t 请选择(1-3):")
		fmt.Scanf("%d\n", &key)
		switch key {
		case 1:
			fmt.Println("登录聊天室")
			fmt.Println("请输入用户的id")
			fmt.Scanf("%d\n", &userId)
			fmt.Println("请输入用户的密码")
			fmt.Scanf("%s\n", &userPwd)
			//完成登录
			//1.创建一个UserProcess的实例
			up := &process.UserProcess{

			}
			up.Login(userId, userPwd)
			fmt.Println("登录成功")
		case 2:
			fmt.Println("注册用户")
			fmt.Println("请输入用户id:")
			fmt.Scanf("%d\n",&userId)
			fmt.Println("请输入用户的密码")
			fmt.Scanf("%s\n",&userPwd)
			fmt.Println("请输入用户的名字")
			fmt.Scanf("%s\n",&userName)
			//loop = false
			//2.调用Userprocess来完成注册的请求
			up := &process.UserProcess{}
			up.Register(userId,userPwd,userName)
		case 3:
			fmt.Println("退出系统")
			os.Exit(0)
		default:
			fmt.Println("你的输入有误,请重新输入")
		}
	}

如果是case2的话，会创建一个up实例，用这个up实例来调用Register的方法。下面将对up实例所绑定的一些方法进行分析，以及对Register进行分析。

up是UserProcess结构体，这个结构体绑定了一个Register和一个Login方法。

package process

import (
	utils "chartroom/client"
	message "chartroom/common"
	"encoding/binary"
	"encoding/json"
	"fmt"
	"net"
	"os"
)

type UserProcess struct{
	//字段
}
func (this *UserProcess) Register (userId int, userPwd string,userName string) (err error) {
	//1.链接到服务器
	conn, err := net.Dial("tcp", "localhost:8884")
	if err != nil {
		fmt.Println("net.Dial err=", err)
		return
	}
	defer conn.Close()
	//2.准备通过conn发送消息给服务器,这个mes的类型是LoginMesType的类型
	var mes message.Message
	mes.Type = message.RegisterMesType

	//3.创建一个LoginMes结构体
	var registerMes message.RegisterMes
	registerMes.UserId = userId
	registerMes.UserPwd = userPwd
	registerMes.UserName = userName

	//4.将loginMes序列化
	data, err := json.Marshal(registerMes)
	if err != nil {
		fmt.Println("json.Marshal err= ", err)
		return
	}

	//5.将data赋给mes.Data字段
	mes.Data = string(data)

	//6.将mes进行序列化 最后这个数据就是我们要发送的数据了 他是一个byte切片
	data, err = json.Marshal(mes)

	if err != nil {
		fmt.Println("json.Marshal err= ", err)
		return
	}

	tf := utils.Transfer{
		Conn: conn,
	}
	//发送data给服务器端
	err = tf.WritePkg(data)

	if err != nil {
		fmt.Println("注册发送信息错误 err=", err)
	}

	mes, err = tf.ReadPkg()

	if err != nil {
		fmt.Println("出错")
		return
	}
	//将mes的Data反序列化成LoginResMes

	var registerResMes message.RegisterResMes
	err = json.Unmarshal([]byte(mes.Data), &registerResMes)
	if registerResMes.Code == 200 {
		fmt.Println("注册成功")
		os.Exit(0)
	} else {
		fmt.Println(registerResMes.Error)
		os.Exit(0)
	}
	return

}


//写一个函数，完成登录
func (up *UserProcess)Login(userId int, userPwd string) (err error) {
	fmt.Println("userPwd=",userPwd)
	//下一步就要开始定协议..
	//fmt.Printf("userId = %d userPwd = %s\n",userId,userPwd)
	//return nil
	//1.链接到服务器
	conn, err := net.Dial("tcp", "localhost:8887")
	if err != nil {
		fmt.Println("net.Dial err=", err)
		return
	}
	//延时关闭
	defer conn.Close()
	//2.准备通过conn发送消息给服务器,这个mes的类型是LoginMesType的类型
	var mes message.Message
	mes.Type = message.LoginMesType

	//3.创建一个LoginMes结构体
	var loginMes message.LoginMes
	loginMes.UserId = userId
	loginMes.UserPwd = userPwd

	//4.将loginMes序列化
	data, err := json.Marshal(loginMes)


	if err != nil {
		fmt.Println("json.Marshal err= ", err)
		return
	}
	//5.将data赋给mes.Data字段
	mes.Data = string(data)


	//6.将mes进行序列化 最后这个数据就是我们要发送的数据了 他是一个byte切片
	data, err = json.Marshal(mes)

	if err != nil {
		fmt.Println("json.Marshal err= ", err)
		return
	}
	
	//7.到这个时候 data就是我们要发送的消息
	//7.1先把data的长度发送给服务器
	//而conn.Write接受的数据类型是byte切片，所以首先要获取到data的长度->转成一个表示长度的byte切片
	var pkglen uint32
	//先定义包的长度，因为他说一会要发送的所以定义成unit32类型的，使用type ByteOrder来转换成byte类型的
	pkglen = uint32(len(data))
	var buf [4]byte
	binary.BigEndian.PutUint32(buf[0:4], pkglen)
	//现在就可以发送了
	n, err := conn.Write(buf[:4])
	if n != 4 || err != nil {
		fmt.Println("conn.Write(bytes) fail", err)
		return
	}
	fmt.Printf("客户端发送的消息长度成功,长度=%d 内容是=%s", len(data), string(data))
	//发送消息本身，之前发送的是data的长度
	_ , err = conn.Write(data)
	if  err != nil {
		fmt.Println("conn.Write(data) fail", err)
		return
	}
	//这里还需要处理服务器端返回的消息，
	tf := utils.Transfer{
		Conn: conn,
	}
	mes,err = tf.ReadPkg()
	//将mes的Data反序列化成LoginResMes
	if err!=nil{
		fmt.Println("出错")
		return
	}
	var loginResMes message.LoginResMes
	err = json.Unmarshal([]byte(mes.Data),&loginResMes)
	if loginResMes.Code == 200{
		//fmt.Println("登录成功")
		//这里还需要再客户端启动一个协程
		//该协程保持和服务器端的通讯，如果服务器有数据推送给客户端
		//则接收并显示在客户端的终端
		go serverProcessMes(conn)

		//1.显示登录成功后的菜单
		for {
			ShowMenu()
		}
	}else if loginResMes.Code == 500{
		fmt.Println(loginResMes.Error)
	}
	return

}

对Register方法进行分析， 

func (this *UserProcess) Register (userId int, userPwd string,userName string) (err error) {
	//1.链接到服务器
	conn, err := net.Dial("tcp", "localhost:8884")
	if err != nil {
		fmt.Println("net.Dial err=", err)
		return
	}
	defer conn.Close()
	//2.准备通过conn发送消息给服务器,这个mes的类型是LoginMesType的类型
	var mes message.Message
	mes.Type = message.RegisterMesType

	//3.创建一个LoginMes结构体
	var registerMes message.RegisterMes
	registerMes.UserId = userId
	registerMes.UserPwd = userPwd
	registerMes.UserName = userName

	//4.将loginMes序列化
	data, err := json.Marshal(registerMes)
	if err != nil {
		fmt.Println("json.Marshal err= ", err)
		return
	}

	//5.将data赋给mes.Data字段
	mes.Data = string(data)

	//6.将mes进行序列化 最后这个数据就是我们要发送的数据了 他是一个byte切片
	data, err = json.Marshal(mes)

	if err != nil {
		fmt.Println("json.Marshal err= ", err)
		return
	}

	tf := utils.Transfer{
		Conn: conn,
	}
	//发送data给服务器端
	err = tf.WritePkg(data)

	if err != nil {
		fmt.Println("注册发送信息错误 err=", err)
	}

	mes, err = tf.ReadPkg()

	if err != nil {
		fmt.Println("出错")
		return
	}
	//将mes的Data反序列化成LoginResMes

	var registerResMes message.RegisterResMes
	err = json.Unmarshal([]byte(mes.Data), &registerResMes)
	if registerResMes.Code == 200 {
		fmt.Println("注册成功")
		os.Exit(0)
	} else {
		fmt.Println(registerResMes.Error)
		os.Exit(0)
	}
	return

}

第一步，会建立一个连接，这个连接可以和server端进行交互。 

conn, err := net.Dial("tcp", "localhost:8884")
	if err != nil {
		fmt.Println("net.Dial err=", err)
		return
	}
	defer conn.Close()

第二步，会创建一个mes对象，

	//2.准备通过conn发送消息给服务器,这个mes的类型是LoginMesType的类型
	var mes message.Message
	mes.Type = message.RegisterMesType

这个mes的形式如下，也就是说Message是一个大类型的结构体，他有data和type，type来进行类型的辨析。

LoginMes是登录的结构体类型，包含用户的基本信息。

LoginResMes是登录的返回值类型，从code和error进行分析。

同理Register。

package message

const (
	//消息类型给成常量
	LoginMesType    = "LoginMes"
	LoginResMesType = "LoginResMes"
	RegisterMesType = "RegisterMes"
)

type Message struct {
	Type string `json:"type"`//消息类型
	Data string `json:"data"`//消息的内容
}

//定义两个消息，后面如果需要还可以增加
type LoginMes struct {
	UserId   int `json:"userId"`
	UserPwd  string `json:"userPwd"`
	UserName string `json:"userName"`
}
type LoginResMes struct {
	Code  int    `json:"code"`// 返回状态码 500 表示该用户还没注册
	Error string `json:"error"`//返回错误信息
}
type RegisterMes struct {
	User	`json:"user"`//他的类型就是User结构体
}
type RegisterResMes struct {
	Code int	`json:"code"` //返回状态码 400 表示该用户以及占有 200表示注册成功
	Error string	`json:"error"`
}

第三步， 会创建一个RegisterMes结构体，利用Register的方法进行赋值。

//3.创建一个RegisterMes结构体
var registerMes message.RegisterMes
registerMes.UserId = userId
registerMes.UserPwd = userPwd
registerMes.UserName = userName

第四步，会将registerMes这个包含注册用户基本信息的结构体进行序列化，会得到一个data，这个data是序列化后的 registerMes，这个registerMes包含注册用户的基本信息。

//4.将RegisterMes序列化
	data, err := json.Marshal(registerMes)
	if err != nil {
		fmt.Println("json.Marshal err= ", err)
		return
	}

第五步，将所得到的序列化后的包含注册用户基本信息的数据，赋值给mes，因为mes这个结构体的data是string类型的，所以需要强制转换。

//5.将data赋给mes.Data字段
	mes.Data = string(data)

 第六步，将所得到的mes进行序列化，这就是最终要发送的数据了

//6.将mes进行序列化 最后这个数据就是我们要发送的数据了 他是一个byte切片
	data, err = json.Marshal(mes)
    if err != nil {
		fmt.Println("json.Marshal err= ", err)
		return
	}

查看Marshal这个函数我们发现， Marshal返回的是一个byte切片，也就是说所得到的data是一个byte切片类型。

func Marshal(v interface{}) ([]byte, error)

第七步，会创建一个Transfer的实例，会利用他进行于server的交互。

tf := utils.Transfer{
		Conn: conn,
	}

查看utils下的Transfer我们会发现，他包含了读包和写包两个方法，而他本身所带两个字段，一个字段是conn也就是注册的时候建立的连接，还有一个字段是buf也就是一个缓冲区。 

type Transfer struct{
	//分析，它应该有哪些字段
	Conn net.Conn
	Buf [8096]byte	//这是传输的时候，使用的缓冲

}

func (this *Transfer) ReadPkg() (mes message.Message, err error) {
	//buf := make([]byte, 8096)
	fmt.Println("等待读取数据")
	//conn.Read 在conn没有被关闭的情况下，才会阻塞
	//如果客户端关闭了 conn 则，就不会阻塞了

	_, err = this.Conn.Read(this.Buf[:4])

	if err != nil {

		fmt.Println("conn.read err=", err)
		return
	}
	//根据buf[:4]转成一个uint32类型
	var pkgLen uint32 //buf[:4]
	pkgLen = binary.BigEndian.Uint32(this.Buf[:4])
	//根据pkgLen 读取消息内容
	n, err := this.Conn.Read(this.Buf[:pkgLen]) //这个函数的意思是，从conn这个套接字里面读[:pkgLen]这个长度，扔到buf里面去

	if n != int(pkgLen) || err != nil {
		//fmt.Println("conn.Read fail err=", err)
		return
	}

	//这个时候，还要讲pkgLen反序列化成 -> message.Message
	err = json.Unmarshal(this.Buf[:pkgLen], &mes)

	if err != nil {
		fmt.Println("json.Unmarsha err=", err)
		return
	}

	fmt.Println("这里的mes",mes)
	return mes,err
}
func (this *Transfer) WritePkg(data []byte)(err error){
	//先发送一个长度给对方
	var pkglen uint32 //先定义包的长度，因为他说一会要发送的所以定义成unit32类型的，使用type ByteOrder来转换成byte类型的
	pkglen = uint32(len(data))
	//var buf [4]byte
	binary.BigEndian.PutUint32(this.Buf[0:4], pkglen)
	//现在就可以发送了
	n, err := this.Conn.Write(this.Buf[:4])
	if n != 4 || err != nil {
		fmt.Println("conn.Write(bytes) fail", err)
		return
	}
	//发送data本身
	n, err = this.Conn.Write(data)
	if uint32(n) != pkglen || err != nil {
		fmt.Println("conn.Write(bytes) fail", err)
		return
	}
	return
}

第八步，利用Transfer中的writePkg进行将数据data发送给服务器

	//发送data给服务器端
	err = tf.WritePkg(data)

	if err != nil {
		fmt.Println("注册发送信息错误 err=", err)
	}

看一下WritePkg的实现

func (this *Transfer) WritePkg(data []byte)(err error){
	//先发送一个长度给对方
	var pkglen uint32 //先定义包的长度，因为他说一会要发送的所以定义成unit32类型的，使用type ByteOrder来转换成byte类型的
	pkglen = uint32(len(data))
	//var buf [4]byte
	binary.BigEndian.PutUint32(this.Buf[0:4], pkglen)
	//现在就可以发送了
	n, err := this.Conn.Write(this.Buf[:4])
	if n != 4 || err != nil {
		fmt.Println("conn.Write(bytes) fail", err)
		return
	}
	//发送data本身
	n, err = this.Conn.Write(data)
	if uint32(n) != pkglen || err != nil {
		fmt.Println("conn.Write(bytes) fail", err)
		return
	}
	return
}

 这里一般是不会出错的，因为Buf[:4]里面的内容是长度，而n是这个写入的长度，并不是真实数据的长度。

	n, err := this.Conn.Write(this.Buf[:4])
	if n != 4 || err != nil {
		fmt.Println("conn.Write(bytes) fail", err)
		return
	}

第九步，客户端从conn中读取信息来获得code，返回结果。

	mes, err = tf.ReadPkg()

	if err != nil {
		fmt.Println("出错")
		return
	}
	//将mes的Data反序列化成LoginResMes

	var registerResMes message.RegisterResMes
	err = json.Unmarshal([]byte(mes.Data), &registerResMes)
	if registerResMes.Code == 200 {
		fmt.Println("注册成功")
		os.Exit(0)
	} else {
		fmt.Println(registerResMes.Error)
		os.Exit(0)
	}
	return

 需要一个registerResMes来接收这个mes这个反序列化后的mes。

var registerResMes message.RegisterResMes
func (this *Transfer) ReadPkg() (mes message.Message, err error) {
	//buf := make([]byte, 8096)
	fmt.Println("等待读取数据")
	//conn.Read 在conn没有被关闭的情况下，才会阻塞
	//如果客户端关闭了 conn 则，就不会阻塞了

	_, err = this.Conn.Read(this.Buf[:4])

	if err != nil {

		fmt.Println("conn.read err=", err)
		return
	}
	//根据buf[:4]转成一个uint32类型
	var pkgLen uint32 //buf[:4]
	pkgLen = binary.BigEndian.Uint32(this.Buf[:4])
	//根据pkgLen 读取消息内容
	n, err := this.Conn.Read(this.Buf[:pkgLen]) //这个函数的意思是，从conn这个套接字里面读[:pkgLen]这个长度，扔到buf里面去

	if n != int(pkgLen) || err != nil {
		//fmt.Println("conn.Read fail err=", err)
		return
	}

	//这个时候，还要讲pkgLen反序列化成 -> message.Message
	err = json.Unmarshal(this.Buf[:pkgLen], &mes)

	if err != nil {
		fmt.Println("json.Unmarsha err=", err)
		return
	}

	fmt.Println("这里的mes",mes)
	return mes,err
}

从server端查看发现，他返回的数据类型 是Message的数据类型，这样客户端就能读取了。

func (this *UserProcess)ServerProcessRegister(mes *message.Message)(err error)
type Message struct {
	Type string `json:"type"`//消息类型
	Data string `json:"data"`//消息的内容
}

anzrs
关注
新手学习-Tcp的服务端与客户端的登录注册系统
JavaNewbie__
07-03 3412
客户端最近临近考试 还有好多科目需要预习 这个只能等到考试后再改一下了 现在这个程序问题很多 import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.InetAdd
网络通信编程
qq_39728274的博客
05-13 1344
网络通信编程入门Socket什么是Socket？ Socket 什么是Socket？   Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口，一般由操作系统提供。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议处理和通信缓存管理等等都隐藏在Socket接口后面，对用户来说，使用一组简单的接口就能进行网络应用编程，让Socket去组织数据，以符合指定的协议。主机 A 的应用程序要能和主机 B 的应用程序通信，必须通过 Socket 建立连接。   客户端连接上
java TCP网络编程简单聊天窗口（登录，注册，客户端和服务端图形界面和数据库）适合当作业或学习
木心Fx的博客
11-15 3635
java基于TCP网络编程简单聊天窗口 包含登录，注册，客户端和服务端图形界面和数据库 储存注册信息 适合新人当作业或学习 示例图 登录界面 注册界面 聊天窗口 非常简洁，简洁的页面，简洁的方法。 方法介绍 /* ServerSocket测试 作为tcp网络通信的服务器端 1、创建ServerSocket对象，绑定监听端口 2、通过accept()方法监听客户端请求 3、连接建立后，通过输入流读取客户端发送的请求信息 4、通过输出流向客户端发送响应信息 5、关闭相关资源 */ 主要代码 服务端
golang学习（1）
DETACH-MENT的博客
10-11 443
Go语言字符串底层数据也是对应的字节数组，但是字符串的只读属性禁止了在程序中对底层字节数组的元素的修改。字符串赋值只是复制了数据地址和对应的长度，而不会导致底层数据的复制。 每个字符串的长度虽然也是固定的，但是字符串的长度并不是字符串类型的一部分。 字符串结构由两个信息组成：第一个是字符串指向的底层字节数组，第二个是字符串的字节的长度。字符串其实是一个结构体，因此字符串的赋值操作也就是reflect.StringHeader结构体的复制过程，并不会涉及底层字节数组的复制。 切片 切片的行为更为灵活，
Android 实现蓝牙客户端与服务器端通信
热门推荐
lovoo的博客
06-03 2万+
一、首先说明：蓝牙通信必须用手机测试，因为avd里没有相关的硬件，会报错！ 好了，看看最后的效果图： 二、概述： 1.判断是否支持Bluetooth BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); if(bluetoothAdapter == null) { //the ...
网络通信和TCP/IP协议详解
qq_45061342的博客
08-26 1595
计算机网络的标准定义是：利用通信线路将地理上分散的、具有独立功能的计算机系统和通信设备按不同的形式连接起来，以功能完善的网络软件及协议实现资源共享和信息传递的系统。计算机网络从覆盖范围上划分可以分为三类：局域网、城域网、广域网。局域网LAN（作用范围一般为几米到几十公里）、城域网MAN（界于WAN与LAN之间）、广域网WAN（作用范围一般为几十到几千公里）。
【C/C++】C++ 网络多线程编程
CodeLuweir 的博客
08-06 5382
前言 学习C++网络编程多线程编程的目的： 巩固C++； 由于C++大多用于服务器，因此网络和多线程是进入大厂腾讯的必走之路； 巩固计算机网络和多线程的知识，方便之后Java的系统学习； 一、网络编程基础知识 1.1 套接字 Q：计算机之间如何通信？ ​ 计算机之间的通信约定为一种使用socket（套接字）的方式，比如： Web 服务器和浏览器，浏览器获取用户输入的URL，向服务器发起请求，服务器分析接收到的URL，将对应的网页内容返回给浏览器，浏览器再经过解析和渲染，就将文字、图片、视频等元素呈现给
优化RPC网络通信
在路上
12-31 984
让你对RPC理解上一个档次
UDP网络编程
weixin_47783699的博客
11-18 2698
使用UDP网络通讯
网络编程学习：TCP/IP协议
kkbbaaii的博客
09-01 1918
网络编程学习：TCP/IP协议
经典项目-海量用户通信系统
05-09
【海量用户通信系统】是一种设计用于处理大量并发用户同时进行通信的系统，它通常需要高效的数据处理、存储和网络通信能力。在这个特定的项目“经典项目-海量用户通信系统”中，采用Go语言和Redis数据库作为核心技术...
Java 网络编程 代码 socket
01-06
CS模式的优点包括交互性强、网络通信量小、响应速度快，因为它将任务分散在两端。然而，它的缺点也很明显，如需要针对不同操作系统开发客户端、更新困难且对客户端计算机配置要求较高。 **浏览器-服务器（BS）模式*...
Go核心编程_海量用户通讯系统 stduy.rar
01-29
在本压缩包“Go核心编程_海量用户通讯系统 study.rar”中，主要涵盖了使用Go语言构建大规模用户通信系统的相关知识。Go语言，又称Golang，是Google开发的一种静态类型的、编译式的、并发型且具有垃圾回收功能的编程...
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 1974
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
Golang | Leetcode Golang题解之第447题回旋镖的数量
weixin_66442839的博客
09-30 402
Golang | Leetcode Golang题解之第447题回旋镖的数量
mysql设置表的某一个字段每天定时清零
GoppViper的博客
10-04 473
这里的STARTS指定了事件开始的时间，‘2024 - 10 - 05 00:00:00’ 是一个示例时间，表示从 2024 年 10 月 5 日开始执行这个每天一次的操作。希望本文对你有所帮助！如果你有任何问题或建议，欢迎在评论区留言。2.检查和开启事件调度器（如果尚未开启）
go语言&protoc的详细用法与例子
最新发布
ruanjianxueyuan113的博客
10-04 253
讲解protoc怎么把某一个目录上的proto文件转成指定目录上的go文件，
Go基础学习08-并发安全型类型-通道（chan）深入研究
FLJS_T的博客
09-28 897
在前面学习中了解到对于单值变量，如：int、string；多值变量，如：map存在多协程对资源竞争的并发问题，为了解决并发性通常需要引入sync.Mutex解决。>对于通道的基本声明方式有三种：声明并初始化带缓冲的通道（ch1）；声明并初始化一个不带缓冲的通道（ch2）；仅仅声明一个通道（ch3） >什么是通道：==一个通道相当于一个先进先出（FIFO）的队列。也就是说，通道中的各个元素值都是严格地按照发送的顺序排列的，先被发送通道的元素值一定会先被接收。Select和for循环实现对channel的多次选
golang rpc
weixin_44575660的博客
10-01 1032
RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务，对应rpc的是本地过程调用，函数调用是最常用的本地过程调用，将本地过程调用变成远程调用会面临着各种问题。函数调用过程：（1）将1和2压入函数的栈中（2）进入add函数，从栈中取出1和2分别赋值给a和b（3）执行a+b将结果压栈（4）将栈中的结果取出打印1.原本的本地函数放到另外一个服务器上去运行，但是引入了很多新问题2.Call的id映射。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值