Socket programming and server-side writing in Go language

With the rapid development of the Internet, more applications require network communication, and socket programming has become an important programming method. The Go language is a programming language that has attracted much attention in recent years, and it also has unique advantages in the field of network programming. This article will introduce socket programming in Go language and how to write a simple server program.

1. Overview of socket programming

Socket is an abstraction layer provided between the application layer and the transport layer, which allows applications to communicate through the network. For most applications, sockets are the entrance and exit for network communication. Specifically, in socket programming, a socket can be regarded as a special type of file. The program can perform network communication by reading and writing this "file".

The core content of Socket programming includes the following aspects:

1. Create socket

Before creating a socket, you need to clarify which protocol is used: TCP or UDP . The choice of protocol will directly affect subsequent programming methods. In the Go language, you can call the corresponding function in the net package to create a socket.

2. Bind address and port

In order for the client to find the server, the server needs to bind the listening address and port. In the Go language, you can call the Listen function in the net package to complete the binding of addresses and ports.

3. Listen for client connection requests

Once the server binds the address and port, it will start listening for client connection requests. In the Go language, you can combine goroutine and select statements to monitor multiple sockets concurrently.

4. Receive and process client requests

When the client requests to establish a connection, the server needs to call the Accept function to receive the client request and hand the client request to the sub-coroutine. deal with.

5. Sending and receiving data

After the client and server establish a connection, both parties can send and receive data through Socket. In the Go language, you can call the Write and Read functions in the net package to send and receive data.

2. Server-side programming in Go language

After understanding the basic knowledge of socket programming, we can start writing server-side programs. This section will take a simple echo program as an example to introduce how to use Go language to write server-side programs.

1. Create a socket

In the Go language, you can create a socket by calling the Listen function in the net package. The parameter of the Listen function is a string, which represents the address and port number we want to bind. If port is 0, a free port is allocated. The following code demonstrates how to create a TCP socket and bind it to the local port 8000.

listener, err := net.Listen("tcp", ":8000")
if err != nil {
    fmt.Println("Error listen:", err)
    return
}
defer listener.Close()

2. Monitor client connection requests

After creating the socket, we need to continuously monitor client connection requests. In the Go language, we can use an infinite for loop to continuously call the Accept function and wait for the client's connection request. The Accept function returns a Socket object conn to which the client connects.

for {
    conn, err := listener.Accept()
    if err != nil {
        fmt.Println("Error accept:", err)
        return
    }
    go handleConnection(conn)
}

3. Processing client requests

The method of processing client requests is placed in a sub-coroutine, so that multi-core CPUs can be fully utilized to improve concurrent processing capabilities. This article takes the echo program as an example, which returns the data sent by the client to the client intact.

func handleConnection(conn net.Conn) {
    buf := make([]byte, 1024)
    defer conn.Close()
    for {
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println("Error reading:", err)
            return
        }
        fmt.Println("Received:", string(buf[:n]))
        _, err = conn.Write(buf[:n])
        if err != nil {
            fmt.Println("Error writing:", err)
            return
        }
    }
}

4. Complete code

The following is the code of a complete echo server program:

package main

import (
    "fmt"
    "net"
)

func main() {
    listener, err := net.Listen("tcp", ":8000")
    if err != nil {
        fmt.Println("Error listen:", err)
        return
    }
    defer listener.Close()

    fmt.Println("Listening on :8000")

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accept:", err)
            continue
        }
        fmt.Println("New client connected")
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    buf := make([]byte, 1024)
    defer conn.Close()
    for {
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println("Error reading:", err)
            return
        }
        fmt.Println("Received:", string(buf[:n]))
        _, err = conn.Write(buf[:n])
        if err != nil {
            fmt.Println("Error writing:", err)
            return
        }
    }
}

Through the above code, we can see that in the Go language, It is very easy to implement a simple echo server program.

3. Summary

This article mainly introduces the basic concepts of socket programming and how to write the simplest echo server program in Go language. Go language provides a very simple and easy-to-use network programming interface, which can greatly reduce programmers' learning costs and programming difficulty, and improve programming efficiency and operating efficiency. For applications that require network communication, Go language is undoubtedly a very good choice.

The above is the detailed content of Socket programming and server-side writing in Go language. For more information, please follow other related articles on the PHP Chinese website!