可序列化对象中的 ArrayList 未携带 writeUnshared/readUnshared（通过网络）

Question

我正在开发一个围绕我自己的客户端-服务器架构构建的 Java 多人游戏。简而言之，客户端每秒请求服务器 World 对象的副本 30 次，并在收到它后，将其客户端副本设置为响应。这一切都是使用 Java 的标准网络 API 完成的。

我遇到的问题是我还在世界中存储了一个 Player 对象的 ArrayList，当我将一个 Player 添加到此列表中时，客户端没有得到更新。它仍然从服务器接收世界的副本，但它不是最新的。

我在过去的项目中遇到过类似的问题，它是由 write/readObject 引起的，通过使用 write/readUnshared 修复了它，但即使这样也不起作用。

以下是通信服务器端的重要内容：

String message;
int sum = 0;
while(active)
{
    message = "";
    try {
        message = in.readUTF();
    } catch (IOException e) {
        active = false;
        System.out.println("Lost connection with client " + socket.getInetAddress());
    }

    if(message.equals("GETWORLD"))
    {
        try {
            sum++;
            if(sum == 100)
                main.world.addPlayer(999, 2, 2);
            System.out.println("Client requested world (#" + sum + ")");
            System.out.println(main.world.players.size());
            out.writeUnshared(main.world);
            out.flush();
            System.out.println("Sent client world (#" + sum + ")");
        } catch (IOException e) {
            active = false;
            System.out.println("Lost connection with client " + socket.getInetAddress());
        }
    }

    if(message.equals("DISCONNECT"))
    {
        active = false;
        System.out.println("Client " + socket.getInetAddress() + " requested disconnect");
    }
}

然后是客户端：

Object read = null;
int sum = 0;
while(active)
{
    try {
        Thread.sleep((long)(1000 / 30.0));

        if(connected)
        {
            sum++;
            System.out.println("Asking server for world (#" + sum + ")");
            out.writeUTF("GETWORLD");
            out.flush();

            read = in.readUnshared();
            if(read instanceof World)
            {
                World temp = (World)read;
                System.out.println(temp.players.size());
                frame.panel.updateWorld((World)read);
                System.out.println("Got world from server (#" + sum + ")");
            }
        }
    } catch (InterruptedException | ClassNotFoundException e1) {
        active = false;
        e1.printStackTrace();
    } catch (IOException e2) {
        active = false;
        System.out.println("Lost connection with server @ " + socket.getInetAddress());
        frame.dispose();
        System.exit(0);
    }
}

显然 sum 变量是用于调试的。 我用一些输出进一步测试了这个，这就是让我害怕的地方：

Client log:
...
Asking server for world (#99)
1
Got world from server (#99)
Asking server for world (#100)
1
Got world from server (#100)
Asking server for world (#101)
1
Got world from server (#101)
...

Server log:
...
Client requested world (#99)
1
Sent client world (#99)
Client requested world (#100)
2
Sent client world (#100)
Client requested world (#101)
2
Sent client world (#101)
...

您可以在此处看到，即使请求编号匹配，World 对象中 Player 对象的数量也存在明显差异。

对于那些好奇的人来说，这是 World 和 Player 类的重要内容：

public class World implements Serializable
{

    public ArrayList<Room> rooms;
    public ArrayList<Player> players;

    private QuickMaths qm;

...

public class Player implements Serializable
{

    private double xPos;
    private double yPos;
    private Color color;

    int id;
    ...

如果这是一个漫长而简单的问题，我深表歉意。我不确定这是参考问题还是其他网络怪癖，但这真的让我发疯。提前致谢。

Answer 1

您的问题在于 writeUnshared，这有点误导。 阅读here：

"请注意，上述规则仅适用于基础级别 用 writeUnshared 写入的对象，而不是任何可传递的 要序列化的对象图中的引用子对象。 "

这意味着播放器对象不会被写入两次，但会使用序列化树中对该对象的旧引用。

对此的解决方案是在每次写入调用后调用reset 方法，以确保不会再次引用旧写入的对象。

所以：

out.writeUnshared(main.world);
out.flush();
out.reset();