Server. Procesarea conexiunilor

Pentru ascultarea și acceptarea cererilor de intrare, în pachetul net este definită funcția net.Listen:

func Listen(network, laddr string) (net.Listener, error)

Funcția primește doi parametri:

• network – protocolul prin care aplicația va primi cereri,
• laddr – adresa locală la care va fi pornit serverul.

Protocolul trebuie să fie unul dintre următoarele valori: "tcp", "tcp4", "tcp6", "unix", "unixpacket".

Adresa locală poate conține doar un număr de port, de exemplu ":8080". În acest caz, aplicația va accepta conexiuni pe toate interfețele de rețea disponibile.

În caz de succes, funcția returnează un obiect al interfeței net.Listener, care oferă funcționalitatea de a accepta conexiuni de intrare. În funcție de protocolul utilizat, obiectul returnat de tip Listener poate fi de tip net.TCPListener sau net.UnixListener (ambele implementează interfața net.Listener).

Principalele metode oferite de net.Listener sunt:

• Accept() – acceptă o conexiune de intrare,
• Close() – închide listenerul.

package main
import (
    "fmt"
    "net"
)
func main() { 
    message := "Hello, I am fabricadecoduri server"   // mesajul trimis
    listener, err := net.Listen("tcp", ":4545") 
     
    if err != nil {
        fmt.Println(err) 
        return
    } 
    defer listener.Close() 
    fmt.Println("Server is listening...")
    for { 
        conn, err := listener.Accept() 
        if err != nil { 
            fmt.Println(err) 
            return
        } 
        conn.Write([]byte(message)) 
        conn.Close() 
    } 
}

Mai întâi, prin apelul net.Listen("tcp", ":4545"), se stabilește ca serverul să asculte conexiunile pe portul 4545 folosind protocolul TCP. După executarea acestei funcții, serverul este lansat și pregătit să accepte conexiuni.

Apoi, într-o buclă infinită for, se acceptă conexiunile de intrare folosind listener.Accept(). Această metodă returnează un obiect de tip net.Conn, care reprezintă clientul conectat. După aceea, putem procesa această conexiune în diverse moduri. De exemplu, putem trimite un mesaj clientului folosind metoda Write. Deoarece această metodă primește un slice de octeți, orice mesaj text trebuie convertit în acest format, astfel:

conn.Write([]byte(message))

Pentru a testa serverul, vom defini o altă aplicație – clientul:

package main import ( "fmt" "os" "net" "io" ) func main() { conn, err := net.Dial("tcp", "127.0.0.1:4545") if err != nil { fmt.Println(err) return } defer conn.Close() io.Copy(os.Stdout, conn) fmt.Println("\nDone") }

Deoarece serverul va fi pornit pe computerul local, pe portul 4545, clientul se va conecta la această adresă folosind:

net.Dial("tcp", "127.0.0.1:4545")

După conectare, va fi trimisă o solicitare către server, iar cu ajutorul apelului:

io.Copy(os.Stdout, conn)

răspunsul primit de la server va fi afișat în consolă.

Mai întâi, pornim serverul. Pe Windows este posibil să apară o fereastră care solicită permisiunea de a permite accesul aplicației la rețea.

După ce vom rula clientul și serverul, în consola clientului vom vedea mesajul de la server!