Socket和RPC和REST简介
1.Socket
两个进程如果需要进行通讯最基本的一个前提能够唯一的标示一个进程，在本地进程通讯中我们可以使用PID来唯一标示一个进程，但PID只在本地唯一，网络中的两个进程PID冲突几率很大，这时候我们需要另辟它径了，我们知道IP层的ip地址可以唯一标示主机，而TCP层协议和端口号可以唯一标示主机的一个进程，这样我们可以利用ip地址＋协议＋端口号唯一标示网络中的一个进程
socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程网络中通信
socket起源于UNIX，在Unix一切皆文件哲学的思想下， socket是一种"打开—读/写—关闭"模式的实现，服务器和客户端各自维护一个"文件"，在建立连接打开后，可以向自己文件写入内容供对方读取或者读取对方内容，通讯结束时关闭文件
Socket通信流程 socket是"打开—读/写—关闭"模式的实现，以使用TCP协议通讯的socket为例
socket起源于UNIX，在Unix一切皆文件哲学的思想下，socket是一种"打开—读/写—关闭"模式的实现，服务器和客户端各自维护一个"文件"，在建立连接打开后，可以向自己文件写入内容供对方读取或者读取对方内容，通讯结束时关闭文件
Socket通信流程 socket是"打开—读/写—关闭"模式的实现，以使⽤用TCP协议通讯的socket为例，其交互流程大概是下图这样的：
Server端
package main
import (
"bufio"
"fmt"
"net"
)
// tcp/server/main.go
// TCP server端
// 处理函数
func process(conn net.Conn) {
defer conn.Close() // 关闭连接
for {
reader := bufio.NewReader(conn)
var buf [128]byte
n, err := reader.Read(buf[:]) // 读取数据
if err != nil {
fmt.Println("read from client failed, err:", err)
break
}
recvStr := string(buf[:n])
fmt.Println("收到client端发来的数据：", recvStr)
conn.Write([]byte(recvStr)) // 发送数据
}
}
func main() {
listen, err := net.Listen("tcp", "127.0.0.1:20000")
if err != nil {
fmt.Println("listen failed, err:", err)
return
}
for {
conn, err := listen.Accept() // 建立连接
if err != nil {
fmt.Println("accept failed, err:", err)
continue
}
go process(conn) // 启动一个goroutine处理连接
}
}
Client端
package main
import (
"bufio"
"fmt"
"net"
"os"
"strings"
)
// 客户端
func main() {
conn, err := net.Dial("tcp", "127.0.0.1:20000")
if err != nil {
fmt.Println("err :", err)
return
}
defer conn.Close() // 关闭连接
inputReader := bufio.NewReader(os.Stdin)
for {
input, _ := inputReader.ReadString('\n') // 读取用户输入
inputInfo := strings.Trim(input, "\r\n")
if strings.ToUpper(inputInfo) == "Q" { // 如果输入q就退出
return
}
_, err = conn.Write([]byte(inputInfo)) // 发送数据
if err != nil {
return
}
buf := [512]byte{}
n, err := conn.Read(buf[:])
if err != nil {
fmt.Println("recv failed, err:", err)
return
}
fmt.Println(string(buf[:n]))
}
}
2.TCP与UDP
在TCP连接中，服务端是一个标准的Listen+Accept的结构，而在客户端Go语言使用net.Dial或DialTimeout进行连接建立
在Go语言的net包中有一个类型TCPConn（只有一个嵌入字段Conn），可以作为客户端和服务单交互的通道，它有两个主要的方法
func (c *TCPConn)Write(b []byte)(n int,err os.Error) func (c *TCPConn)Read(b []byte)(n int,err os.Error)这两个方法实现了Reader和Write接口，实现了这两个接口方法就拥有了文件的读写能力，TCPConn用这两个方法可以在客户端和服务端写数据
在Go语言中通过ResolveTCPAddr获取一个TCPAddr:
func ResolveTCPAddr(net,addr string)(*TCPAddr,os.Error)ResolveRCPAddr()函数的参数net是tcp4,tcp6,tcp中的任意一个，参数addr表示域名或者IP地址，以下是TCP建立的具体代码：
// tcp server 服务端代码 package main import ( "bufio" "fmt" "io" "net" "time" ) func main() { var tcpAddr *net.TCPAddr tcpAddr, _ = net.ResolveTCPAddr("tcp", "127.0.0.1:999") tcpListener, _ := net.ListenTCP("tcp", tcpAddr) defer tcpListener.Close() fmt.Println("Server ready to read ...") for { tcpConn, err := tcpListener.AcceptTCP() if err != nil { fmt.Println("accept error:", err) continue } fmt.Println("A client connected : " + tcpConn.RemoteAddr().String()) go tcpPipe(tcpConn) } } func tcpPipe(conn *net.TCPConn) { ipStr := conn.RemoteAddr().String() defer func() { fmt.Println(" Disconnected : " + ipStr) conn.Close() }() reader := bufio.NewReader(conn) i := 0 for { message, err := reader.ReadString('\n') //将数据按照换行符进行读取。 if err != nil || err == io.EOF { break } fmt.Println(string(message)) time.Sleep(time.Second * 3) msg := time.Now().String() + conn.RemoteAddr().String() + " Server Say hello! \n" b := []byte(msg) conn.Write(b) i++ if i > 10 { break } } }服务端tcpListener.AcceptTCP()接收一个客户端连接请求，通过go tcpPipe(tcpConn)开启一个新协程来管理这对连接。在func tcpPipe(conn *net.TCPConn)中，处理服务端和客户端数据的交换，通过bufio.NewReader读取客户端发送过来的数据，同时conn.Write向客户端发送数据
客户端代码如下：
// tcp client package main import ( "bufio" "fmt" "io" "net" "time" ) func main() { var tcpAddr *net.TCPAddr tcpAddr, _ = net.ResolveTCPAddr("tcp", "127.0.0.1:999") conn, err := net.DialTCP("tcp", nil, tcpAddr) if err != nil { fmt.Println("Client connect error ! " + err.Error()) return } defer conn.Close() fmt.Println(conn.LocalAddr().String() + " : Client connected!") onMessageRecived(conn) } func onMessageRecived(conn *net.TCPConn) { reader := bufio.NewReader(conn) b := []byte(conn.LocalAddr().String() + " Say hello to Server... \n") conn.Write(b) for { msg, err := reader.ReadString('\n') fmt.Println("ReadString") fmt.Println(msg) if err != nil || err == io.EOF { fmt.Println(err) break } time.Sleep(time.Second * 2) fmt.Println("writing...") b := []byte(conn.LocalAddr().String() + " write data to Server... \n") _, err = conn.Write(b) if err != nil { fmt.Println(err) break } } }客户端net.DialTCP("tcp",nil,tcpAddr)向服务端发起一个连接请求，调用onMessageRecived(conn)，处理客户端和服务端数据的发送与接收。在func onMessageRecived(conn *net.TCPConn)中，通过bufio.NewReader读取服务端发送过来的数据
运行结果：
server: Server ready to read ... A client connected : 127.0.0.1:58719 127.0.0.1:58719 Say hello to Server... 127.0.0.1:58719 write data to Server... 127.0.0.1:58719 write data to Server... 127.0.0.1:58719 write data to Server... client: 127.0.0.1:58719 : Client connected! ReadString 2021-05-04 21:58:09.6199316 +0800 CST m=+9.972212001127.0.0.1:58719 Server Say hello! writing... ReadString 2021-05-04 21:58:14.658393 +0800 CST m=+15.010673401127.0.0.1:58719 Server Say hello! writing... ReadString 2021-05-04 21:58:19.6595863 +0800 CST m=+20.011866701127.0.0.1:58719 Server Say hello!
3.WebSocket
WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯它建立在TCP之上，同 HTTP一样通过TCP来传输数据。 WebSocket同HTTP一样也是应用层的协议，并且一开始的握手也需要借助HTTP请求完成。
它和 HTTP 最大不同是 :
- WebSocket 是一种双向通信协议，在建立连接后， WebSocket 服务器和 Browser/Client Agent 都能主动的向对方发送或接收数据，就像 Socket 一样；
- WebSocket 需要类似 TCP 的客户端和服务端通过握手连接，连接成功后才能相互通信。
对于传统 HTTP 每次请求-应答都需要客户端与服务端建立连接的模式，
WebSocket 是类似 Socket 的 TCP 长连接的通讯模式，一旦 WebSocket 连接建立后，后续数据都以帧序列的形式传输。在客户端断开 WebSocket 连接或Server端断掉连接前，不需要客户端和服务端重新发起连接请求。在海量并发及客户端与服务器交互负载流量大的情况下，极大的节省了网络带宽资源的消耗，有明显的性能优势，且客户端发送和接受消息是在同一个持久连接上发起，实时性优势明显。
WebSocket连接过程（握手）
在WebSocket中，只需要服务器和浏览器通过HTTP协议进行一个握手的动作，然后单独建立一条TCP的通信通道进行数据的传送。
- 浏览器，服务器建立TCP连接，三次握手。这是通信的基础，传输控制层，若失败后续都不执行
- TCP连接成功后，浏览器通过HTTP协议向服务器传送WebSocket支持的版本号等信息。（开始前的HTTP握手）
- 服务器收到客户端的握手请求后，同样采用HTTP协议回馈数据
- 当收到了连接成功的消息后，通过TCP通道进行传输通信
4.RPC
Remote Procedure Call 远程过程调用 它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。 RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中， RPC跨越了传输层和应用层。 RPC使得开发包括网络分布式多程序在内的应用程序更加容易。
一个完整的RPC架构里面包含了四个核心的组件，分别是Client,Server,Client Stub以及Server Stub，这个Stub可以了解为存根
客户端（Client），服务的调用方。
服务端（Server），真正的服务提供者。
客户端存根，存放服务端的地址消息，再将客户端的请求参数打包成网络消息，然后通过网络远程发送给服务方
服务端存根，接收客户端发送过来的消息，将消息解包，并调用本地的方法。
RPC采用客户机/服务器模式，通信是建立在Socket之上的,出于一种类比的愿望,在一台机器上运行的主程序,可以调用另一台机器上准备好的子程序,就像LPC(本地过程调用)。请求程序就是一个客户机，而服务提供程序就是一个服务器。首先，调用进程发送一个有进程参数的调用信息到服务进程，然后等待应答信息。在服务端，进程保持睡眠状态直到调用信息的到达为止。当一个调用信息到达，服务器获得进程参数，计算结果，发送答复信息，然后等待下一个调用信息，最后，客户端调用过程接收答复信息，获得进程结果，然后调用执行继续进行。
5.REST & RESTful
REST全称是Representational State Transfer，中文意思是表述性状态转移。 REST指的是一组架构约束条件和原则。如果一个架构符合REST的约束条件和原则，我们就称它为RESTful架构。
REST架构的主要原则
在REST中的一切都被认为是一种资源
每个资源由URI标识
使用统一的接口。处理资源使用POST， GET， PUT， DELETE操作类似创建，读取，更新和删（CRUD）操作。
无状态：每个请求是一个独⽴的请求。从客户端到服务器的每个请求都必须包含所有必要的信息，以便于理解。
同一个资源具有多种表现形式，例如XML， JSON
RESTful API 简单例子
[POST] http://localhost/users // 新增
[GET] http://localhost/users/1 // 查询
[PATCH] http://localhost/users/1 // 更新
[PUT] http://localhost/users/1 // 覆盖，全部更新
[DELETE] http://localhost/users/1 // 删除