Android Socket编程：建立连接、发送和接收信息（附工具类）

前言

在Android应用程序中，Socket编程是一种常见的方式，用于实现网络通信。本篇博客将介绍如何在Android平台上使用Socket建立连接、发送和接收信息，为实现即时通讯或其他网络功能提供基础。

1. 概述

Socket是一种提供网络通信能力的编程接口，通过它，应用程序可以在网络上进行数据传输。在Android中，我们可以使用Socket和ServerSocket类来创建客户端和服务器端，进行双向通信。

2. 创建Socket连接

在客户端和服务器端都需要使用Socket对象来建立连接。以下是Android客户端建立Socket连接的步骤：

// 在异步任务或后台线程中执行
try {
    String serverIpAddress = "192.168.1.1"; // 服务器IP地址
    int serverPort = 8080; // 服务器端口

    Socket socket = new Socket(serverIpAddress, serverPort);
    
    // 连接成功，可以进行后续操作
} catch (IOException e) {
    e.printStackTrace();
}

3. 发送信息

建立连接后，我们可以使用OutputStream将数据发送到服务器：

try {
    OutputStream outputStream = socket.getOutputStream();
    PrintWriter writer = new PrintWriter(new OutputStreamWriter(outputStream));

    // 发送消息
    writer.println("Hello, Server!");
    writer.flush();
} catch (IOException e) {
    e.printStackTrace();
}

4. 接收信息

使用InputStream可以从服务器接收数据：

try {
    InputStream inputStream = socket.getInputStream();
    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));

    // 读取服务器发送的消息
    String receivedMessage = reader.readLine();
    // 处理接收到的消息
} catch (IOException e) {
    e.printStackTrace();
}

5. 完整示例

以下是一个简单的示例 Socket 工具类，用于处理连接、发送和接收消息：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;

public class SocketUtils {

    private Socket socket = null;
    private  InputStream mInputStream = null;
    private BufferedReader reader = null;
    private PrintWriter writer = null;
    private OnMessageReceivedListener messageListener;

    public SocketUtils(String serverIpAddress, int serverPort) {
        try {
            socket = new Socket();
            SocketAddress socAddress = new InetSocketAddress(serverIpAddress, serverPort);
            socket.connect(socAddress, 800);
             // 启动心跳线程
            socket.setKeepAlive(true);
            mInputStream = socket.getInputStream();
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            writer = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()), true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void setOnMessageReceivedListener(OnMessageReceivedListener listener) {
        this.messageListener = listener;
    }

    public void startListening() {
        new Thread(new Runnable() {
            @Override
            public void run() {
            	char[] buffer = new char[1024];  // Adjust the buffer size as needed
            	byte[] arrayOfByte = new byte[1024];
       			StringBuilder stringBuilder = new StringBuilder();
                try {
                    while (!socket.isClosed()) {
                    	//方法一：读行
                        String receivedMessage = reader.readLine();
                        if (receivedMessage != null && messageListener != null) {
                            messageListener.onMessageReceived(receivedMessage);
                        }
                        //方法二：基于字符的读取或基于字节的读取
                        int bytesRead = reader.read(buffer, 0, buffer.length);
                        if (bytesRead != -1) {
                            stringBuilder.append(buffer, 0, bytesRead);
                        } else {
                            // End of stream or connection closed
                            if (stringBuilder.length() > 0 && messageListener != null) {
                                // Process the entire content at once
                                messageListener.onMessageReceived(stringBuilder.toString());
                            }

                            // Optionally, notify listener about connection loss
                            if (messageListener != null) {
                                messageListener.onConnectionLost();
                            }
                            break;
                        }
                        //方法三：基于字符的读取或基于字节的读取,如果bytesRead一直不返回-1，可以尝试替换以下方法
                        if (mInputStream.available() > 0) {
                            String str = new String(arrayOfByte, 0, mInputStream.read(arrayOfByte));
                            if (str.length() > 0 && messageListener != null) {
                                // Process the entire content at once
                                messageListener.onMessageReceived(str);
                            }
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    // 处理连接中断的情况
                    if (messageListener != null) {
                        messageListener.onConnectionLost();
                    }
                }
            }
        }).start();
    }

    public void sendMessage(String message) {
        if (socket != null && socket.isConnected()) {
            writer.println(message);
        }
    }

    public void closeConnection() {
        try {
            if (socket != null && !socket.isClosed()) {
                socket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public interface OnMessageReceivedListener {
        void onMessageReceived(String message);

        void onConnectionLost();
    }
}

import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    private SocketUtils socketUtils;
    private TextView messageTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        messageTextView = findViewById(R.id.messageTextView);

        // 初始化 SocketUtils，替换成你的服务器地址和端口
        socketUtils = new SocketUtils("your_server_ip", 8080);

        // 设置消息监听器
        socketUtils.setOnMessageReceivedListener(new SocketUtils.OnMessageReceivedListener() {
            @Override
            public void onMessageReceived(final String message) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        // 在UI线程更新消息
                        updateMessageUI(message);
                    }
                });
            }

            @Override
            public void onConnectionLost() {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        // 处理连接中断的情况，例如显示提示或重新连接
                        handleConnectionLost();
                    }
                });
            }
        });

        // 启动监听
        socketUtils.startListening();
    }

    @Override
    protected void onDestroy() {
        // 在 Activity 销毁时关闭连接
        socketUtils.closeConnection();
        super.onDestroy();
    }

    private void updateMessageUI(String message) {
        // 在这里更新UI，例如将消息显示在 TextView 中
        messageTextView.setText(message);
    }

    private void handleConnectionLost() {
        // 处理连接中断的情况，例如显示提示或重新连接
        messageTextView.setText("Connection Lost");
    }
}

6. 注意事项

Socket通信涉及到网络操作，因此建议在后台线程或异步任务中执行，以避免阻塞主线程。
在实际应用中，考虑使用线程池、Handler、或者其他异步处理方式，以更好地管理网络操作。

7. 结语

通过本文，我们学习了在Android应用中如何使用Socket建立连接、发送和接收信息。这是实现网络通信的基础，开发者可以根据具体需求扩展这些功能，构建出更为复杂和实用的网络应用。在进行Socket编程时，务必注意异常处理和线程管理，以确保应用程序的稳定性和性能。