Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

SpringBoot: Performance War

DZone 's Guide to

SpringBoot: Performance War

A closer look at SpringBoot and its role in performance.

· Performance Zone ·
Free Resource

Performance Matrix of Reactive APIs With WebFulx and Redis

Reactive Systems are designed to address challenges posed by modern software systems - the challenges related to a large number of users and high throughput. Reactive systems are expected to be highly responsive, resilient, elastic and message-driven.

In this article we will:

  • Build a set of fully non-blocking REST API using SpringBoot 2.0, WebFlux and Reactive Redis.
  • Performance test the above Reactive APIs against the traditional non-reactive APIs

The code used in this example can be downloaded from  GitHub

Step One: Create a Skeleton Reactive WebFlux SpringBoot Project

Create a SpringBoot maven project using - https://start.spring.io

Add the following dependencies:

  •  spring-boot-starter-web 
  •  spring-boot-starter-data-redis 
  •  spring-webflux 
  •  spring-boot-starter-data-redis-reactive 

Refer to the dependencies in pom.xml

Step Two: Create Domain Objects

The demo project uses the domain objects Customer and Account. A customer can have multiple accounts.

Image title

Step Three: Create Non-Blocking Reactive REST APIs Using WebFlux

Create a REST controller CustomerControllerRx for the purpose of serving the following reactive no-blocking APIs.

  • Add/update a Customer
  • findById a Customer

The code snippet uses Mono which is an implementation of Reactive streams Publisher interface and ReactiveRedisTemplate and ReactiveValueOperations to interact with Redis in a non-blocking way.

@RestController
@RequestMapping("/customers/rx")
public class CustomerControllerRx {

    @Autowired
    private ReactiveRedisTemplate<String, Customer> redisTemplate;
    private ReactiveValueOperations<String, Customer> reactiveValueOps;

  @PostMapping
  public Mono<Boolean> add(@RequestBody Customer customer) {
      reactiveValueOps = redisTemplate.opsForValue();
      Mono<Boolean> result = reactiveValueOps.set(customer.getExternalId(), customer);
      return result;
  }

  @GetMapping("/{id}")
  public Mono<Customer> findById(@PathVariable("id") String id) {
      reactiveValueOps = redisTemplate.opsForValue();
      Mono<Customer> fetchedAccount = reactiveValueOps.get(id);
      return fetchedAccount;
  }
}

ReactiveRedisTemplate is configured in  RedisConfigRx

Step Four: Create Synchronous (Blocking) REST API

Create a REST controller CustomerController for the purpose of serving non-reactive blocking APIs. We are using CustomerRepository which extends a CurdRepository to interact with the Redis database.

@RestController
@RequestMapping("/customers")
public class CustomerController {

    @Autowired
    CustomerRepository repository;

    @PostMapping
    public Customer add(@RequestBody Customer customer) {
        return repository.save(customer);
    }

    @GetMapping("/{externalId}")
    public Customer findById(@PathVariable("externalId") String externalId) {

        Customer optCustomer = repository.findByExternalId(externalId);

        if (Optional.ofNullable(optCustomer).isPresent())
            return optCustomer;
        else{
            return null;
        }
    }
}
// Code for CustomerRepository
public interface CustomerRepository extends CrudRepository<Customer, Long> {

    Customer findByExternalId(String externalId);
    List<Customer> findByAccountsId(Long id);
}

Step Five: Connecting to Redis Using Docker

  • Redis doesn’t officially support Windows. However, the easiest way to get Redis up and running for UNIX or Windows is by using Docker.
  • Use the following steps to pull a redis image from docker hub and to start on port 6379 in detached mode.
$ docker pull redis  

$ docker run -d -p 6379:6379 --name redis1 redis

$ docker ps -a           // make sure redis is up and running.

Refer to application.yml for Redis connection properties.

Step Six: Set Up JMeter for Testing

The above plugins are zip files and can be extracted to the lib folder of the JMeter installation folder. Once the plugins are installed, JMeter can be started from the bin folder.

The next step is to create Test Plans for the APIs that are required to be benchmarked. I have the following Test Plans for the APIs.

GetCustomers.jmx

  • To performance test non-reactive CustomerController : findById () method.
  • Get Mapping

SaveCustomers.jmx

  • To performance test non-reactive CustomerController : add () method.
  • PostMapping

GetCustomersRx.jmx

  • To performance test reactive CustomerControllerRx : findById () method.
  • Get Mapping

SaveCustomersRx.jmx

  • To performance test reactive CustomerControllerRx : Add () method.
  • PostMapping

The above Test Plans can be opened in JMeter and configured for a different number of concurrent users — E.g.  5, 50, 100, 400, 500 and so on. Now, JMeter test cases can be executed in a non-UI mode as below.

jmeter -n -t  <TestPLan.jmx> -l <TestPlan.jtl>  -e  -o <output folder>

Where:

              -n           run in non-GUI mode

              -t            provide the name of the test file

              -l            name of the output report file

              -e           jMeter to follow post-processing specified in the jmx file.

              -o           dashboard folder.

Step Seven: Benchmark Reactive REST APIs vs. Blocking REST APIs

Start SpringRedisReactiveApplication 

  • Make sure the application starts without errors by connecting to the Redis DB on Docker.
  • Set no of users (threads) and loops (iterations) for the Test Plans.

Open the TestPlan using JMeter UI and change the number of users (threads) and set the number of loops. Save the test plan. Exit JMeter UI.

  • Execute Test Plans

Go to JMeter\bin folder and execute:

jmeter          -n -t  <path>\SaveCustomers.jmx -l <path>\SaveCustomers.jtl

                       -e -o             <path>\SaveCustomersOutput-5Users

The above command will run SaveCustomers.jmx TestCases creates a reporting folder named SaveCustomersOutput-5Users

  • Repeat step 6 (b) and 6 (c) for the other test plans, every time changing the output folder name.
    • SaveCustomersRx.jmx
    • GetCustomers.jmx
    • SaveCustomersRx
  • Repeat step 6 (b), (c) and (d) for 10, 50, 100, 200 and 400 users.

Performance Metrics

Image title

Image title

Image title

Image title


Small no of concurrent users

  • The performance of Blocking APIs is perfectly fine.
  • Performance is affected when the no of users is increased.

A large no of concurrent users

  • non-blocking asynchronous Spring WebFlux APIs performs significantly better.
  • 30 to 40% increase in response times with Reactive components.
  • A threshold is reached when the number of users is about 300.
Topics:
web series ,micro service ,reactive ,reactive microservices ,perfoemance ,jmeter ,redis ,docker

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}