No se pueden enviar datos de gob a través de TCP en la programación de Go

Question

Tengo una aplicación de servidor cliente, usando conexión TCP

Cliente:

type Q struct {
sum int64
}
type P struct {
M, N int64
}
func main() {
...
//read M and N
...
tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
...
var p P
p.M = M
p.N = N
err = enc.Encode(p)
}

Servidor:

type Q struct {
sum int64
}
type P struct {
M, N int64
}
func main() {
...
tcpAddr, err := net.ResolveTCPAddr("ip4", service)
listener, err := net.ListenTCP("tcp", tcpAddr)
...
var connB bytes.Buffer
dec := gob.NewDecoder(&connB)
var p P
err = dec.Decode(p)
fmt.Printf("{%d, %d}/n", p.M, p.N)
}

El resultado en el servicio es {0, 0} porque no sé cómo obtener una variable de net.Conn . net.Conn de net.Conn .

¿Hay alguna manera de enviar variables de gob a través de TCP?

Si es verdad, ¿cómo se puede hacer esto? ¿O hay alguna alternativa en el envío de números a través de TCP?

Cualquier ayuda o código de muestra sería realmente apreciado.

Answer 1

Aquí hay un ejemplo completo.

Servidor:

package main
import (
"fmt"
"net"
"encoding/gob"
)
type P struct {
M, N int64
}
func handleConnection(conn net.Conn) {
dec := gob.NewDecoder(conn)
p := &P{}
dec.Decode(p)
fmt.Printf("Received : %+v", p);
conn.Close()
}
func main() {
fmt.Println("start");
ln, err := net.Listen("tcp", ":8080")
if err != nil {
// handle error
}
for {
conn, err := ln.Accept() // this blocks until connection or error
if err != nil {
// handle error
continue
}
go handleConnection(conn) // a goroutine handles conn so that the loop can accept other connections
}
}

Cliente:

package main
import (
"fmt"
"log"
"net"
"encoding/gob"
)
type P struct {
M, N int64
}
func main() {
fmt.Println("start client");
conn, err := net.Dial("tcp", "localhost:8080")
if err != nil {
log.Fatal("Connection error", err)
}
encoder := gob.NewEncoder(conn)
p := &P{1, 2}
encoder.Encode(p)
conn.Close()
fmt.Println("done");
}

Inicie el servidor, luego el cliente, y verá que el servidor muestra el valor P recibido.

Unas pocas observaciones para dejarlo claro:

• Cuando escuchas en un zócalo, debes pasar el zócalo abierto a un goroutine que lo manejará.
• Conn implementa las interfaces de Reader y Writer , lo que facilita su uso: se lo puede dar a un Decoder o Encoder
• En una aplicación real, probablemente tendría la definición de estructura P en un paquete importado por ambos programas