真正简单的 TCP 客户端

Question

我想用我的应用程序输入我的服务器的 url，例如 http://192.168.1.8/ 和端口，例如 1234 。当我的服务器收到 TCP 请求消息时，它会发回一个文件（服务器已经实现）。

我认为我不需要像 AsyncTask 这样复杂的东西，因为我不想保持连接。从服务器接收到答案，我的连接必须关闭。

任何有关前进方向或提示的指示都将受到高度赞赏。

原文由 G.V. 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

这是一个简单的 TCP 客户端，它使用了我根据本教程中的代码开始工作的套接字（ 本教程 的代码也可以 在这个 GitHub 存储库中 找到）。

请注意，此代码适用于在客户端和服务器之间来回发送字符串，通常采用 JSON 格式。

下面是 TCP 客户端代码：

 import android.util.Log;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;

public class TcpClient {

    public static final String TAG = TcpClient.class.getSimpleName();
    public static final String SERVER_IP = "192.168.1.8"; //server IP address
    public static final int SERVER_PORT = 1234;
    // message to send to the server
    private String mServerMessage;
    // sends message received notifications
    private OnMessageReceived mMessageListener = null;
    // while this is true, the server will continue running
    private boolean mRun = false;
    // used to send messages
    private PrintWriter mBufferOut;
    // used to read messages from the server
    private BufferedReader mBufferIn;

    /**
     * Constructor of the class. OnMessagedReceived listens for the messages received from server
     */
    public TcpClient(OnMessageReceived listener) {
        mMessageListener = listener;
    }

    /**
     * Sends the message entered by client to the server
     *
     * @param message text entered by client
     */
    public void sendMessage(final String message) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                if (mBufferOut != null) {
                    Log.d(TAG, "Sending: " + message);
                    mBufferOut.println(message);
                    mBufferOut.flush();
                }
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }

    /**
     * Close the connection and release the members
     */
    public void stopClient() {

        mRun = false;

        if (mBufferOut != null) {
            mBufferOut.flush();
            mBufferOut.close();
        }

        mMessageListener = null;
        mBufferIn = null;
        mBufferOut = null;
        mServerMessage = null;
    }

    public void run() {

        mRun = true;

        try {
            //here you must put your computer's IP address.
            InetAddress serverAddr = InetAddress.getByName(SERVER_IP);

            Log.d("TCP Client", "C: Connecting...");

            //create a socket to make the connection with the server
            Socket socket = new Socket(serverAddr, SERVER_PORT);

            try {

                //sends the message to the server
                mBufferOut = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);

                //receives the message which the server sends back
                mBufferIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                //in this while the client listens for the messages sent by the server
                while (mRun) {

                    mServerMessage = mBufferIn.readLine();

                    if (mServerMessage != null && mMessageListener != null) {
                        //call the method messageReceived from MyActivity class
                        mMessageListener.messageReceived(mServerMessage);
                    }

                }

                Log.d("RESPONSE FROM SERVER", "S: Received Message: '" + mServerMessage + "'");

            } catch (Exception e) {
                Log.e("TCP", "S: Error", e);
            } finally {
                //the socket must be closed. It is not possible to reconnect to this socket
                // after it is closed, which means a new socket instance has to be created.
                socket.close();
            }

        } catch (Exception e) {
            Log.e("TCP", "C: Error", e);
        }

    }

    //Declare the interface. The method messageReceived(String message) will must be implemented in the Activity
    //class at on AsyncTask doInBackground
    public interface OnMessageReceived {
        public void messageReceived(String message);
    }

}

然后，在 Activity 中声明一个 TcpClient 作为成员变量：

 public class MainActivity extends Activity {

    TcpClient mTcpClient;

    //............

然后，使用 AsyncTask 连接到您的服务器并在 UI 线程上接收响应（请注意，从服务器接收到的消息在 AsyncTask 中的 onProgressUpdate() 方法覆盖中处理）：

 public class ConnectTask extends AsyncTask<String, String, TcpClient> {

    @Override
    protected TcpClient doInBackground(String... message) {

        //we create a TCPClient object
        mTcpClient = new TcpClient(new TcpClient.OnMessageReceived() {
            @Override
            //here the messageReceived method is implemented
            public void messageReceived(String message) {
                //this method calls the onProgressUpdate
                publishProgress(message);
            }
        });
        mTcpClient.run();

        return null;
    }

    @Override
    protected void onProgressUpdate(String... values) {
        super.onProgressUpdate(values);
        //response received from server
        Log.d("test", "response " + values[0]);
        //process server response here....

}

要开始连接到您的服务器，请执行 AsyncTask：

 new ConnectTask().execute("");

然后，向服务器发送消息：

 //sends the message to the server
if (mTcpClient != null) {
    mTcpClient.sendMessage("testing");
}

您可以随时关闭与服务器的连接：

 if (mTcpClient != null) {
    mTcpClient.stopClient();
}

原文由 Daniel Nugent 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 2

最终的部署环境是什么？您的代码指向本地 IP。当您将其部署到真实的服务器环境时，情况可能会发生变化？如果您在托管服务器中启动此代码，请注意 NAT 问题。然后您将无法获取数据包。考虑使用更复杂的协议（例如，Socket.io 可以提供帮助）

原文由 Rami Khawaly 发布，翻译遵循 CC BY-SA 4.0 许可协议