Golang TCP Server

Neste guia, aprenderemos a criar um servidor TCP simples que aceite conexões de entrada com o servidor. O servidor responderá com uma mensagem e os dados e tempo atuais.

Este é um bom tutorial para iniciantes que desejam se familiarizar com o pacote Go Net e como lidar com solicitações.

Começando

Embora o tutorial seja muito amigável para iniciantes, recomendamos ter o básico de trabalhar com o idioma Go em mãos.

Compreender como trabalhar com os pacotes GO também é muito benéfico.

Pacote Net Golang

O pacote líquido faz parte da biblioteca padrão Go. É usado para fornecer interface portátil para trabalhar com operações de E/S de rede. Isso inclui soquetes TCP/IP, UDP, DNS e UNIX Domain.

Usaremos este pacote para criar um servidor TCP.

Construindo um servidor TCP simples

Vamos agora entrar no código e aprender a construir um servidor TCP. Comece criando um arquivo GO para escrever seu código:

MKDIR TCP-SERVER
Toque no servidor.ir

Edite o arquivo com seu editor de texto de escolha e insira as linhas abaixo:

Pacote principal
importação (
"FMT"
"líquido"
"OS"
)

As linhas acima definem o pacote como um pacote independente e importa os pacotes necessários.

O próximo passo é definir os parâmetros para o nosso servidor. Podemos defini -los como variáveis ​​globais como:

const (
Host = "localhost"
Porta = "9001"
Type = "tcp"
)

O próximo passo é ouvir as conexões recebidas. Podemos fazer isso usando a rede.Ouça o método. A sintaxe da função é como mostrado:

func Listen (rede, string de endereço) (ouvinte, erro)

Ele leva o tipo de conexão (como TCP, TCP4, TCP6, UNIX ou Unixpacket), o host e a porta de conexão. A função retornará uma conexão de escuta no endereço especificado.

Um código de exemplo é como mostrado:

Ouça, err: = net.Ouça (tipo, host+":"+porta)
se err != nil
registro.Fatal (ERR)
OS.Saída (1)

Verificamos se o ouvinte encontra algum erro, se verdadeiro, ele registra a mensagem de erro e existe com um código de status de 1.

Também precisamos fechar o ouvinte após o término do servidor. Podemos fazer isso usando a palavra -chave de adiamento e o método de fechamento

ouvir.Fechar()

O próximo passo é ouvir continuamente as conexões. Podemos fazer isso usando um loop para:

para
Conn, err: = Ouça.Aceitar()
se err != nil
registro.Fatal (ERR)
OS.Saída (1)
// lida com conexões de entrada

Para lidar com quaisquer solicitações recebidas, podemos criar uma função como:

Func HandleincomingRequest (Conn Net.Conn)
// armazenar dados recebidos
buffer: = make ([] byte, 1024)
_, err: = Conn.Leia (buffer)
se err != nil
registro.Fatal (ERR)

// responder
Tempo: = Tempo.Agora().Format ("Segunda-feira, 02 de janeiro-06 15:04:05 MST")
Conn.Escreva ([] byte ("oi de volta!"))
Conn.Escreva ([] byte (tempo))
// Fechar Conn
Conn.Fechar()

No exemplo acima, definimos uma função que leva Conn of Type Net.Conn Struct como o parâmetro.

Em seguida, definimos um novo buffer para armazenar os dados recebidos do tamanho 1024. O próximo bloco lê o horário atual usando o tempo.Pacote agora ().

Usando o método de gravação, podemos escrever a hora e uma string para o cliente. Finalmente, definimos o Conn.Fechar () para fechar a conexão.

O código -fonte completo é como mostrado:

Pacote principal
importação (
"registro"
"líquido"
"OS"
"tempo"
)
const (
Host = "localhost"
Porta = "9001"
Type = "tcp"
)
func main ()
Ouça, err: = net.Ouça (tipo, host+":"+porta)
se err != nil
registro.Fatal (ERR)
OS.Saída (1)

// Fechar o ouvinte
adiar ouça.Fechar()
para
Conn, err: = Ouça.Aceitar()
se err != nil
registro.Fatal (ERR)
OS.Saída (1)

vá manuseincomingRequest (Conn)


Func HandleincomingRequest (Conn Net.Conn)
// armazenar dados recebidos
buffer: = make ([] byte, 1024)
_, err: = Conn.Leia (buffer)
se err != nil
registro.Fatal (ERR)

// responder
Tempo: = Tempo.Agora().Format ("Segunda-feira, 02 de janeiro-06 15:04:05 MST")
Conn.Escreva ([] byte ("oi de volta!\ n "))
Conn.Escreva ([] byte (tempo))
// Fechar Conn
Conn.Fechar()

Compilar e executar servidor

Depois de concluído, salve o arquivo e execute o comando abaixo para compilar o ouvinte em um binário:

vá construir servidor.ir

Em seguida, execute o servidor como:

./servidor.exe

O comando acima deve executar o servidor TCP e podemos fazer conexões com ele.

Testando o servidor TCP

Para testar o servidor TCP, você pode usar o NetCat usando o comando:

NC Localhost 9001

Em seguida, envie uma mensagem como:

Oi!

O servidor deve responder com um HI de volta e a data e hora atuais.

Oi de novo!
Terça-feira, 01-feb-22 18:03:56 Eat

Conclusão

E com isso, concluímos nosso tutorial. Este guia apresenta você ao básico de trabalhar com o pacote de rede criando um servidor TCP.

Obrigado pela leitura!