Android(Java/Kotlin)环境下如何使用单个Socket发送多条消息

核心思路：将Socket连接、输入输出流的生命周期从单次请求中抽离，封装为独立的管理类，仅在首次使用时建立连接，所有请求复用同一个连接，待所有操作完成后再销毁资源，即可解决频繁新建销毁Socket导致的性能问题。

原有代码存在的问题 #

• 变量拼写错误：socktst 应为 socket
• 不必要的非空断言!!，直接初始化的Socket本身为非空，无需额外断言
• 缺少flush调用，消息写入缓冲区后未强制发送，可能偶发消息无法送达的问题
• 未约定消息边界，使用readLine()读取响应的前提是服务端返回的每条响应末尾必须携带换行符\n，否则会出现永久阻塞

1. 封装长连接管理类 #

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import java.io.BufferedReader
import java.io.DataOutputStream
import java.io.InputStreamReader
import java.net.Socket

class SocketLongConnectionManager(
    private val address: String,
    private val port: Int
) {
    // 互斥锁保证多协程调用时的线程安全，避免流写入乱序
    private val mutex = Mutex()
    private var socket: Socket? = null
    private var inputReader: BufferedReader? = null
    private var outputStream: DataOutputStream? = null

    /**
     * 初始化连接，首次使用前调用一次即可
     */
    suspend fun connect() = withContext(Dispatchers.IO) {
        if (socket?.isConnected == true && !socket!!.isClosed) return@withContext
        closeInternal()
        socket = Socket(address, port)
        inputReader = BufferedReader(InputStreamReader(socket!!.getInputStream()))
        outputStream = DataOutputStream(socket!!.getOutputStream())
    }

    /**
     * 发送消息并获取服务端响应
     */
    suspend fun sendMessage(message: String): String? = withContext(Dispatchers.IO) {
        check(socket?.isConnected == true && !socket!!.isClosed) { "Socket未连接，请先调用connect()方法初始化" }
        mutex.withLock {
            return@withContext try {
                // 消息末尾加换行符适配readLine的读取规则，和服务端协议保持一致即可
                outputStream!!.write((message + "\n").toByteArray())
                outputStream!!.flush()
                inputReader!!.readLine()
            } catch (e: Exception) {
                e.printStackTrace()
                // 可在此处添加异常自动重连逻辑
                null
            }
        }
    }

    /**
     * 所有操作完成后调用，销毁连接释放资源
     */
    suspend fun close() = withContext(Dispatchers.IO) {
        mutex.withLock {
            closeInternal()
        }
    }

    private fun closeInternal() {
        runCatching { inputReader?.close() }
        runCatching { outputStream?.close() }
        runCatching { socket?.close() }
        inputReader = null
        outputStream = null
        socket = null
    }
}

2. 使用示例 #

以下为每秒发送一次消息的场景使用示例：

// 全局复用同一个管理类实例即可
val socketManager = SocketLongConnectionManager("服务端地址", 服务端端口)

lifecycleScope.launch {
    // 初始化连接
    socketManager.connect()
    // 循环发送消息，可根据需求调整循环次数或添加退出条件
    while (true) {
        val response = socketManager.sendMessage("待发送的消息内容")
        // 拿到响应后可直接更新UI
        delay(1000)
    }
    // 不需要使用连接时调用关闭，例如页面销毁、应用退出时
    socketManager.close()
}

3. 注意事项 #

• 消息边界约定：如果服务端返回的响应未携带换行符，需要修改读取逻辑，例如按固定长度读取、按特殊分隔符读取等，避免读取阻塞
• 自动重连：实际使用时可在捕获到网络异常时自动调用connect()方法重建连接，避免连接断开后无法发送消息
• 心跳机制：长时间闲置的连接可能会被服务端主动断开，可每隔30~60秒发送一次心跳包维持连接活性
• 权限配置：Android平台使用时需要在Manifest中添加网络权限，且所有网络操作默认已切换到IO线程执行，不会阻塞主线程

内容的提问来源于stack exchange，提问作者Adel Karshenas