refactor: SPA app improvements (#10)

MukjepScarlet · web-flow · commit 1ca243666580 · 2025-12-08T22:32:51.000+08:00
* Add functional interface RequestHandler

* RequestContext.contentBuffer to ByteArrayOutputStream (avoid multiple Charset actions)

* improve ZipServant response creation
diff --git a/src/main/kotlin/net/ccbluex/netty/http/HttpConductor.kt b/src/main/kotlin/net/ccbluex/netty/http/HttpConductor.kt
@@ -35,13 +35,13 @@ import net.ccbluex.netty.http.util.httpNoContent
  * @return The response to the request.
  */
 internal fun HttpServer.processRequestContext(context: RequestContext) = runCatching {
-    val content = context.contentBuffer.toString()
+    val content = context.contentBuffer.toByteArray()
     val method = context.httpMethod
 
     logger.debug("Request {}", context)
 
     if (!context.headers["content-length"].isNullOrEmpty() &&
-        context.headers["content-length"]?.toInt() != content.toByteArray(Charsets.UTF_8).size) {
+        context.headers["content-length"]?.toInt() != content.size) {
         logger.warn("Received incomplete request: $context")
         return@runCatching httpBadRequest("Incomplete request")
     }
@@ -59,13 +59,13 @@ internal fun HttpServer.processRequestContext(context: RequestContext) = runCatc
         path = context.path,
         remainingPath = remaining,
         method = method,
-        body = content,
+        body = content.toString(Charsets.UTF_8),
         params = params,
         queryParams = context.params,
         headers = context.headers
     )
 
-    return@runCatching node.handleRequest(requestObject)
+    return@runCatching node.handle(requestObject)
 }.getOrElse {
     logger.error("Error while processing request object: $context", it)
     httpInternalServerError(it.message ?: "Unknown error")
diff --git a/src/main/kotlin/net/ccbluex/netty/http/HttpServerHandler.kt b/src/main/kotlin/net/ccbluex/netty/http/HttpServerHandler.kt
@@ -111,9 +111,7 @@ internal class HttpServerHandler(private val server: HttpServer) : ChannelInboun
                 }
 
                 // Append content to the buffer
-                requestContext
-                    .contentBuffer
-                    .append(msg.content().toString(Charsets.UTF_8))
+                msg.content().readBytes(requestContext.contentBuffer, msg.content().readableBytes())
 
                 // If this is the last content, process the request
                 if (msg is LastHttpContent) {
diff --git a/src/main/kotlin/net/ccbluex/netty/http/model/RequestContext.kt b/src/main/kotlin/net/ccbluex/netty/http/model/RequestContext.kt
@@ -21,9 +21,10 @@ package net.ccbluex.netty.http.model
 
 import io.netty.handler.codec.http.HttpHeaders
 import io.netty.handler.codec.http.HttpMethod
+import java.io.ByteArrayOutputStream
 
 data class RequestContext(var httpMethod: HttpMethod, var uri: String, var headers: HttpHeaders) {
-    val contentBuffer = StringBuilder()
+    val contentBuffer = ByteArrayOutputStream()
     val path = uri.substringBefore('?', uri)
     val params = getUriParams(uri)
 }
diff --git a/src/main/kotlin/net/ccbluex/netty/http/model/RequestHandler.kt b/src/main/kotlin/net/ccbluex/netty/http/model/RequestHandler.kt
@@ -0,0 +1,7 @@
+package net.ccbluex.netty.http.model
+
+import io.netty.handler.codec.http.FullHttpResponse
+
+fun interface RequestHandler {
+    fun handle(request: RequestObject): FullHttpResponse
+}
diff --git a/src/main/kotlin/net/ccbluex/netty/http/rest/FileServant.kt b/src/main/kotlin/net/ccbluex/netty/http/rest/FileServant.kt
@@ -37,8 +37,8 @@ class FileServant(part: String, private val baseFolder: File) : Node(part) {
 
     override val isExecutable = true
 
-    override fun handleRequest(requestObject: RequestObject): FullHttpResponse {
-        val path = requestObject.remainingPath
+    override fun handle(request: RequestObject): FullHttpResponse {
+        val path = request.remainingPath
         val sanitizedPath = path.replace("..", "")
         val file = baseFolder.resolve(sanitizedPath)
 
diff --git a/src/main/kotlin/net/ccbluex/netty/http/rest/Node.kt b/src/main/kotlin/net/ccbluex/netty/http/rest/Node.kt
@@ -21,9 +21,7 @@ package net.ccbluex.netty.http.rest
 
 import io.netty.handler.codec.http.FullHttpResponse
 import io.netty.handler.codec.http.HttpMethod
-import net.ccbluex.netty.http.util.httpFile
-import net.ccbluex.netty.http.util.httpForbidden
-import net.ccbluex.netty.http.util.httpNotFound
+import net.ccbluex.netty.http.model.RequestHandler
 import net.ccbluex.netty.http.model.RequestObject
 import java.io.File
 import java.io.InputStream
@@ -34,7 +32,7 @@ import java.io.InputStream
  * @property part The part of the path this node represents.
  */
 @Suppress("TooManyFunctions")
-open class Node(val part: String) {
+open class Node(val part: String) : RequestHandler {
 
     open val isRoot = part.isEmpty()
     open val isExecutable = false
@@ -66,7 +64,7 @@ open class Node(val part: String) {
      * @param handler The handler function for the route.
      * @return The node representing the route.
      */
-    fun route(path: String, method: HttpMethod, handler: (RequestObject) -> FullHttpResponse) =
+    fun route(path: String, method: HttpMethod, handler: RequestHandler) =
         chain({ Route(it, method, handler) }, *path.asPathArray())
 
     /**
@@ -89,28 +87,28 @@ open class Node(val part: String) {
     fun zip(path: String, zipInputStream: InputStream) =
         chain({ ZipServant(it, zipInputStream) }, *path.asPathArray())
 
-    fun get(path: String, handler: (RequestObject) -> FullHttpResponse)
+    fun get(path: String, handler: RequestHandler)
             = route(path, HttpMethod.GET, handler)
 
-    fun post(path: String, handler: (RequestObject) -> FullHttpResponse)
+    fun post(path: String, handler: RequestHandler)
             = route(path, HttpMethod.POST, handler)
 
-    fun put(path: String, handler: (RequestObject) -> FullHttpResponse)
+    fun put(path: String, handler: RequestHandler)
             = route(path, HttpMethod.PUT, handler)
 
-    fun delete(path: String, handler: (RequestObject) -> FullHttpResponse)
+    fun delete(path: String, handler: RequestHandler)
             = route(path, HttpMethod.DELETE, handler)
 
-    fun patch(path: String, handler: (RequestObject) -> FullHttpResponse)
+    fun patch(path: String, handler: RequestHandler)
             = route(path, HttpMethod.PATCH, handler)
 
-    fun head(path: String, handler: (RequestObject) -> FullHttpResponse)
+    fun head(path: String, handler: RequestHandler)
             = route(path, HttpMethod.HEAD, handler)
 
-    fun options(path: String, handler: (RequestObject) -> FullHttpResponse)
+    fun options(path: String, handler: RequestHandler)
             = route(path, HttpMethod.OPTIONS, handler)
 
-    fun trace(path: String, handler: (RequestObject) -> FullHttpResponse)
+    fun trace(path: String, handler: RequestHandler)
             = route(path, HttpMethod.TRACE, handler)
 
     /**
@@ -134,18 +132,15 @@ open class Node(val part: String) {
     /**
      * Handles an HTTP request.
      *
-     * @param requestObject The request object.
+     * @param request The request object.
      * @return The HTTP response.
      */
-    open fun handleRequest(requestObject: RequestObject): FullHttpResponse {
-        error("Node does not implement handleRequest")
-    }
+    override fun handle(request: RequestObject): FullHttpResponse = throw NotImplementedError()
 
     /**
      * Checks if the node matches a part of the path and HTTP method.
      *
      * @param part The part of the path.
-     * @param method The HTTP method.
      * @return True if the node matches, false otherwise.
      */
     open fun matches(index: Int, part: String) =
diff --git a/src/main/kotlin/net/ccbluex/netty/http/rest/Route.kt b/src/main/kotlin/net/ccbluex/netty/http/rest/Route.kt
@@ -19,13 +19,9 @@
  */
 package net.ccbluex.netty.http.rest
 
-import io.netty.handler.codec.http.FullHttpResponse
 import io.netty.handler.codec.http.HttpMethod
-import net.ccbluex.netty.http.util.httpFile
-import net.ccbluex.netty.http.util.httpForbidden
-import net.ccbluex.netty.http.util.httpNotFound
+import net.ccbluex.netty.http.model.RequestHandler
 import net.ccbluex.netty.http.model.RequestObject
-import java.io.File
 
 /**
  * Represents a route in the routing tree.
@@ -34,10 +30,10 @@ import java.io.File
  * @property method The HTTP method of the route.
  * @property handler The handler function for the route.
  */
-open class Route(name: String, private val method: HttpMethod, val handler: (RequestObject) -> FullHttpResponse)
+open class Route(name: String, private val method: HttpMethod, val handler: RequestHandler)
     : Node(name) {
     override val isExecutable = true
-    override fun handleRequest(requestObject: RequestObject) = handler(requestObject)
+    override fun handle(request: RequestObject) = handler.handle(request)
     override fun matchesMethod(method: HttpMethod) =
         this.method == method && super.matchesMethod(method)
 
diff --git a/src/main/kotlin/net/ccbluex/netty/http/rest/ZipServant.kt b/src/main/kotlin/net/ccbluex/netty/http/rest/ZipServant.kt
@@ -19,16 +19,24 @@
  */
 package net.ccbluex.netty.http.rest
 
+import io.netty.buffer.ByteBuf
+import io.netty.buffer.Unpooled
+import io.netty.handler.codec.http.DefaultFullHttpResponse
+import io.netty.handler.codec.http.EmptyHttpHeaders
 import io.netty.handler.codec.http.FullHttpResponse
-import net.ccbluex.netty.http.util.httpFileStream
+import io.netty.handler.codec.http.HttpHeaderNames
+import io.netty.handler.codec.http.HttpResponseStatus
+import io.netty.handler.codec.http.HttpVersion
+import io.netty.handler.codec.http.ReadOnlyHttpHeaders
 import net.ccbluex.netty.http.util.httpNotFound
 import net.ccbluex.netty.http.model.RequestObject
 import org.apache.tika.Tika
-import java.io.ByteArrayInputStream
 import java.io.InputStream
 import java.util.zip.ZipEntry
 import java.util.zip.ZipInputStream
 
+private val tika = Tika()
+
 /**
  * Represents a zip servant in the routing tree that serves files from a zip archive kept in memory.
  *
@@ -48,32 +56,28 @@ class ZipServant(part: String, zipInputStream: InputStream) : Node(part) {
      */
     private data class ZipFileEntry(
         val name: String,
-        val data: ByteArray,
-        val isDirectory: Boolean
+        val data: ByteBuf,
+        val isDirectory: Boolean,
     ) {
-        override fun equals(other: Any?): Boolean {
-            if (this === other) return true
-            if (javaClass != other?.javaClass) return false
-
-            other as ZipFileEntry
-
-            if (name != other.name) return false
-            if (!data.contentEquals(other.data)) return false
-            if (isDirectory != other.isDirectory) return false
-
-            return true
-        }
+        private val headers =
+            ReadOnlyHttpHeaders(
+                false,
+                HttpHeaderNames.CONTENT_TYPE, tika.detect(name),
+                HttpHeaderNames.CONTENT_LENGTH, data.readableBytes().toString(),
+            )
 
-        override fun hashCode(): Int {
-            var result = name.hashCode()
-            result = 31 * result + data.contentHashCode()
-            result = 31 * result + isDirectory.hashCode()
-            return result
+        fun toResponse(): FullHttpResponse {
+            return DefaultFullHttpResponse(
+                HttpVersion.HTTP_1_1,
+                HttpResponseStatus.OK,
+                data.duplicate(),
+                headers,
+                EmptyHttpHeaders.INSTANCE,
+            )
         }
     }
 
     private val zipFiles: Map<String, ZipFileEntry>
-    private val tika = Tika()
 
     init {
         zipFiles = loadZipData(zipInputStream)
@@ -96,10 +100,10 @@ class ZipServant(part: String, zipInputStream: InputStream) : Node(part) {
                 val isDirectory = entry.isDirectory
 
                 if (isDirectory) {
-                    files[name] = ZipFileEntry(name, ByteArray(0), true)
+                    files[name] = ZipFileEntry(name, Unpooled.EMPTY_BUFFER, true)
                 } else {
                     val data = zis.readBytes()
-                    files[name] = ZipFileEntry(name, data, false)
+                    files[name] = ZipFileEntry(name, Unpooled.wrappedBuffer(data), false)
                 }
 
                 zis.closeEntry()
@@ -110,8 +114,8 @@ class ZipServant(part: String, zipInputStream: InputStream) : Node(part) {
         return files
     }
 
-    override fun handleRequest(requestObject: RequestObject): FullHttpResponse {
-        val path = requestObject.remainingPath.removePrefix("/")
+    override fun handle(request: RequestObject): FullHttpResponse {
+        val path = request.remainingPath.removePrefix("/")
         val cleanPath = path.substringBefore("?")
         val sanitizedPath = cleanPath.replace("..", "")
 
@@ -141,11 +145,7 @@ class ZipServant(part: String, zipInputStream: InputStream) : Node(part) {
         // Try to find exact file match first (non-directory)
         val exactMatch = findFile(sanitizedPath)
         if (exactMatch != null && !exactMatch.isDirectory) {
-            return httpFileStream(
-                stream = ByteArrayInputStream(exactMatch.data),
-                contentType = tika.detect(exactMatch.name),
-                contentLength = exactMatch.data.size
-            )
+            return exactMatch.toResponse()
         }
 
         // Handle directory requests or SPA routes
@@ -154,47 +154,31 @@ class ZipServant(part: String, zipInputStream: InputStream) : Node(part) {
             sanitizedPath.isEmpty() -> {
                 val indexEntry = findIndexInDirectory("")
                 if (indexEntry != null && !indexEntry.isDirectory) {
-                    return httpFileStream(
-                        stream = ByteArrayInputStream(indexEntry.data),
-                        contentType = tika.detect(indexEntry.name),
-                        contentLength = indexEntry.data.size
-                    )
+                    return indexEntry.toResponse()
                 }
             }
 
             // Case 2: Path ends with "/" - explicit directory request
             sanitizedPath.endsWith("/") -> {
                 val indexEntry = findIndexInDirectory(directoryPath)
                 if (indexEntry != null && !indexEntry.isDirectory) {
-                    return httpFileStream(
-                        stream = ByteArrayInputStream(indexEntry.data),
-                        contentType = tika.detect(indexEntry.name),
-                        contentLength = indexEntry.data.size
-                    )
+                    return indexEntry.toResponse()
                 }
             }
 
             // Case 3: Path contains "#" - SPA route with fragment
             fragmentIndex != -1 -> {
                 val indexEntry = findIndexInDirectory(directoryPath)
                 if (indexEntry != null && !indexEntry.isDirectory) {
-                    return httpFileStream(
-                        stream = ByteArrayInputStream(indexEntry.data),
-                        contentType = tika.detect(indexEntry.name),
-                        contentLength = indexEntry.data.size
-                    )
+                    return indexEntry.toResponse()
                 }
             }
 
             // Case 4: Check if path is an implicit directory and has index.html
             isImplicitDirectory(sanitizedPath) -> {
                 val indexEntry = findIndexInDirectory(sanitizedPath)
                 if (indexEntry != null && !indexEntry.isDirectory) {
-                    return httpFileStream(
-                        stream = ByteArrayInputStream(indexEntry.data),
-                        contentType = tika.detect(indexEntry.name),
-                        contentLength = indexEntry.data.size
-                    )
+                    return indexEntry.toResponse()
                 }
             }
         }
diff --git a/src/test/kotlin/ZipServantTest.kt b/src/test/kotlin/ZipServantTest.kt
diff --git a/src/test/kotlin/util/Base64Test.kt b/src/test/kotlin/util/Base64Test.kt

Original file line number	Diff line number	Diff line change
`@@ -111,9 +111,7 @@ internal class HttpServerHandler(private val server: HttpServer) : ChannelInboun`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`// Append content to the buffer`
`114`		`- requestContext`
`115`		`- .contentBuffer`
`116`		`- .append(msg.content().toString(Charsets.UTF_8))`
	`114`	`+ msg.content().readBytes(requestContext.contentBuffer, msg.content().readableBytes())`
`117`	`115`
`118`	`116`	`// If this is the last content, process the request`
`119`	`117`	`if (msg is LastHttpContent) {`