在posix标准推出后，socket在各大主流os平台上都得到了很好的支持。而golang是自带runtime的跨平台编程语言，go中提供给开发者的socket api是建立在操作系统原生socket接口之上的。但golang 中的socket接口在行为特点与操作系统原生接口有一些不同。本文将对结合一个简单的hello/hi的网络聊天程序加以分析。
一、socket简介
首先进程之间可以进行通信的前提是进程可以被唯一标识，在本地通信时可以使用pid唯一标识，而在网络中这种方法不可行，我们可以通过ip地址+协议+端口号来唯一标识一个进程，然后利用socket进行通信。
socket是位于应用层和传输层中的抽象层，它是不属于七层架构中的:
而socket通信流程如下:
1.服务端创建socket
2.服务端绑定socket和端口号
3.服务端监听该端口号
4.服务端启动accept()用来接收来自客户端的连接请求，此时如果有连接则继续执行，否则将阻塞在这里。
5.客户端创建socket
6.客户端通过ip地址和端口号连接服务端，即tcp中的三次握手
7.如果连接成功，客户端可以向服务端发送数据
8.服务端读取客户端发来的数据
9.任何一端均可主动断开连接
二、socket编程
有了抽象的socket后，当使用tcp或udp协议进行web编程时，可以通过以下的方式进行
服务端伪代码:
我要评论listenfd = socket(……)
bind(listenfd, serverip:port, ……)
listen(listenfd, ……)
while(true) {
conn = accept(listenfd, ……)
receive(conn, ……)
send(conn, ……)
}
客户端伪代码:
clientfd = socket(……) connect(clientfd, serverip:port, ……) send(clientfd, data) receive(clientfd, ……) close(clientfd)
上述伪代码中，listenfd就是为了实现服务端监听创建的socket描述符，而bind方法就是服务端进程占用端口，避免其它端口被其它进程使用，listen方法开始对端口进行监听。下面的while循环用来处理客户端源源不断的请求，accept方法返回一个conn，用来区分各个客户端的连接的，之后的接受和发送动作都是基于这个conn来实现的。其实accept就是和客户端的connect一起完成了tcp的三次握手。
golang中提供了一些网络编程的api,包括dial,listen,accept,read,write,close等.
3.1 listen()
首先使用服务端net.listen()方法创建套接字，绑定端口和监听端口。
1 func listen(network, address string) (listener, error) {
2 var lc listenconfig
3 return lc.listen(context.background(), network, address)
4 }
以上是golang提供的listen函数源码，其中network表示网络协议，如tcp,tcp4,tcp6,udp,udp4,udp6等。address为绑定的地址，返回的listener实际上是一个套接字描述符，error中保存错误信息。
而在linuxsocket中使用socket,bind和listen函数来完成同样功能
// socket(协议域，套接字类型，协议) int socket(int domain, int type, int protocol); int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); int listen(int sockfd, int backlog);
3.2 dial()
当客户端想要发起莫个连接时，就会使用net.dial()方法来发起连接
func dial(network, address string) (conn, error) {
var d dialer
return d.dial(network, address)
}
其中network表示网络协议，address为要建立连接的地址，返回的conn实际是标识每一个客户端的，在golang中定义了一个conn的接口:
type conn interface {
read(b []byte) (n int, err error)
write(b []byte) (n int, err error)
close() error
localaddr() addr
remoteaddr() addr
setdeadline(t time.time) error
setreaddeadline(t time.time) error
setwritedeadline(t time.time) error
}
其中netfd是golang网络库里最核心的数据结构，贯穿了golang网络库所有的api,对底层的socket进行封装，屏蔽了不同操作系统的网络实现，这样通过返回的conn，我们就可以使用golang提供的socket底层函数了。
在linuxsocket中使用connect函数来创建连接
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
3.3 accept()
当服务端调用net.listen()后会开始监听指定地址，而客户端调用net.dial()后发起连接请求，然后服务端调用net.accept()接收请求，这里端与端的连接就建立好了，实际上到这一步也就完成了tcp中的三次握手。
accept() (conn, error)
golang的socket实际上是非阻塞的,但golang本身对socket做了一定处理，使其看起来是阻塞的。
在linuxsocket中使用accept函数来实现同样功能
//sockfd是服务器套接字描述符，sockaddr返回客户端协议地址，socklen_t是协议地址长度。
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
3.4 write()
端与端的连接已经建立了，接下来开始进行读写操作，conn.write()向socket写数据
func (c *conn) write(b []byte) (int, error) {
if !c.ok() {
return 0, syscall.einval
}
n, err := c.fd.write(b)
if err != nil {
err = &operror{op: "write", net: c.fd.net, source: c.fd.laddr, addr: c.fd.raddr, err: err}
}
return n, err
}
其中写入的数据是一个二进制字节流，n返回的数据的长度，err保存错误信息
linuxsocket中对应的则是send函数
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
3.5 read()
客户端发送完数据以后，服务端可以接收数据，golang中调用conn.read()读取数据，源码如下:
read(b []byte) (n int, err error)
其参数与write()中的含义一样，在linuxsocket中使用recv函数完成此功能
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
3.6 close()
当服务端或者客户端想要关闭套接字时，调用close()方法关闭连接。
close() error
func (c *conn) close() error { if !c.ok() { return syscall.einval } err := c.fd.close() if err != nil { err = &operror{op: "close", net: c.fd.net, source: c.fd.laddr, addr: c.fd.raddr, err: err} } return err }
在linuxsocket中使用close函数
int close(int socketfd)
4.1 server.go
package main
import (
"fmt"
"net"
"strings"
)
//usermap保存的是当前聊天室所有用户id的集合
var usermap map[string]net.conn = make(map[string]net.conn)
func main() {
//监听本地所有ip的8000端口
listen_socket, err := net.listen("tcp", "127.0.0.1:8000")
if err != nil {
fmt.println("服务启动失败")
}
//关闭监听的端口
defer listen_socket.close()
fmt.println("等待用户加入聊天室")
for {
//用于conn接收链接
conn, err := listen_socket.accept()
if err != nil {
fmt.println("连接失败")
}
//打印加入聊天室的公网ip地址
fmt.println(conn.remoteaddr(), "连接成功")
//定义一个goroutine，这里主要是为了并发运行
go dataprocessing(conn)
}
}
func dataprocessing(conn net.conn) {
for {
//定义一个长度为255的切片
data := make([]byte, 255)
//读取客户端传来的数据，msg_length保存长度，err保存错误信息
msg_length, err := conn.read(data)
if msg_length == 0 || err != nil {
continue
}
//解析协议,通过分隔符"|"获取需要的数据,msg_str[0]存放操作类别
//msg_str[1]存放用户名，msg_str[2]如果有就存放发送的消息
msg_str := strings.split(string(data[0:msg_length]), "|")
switch msg_str[0] {
case "nick":
fmt.println(conn.remoteaddr(), "的用户名是", msg_str[1])
for user, message := range usermap {
//向除自己之外的用户发送加入聊天室的消息
if user != msg_str[1] {
message.write([]byte("用户" + msg_str[1] + "加入聊天室"))
}
}
//将该用户加入用户id的集合
usermap[msg_str[1]] = conn
case "send":
for user, message := range usermap {
if user != msg_str[1] {
fmt.println("send "+msg_str[2]+" to ", user)
//向除自己之外的用户发送聊天消息
message.write([]byte(" 用户" + msg_str[1] + ": " + msg_str[2]))
}
}
case "quit":
for user, message := range usermap {
if user != msg_str[1] {
//向除自己之外的用户发送退出聊天室的消失
message.write([]byte("用户" + msg_str[1] + "退出聊天室"))
}
}
fmt.println("用户 " + msg_str[1] + "退出聊天室")
//将该用户名从用户id的集合中删除
delete(usermap, msg_str[1])
}
}
}
5.2 client.go
package main
import (
"bufio"
"fmt"
"net"
"os"
)
var nick string = ""
func main() {
//拨号操作
conn, err := net.dial("tcp", "127.0.0.1:8000")
if err != nil {
fmt.println("连接失败")
}
defer conn.close()
fmt.println("连接服务成功 \n")
//创建用户名
fmt.printf("在进入聊天室之前给自己取个名字吧:")
fmt.scanf("%s", &nick)
fmt.println("用户" + nick + "欢迎进入聊天室")
//向服务器发送数据
conn.write([]byte("nick|" + nick))
//定义一个goroutine，这里主要是为了并发运行
go sendmessage(conn)
var msg string
for {
msg = ""
//由于golangz的fmt包输入字符串不能读取空格，所以此处重写了一个scanf函数
scanf(&msg)
if msg == "quit" {
//这里的quit，send，以及上面的nick是为了识别客户端做的是设置用户名，发消息还是退出
conn.write([]byte("quit|" + nick))
break
}
if msg != "" {
conn.write([]byte("send|" + nick + "|" + msg))
}
}
}
func sendmessage(conn net.conn) {
for {
//定义一个长度为255的切片
data := make([]byte, 255)
//读取服务器传来的数据，msg_length保存长度，err保存错误信息
msg_length, err := conn.read(data)
if msg_length == 0 || err != nil {
break
}
fmt.println(string(data[0:msg_length]))
}
}
//重写的scanf函数
func scanf(a *string) {
reader := bufio.newreader(os.stdin)
data, _, _ := reader.readline()
*a = string(data)
}
golang中使用goroutine实现并发
5.3 运行截图
多人聊天截图(左上角为服务端)
用户退出聊天室(左上角为服务端)
参考资料:
如对本文有疑问， 点击进行留言回复！！
网友评论