Question

我对整个“套接字”和网络世界都很陌生。

首先，我想制作一个像“omegle”这样的随机聊天程序，它完美无缺。我认为我在代码中遇到了一些严重的问题，但它有效 - 所以为什么要这么麻烦？（但愿我做了，可惜我没有）。

现在我在Android的“Tic Tac Toe”游戏中添加了一个“多人游戏”选项，它出错了，我花了很多时间想出如何解决这个问题，但没有任何效果，我的应用程序一直在崩溃。

这是简单聊天程序的代码。

服务器

public class server {
public static Map<Integer, MiniServer> clients;

public static void main(String args[]) throws IOException {
    clients = new HashMap<>();
    boolean listeningSocket = true;
    ServerSocket serverSocket = new ServerSocket(1234);
    while (listeningSocket) {
        Socket socket = serverSocket.accept();
        MiniServer mini = new MiniServer(socket);
        if (clients.isEmpty()) {
            clients.put(1, mini);
            mini.setId(1);
        } else {
            int i = 1;
            while (clients.containsKey(i))
                i++;
            clients.put(i, mini);
            mini.setId(i);
        }
        mini.start();
    }
    serverSocket.close();
}

客户

public class client {
private static String message;
private static boolean connected;
private static boolean connectedInternet;

public static void main(String args[]) throws UnknownHostException, IOException {
    Scanner textReader = new Scanner(System.in);
    Socket socket = new Socket("127.0.0.1", 1234);
    Scanner inputStreamReader = new Scanner(socket.getInputStream());
    connectedInternet = true;
    System.out.println("Hello Stranger, get ready to chat.");
    PrintStream printStream = new PrintStream(socket.getOutputStream());
    Thread getMessage = new Thread() {
        public void run() {
            while (true) {
                message = textReader.nextLine();
                if (!connected)
                    System.out.println("You are not connected to another Stranger yet, please wait.");
                else
                    printStream.println(message);
            }
        }
    };
    getMessage.start();
    while (connectedInternet) {
        String temp = inputStreamReader.nextLine();
        if (temp.equals("connected")) {
            connected = true;
            System.out.println("Found a Stranger, say hey !");
        } else if (connected) {
            if (temp.equals("!close")) {
                System.out.println("Stranger disconnected.");
                printStream.println("!new");
            } else
                System.out.println("Stranger: " + temp);
        }

    }
    textReader.close();
    socket.close();
    inputStreamReader.close();
}

MiniServer

public class MiniServer extends Thread {
private Socket socket = null;
public int id;
private boolean foundPlayer;
private int colleague;
private boolean connected;

public MiniServer(Socket socket) {
    super("MiniServer");
    this.socket = socket;
}

public void run() {
    Scanner inputStreamReader = null;
    String message;
    try {
        inputStreamReader = new Scanner(socket.getInputStream());
    } catch (IOException e) {
        e.printStackTrace();
    }
    PrintStream p = null;
    try {
        p = new PrintStream(socket.getOutputStream());
    } catch (IOException e) {
        e.printStackTrace();
    }
    List<Integer> keys = new ArrayList<Integer>(server.clients.keySet());
    while (!foundPlayer) {
        for (Integer key : keys) {
            if (!server.clients.get(key).foundPlayer && key != id) {
                server.clients.get(key).foundPlayer = true;
                foundPlayer = true;
                server.clients.get(key).colleague = id;
                colleague = server.clients.get(key).id;
            }
        }
        try {
            keys = new ArrayList<Integer>(server.clients.keySet());
        } catch (ConcurrentModificationException e) {

        }
    }
    p.println("connected");
    connected = true;
    while (connected) {
        try {
            message = inputStreamReader.nextLine();
            if (message.equals("!new")) {
                foundPlayer = false;
                keys = new ArrayList<Integer>(server.clients.keySet());
                while (!foundPlayer) {
                    for (Integer key : keys) {
                        if (!server.clients.get(key).foundPlayer && key != id) {
                            server.clients.get(key).foundPlayer = true;
                            foundPlayer = true;
                            server.clients.get(key).colleague = id;
                            colleague = server.clients.get(key).id;
                        }
                    }
                    try {
                        keys = new ArrayList<Integer>(server.clients.keySet());
                    } catch (ConcurrentModificationException e) {

                    }
                }
                p.println("connected");
            } else
                sendToClient(message);
        } catch (NoSuchElementException e) {
            server.clients.remove(id);
            sendToClient("!close");
            closeSocket();
            connected = false;
        }
    }
}

public void setId(int i) {
    id = i;
}

public void sendToClient(String message) {
    Socket colleagueSocket = server.clients.get(colleague).socket;
    PrintStream rr = null;
    try {
        rr = new PrintStream(colleagueSocket.getOutputStream());
    } catch (IOException e) {
        e.printStackTrace();
    }
    rr.println(message);
}

public void closeSocket() {
    try {
        socket.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

这个程序效果很好，但我很确定它有很多问题现在这是我的Android应用程序的服务器端代码 服务器

public class Server {
public static Map<Integer, MiniServer> clients;

public static void main(String args[]) throws IOException {
    clients = new HashMap<>();
    boolean listeningSocket = true;
    ServerSocket serverSocket = new ServerSocket(1234);
    while (listeningSocket) {
        Socket socket = serverSocket.accept();
        MiniServer mini = new MiniServer(socket);
        if (clients.isEmpty()) {
            clients.put(1, mini);
            mini.setId(1);
        } else {
            int i = 1;
            while (clients.containsKey(i))
                i++;
            clients.put(i, mini);
            mini.setId(i);
        }
        mini.start();
    }
    serverSocket.close();
}

迷你服务器

public class MiniServer extends Thread {
private Socket socket;
private Socket colleagueSocket;
public int id;
private boolean foundPlayer;
private int colleague;
private boolean connected;
private String crossOrCircle;
private boolean thisGoes;
private Thread timeOut;
private PrintStream p;
private Timer timer;

public MiniServer(Socket socket) {
    super("MiniServer");
    this.socket = socket;
}

public void run() {
    Scanner inputStreamReader = null;
    String message;
    try {
        inputStreamReader = new Scanner(socket.getInputStream());
    } catch (IOException e) {
        e.printStackTrace();
    }
    try {
        p = new PrintStream(socket.getOutputStream());
    } catch (IOException e) {
        e.printStackTrace();
    }
    List<Integer> keys = new ArrayList<Integer>(Server.clients.keySet());
    while (!foundPlayer) {
        for (Integer key : keys) {
            if (!Server.clients.get(key).foundPlayer && key != id) {
                Server.clients.get(key).foundPlayer = true;
                foundPlayer = true;
                Server.clients.get(key).colleague = id;
                colleague = Server.clients.get(key).id;
                crossOrCircle = "X";
                Server.clients.get(key).crossOrCircle = "O";
                thisGoes = true;
                Server.clients.get(key).thisGoes = false;
                colleagueSocket=Server.clients.get(key).colleagueSocket;
                Server.clients.get(key).colleagueSocket=socket;
            }
        }
        try {
            keys = new ArrayList<Integer>(Server.clients.keySet());
        } catch (ConcurrentModificationException e) {

        }
    }
    p.println("connected");
    connected = true;
    p.println(crossOrCircle);
    while (connected) {
        try {
            message = inputStreamReader.nextLine();
            if (Character.toString(message.charAt(0)).equals(crossOrCircle) && thisGoes) {
                p.println(message);
                sendToClient(message);
                thisGoes = false;
                Server.clients.get(colleague).thisGoes = true;
            } else if (message.equals("!close")) {
                sendToClient("!closeClient");
                p.println("!closeClient");
                Server.clients.get(colleague).connected = false;
                connected = false;
                Server.clients.get(colleague).closeSocket();
                closeSocket();
                Server.clients.remove(colleague);
                Server.clients.remove(id);
            } else if (message.equals("!pause")) {
                timeOut = new Thread() {
                    @Override
                    public void run() {
                        timer = new Timer();
                        timer.schedule(
                                new TimerTask() {
                                    @Override
                                    public void run() {
                                        sendToClient("!closeClient");
                                        p.println("!closeClient");
                                        Server.clients.get(colleague).connected = false;
                                        connected = false;
                                        Server.clients.get(colleague).closeSocket();
                                        closeSocket();
                                        Server.clients.remove(colleague);
                                        Server.clients.remove(id);
                                    }
                                },
                                5000
                        );
                    }
                };
                timeOut.start();
            } else if (message.equals("!resume")) {
                timer.cancel();
            }
        } catch (NoSuchElementException e) {
            sendToClient("!closeClient");
            p.println("!closeClient");
            Server.clients.get(colleague).connected = false;
            connected = false;
            Server.clients.get(colleague).closeSocket();
            closeSocket();
            Server.clients.remove(colleague);
            Server.clients.remove(id);
        }
    }
}

public void setId(int i) {
    id = i;
}

public void sendToClient(String message) {
        PrintStream rr = null;
        try {
            rr = new PrintStream(colleagueSocket.getOutputStream());
        } catch (IOException | NullPointerException e) {
            e.printStackTrace();
        }
        rr.println(message);
    }
public void closeSocket() {
    try {
        socket.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
public Socket getSocket(){
    return this.socket;
}

sendClient（）方法存在问题，它不断抛出NullPointerException 我能做什么？我不是要你解决我的问题你能给我一些建议吗？非常感谢你:) 编辑：
我忘了提一些事情 - 我正在我的计算机上运行服务器，而且我正在使用两个连接到局域网的不同设备。

java.lang.NullPointerException
    at com.ilya.rabinovich.tictactoe.MiniServer.sendToClient(MiniServer.java:134)
    at com.ilya.rabinovich.tictactoe.MiniServer.run(MiniServer.java:75)
Exception in thread "MiniServer" java.lang.NullPointerException
    at com.ilya.rabinovich.tictactoe.MiniServer.sendToClient(MiniServer.java:138)
    at com.ilya.rabinovich.tictactoe.MiniServer.run(MiniServer.java:75)

编辑2：
我通过更改此行来修复此异常

                    colleagueSocket=Server.clients.get(key).colleagueSocket;

到

                    colleagueSocket=Server.clients.get(key).socket;

当在Android模拟器（android studio）上运行这个应用程序时，它工作得很好，但是当我尝试在外部设备（Lg g3和nexus 7）上运行这个应用程序时，它的工作非常奇怪并且大部分时间都会崩溃。 /> 编辑3：
好的，我解决了问题=）
问题出在客户端（runOnUiThread）无论如何，你认为有办法改进我的服务器代码吗？谢谢！

Answer 1

我不知道你是否已经这样做了，但你需要在config.xml文件中将服务器ip列入白名单。这可能是一个原因。

为一个简单的聊天做了一个代码，它工作，在Android工作室做类似的事情，它没有用，有什么不对？

1 个答案: