Continuando minha busca por comparações de desempenho, este artigo é sobre Node.js e Springboot. Spring boot é uma tecnologia de servidor leve construída sobre Java que é usada principalmente para serviços da web. O Spring Boot facilita a criação de aplicativos autônomos baseados em Spring de nível de produção que você pode “simplesmente executar”. Spring boot é bastante popular no mundo java.

Quem você acha que é mais rápido para um caso simples de hello world? Acho que a resposta pode ser Springboot porque é compilado em código de byte enquanto o Node.js é interpretado. Se você estiver interessado em descobrir a resposta correta, continue lendo. Você pode se surpreender!

Configurar

O teste é executado no MacBook Pro M1 com 16G de RAM. O teste é executado usando o conhecido testador de HTTP: Bombardier . O teste é executado para 50, 100 e 200 conexões simultâneas.

As versões são:

• Node.js v19.6.0
• Springboot 3.0.2 com Java17

Node.js

O código Node.js possui um roteador mínimo que o torna equivalente à funcionalidade fornecida pelo servidor nativo do Spring.

import http from "node:http";

http.createServer((req, resp) => {
  try {
    if (req.method !== "GET") {
      return resp.writeHead(405).end();
    }
    if (req.url !== "/") {
      return resp.writeHead(404).end();
    }
    resp.writeHead(200, {
      "content-type": "text/plain",
    });
    resp.end("Hello world");
  } catch (e) {
    resp.writeHead(500).end();
  }
}).listen(3000);

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.http.ResponseEntity;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @GetMapping("/")
    public String handleRequest() {
        return "Hello World!";
    }
}

Um total de 5 milhões (5 milhões) de solicitações são executadas para cada nível de simultaneidade.

As seguintes medições são feitas:

• Tempo gasto
• Solicitações por segundo
• Latências : média, mediana, q25, q75, q90, máximo (em milissegundos)
• Uso do sistema : uso médio de CPU e memória

Aqui estão os gráficos que representam os resultados para cada tipo de medição:

(Observe que todas as latências estão em milissegundos)

minha análise

Primeiro, Spring/Java é um aplicativo com muitos recursos. Para um caso simples de hello world com 200 conexões simultâneas, o Spring usa ~ 190% da CPU e 470 MB de memória. Comparativamente, o Node.js usa 95% da CPU e 82M de memória.

Agora, para as latências, as latências da primavera são menores que as do Node.js até o terceiro quartil. O Spring falha com leituras de latência máxima que duram segundos, enquanto a latência máxima do Node.js atinge 123ms. Mesmo a latência média do Spring (0,6 ms) é significativamente melhor do que a do Node.js (2,5 ms).

Para concluir, o Node.js oferece mais RPS usando significativamente menos recursos do sistema.

ATUALIZAÇÃO : Como este artigo ficou bastante popular na comunidade, recebi comentários de que a comparação do servidor nativo do Node com um framework como o Springboot é injusta. Um ponto muito válido. Já publiquei artigos para comparar Express e Fastify com Springboot. Os links são:

• Expresso vs Springboot
• Fastify vs Springboot

• Expresso vs Spring Webflux
• Fastify vs Spring Webflux