Question

我正在尝试使用Genson库在服务器和客户端之间执行通信。我检测到以下问题：尝试向服务器发送消息时，服务器上的genson尝试读取消息时，我的应用程序停顿了。

同时，如果我关闭客户端，则可以完美读取和处理该消息。我以为这是僵局，但不确定。

原生Java序列化没有这样的问题。

这是我的服务器：

import com.owlike.genson.Genson;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;

public class Server {
    public static void main(String[] args) throws IOException {
        Genson genson = new Genson();

        try (ServerSocket server = new ServerSocket(9991)) {
            try (Socket socket = server.accept()) {
                int[] loc = genson.deserialize(socket.getInputStream(), int[].class);
                System.out.println("Server: " + Arrays.toString(loc));
                genson.serialize(loc, socket.getOutputStream());
            }
        }
    }
}

这里是客户：

import com.owlike.genson.Genson;

import java.io.IOException;
import java.net.Socket;
import java.util.Arrays;

public class Client {
    public static void main(String[] args) throws IOException {
        Genson genson = new Genson();

        try (Socket socket = new Socket("localhost", 9991)) {
            genson.serialize(new int[] {1, 2, 3}, socket.getOutputStream());
            int[] loc = genson.deserialize(socket.getInputStream(), int[].class);
            System.out.println("Client: " + Arrays.toString(loc));
        }
    }
}

我非常感谢您对这个问题的帮助。预先感谢。

编辑：这真的很奇怪。我做了一些其他测试，这是我得到的：

其他课程：

import com.owlike.genson.annotation.JsonProperty;

import java.io.Serializable;

public class Tester implements Serializable {
    public static final Tester TEST = new Tester(Math.E);

    private double val = Math.PI;

    public Tester(@JsonProperty("val") double val) {
        this.val = val;
    }

    public Tester() {}

    public String toString() {
        return "" + val;
    }
}

在客户请求中写了genson.serialize(Tester.TEST, socket.getOutputStream())后，我得到了同样奇怪的结果。但是写了genson.serialize(new Tester(Double.NaN), socket.getOutputStream())的结果就是扩展的结果。

此外，如果我将Tester类中的唯一字段定义为int[]类型，可以说，它仅适用于null或new int[0]的值。

除此之外，如果我尝试对范围为0..9的整数进行序列化和传输int，则会观察到以下行为：相同的怪异之处在于，当我关闭客户端时，服务器始终显示0的值。

此外，对于诸如Double.NaN，Double.POSITIVE_INFINITY，Integer.MAX_VALUE之类的常量，也没有什么奇怪的（一切都能按预期工作）。

对于那些附加测试Genson类的定义如下：

Genson genson = new GensonBuilder()
        .useMethods(false)
        .setFieldFilter(VisibilityFilter.PRIVATE)
        .create();

请注意，当使用流向文件/从文件进行SER / DESER请求时，没有这样的问题：

import com.owlike.genson.Genson;
import com.owlike.genson.GensonBuilder;
import com.owlike.genson.reflect.VisibilityFilter;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class FileTest {
    private static final String FILENAME = "test.json";

    public static void main(String[] args) throws IOException {
        Genson genson = new GensonBuilder()
                .useMethods(false)
                .setFieldFilter(VisibilityFilter.PRIVATE)
                .useIndentation(true)
                .create();

        try (OutputStream stream = new FileOutputStream(FILENAME)) {
            genson.serialize(Tester.TEST, stream);
        }

        try (InputStream stream = new FileInputStream(FILENAME)) {
            System.out.println(genson.deserialize(stream, Tester.class));
        }
    }
}

Answer 1

看起来这一直都是我的错误。我忘记了套接字的流无法关闭（除非您也想关闭套接字）。因此，在这种情况下，Server会尝试从InputStream获取尽可能多的数据，但是它不会消耗所有流（因为它总是打开的，并且可以随时从客户端发送数据）。因此Server基本上冻结了等待数据，但是没有更多数据可以来了。结果，我们遇到了上述情况。

一种解决方案是指定某种协议来表示查询大小，以便Server知道应该消耗多少数据。有关更多详细信息，请参见this答案。

Answer 2

阅读API中的某些代码路径将尽力确保至少有N个可用字节或已达到EOF。如您所述，解析数字（不是常数）时总是发生这种情况。

一个选项可能是实现一个小的层，该层序列化为字节数组或字符串，获取消息长度并将其写入输出，然后是有效负载。在读取方面，您将首先读取长度，然后在while循环中从流中读取，直到达到该长度或EOF。

然后，您只需将其传递给Genson。将其在内存消息中反序列化。

从套接字流读取时，Genson的行为很奇怪

2 个答案: