Spring Boot
Recently, one of the big customers asked if we can integrate light-4j middleware handlers to address cross-cutting concerns to Spring Boot applications. They want to leverage the light-4j middleware handlers as they are faster, smaller and easier to customize. Most importantly, these handlers work with Light infrastructure to form an ecosystem to support microservices architecture. In this way, they can migrate their thousands of Spring Boot applications to Light without changing the existing controllers and business logic. The different development teams welcome the idea as they can still use Spring Boot to develop or maintain their applications without knowing the light-4j middleware injections as the DevOps team handles it in the pipeline.
The customer realizes the performance difference between Light-4j and Spring Boot as they have compared both with their typical applications. While we are working on the integration in light-spring-boot project, we can easily inject Light-4j handlers to the Spring Boot application in the same process. So we did a simple performance test to figure out what is the difference between the Light-4j implementation vs. Spring Boot controller.
If you want to watch a video walk through.
Setup
We first generated a Spring Boot application with https://start.spring.io/ with Web dependency with Spring Boot 2.1.3 version. Once the project is downloaded to the local, we switch the default Tomcat embedded server to Undertow
We have updated the pom.xml to exclude the Tomcat server and added Undertow to the dependency.
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-undertow</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
Spring Controller
We have added a RestController as following. This is a very simple controller that returns OK to the /spring-boot path.
package com.networknt.demo;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class GreetingController {
@RequestMapping("/spring-boot")
public String greeting() {
return "OK";
}
}
Light-4j Handler
Now let’s inject a light-4j handler to return OK to the /light-4j path in the SpringBootApplication.
package com.networknt.demo;
import io.undertow.Handlers;
import io.undertow.Undertow;
import io.undertow.server.HttpHandler;
import io.undertow.server.HttpServerExchange;
import io.undertow.server.RoutingHandler;
import io.undertow.servlet.api.DeploymentInfo;
import io.undertow.util.Headers;
import io.undertow.util.Methods;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.embedded.undertow.UndertowBuilderCustomizer;
import org.springframework.boot.web.embedded.undertow.UndertowDeploymentInfoCustomizer;
import org.springframework.boot.web.embedded.undertow.UndertowServletWebServerFactory;
import org.springframework.context.annotation.Bean;
import java.util.Collections;
@SpringBootApplication
public class DemoApplication {
@Bean
UndertowServletWebServerFactory embeddedServletWebFactory() {
UndertowServletWebServerFactory factory = new UndertowServletWebServerFactory();
factory.addDeploymentInfoCustomizers(new UndertowDeploymentInfoCustomizer() {
@Override
public void customize(DeploymentInfo deploymentInfo) {
deploymentInfo.addInitialHandlerChainWrapper(handler -> {
return Handlers.path()
.addPrefixPath("/", handler)
.addPrefixPath("/light-4j", getTestHandler());
}
);
}
});
return factory;
}
static HttpHandler getTestHandler() {
return new HttpHandler() {
@Override
public void handleRequest(HttpServerExchange httpServerExchange) throws Exception {
httpServerExchange.getResponseSender().send("OK");
}
};
}
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
As you can see, we have added a customizer to handle the /light-4j with an Undertow HttpHandler, and Spring Boot still handles other paths. Light-4j handler is the same with externalized configuration and other enterprise-level features. When you are using light-spring-boot, this injection will be done transparently with the pom.xml dependency and Spring @component scanning.
Start the Server
To build the server, run the following maven command.
mvn clean install
To start the server, run the following command.
java -jar target/performance-0.0.1-SNAPSHOT.jar
Now you can test the two paths by issue the following curl commands. The response will be the same OK.
Spring Boot
curl http://localhost:8080/spring-boot
Light-4j
curl http://localhost:8080/light-4j
Performance
We are using the wrk to test the perforamnce and a wrk pipeline.lua to generate as many requests as possible. To learn how to use wrk on Linux and Mac, please visit https://doc.networknt.com/tool/wrk-perf/. If you don’t want to create the pipeline.lua file manually, then you can checkout the microservices-framework-benchmark which has the file in the root folder.
Now, let’s test the performance of these two different paths.
Spring Boot
steve@freedom:~/networknt/microservices-framework-benchmark$ wrk -t8 -c128 -d30s http://localhost:8080 -s pipeline.lua --latency -- /spring-boot 64
Running 30s test @ http://localhost:8080
8 threads and 128 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 19.89ms 13.15ms 103.76ms 64.24%
Req/Sec 30.50k 2.27k 37.76k 69.58%
Latency Distribution
50% 18.79ms
75% 29.92ms
90% 41.53ms
99% 0.00us
7286784 requests in 30.02s, 0.96GB read
Requests/sec: 242744.25
Transfer/sec: 32.64MB
Light-4j
steve@freedom:~/networknt/microservices-framework-benchmark$ wrk -t8 -c128 -d30s http://localhost:8080 -s pipeline.lua --latency -- /light-4j 64
Running 30s test @ http://localhost:8080
8 threads and 128 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 0.93ms 588.47us 15.83ms 62.78%
Req/Sec 617.40k 49.68k 1.24M 88.89%
Latency Distribution
50% 0.98ms
75% 1.54ms
90% 2.23ms
99% 0.00us
147690816 requests in 30.10s, 13.89GB read
Requests/sec: 4906794.22
Transfer/sec: 472.63MB
In comparing the two results, we can see that the light-4j path achieves about 20 times the throughput of spring-boot path and the latency is 0.93ms vs. 19.89ms. Imagine if you wanted to reach the same throughput and same latency of light-4j path: how many Spring Boot instances would be needed? We have one customer who switched from Spring Boot to Light-4j for their service that collects data from IoT devices and they reduced from 250 medium size AWS VMs to only 4 small size AWS VMs with much better performance.
The test was done on my desktop computer with AMD 2700X and 32GB memory. The source code can be found at Github and you can run it locally.