spring-boot TCP 服务器：在回答“多行”请求之前等待“空行”

Question

我想为带有 spring-boot 的后缀编写自定义check_policy_service ( http://www.postfix.org/SMTPD_POLICY_README.html )。

简短：后缀发送多行，如：

foo=bar
me=you
year=123
[empty line]

空行表示请求已完成，现在 spring-boot 应用程序应该处理数据并返回类似action=ok的内容

问题：在我当前的设置中，应用程序尝试立即处理第 1 行foo=bar并且不会等到[empty line]被发送。 如何让应用程序等待空行？

当前设置：spring-boot 2.6.3

@Configuration
class TcpServerConfig {
//    @Value("\${tcp.server.port}")
    private val port = 6676
    @Bean
    fun serverConnectionFactory(): AbstractServerConnectionFactory {
        val serverConnectionFactory = TcpNioServerConnectionFactory(port)
        serverConnectionFactory.setUsingDirectBuffers(true)
        serverConnectionFactory.isSingleUse = false // reuse socket
        return serverConnectionFactory
    }
    @Bean
    fun inboundChannel(): MessageChannel {
        return DirectChannel()
    }

    @Bean
    fun inboundGateway(
        serverConnectionFactory: AbstractServerConnectionFactory,
        inboundChannel: MessageChannel
    ): TcpInboundGateway {
        val tcpInboundGateway = TcpInboundGateway()
        tcpInboundGateway.setConnectionFactory(serverConnectionFactory)
        tcpInboundGateway.setRequestChannel(inboundChannel)
        return tcpInboundGateway
    }
}

@MessageEndpoint
class TcpServerEndpoint {

    @ServiceActivator(inputChannel = "inboundChannel")
    fun process(message: ByteArray): ByteArray {
        
        // I would need to have `message` contain every line until empty line - not a single line        
        println(String(message))
        
        // TODO handle message accordingly
        return "action=ok\n".toByteArray()
    }
}

我不确定在哪里挂钩。也许DirectChannel需要别的东西？

我写了一个快速的非 spring-boot 实现，它可以工作，所以基本上我需要 spring-boot-ified 版本：

fun main(args: Array<String>) {
    val server = ServerSocket(9999)
    println("Server is running on port ${server.localPort}")

    while (true) {
        val client = server.accept()
        println("Client connected: ${client.inetAddress.hostAddress}")

        // Run client in it's own thread.
        thread { ClientHandler(client).run() }
    }

}

class ClientHandler(client: Socket) {
    private val client: Socket = client
    private val reader: BufferedReader = BufferedReader(InputStreamReader(client.getInputStream()))
    private val writer: PrintWriter = PrintWriter(client.getOutputStream(), true)
    private var running: Boolean = false

    fun run() {
        running = true
        while (running) {
            try {
                do {
                    val line = reader.readLine() ?: break
                    // TODO collect all lines in a list and handle
                } while (line.isNotEmpty())

                write("action=ok")

            } catch (ex: Exception) {
                // TODO: Implement exception handling
                ex.printStackTrace()
                shutdown()
            } finally {

            }
        }
    }

    private fun write(message: String) {
        writer.write((message + "\n\n"))
        writer.flush()
    }
    private fun shutdown() {
        running = false
        client.close()
        println("${client.inetAddress.hostAddress} closed the connection")
    }
}

神奇的部分是读取所有行直到行为空然后处理请求

Answer 1

您需要设置Deserializer ，以便 Spring 知道何时将读取的内容（到目前为止）释放给处理程序，如文档中所述。

在您的情况下，您应该编写一个实现接口org.springframework.core.serializer.Deserializer的自定义解串器，一旦检测到连续两个换行符，它就会将内容释放给处理程序。 让它返回一个List<String> ，其中包含 Postfix 发送的行：

class DoubleNewLineDeserializer: Deserializer<List<String>> {

    companion object {
        const val UNIX_NEWLINE = "\n\n"
        const val WINDOWS_NEWLINE = "\r\n\r\n"
        val CRLFRegex = Regex("[\r\n]+")
    }

    override fun deserialize(inputStream: InputStream): List<String> {
        val builder = StringBuilder()
        while(!builder.endsWith(UNIX_NEWLINE) && !builder.endsWith(WINDOWS_NEWLINE))
            builder.append(inputStream.read().toChar())
        return builder.toString().split(CRLFRegex).filter { it.isNotEmpty() }
    }

}

这个反序列化器读取输入，直到它找到一个双新行（这里是\n\n或\r\n\r\n ，你可以根据需要修改它），此时它删除消息定界符，然后将消息返回为行列表。

最后，在ServerConnectionFactory上设置新的反序列化器：

serverConnectionFactory.deserializer = DoubleNewLineDeserializer()

输入到 TCP 套接字：

foo=bar
me=you
year=123
[empty line]
[empty line]

处理程序的输入：

[foo=bar, me=you, year=123]