Golang TCP 客户端不向 Java TCP 服务器发送“End of Stream”

从现在开始，努力学习吧！本文《Golang TCP 客户端不向 Java TCP 服务器发送“End of Stream”》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

我正在编写一个简单的 golang tcp 客户端，它与 java tcp 服务器通信。

我已成功让 golang 客户端向我的 java 服务器发送消息。

但是，我的 java 代码期望 stream 的 end （其中 inputstream.read() 返回 -1）来知道是时候停止读取客户端消息了。

看起来 golang 不会通过 connection.write() 发送 end of stream 消息，除非我先 clos​​e() 连接。

下面是我的 java 服务器代码：

package com.mycompany.app;

import com.google.gson.*;
import com.google.common.primitives.bytes;
import java.io.*;
import java.net.socket;
import java.util.arraylist;
import java.util.list;
import java.net.serversocket;
import java.net.socketexception;

public class myapp {
    public static void main(string[] args) {
        int port = 9000;

        // start listening for messages.
        try (serversocket serversocket = new serversocket(port)) {
            system.out.println("listening on port " + port + "...");

            // never stop listening for messages.
            while (true) {
                try {
                    // accept a client connection.
                    socket socket = serversocket.accept();

                    // read message from the client.
                    datainputstream inputstream = new datainputstream(socket.getinputstream());

                    list list = new arraylist();
                    int input = inputstream.read();

                    while (input != -1) {
                        list.add((byte) input);
                        input = inputstream.read();
                    }

                    byte[] jsonbytes = bytes.toarray(list);

                    if (jsonbytes.length > 0) {
                        string jsonstring = new string(jsonbytes);

                        system.out.println("received: " + jsonstring);

                        // unmarshal from json.
                        person person = new gson().fromjson(jsonstring, person.class);

                        system.out.println("person: " + person.name + " " + person.age);
                    }
                } catch (eofexception e) {
                    // a client has disconnected. do nothing.
                } catch (socketexception e) {
                    // a client connection has been terminated unexpectedly. do nothing.
                } catch (exception e) {
                    e.printstacktrace();
                }
            }
        } catch (exception e) {
            e.printstacktrace();
        }
    }
}

class person {
    string name;
    int age;
}

下面是我的 golang 客户端代码：

package main

import (
    "bufio"
    "encoding/json"
    "fmt"
    "net"
    "os"
    "strings"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    reader := bufio.NewReader(os.Stdin)

    for {
        func() {
            // Dial the Java Server.
            conn, err := net.Dial("tcp", "localhost:9000")
            if err != nil {
                fmt.Println(err)
            }

            defer conn.Close()

            fmt.Print("Enter Name: ")
            strName, err := reader.ReadString('\n')
            strName = strings.TrimSpace(strName)

            var person Person
            person.Name = strName
            person.Age = 18

            jsonBytes, err := json.Marshal(person)
            if err != nil {
                fmt.Println(err)
                return
            }

            // Write our message to the connection.
            _, err = conn.Write(jsonBytes)
            if err != nil {
                fmt.Println(err)
                return
            }

            fmt.Println("Sent: " + string(jsonBytes))
        }()
    }
}

关于如何告诉 java 我们已经完成了从 golang 编写消息的任何建议？或者是否有更好的方法来处理 java x golang tcp 客户端-服务器连接？

这是一个很大的问题，因为 tcp 连接的基本场景之一是发送和接收：

例如

1. 客户端发送消息并等待结果。

2. 服务器处理消息并返回结果。

3. 客户端对结果执行某些操作。

解决方案

我终于按照 @nos 的建议调用 clos​​ewrite() 而不是 clos​​e() 来工作。

不得不稍微更改一下我的 tcp 连接代码，但它的效果非常好。

此解决方案非常适合我的目的，因为我只计划从客户端连接执行 1 次发送，并可能在关闭之前执行 1 次读取。

非常感谢所有提供帮助的人！

下面是我更新的 golang 客户端代码：

package main

import (
    "bufio"
    "encoding/json"
    "fmt"
    "net"
    "os"
    "strings"
)

// Person struct.
type Person struct {
    Name string
    Age  int
}

func main() {
    reader := bufio.NewReader(os.Stdin)

    for {
        func() {
            // Dial the Java Server.
            tcpAddr, err := net.ResolveTCPAddr("tcp", "localhost:9000")
            if err != nil {
                fmt.Println(err)
                return
            }

            conn, err := net.DialTCP("tcp", nil, tcpAddr)
            if err != nil {
                fmt.Println(err)
                return
            }

            defer conn.Close()

            fmt.Print("Enter Name: ")
            strName, err := reader.ReadString('\n')
            strName = strings.TrimSpace(strName)

            var person Person
            person.Name = strName
            person.Age = 18

            jsonBytes, err := json.Marshal(person)
            if err != nil {
                fmt.Println(err)
                return
            }

            // Write our message to the connection.
            _, err = conn.Write(jsonBytes)
            if err != nil {
                fmt.Println(err)
                return
            }

            // Tell the server that we're done writing.
            err = conn.CloseWrite()
            if err != nil {
                fmt.Println(err)
                return
            }

            // Read Message From Server code goes here.

            fmt.Println("Sent: " + string(jsonBytes))
        }()
    }
}

对于初学者，您可能希望确保客户端代码可靠地关闭套接字。但这并不是您应该做的全部。

客户端进程应因关闭套接字而触发 tcp fin。由于客户端进程完全退出，套接字应该关闭。不知道为什么你的情况并非如此。你等得够久吗？

但是，为了使您的服务器不会无限期挂起，您需要警惕这种情况。考虑客户端和服务器之间存在活动 tcp 连接的情况。当服务器等待来自客户端的数据时，客户端所在的地方断电了。由于客户端无法发送 fin，因此服务器连接不会有任何流量。该 tcp 连接将永远保持挂起状态，除非......

您可以在服务器端设置保持活动选项或超时选项。

保持活动：https://docs.oracle.com/javase/7/docs/api/java/net/SocketOptions.html#SO_KEEPALIVE

超时：https://docs.oracle.com/javase/7/docs/api/java/net/SocketOptions.html#SO_TIMEOUT

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~