Merge branch 'master' of https://github.com/noear/FrameworkBenchmarks

Author: noear

frameworks/FSharp/oxpecker/README.md

@@ -19,5 +19,5 @@ This includes tests for plaintext, json, fortunes, single query, mutliple querie
 
 * [Oxpecker](https://github.com/Lanayx/Oxpecker)
 * [Npgsql](https://github.com/npgsql/npgsql)
-* [System.Text.Json](https://github.com/dotnet/runtime/tree/main/src/libraries/System.Text.Json)
+* [SpanJson](https://github.com/Tornhoof/SpanJson)
 * ASP.NET Core

frameworks/FSharp/oxpecker/src/App/App.fsproj

@@ -15,6 +15,8 @@
   <ItemGroup>
     <PackageReference Update="FSharp.Core" Version="8.0.400" />
     <PackageReference Include="Oxpecker" Version="0.14.1" />
+    <PackageReference Include="Oxpecker.ViewEngine" Version="0.14.0" />
     <PackageReference Include="Npgsql" Version="8.0.3" />
+    <PackageReference Include="SpanJson" Version="4.2.0" />
   </ItemGroup>
 </Project>

frameworks/FSharp/oxpecker/src/App/Program.fs

@@ -2,6 +2,7 @@ namespace App
 
 open System
 open Oxpecker
+open System.Runtime.InteropServices
 
 [<RequireQualifiedAccess>]
 module HtmlViews =
@@ -26,21 +27,20 @@ module HtmlViews =
         ) |> RenderHelpers.prerender
 
     let fortunes (fortunesData: ResizeArray<Fortune>) =
-        RenderHelpers.combine head tail (
-            __() {
-                for fortune in fortunesData do
-                    tr() {
-                        td() { raw <| string fortune.id }
-                        td() { fortune.message }
-                    }
+        let fragment = __()
+        for fortune in CollectionsMarshal.AsSpan fortunesData do
+            tr() {
+                td() { raw <| string fortune.id }
+                td() { fortune.message }
             }
-        )
+            |> fragment.AddChild
+        RenderHelpers.combine head tail fragment
 
 [<RequireQualifiedAccess>]
 module HttpHandlers =
     open System.Text
     open Microsoft.AspNetCore.Http
-    open System.Text.Json
+    open SpanJson
 
     let private extra =
         {
@@ -98,9 +98,9 @@ module HttpHandlers =
             ctx.WriteBytes(result)
 
     let jsonSimple value : EndpointHandler =
-        let options = JsonSerializerOptions(JsonSerializerDefaults.Web)
         fun ctx ->
-            ctx.Response.WriteAsJsonAsync(value, options)
+            ctx.SetContentType("application/json")
+            JsonSerializer.Generic.Utf8.SerializeAsync<_>(value, stream = ctx.Response.Body).AsTask()
 
     let endpoints =
         [|

frameworks/Java/spring-webflux/pom.xml

@@ -13,7 +13,7 @@
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.3.1</version>
+        <version>3.3.3</version>
     </parent>
 
     <properties>

frameworks/Java/spring-webflux/src/main/java/benchmark/App.java

@@ -1,13 +1,30 @@
 package benchmark;
 
+import benchmark.web.ServerFilter;
+
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.http.server.reactive.HttpHandler;
 import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.web.reactive.function.server.HandlerStrategies;
+import org.springframework.web.reactive.function.server.RouterFunction;
+import org.springframework.web.reactive.function.server.RouterFunctions;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import org.springframework.web.reactive.result.view.ViewResolver;
+import org.springframework.web.server.WebHandler;
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
 
 @SpringBootApplication
 @EnableScheduling
 public class App  {
 
+    @Bean
+    public HttpHandler httpHandler(RouterFunction<ServerResponse> route, ServerFilter serverFilter, ViewResolver viewResolver) {
+        WebHandler webHandler = RouterFunctions.toWebHandler(route, HandlerStrategies.builder().viewResolver(viewResolver).build());
+        return WebHttpHandlerBuilder.webHandler(webHandler).filter(serverFilter).build();
+    }
+
     public static void main(String[] args) {
         SpringApplication.run(App.class, args);
     }

frameworks/Java/spring-webflux/src/main/java/benchmark/web/WebfluxHandler.java renamed to frameworks/Java/spring-webflux/src/main/java/benchmark/web/DbHandler.java

@@ -2,11 +2,9 @@
 
 import java.util.Collections;
 import java.util.List;
-import java.util.Optional;
 import java.util.concurrent.ThreadLocalRandom;
 
 import benchmark.model.Fortune;
-import benchmark.model.Message;
 import benchmark.model.World;
 import benchmark.repository.DbRepository;
 import reactor.core.publisher.Flux;
@@ -21,26 +19,14 @@
 import static java.util.Comparator.comparing;
 
 @Component
-public class WebfluxHandler {
+public class DbHandler {
 
     private final DbRepository dbRepository;
 
-    public WebfluxHandler(DbRepository dbRepository) {
+    public DbHandler(DbRepository dbRepository) {
         this.dbRepository = dbRepository;
     }
 
-    public Mono<ServerResponse> plaintext(ServerRequest request) {
-        return ServerResponse.ok()
-                .contentType(MediaType.TEXT_PLAIN)
-                .bodyValue("Hello, World!");
-    }
-
-    public Mono<ServerResponse> json(ServerRequest request) {
-        return ServerResponse.ok()
-                .contentType(MediaType.APPLICATION_JSON)
-                .bodyValue(new Message("Hello, World!"));
-    }
-
     public Mono<ServerResponse> db(ServerRequest request) {
         int id = randomWorldNumber();
         Mono<World> world = dbRepository.getWorld(id)
@@ -52,7 +38,7 @@ public Mono<ServerResponse> db(ServerRequest request) {
     }
 
     public Mono<ServerResponse> queries(ServerRequest request) {
-        int queries = getQueries(request);
+        int queries = parseQueryCount(request.queryParams().getFirst("queries"));
 
         Mono<List<World>> worlds = Flux.range(0, queries)
                 .flatMap(i -> dbRepository.getWorld(randomWorldNumber()))
@@ -64,21 +50,21 @@ public Mono<ServerResponse> queries(ServerRequest request) {
                 });
     }
 
-    private static int parseQueryCount(Optional<String> maybeTextValue) {
-        if (!maybeTextValue.isPresent()) {
+    private static int parseQueryCount(String maybeTextValue) {
+        if (maybeTextValue == null) {
             return 1;
         }
         int parsedValue;
         try {
-            parsedValue = Integer.parseInt(maybeTextValue.get());
+            parsedValue = Integer.parseInt(maybeTextValue);
         } catch (NumberFormatException e) {
             return 1;
         }
         return Math.min(500, Math.max(1, parsedValue));
     }
 
     public Mono<ServerResponse> updates(ServerRequest request) {
-        int queries = getQueries(request);
+        int queries = parseQueryCount(request.queryParams().getFirst("queries"));
 
         Mono<List<World>> worlds = Flux.range(0, queries)
                 .flatMap(i -> dbRepository.findAndUpdateWorld(randomWorldNumber(), randomWorldNumber()))
@@ -101,10 +87,6 @@ public Mono<ServerResponse> fortunes(ServerRequest request) {
                 .render("fortunes", Collections.singletonMap("fortunes", result));
     }
 
-    private static int getQueries(ServerRequest request) {
-        return parseQueryCount(request.queryParam("queries"));
-    }
-
     private static int randomWorldNumber() {
         return 1 + ThreadLocalRandom.current().nextInt(10000);
     }

frameworks/Java/spring-webflux/src/main/java/benchmark/web/JsonHandler.java

@@ -0,0 +1,54 @@
+package benchmark.web;
+
+import java.util.Map;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectWriter;
+import reactor.core.publisher.Mono;
+
+import org.springframework.core.io.buffer.DataBuffer;
+import org.springframework.core.io.buffer.DataBufferFactory;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.HandlerFunction;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+@Component
+public class JsonHandler implements HandlerFunction<ServerResponse> {
+
+	private final ObjectWriter writer;
+
+	public JsonHandler(ObjectMapper objectMapper) {
+		this.writer = objectMapper.writerFor(Map.class);
+	}
+
+	@Override
+	public Mono<ServerResponse> handle(ServerRequest request) {
+		return ServerResponse.ok()
+				.body((message, context) -> {
+					DataBuffer buffer = serialize(request, Map.of("message", "Hello, world!"));
+					HttpHeaders headers = message.getHeaders();
+					headers.setContentLength(buffer.readableByteCount());
+					headers.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
+					return message.writeWith(Mono.just(buffer));
+				});
+	}
+
+	private DataBuffer serialize(ServerRequest request, Object object) {
+		try {
+			byte[] bytes = this.writer.writeValueAsBytes(object);
+			return bufferFactory(request).wrap(bytes);
+		}
+		catch (JsonProcessingException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	private static DataBufferFactory bufferFactory(ServerRequest request) {
+		return request.exchange().getResponse().bufferFactory();
+	}
+
+}

frameworks/Java/spring-webflux/src/main/java/benchmark/ServerFilter.java renamed to frameworks/Java/spring-webflux/src/main/java/benchmark/web/ServerFilter.java

@@ -1,6 +1,5 @@
 package benchmark.web;
 
-import io.netty.handler.codec.http.HttpHeaderNames;
 import org.springframework.http.HttpHeaders;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
@@ -28,8 +27,8 @@ public void updateDate() {
     @Override
     public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
         HttpHeaders headers = exchange.getResponse().getHeaders();
-        headers.add(HttpHeaderNames.SERVER.toString(), SERVER_NAME);
-        headers.add(HttpHeaderNames.DATE.toString(), this.date);
+        headers.add(HttpHeaders.SERVER, SERVER_NAME);
+        headers.add(HttpHeaders.DATE, this.date);
         return chain.filter(exchange);
     }
 }

frameworks/Java/spring-webflux/src/main/java/benchmark/web/TextHandler.java

@@ -0,0 +1,37 @@
+package benchmark.web;
+
+import java.nio.charset.StandardCharsets;
+
+import reactor.core.publisher.Mono;
+
+import org.springframework.core.io.buffer.DataBufferFactory;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.HandlerFunction;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+@Component
+public class TextHandler implements HandlerFunction<ServerResponse> {
+
+	private static final byte[] TEXT_BODY = "Hello, World!".getBytes(StandardCharsets.UTF_8);
+
+	private static final String TEXT_BODY_LENGTH = String.valueOf(TEXT_BODY.length);
+
+	@Override
+	public Mono<ServerResponse> handle(ServerRequest request) {
+		return ServerResponse.ok()
+				.body((message, context) -> {
+					HttpHeaders headers = message.getHeaders();
+					headers.add(HttpHeaders.CONTENT_LENGTH, TEXT_BODY_LENGTH);
+					headers.add(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_PLAIN_VALUE);
+					return message.writeWith(Mono.just(bufferFactory(request).wrap(TEXT_BODY)));
+				});
+	}
+
+	private static DataBufferFactory bufferFactory(ServerRequest request) {
+		return request.exchange().getResponse().bufferFactory();
+	}
+
+}

frameworks/Java/spring-webflux/src/main/java/benchmark/web/WebfluxRouter.java

@@ -1,23 +1,32 @@
 package benchmark.web;
 
+import reactor.core.publisher.Mono;
+
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.function.server.HandlerFunction;
 import org.springframework.web.reactive.function.server.RouterFunction;
-import org.springframework.web.reactive.function.server.RouterFunctions;
 import org.springframework.web.reactive.function.server.ServerResponse;
 
 @Configuration
 public class WebfluxRouter {
 
     @Bean
-    public RouterFunction<ServerResponse> route(WebfluxHandler handler) {
-        return RouterFunctions.route()
-                .GET("/plaintext", handler::plaintext)
-                .GET("/json", handler::json)
-                .GET("/db", handler::db)
-                .GET("/queries", handler::queries)
-                .GET("/updates", handler::updates)
-                .GET("/fortunes", handler::fortunes)
-                .build();
+    public RouterFunction<ServerResponse> route(
+            TextHandler textHandler, JsonHandler jsonHandler, DbHandler dbHandler) {
+
+        return request -> {
+            HandlerFunction<ServerResponse> fn = switch (request.uri().getRawPath()) {
+                case "/plaintext" -> textHandler;
+                case "/json" -> jsonHandler;
+                case "/db" -> dbHandler::db;
+                case "/queries" -> dbHandler::queries;
+                case "/updates" -> dbHandler::updates;
+                case "/fortunes" -> dbHandler::fortunes;
+                default -> r -> ServerResponse.notFound().build();
+            };
+            return Mono.just(fn);
+        };
     }
+
 }