Question

我正在尝试使用Android手机作为客户端创建客户端/服务器应用程序，使用AsyncTask从UI发送消息。

我已经编写了一些非常基本的实现来测试连接以及接收/发送消息的方式，我发现了一个非常大的问题。

从我的角度来看，客户端部分似乎工作得很好。但服务器部分是问题所在。我不能让服务器从客户端读取和显示消息。

我尝试了类似while(line = (in.readLine()) != null) {}的内容，但似乎无效。

在我从客户端发送第一个单词后，服务器读取空值并停止。

当客户端没有发送任何内容时，有人可以告诉我一个正确的方法来保持服务器运行吗？如果不是100％必要，我想避免使用while(true)。

这是迄今为止的实施：

服务器：

public class SocketServerThread extends Thread {
private static final Logger log = Logger.getLogger(SocketServerThread.class);
private static final int SERVER_PORT_NUMBER = 5000;

@Override
public void run() {
    try {

        ServerSocket serverSocket = new ServerSocket(SERVER_PORT_NUMBER);
        serverSocket.setReuseAddress(true);
        log.info("Waiting for connection...");

        Socket clientSocket = serverSocket.accept();
        log.info("Connected! Receiving message...");

        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        try {
            while (true) {
                String line = in.readLine();
                if (line != null) {
                    log.info(line);
                }
            }
        } catch (Exception e) {
            log.error("Unexpected exception while sending / receiving messages.");
            e.printStackTrace();
        } finally {
            in.close();
            clientSocket.close();
            serverSocket.close();
        }

    } catch (Exception e) {
        e.printStackTrace();
    }
}

客户端：

public class MyAsyncTask extends AsyncTask<String, Integer, String> {

private static final String TAG = "MyAsyncTask";
private static final String SERVER_IP_ADDRESS = "10.0.2.2";
private static final int SERVER_PORT_NUMBER = 5000;
private PrintWriter out;

@Override
protected String doInBackground(String... params) {
    String message = "";
    try {
        InetAddress address = InetAddress.getByName(SERVER_IP_ADDRESS);
        Log.d(TAG, "Connecting...");
        Socket socket = new Socket(address, SERVER_PORT_NUMBER);
        try {
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
            Log.d(TAG, "I/O created");
            message = params[0];
            if (!message.equals("stop")) {
                sendMessage(message);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            out.flush();
            out.close();
            socket.close();
        }

    } catch (Exception e) {
        e.printStackTrace();
    }
    return message;
}

private void sendMessage(String message) {
    if (out != null && !out.checkError()) {
        out.println(message);
        out.flush();
        Log.d(TAG, "Sent message: " + message);
    }
}

@Override
protected void onPostExecute(String s) {
    super.onPostExecute(s);
    Log.d(TAG, "onPostExecute(), s: " + s);
}

谢谢。

Answer 1

问题是你的BufferedReader只读取第一个输入流。为了在此之后接收文本，您必须重新读取输入流。我通过在读完时重新创建套接字来实现它，这样我就可以读取下一个即将发布的数据了。我在我的应用程序中使用以下代码。你可以用这个

private ServerSocket serverSocket;
public static final int SERVERPORT = 5000;
Thread serverThread = null;

public void startSocketServer(){

    this.serverThread = new Thread(new ServerThread());
    this.serverThread.start();
}

public void stopSocket(){

        if(serverSocket != null){
            try{
                serverSocket.close();
            }
            catch (IOException e){
                e.printStackTrace();
            }

        }
    }

class ServerThread implements Runnable {

    public void run() {
        Socket socket = null;
        try {
            Log.wtf(TAG,"Socket: New Socket");
            serverSocket = new ServerSocket(SERVERPORT);
            if(serverSocket == null){
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        startSocketServer();
                    }
                });
                return;
            }
            while (!Thread.currentThread().isInterrupted() && !serverSocket.isClosed()) {

                try {
                    socket = serverSocket.accept();
                    Log.wtf(TAG,"Socket: Accepting");
                    CommunicationThread commThread = new CommunicationThread(socket);
                    new Thread(commThread).start();

                } catch (IOException e) {
                    Log.wtf(TAG,"Socket: Error");
                    e.printStackTrace();
                }
                if(Thread.currentThread().isInterrupted()){
                    Log.wtf(TAG, "Thread Interrupted");
                }
                if(serverSocket.isClosed()){
                    Log.wtf(TAG, "serverSocket closed");
                }
            }

        } catch (IOException e) {
            e.printStackTrace();

        }

    }
}

class CommunicationThread implements Runnable {

    private Socket clientSocket;





    public CommunicationThread(Socket clientSocket) {

        this.clientSocket = clientSocket;
        log.info("Connected! Receiving message...");
        try {
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
    try {
        while (true) {
            String line = in.readLine();
            if (line != null) {
                log.info(line);
            }
            else 
              break;//This will exit the loop and refresh the socket for next data
        }
    } catch (Exception e) {
        log.error("Unexpected exception while sending / receiving messages.");
        e.printStackTrace();
    }
    finally {
        in.close();
        clientSocket.close();
    }
            refreshSocket();



        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    }

    public void refreshSocket(){
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                stopSocket();
                startSocketServer();
            }
        });

    }

只需调用 startSocketServer（）即可在代码中启动服务器套接字。

Android客户端/服务器应用程序 - 持续接收消息的正确方法

1 个答案: