Servidor Golang TCP

En esta guía, aprenderemos cómo crear un servidor TCP simple que acepte conexiones entrantes con el servidor. El servidor responderá con un mensaje y los datos y la hora actuales.

Este es un buen tutorial para principiantes que desean familiarizarse con el paquete GO Net y cómo manejar las solicitudes.

Empezando

Aunque el tutorial es muy amigable para principiantes, recomendamos tener los conceptos básicos de trabajar con el idioma Go en cuestión.

Comprender cómo trabajar con los paquetes GO también es muy beneficioso.

Paquete de red de Golang

El paquete neto es parte de la biblioteca estándar GO. Se utiliza para entregar una interfaz portátil para trabajar con operaciones de E/S de red. Esto incluye TCP/IP, UDP, DNS y Sockets de dominio Unix.

Usaremos este paquete para crear un servidor TCP.

Construyendo un servidor TCP simple

Entremos ahora en el código y aprendamos a construir un servidor TCP. Comience por crear un archivo Go para escribir su código:

servidor MKDIR TCP
servidor táctil.ir

Edite el archivo con su editor de texto de elección e ingrese las líneas a continuación:

paquete principal
importar (
"FMT"
"neto"
"OS"
)

Las líneas anteriores definen el paquete como un paquete independiente e importan los paquetes requeridos.

El siguiente paso es definir los parámetros para nuestro servidor. Podemos definirlos como variables globales como:

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

El siguiente paso es escuchar las conexiones entrantes. Podemos hacer esto usando la red.Método de escucha. La sintaxis de la función es como se muestra:

FUNC Listen (red, cadena de direcciones) (oyente, error)

Toma el tipo de conexión (como TCP, TCP4, TCP6, UNIX o UnixPacket), el host y el puerto de conexión. La función devolverá una conexión de escucha en la dirección especificada.

Un código de ejemplo es como se muestra:

Escucha, err: = net.Escuchar (escriba, host+":"+puerto)
Si err != nulo
registro.Fatal (err)
sistema operativo.Salir (1)

Verificamos si el oyente encuentra algún error, si es cierto, registra el mensaje de error y existe con un código de estado de 1.

También necesitamos cerrar el oyente después de que termine el servidor. Podemos hacer esto utilizando la palabra clave de diferir y el método de cierre

escuchar.Cerca()

El siguiente paso es escuchar continuamente las conexiones. Podemos hacer esto usando un bucle para:

para
Conn, err: = escuchar.Aceptar()
Si err != nulo
registro.Fatal (err)
sistema operativo.Salir (1)
// manejar conexiones entrantes

Para manejar cualquier solicitud entrante, podemos crear una función como:

FUNC HandleInComingRequest (Conn Net.Conn)
// almacenar datos entrantes
buffer: = make ([] byte, 1024)
_, err: = Conn.Leer (búfer)
Si err != nulo
registro.Fatal (err)

// responder
Tiempo: = Tiempo.Ahora().Formato ("Lunes, 02-Jan-06 15:04:05 MST")
conn.Escribir ([] byte ("hola back!"))
conn.Escribir ([] byte (tiempo))
// Cerrar conn
conn.Cerca()

En el ejemplo anterior, definimos una función que toma conn de type net.Conn struct como parámetro.

Luego definimos un nuevo búfer para almacenar los datos entrantes del tamaño 1024. El siguiente bloque lee la hora actual usando la hora.Ahora () paquete.

Usando el método de escritura, podemos escribir la hora y una cadena al cliente. Finalmente, configuramos la Conn.Cerrar () para cerrar la conexión.

El código fuente completo es como se muestra:

paquete principal
importar (
"registro"
"neto"
"OS"
"tiempo"
)
const (
Host = "localhost"
Puerto = "9001"
Type = "tcp"
)
func Main ()
Escucha, err: = net.Escuchar (escriba, host+":"+puerto)
Si err != nulo
registro.Fatal (err)
sistema operativo.Salir (1)

// Cerrar oyente
diferir escuchar.Cerca()
para
Conn, err: = escuchar.Aceptar()
Si err != nulo
registro.Fatal (err)
sistema operativo.Salir (1)

Ve a HandleIncomingRequest (Conn)


FUNC HandleInComingRequest (Conn Net.Conn)
// almacenar datos entrantes
buffer: = make ([] byte, 1024)
_, err: = Conn.Leer (búfer)
Si err != nulo
registro.Fatal (err)

// responder
Tiempo: = Tiempo.Ahora().Formato ("Lunes, 02-Jan-06 15:04:05 MST")
conn.Escribir ([] byte ("hola back!\norte"))
conn.Escribir ([] byte (tiempo))
// Cerrar conn
conn.Cerca()

Compilar y ejecutar servidor

Una vez completado, guarde el archivo y ejecute el comando a continuación para compilar el oyente en un binario:

Ir a construir servidor.ir

A continuación, ejecute el servidor como:

./servidor.exe

El comando anterior debe ejecutar el servidor TCP y podemos hacer conexiones a él.

Prueba del servidor TCP

Para probar el servidor TCP, puede usar NetCAT usando el comando:

NC Localhost 9001

A continuación, envíe un mensaje como:

Hola!

El servidor debe responder con una retroceder y la fecha y la hora actuales.

Hola de nuevo!
Martes 22-22-22 18:03:56 EAT

Conclusión

Y con eso, hemos concluido nuestro tutorial. Esta guía le presenta los conceptos básicos de trabajar con el paquete neto creando un servidor TCP.

Gracias por leer!