Shulou(Shulou.com)06/03 Report--

This article focuses on "how to understand the basic network programming of the Go language". Interested friends may wish to have a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to understand the basic network programming of the Go language.

Socker programming

The TCP and UDP we learn are collectively referred to as Socker programming, also known as socket programming.

In fact, it is a very complex process for multiple machines to communicate with each other, from laying network cables, network cable interfaces, switches, routers, to stipulating various protocols.

Then to the application layer QQ, Wechat and other software.

If you don't have a set of standards, you have to implement it on your own every time you use it, maybe every programmer is not as simple as losing hair!

With Socker, Socker will hide all kinds of tedious underlying operations before the application layer, and we may only need Socker.TCP to realize the communication of TCP protocol.

Go language TCP

TCP is a stable, reliable long connection

Since communication is involved, there must be two terminals, at least one is the server, the other is the client, just like our Taobao, every time we open Taobao, we have to link it, of course, Taobao is not directly TCP.

Server side

Implementing the server side in Go, and concurrency on the server side is very simple, you only need to let each connection be handled by a co-program!

Code

Package main import ("bufio"fmt"net") func process (conn net.Conn) {defer conn.Close () for {reader: = bufio.NewReader (conn) buf: = make ([] byte, 128) n, err: = reader.Read (buf) if err! = nil {fmt.Println ("data read failed" Err) return} recvStr: = string (buf [: n]) fmt.Println ("value sent by the client:", recvStr)}} func main () {lister, err: = net.Listen ("tcp", "0.0.0.0VR 8008") if err! = nil {fmt.Println ("connection failed") Err)} for {fmt.Println ("waiting for connection to be established, it will block at this time") conn, err: = lister.Accept () / / waiting for connection to be established fmt.Println ("connection established successfully, continue") if err! = nil {fmt.Println ("connection establishment failed" Err) / / continue to monitor the next link continue} go process (conn)}}

Client

The client is very simple, relatively speaking, there is no need for concurrency, just a connection.

Code

Package main import ("bufio"fmt"net"os") / / client func main () {conn, err: = net.Dial ("tcp", "192.168.10.148fmt 8008") if err! = nil {fmt.Println ("connection to server failed") Err)} defer conn.Close () inputReader:=bufio.NewReader (os.Stdin) for {fmt.Println (":") input,_:=inputReader.ReadString ('\ n') _, err = conn.Write ([] byte (input)) if err! = nil {fmt.Println ("sent successfully")}

Execution result

In this way, we implement the server side to process all client requests concurrently.

Sticky bag

Let's take a look at what a sticky bag is.

Server side

Package main import ("bufio"fmt"io"net") func process (conn net.Conn) {defer conn.Close () reader: = bufio.NewReader (conn) buf: = make ([] byte, 1024) for {n Err: = reader.Read (buf) / / finished reading if err = = io.EOF {fmt.Println ("finished") break} / / misread if err! = nil {fmt.Println ("data read failed") Err) return} recvStr: = string (buf [: n]) fmt.Println ("value sent by the client:", recvStr)}} func main () {lister, err: = net.Listen ("tcp", "0.0.0.0VR 8008") if err! = nil {fmt.Println ("connection failed") Err) return} defer lister.Close () for {fmt.Println ("waiting for connection to be established, it will block at this time") conn, err: = lister.Accept () / / wait for connection to be established fmt.Println ("connection established successfully, continue") if err! = nil {fmt.Println ("connection establishment failed" Err) / / continue to monitor the next link continue} go process (conn)}}

Client

Package main import ("fmt"net") / / client func main () {conn, err: = net.Dial ("tcp", "192.168.10.148 err") if err! = nil {fmt.Println ("failed to connect to the server", err)} defer conn.Close () for I: = 0; I

< 10; i++ { sendStr := "hello world ads asdf asd fads fadsf ads ads asd asd ads " conn.Write([]byte(sendStr)) time.Sleep(time.Second) } } 注意:18行代码睡眠了1s 执行结果 如果我注释了第18行代码

Execution result

Straight to the point, what? What is the situation? shouldn't it be the same as before?

Every time a value is sent, it will be received over there, how come it is all together!

Reason

The main reason is that we are application layer software, software running on top of the operating system, when we send a data to the server, it is sent by calling the relevant interface of the operating system, and the operating system goes through a variety of complex operations. send it to the other machine.

However, the operating system has a buffer for sending data. by default, if the buffer is of size, if the buffer is not full, the data will not be sent, so when the above client sends data, the buffer of the system is not full. has been pressed in the operating system buffer, and finally found that there is no data, only once sent to the server

But why does sleep (1) work again? This is because there is more than one program in the buffer, and 1 second is enough time for other programs to fill the buffer and then send their own data, which is why there is no problem in the first operation and the second time, because the second time is all filled by our client.

Solve the sticky bag

Tool function

Let's encapsulate the function of unpacking the packet.

Socker_sitck/stick.go

Package socker_stick import ("bufio"bytes"encoding/binary"fmt") / / Encode encodes the message func Encode (message string) ([] byte, error) {length: = int32 (len (message)) var pkg = new (bytes.Buffer) / / writes the message header err: = binary.Write (pkg, binary.LittleEndian) Length) if err! = nil {fmt.Println ("write header failed", err) return nil, err} / / write message entity err = binary.Write (pkg, binary.LittleEndian, [] byte (message)) if err! = nil {fmt.Println ("write message entity failed", err) return nil, err} return pkg.Bytes () Nil} / / Decode decode message func Decode (reader * bufio.Reader) (string, error) {/ / read message length lengthByte, _: = reader.Peek (4) lengthBuff: = bytes.NewBuffer (lengthByte) var length int32 err: = binary.Read (lengthBuff, binary.LittleEndian, & length) if err! = nil {return "" Err} / / BuffRead returns the existing readable bytes of the buffer if int32 (reader.Buffered ()) < length+4 {return ", err} pack: = make ([] byte, int (4+length)) _, err = reader.Read (pack) if err! = nil {return", err} return string (pack [4:]), nil}

Server side

Package main import ("a3_course/socker_stick"bufio"fmt"io"net") func process (conn net.Conn) {defer conn.Close () reader: = bufio.NewReader (conn) for {msg Err: = socker_stick.Decode (reader) / / finished reading if err = = io.EOF {fmt.Println ("finished") break} / / misread if err! = nil {fmt.Println ("data read failed") Err) return} fmt.Println ("value sent by the client:", msg)}} func main () {lister, err: = net.Listen ("tcp", "0.0.0.0fmt.Println 8008") if err! = nil {fmt.Println ("connection failed") Err) return} defer lister.Close () for {fmt.Println ("waiting for connection to be established, it will block at this time") conn, err: = lister.Accept () / / wait for connection to be established fmt.Println ("connection established successfully, continue") if err! = nil {fmt.Println ("connection establishment failed" Err) / / continue to monitor the next link continue} go process (conn)}}

Client

Package main import ("a3_course/socker_stick"fmt"net") / / client func main () {conn, err: = net.Dial ("tcp", "192.168.10.148 fmt 8008") if err! = nil {fmt.Println ("failed to connect to the server", err)} defer conn.Close () for I: = 0; I < 10 ITunes + {sendStr: = "hello world ads asdf asd fads fadsf ads ads asd asd ads" data, err: = socker_stick.Encode (sendStr) if err! = nil {fmt.Println ("Encoding failure", err) return} conn.Write (data) / / time.Sleep (time.Second)}}

Execution result

This time, no matter how many times it was executed, it always turned out like this.

By the way, only TCP has sticky bags.

Go language UDP

UDP is a connectionless protocol. The client does not care if there is a problem with the server. The client only sends it. It is usually used in areas with high real-time performance.

For example, the live broadcast industry

Server side

Package main import ("fmt"net") func main () {listen, err: = net.ListenUDP ("udp", & net.UDPAddr {IP: net.IPv4 (0,0,0,0), Port: 8009,}) if err! = nil {panic ("udp failed to start, err:%v" Err)} defer listen.Close () for {var data = make ([] byte,1024) n, addr, err: = listen.ReadFromUDP (data) if err! = nil {panic (fmt.Sprintf ("read data failed, err:%v", err))} fmt.Println (string (data [: n])), addr,n)}}

Client

Package main import ("fmt"net") func main () {socker, err: = net.DialUDP ("udp", nil, & net.UDPAddr {IP: net.IPv4 (0,0,0,0), Port: 8009,}) if err! = nil {panic ("connection to the server, err:%v" Err)} defer socker.Close () sendStr:= "Hello" _, err = socker.Write ([] byte (sendStr)) if err! = nil {panic (fmt.Sprintf ("data transmission failed, err:%v", err))}}

Execution result

At this point, I believe you have a deeper understanding of "how to understand the basic network programming of the Go language". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.