Question

我正在创建简单的点对点游戏。目前我正在服务器/客户端（节点）方面。我发现了一个奇怪的问题，我可以从套接字创建ObjectOutputStream，但在创建ObjectInputStream时程序停止。要存储套接字并创建流我正在使用我自己的类（下面的代码）。我做错了什么？

public void run() {
    try {
        while (this.listen) {

            temp = serverSocket.accept();
            sockList.addSocket(temp);
            sockList.addObjOutStrm(temp);
            sockList.addObjInStrm(temp); // <------------------------ program stops


            setChanged();
            notifyObservers(temp);

            System.out.println("SERVER: Dodalem uzytkownika, oto pelna lista:\n\n"
                            + sockList + "\n");

            synchronized (sockList) {
                for (ObjectOutputStream oos : sockList.getOOSList()) {
                    oos.writeObject(sockList.extractToString());
                }
            }
        }
    } catch (IOException e) {
        System.err.println("SERVER: Błąd I/O serwera podczas nasluchu");
        //e.printStackTrace();
    }
}

我自己的类来存储套接字和流：

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SocketList {
    private List<ObjectOutputStream> obOutStrList;
    private List<ObjectInputStream> obInStrList;
    private List<Socket> sockList;

    private int maxUsers;
    private int currentUsers;

    public SocketList() {
        obOutStrList = Collections
                .synchronizedList(new ArrayList<ObjectOutputStream>());
        obInStrList = Collections
                .synchronizedList(new ArrayList<ObjectInputStream>());
        sockList = Collections.synchronizedList(new ArrayList<Socket>());

        maxUsers = 4;
        currentUsers = 0;
    }

    synchronized public void addSocket(Socket sock) {
        if (sockList.size() < 4) {
            sockList.add(sock);
            currentUsers++;
        } else {
            System.out.println("sockList: Blad max uzytkownikow");
        }
    }

    synchronized public void addObjOutStrm(Socket sock) {
        try {
            obOutStrList.add(new ObjectOutputStream(sock.getOutputStream()));
        } catch (IOException e) {
            System.out.println("Problem z uzyskaniem strumienia wyjsciowego dla " + sock.getInetAddress().getHostAddress().toString());
            e.printStackTrace();
        }
    }

    synchronized public void addObjInStrm(Socket sock) {
        try {
            obInStrList.add(new ObjectInputStream(sock.getInputStream()));
        } catch (IOException e) {
            System.out.println("Problem z uzyskaniem strumienia wejsciowego dla " + sock.getInetAddress().getHostAddress().toString());
            e.printStackTrace();
        }
    }

    synchronized public void removeSock(Socket s) {
        if (sockList.contains(s)) {
            System.out.println("SOCKETLIST: Usuwam " + s.toString());
            sockList.remove((Socket) s);
        }
    }

    synchronized public List<Socket> getSockList() {
        return sockList;
    }

    synchronized public List<ObjectOutputStream> getOOSList() {
        return obOutStrList;
    }

    synchronized public List<ObjectInputStream> getOISList() {
        return obInStrList;
    }

    public String toString() {
        return sockList.toString();
    }

    public String[] extractToString() {
        String[] retArr = new String[currentUsers];

        for (int i = 0; i < sockList.size(); i++)
            retArr[i] = sockList.get(i).getInetAddress().getHostAddress()
                    .toString();

        return retArr;
    }

}

Answer 1

你确定，你想这样做吗？读取写入对象不是非常便携，使用某种协议与XML或JSON等数据结构进行通信。这更便于携带。
对你的问题：

new ObjectInputStream(sock.getInputStream())

将阻塞并等待标头写入流，如JavaDoc所示：

此构造函数将阻塞，直到相应的ObjectOutputStream已写入并刷新标头。

总的来说，我强烈建议您使用不同的体系结构，使用多线程来处理服务器上的客户端连接，可能使用线程池甚至可能使用消息队列。请参阅包java.util.concurrent，了解您所需的一切。

点击此处，开始：http://tutorials.jenkov.com/java-multithreaded-servers/multithreaded-server.html

Java：ObjectInputStream + Socket

1 个答案: