netty: improve performance by caching the content-length header on bytes wrapped responses

jknack · jknack · commit 1761a3428964 · 2025-07-14T07:35:34.000-03:00
diff --git a/modules/jooby-jetty/src/main/java/io/jooby/jetty/JettyServer.java b/modules/jooby-jetty/src/main/java/io/jooby/jetty/JettyServer.java
@@ -31,6 +31,7 @@
 import com.typesafe.config.Config;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import io.jooby.*;
+import io.jooby.buffer.BufferedOutputFactory;
 import io.jooby.internal.jetty.JettyHandler;
 import io.jooby.internal.jetty.JettyHttpExpectAndContinueHandler;
 import io.jooby.internal.jetty.PrefixHandler;
@@ -45,6 +46,7 @@
 public class JettyServer extends io.jooby.Server.Base {
 
   private static final int THREADS = 200;
+  private BufferedOutputFactory outputFactory;
 
   private Server server;
 
@@ -69,6 +71,14 @@ public JettyServer(@NonNull ServerOptions options) {
 
   public JettyServer() {}
 
+  @NonNull @Override
+  public BufferedOutputFactory getOutputFactory() {
+    if (outputFactory == null) {
+      this.outputFactory = BufferedOutputFactory.create(getOptions().getBuffer());
+    }
+    return outputFactory;
+  }
+
   @NonNull @Override
   public JettyServer setOptions(@NonNull ServerOptions options) {
     super.setOptions(options.setWorkerThreads(options.getWorkerThreads(THREADS)));
diff --git a/modules/jooby-kotlin/src/test/kotlin/io/jooby/kt/Idioms.kt b/modules/jooby-kotlin/src/test/kotlin/io/jooby/kt/Idioms.kt
@@ -13,8 +13,8 @@ import java.time.Duration
 import kotlinx.coroutines.delay
 
 /**
- * Kotlin DLS in action, this class does nothing but we need it to make sure Kotlin version compiles
- * sucessfully.
+ * Kotlin DLS in action, this class does nothing, but we need it to make sure Kotlin version
+ * compiles successfully.
  */
 class Idioms :
   Kooby({
diff --git a/modules/jooby-netty/src/main/java/io/jooby/internal/netty/HeadersMultiMap.java b/modules/jooby-netty/src/main/java/io/jooby/internal/netty/HeadersMultiMap.java
@@ -505,8 +505,8 @@ static void encoderHeader(CharSequence name, CharSequence value, ByteBuf buf) {
   }
 
   private static void writeAscii(ByteBuf buf, int offset, CharSequence value) {
-    if (value instanceof AsciiString) {
-      ByteBufUtil.copy((AsciiString) value, 0, buf, offset, value.length());
+    if (value instanceof AsciiString ascii) {
+      buf.setBytes(offset, ascii.array(), ascii.arrayOffset(), value.length());
     } else {
       buf.setCharSequence(offset, value, CharsetUtil.US_ASCII);
     }
diff --git a/modules/jooby-netty/src/main/java/io/jooby/internal/netty/NettyByteArrayWrappedOutput.java b/modules/jooby-netty/src/main/java/io/jooby/internal/netty/NettyByteArrayWrappedOutput.java
@@ -0,0 +1,74 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.netty;
+
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+import io.jooby.Context;
+import io.jooby.buffer.BufferedOutput;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.util.AsciiString;
+
+public class NettyByteArrayWrappedOutput implements NettyByteBufOutput {
+
+  private final byte[] buffer;
+  private final int offset;
+  private final int length;
+  private final AsciiString contentLength;
+
+  protected NettyByteArrayWrappedOutput(byte[] buffer, int offset, int length) {
+    this.buffer = buffer;
+    this.offset = offset;
+    this.length = length;
+    this.contentLength = AsciiString.of(Integer.toString(length - offset));
+  }
+
+  @NonNull public ByteBuf byteBuf() {
+    return Unpooled.wrappedBuffer(buffer, offset, length);
+  }
+
+  @Override
+  @NonNull public BufferedOutput write(byte b) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  @NonNull public BufferedOutput write(byte[] source) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  @NonNull public BufferedOutput write(byte[] source, int offset, int length) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  @NonNull public BufferedOutput write(@NonNull String source, @NonNull Charset charset) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public void send(Context ctx) {
+    if (ctx instanceof NettyContext netty) {
+      netty.send(Unpooled.wrappedBuffer(buffer, offset, length), contentLength);
+    } else {
+      ctx.send(asByteBuffer());
+    }
+  }
+
+  @Override
+  public BufferedOutput write(@NonNull CharBuffer source, @NonNull Charset charset) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  @NonNull public BufferedOutput clear() {
+    return this;
+  }
+}
diff --git a/modules/jooby-netty/src/main/java/io/jooby/internal/netty/NettyByteBufOutput.java b/modules/jooby-netty/src/main/java/io/jooby/internal/netty/NettyByteBufOutput.java
@@ -41,7 +41,8 @@ default int size() {
   @Override
   default void send(Context ctx) {
     if (ctx instanceof NettyContext netty) {
-      netty.send(byteBuf());
+      var buf = byteBuf();
+      netty.send(buf, Integer.toString(buf.readableBytes()));
     } else {
       ctx.send(asByteBuffer());
     }
diff --git a/modules/jooby-netty/src/main/java/io/jooby/internal/netty/NettyByteBufferWrappedOutput.java b/modules/jooby-netty/src/main/java/io/jooby/internal/netty/NettyByteBufferWrappedOutput.java
@@ -0,0 +1,71 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.netty;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+import io.jooby.Context;
+import io.jooby.buffer.BufferedOutput;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.util.AsciiString;
+
+public class NettyByteBufferWrappedOutput implements NettyByteBufOutput {
+
+  private final ByteBuffer buffer;
+  private final AsciiString contentLength;
+
+  protected NettyByteBufferWrappedOutput(ByteBuffer buffer) {
+    this.buffer = buffer;
+    this.contentLength = AsciiString.of(Integer.toString(buffer.remaining()));
+  }
+
+  @NonNull public ByteBuf byteBuf() {
+    return Unpooled.wrappedBuffer(buffer);
+  }
+
+  @Override
+  @NonNull public BufferedOutput write(byte b) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  @NonNull public BufferedOutput write(byte[] source) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  @NonNull public BufferedOutput write(byte[] source, int offset, int length) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  @NonNull public BufferedOutput write(@NonNull String source, @NonNull Charset charset) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public void send(Context ctx) {
+    if (ctx instanceof NettyContext netty) {
+      netty.send(Unpooled.wrappedBuffer(buffer), contentLength);
+    } else {
+      ctx.send(asByteBuffer());
+    }
+  }
+
+  @Override
+  public BufferedOutput write(@NonNull CharBuffer source, @NonNull Charset charset) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  @NonNull public BufferedOutput clear() {
+    return this;
+  }
+}
diff --git a/modules/jooby-netty/src/main/java/io/jooby/internal/netty/NettyContext.java b/modules/jooby-netty/src/main/java/io/jooby/internal/netty/NettyContext.java
@@ -580,10 +580,14 @@ public final Context send(ByteBuffer data) {
     return this;
   }
 
-  public Context send(@NonNull ByteBuf data) {
+  private Context send(@NonNull ByteBuf data) {
+    return send(data, Integer.toString(data.readableBytes()));
+  }
+
+  Context send(@NonNull ByteBuf data, CharSequence contentLength) {
     try {
       responseStarted = true;
-      setHeaders.set(CONTENT_LENGTH, Integer.toString(data.readableBytes()));
+      setHeaders.set(CONTENT_LENGTH, contentLength);
       var response = new DefaultFullHttpResponse(HTTP_1_1, status, data, setHeaders, NO_TRAILING);
       if (ctx.channel().eventLoop().inEventLoop()) {
         needsFlush = true;
diff --git a/modules/jooby-netty/src/main/java/io/jooby/internal/netty/NettyResponseEncoder.java b/modules/jooby-netty/src/main/java/io/jooby/internal/netty/NettyResponseEncoder.java
@@ -18,9 +18,4 @@ protected void encodeHeaders(HttpHeaders headers, ByteBuf buf) {
       super.encodeHeaders(headers, buf);
     }
   }
-
-  @Override
-  public boolean acceptOutboundMessage(Object msg) throws Exception {
-    return super.acceptOutboundMessage(msg);
-  }
 }
diff --git a/modules/jooby-netty/src/main/java/io/jooby/netty/NettyServer.java b/modules/jooby-netty/src/main/java/io/jooby/netty/NettyServer.java
@@ -22,6 +22,7 @@
 import io.jooby.ServerOptions;
 import io.jooby.SneakyThrows;
 import io.jooby.SslOptions;
+import io.jooby.buffer.BufferedOutputFactory;
 import io.jooby.internal.netty.*;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.buffer.ByteBufAllocator;
@@ -53,6 +54,7 @@ public class NettyServer extends Server.Base {
   private ExecutorService worker;
 
   private List<Jooby> applications;
+  private NettyBufferedOutputFactory outputFactory;
 
   /**
    * Creates a server.
@@ -80,6 +82,15 @@ public NettyServer(@NonNull ServerOptions options) {
 
   public NettyServer() {}
 
+  @NonNull @Override
+  public BufferedOutputFactory getOutputFactory() {
+    if (outputFactory == null) {
+      outputFactory =
+          new NettyBufferedOutputFactory(ByteBufAllocator.DEFAULT, getOptions().getBuffer());
+    }
+    return outputFactory;
+  }
+
   @Override
   protected ServerOptions defaultOptions() {
     return new ServerOptions().setServer(getName());
@@ -101,9 +112,7 @@ public Server start(@NonNull Jooby... application) {
         worker = newFixedThreadPool(options.getWorkerThreads(), new DefaultThreadFactory("worker"));
       }
       // Make sure context use same buffer factory
-      var outputFactory = new NettyOutputFactory(ByteBufAllocator.DEFAULT, options.getBuffer());
       for (var app : applications) {
-        app.setOutputFactory(outputFactory);
         app.getServices().put(ServerOptions.class, options);
         app.getServices().put(Server.class, this);
       }
@@ -124,6 +133,7 @@ public Server start(@NonNull Jooby... application) {
       this.dateLoop = Executors.newSingleThreadScheduledExecutor();
       var dateService = new NettyDateService(dateLoop);
 
+      var outputFactory = (NettyBufferedOutputFactory) getOutputFactory();
       var allocator = outputFactory.getAllocator();
       var http2 = options.isHttp2() == Boolean.TRUE;
       /* Bootstrap: */
diff --git a/modules/jooby-test/src/main/java/io/jooby/test/JoobyExtension.java b/modules/jooby-test/src/main/java/io/jooby/test/JoobyExtension.java
@@ -69,12 +69,16 @@ public void beforeAll(ExtensionContext context) throws Exception {
   }
 
   private Jooby startApp(ExtensionContext context, JoobyTest metadata) throws Exception {
+    var server = Server.loadServer();
+    var serverOptions = server.getOptions();
+    serverOptions.setPort(port(metadata.port(), DEFAULT_PORT));
+    server.setOptions(serverOptions);
     Jooby app;
     String factoryMethod = metadata.factoryMethod();
     if (factoryMethod.isEmpty()) {
       var defaultEnv = System.getProperty("application.env");
       System.setProperty("application.env", metadata.environment());
-      app = Jooby.createApp(metadata.executionMode(), reflectionProvider(metadata.value()));
+      app = Jooby.createApp(server, metadata.executionMode(), reflectionProvider(metadata.value()));
       if (defaultEnv != null) {
         System.setProperty("application.env", defaultEnv);
       } else {
@@ -83,14 +87,6 @@ private Jooby startApp(ExtensionContext context, JoobyTest metadata) throws Exce
     } else {
       app = fromFactoryMethod(context, metadata, factoryMethod);
     }
-    var server = Server.loadServer();
-    var serverOptions = server.getOptions();
-    //    ServerOptions serverOptions = app.getServerOptions();
-    //    if (serverOptions == null) {
-    //      serverOptions = server.getOptions();
-    //    }
-    serverOptions.setPort(port(metadata.port(), DEFAULT_PORT));
-    server.setOptions(serverOptions);
     server.start(app);
     ExtensionContext.Store store = getStore(context);
     store.put("server", server);
diff --git a/modules/jooby-undertow/src/main/java/io/jooby/undertow/UndertowServer.java b/modules/jooby-undertow/src/main/java/io/jooby/undertow/UndertowServer.java
@@ -21,6 +21,7 @@
 import io.jooby.ServerOptions;
 import io.jooby.SneakyThrows;
 import io.jooby.SslOptions;
+import io.jooby.buffer.BufferedOutputFactory;
 import io.jooby.exception.StartupException;
 import io.jooby.internal.undertow.UndertowHandler;
 import io.jooby.internal.undertow.UndertowWebSocket;
@@ -53,6 +54,8 @@ public class UndertowServer extends Server.Base {
 
   private XnioWorker worker;
 
+  private BufferedOutputFactory outputFactory;
+
   public UndertowServer(@NonNull ServerOptions options) {
     setOptions(options);
   }
@@ -66,6 +69,14 @@ public UndertowServer setOptions(@NonNull ServerOptions options) {
     return this;
   }
 
+  @NonNull @Override
+  public BufferedOutputFactory getOutputFactory() {
+    if (outputFactory == null) {
+      outputFactory = BufferedOutputFactory.create(getOptions().getBuffer());
+    }
+    return outputFactory;
+  }
+
   @Override
   protected ServerOptions defaultOptions() {
     return new ServerOptions().setIoThreads(ServerOptions.IO_THREADS).setServer(getName());
diff --git a/tests/src/test/java/io/jooby/junit/ServerProvider.java b/tests/src/test/java/io/jooby/junit/ServerProvider.java
@@ -8,14 +8,14 @@
 import static java.util.stream.StreamSupport.stream;
 
 import java.util.ServiceLoader;
-import java.util.function.Supplier;
 
 import io.jooby.Server;
+import io.jooby.ServerOptions;
 import io.jooby.jetty.JettyServer;
 import io.jooby.netty.NettyServer;
 import io.jooby.undertow.UndertowServer;
 
-public class ServerProvider implements Supplier<Server> {
+public class ServerProvider {
   private Class serverClass;
 
   public ServerProvider(Class serverClass) {
@@ -39,11 +39,15 @@ public String getName() {
     return serverClass.getSimpleName().replace("Server", "");
   }
 
-  @Override
-  public Server get() {
-    return stream(ServiceLoader.load(Server.class).spliterator(), false)
-        .filter(s -> serverClass.isInstance(s))
-        .findFirst()
-        .orElseThrow(() -> new IllegalArgumentException("Server not found: " + serverClass));
+  public Server get(ServerOptions options) {
+    var server =
+        stream(ServiceLoader.load(Server.class).spliterator(), false)
+            .filter(s -> serverClass.isInstance(s))
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException("Server not found: " + serverClass));
+    if (options != null) {
+      server.setOptions(options);
+    }
+    return server;
   }
 }
diff --git a/tests/src/test/java/io/jooby/junit/ServerTestRunner.java b/tests/src/test/java/io/jooby/junit/ServerTestRunner.java

Original file line number	Diff line number	Diff line change
`@@ -505,8 +505,8 @@ static void encoderHeader(CharSequence name, CharSequence value, ByteBuf buf) {`
`505`	`505`	`}`
`506`	`506`
`507`	`507`	`private static void writeAscii(ByteBuf buf, int offset, CharSequence value) {`
`508`		`- if (value instanceof AsciiString) {`
`509`		`- ByteBufUtil.copy((AsciiString) value, 0, buf, offset, value.length());`
	`508`	`+ if (value instanceof AsciiString ascii) {`
	`509`	`+ buf.setBytes(offset, ascii.array(), ascii.arrayOffset(), value.length());`
`510`	`510`	`} else {`
`511`	`511`	`buf.setCharSequence(offset, value, CharsetUtil.US_ASCII);`
`512`	`512`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,9 +18,4 @@ protected void encodeHeaders(HttpHeaders headers, ByteBuf buf) {`
`18`	`18`	`super.encodeHeaders(headers, buf);`
`19`	`19`	`}`
`20`	`20`	`}`
`21`		`-`
`22`		`- @Override`
`23`		`- public boolean acceptOutboundMessage(Object msg) throws Exception {`
`24`		`- return super.acceptOutboundMessage(msg);`
`25`		`- }`
`26`	`21`	`}`