Скорость работы Vapor по сравнению с другими веб-фреймворками

Vapor и Express оказались быстрейшими в рамках конкурса, конкурируя с чистым Go.

import Vapor import Fluent import FluentSQLite  let app = Application()  do {     let driver = try SQLiteDriver(path: "/home/helper/database/test.sqlite")     Database.default = Database(driver: driver) } catch {     print("Could not open SQLite database: \(error)") }  app.get("plaintext") { request in     return "Hello, world!" }  app.get("json") { request in     return JSON([         "array": [1, 2, 3],         "dict": ["one": 1, "two": 2, "three": 3],         "int": 42,         "string": "test",         "double": 3.14,         "null": nil     ]) }  app.get("sqlite-fetch") { request in     guard let user = try User.random() else {         throw Abort.notFound     }      return user }  app.globalMiddleware = []  app.start() 

class BenchmarkController < ActionController::Base    def plaintext       render plain: "Hello world"    end     def json       a = [1, 2, 3]       d = {"one" => 1, "two" => 2, "three" => 3}        r = {"array" => a, "dict" => d, "int" => 42, "string" => "test", "double" => 3.14, "null" => nil}               render :json => r    end     def sqlite        r = ActiveRecord::Base.connection.exec_query("SELECT * FROM users ORDER BY random() LIMIT 1")        render :json => r    end end 

production:   <<: *default   database: /home/helper/database/test.sqlite 

Rails.application.routes.draw do   get 'plaintext' => 'benchmark#plaintext'   get 'json' => 'benchmark#json'   get 'sqlite-fetch' => 'benchmark#sqlite' end 

using System; using System.IO; using System.Linq; using System.Reflection; using Dapper; using Microsoft.Data.Sqlite; using Nancy;  namespace NancyVsVapor {     public class HomeModule : NancyModule     {         private static string connstring = string.Concat("Data Source=", Path.Combine(             Path.GetDirectoryName(typeof(HomeModule).GetTypeInfo().Assembly.Location),             "test.sqlite"));          private static Random random = new Random();          public HomeModule()         {             Get("/plaintext", _ => "Hello, World!");              Get("/json", _ =>             {                 return Response.AsJson(new JsonModel());             });              Get("sqlite-fetch", async (_, __) =>             {                 using (var conn = new SqliteConnection(connstring))                 {                     var users = await conn.QueryAsync<User>("select * from users where id = @id", new { id = random.Next(1, 3) });                     return Response.AsJson(users.FirstOrDefault());                 }             });         }     } } 

server {     listen 8701;      root /home/helper/laravel-tanner/benchmark/public;     index index.php index.html index.htm;      server_name 107.170.131.198;      location / {         try_files $uri $uri/ /index.php?$query_string;     }      location ~ \.php$ {         try_files $uri /index.php =404;         fastcgi_split_path_info ^(.+\.php)(/.+)$;         fastcgi_pass unix:/var/run/php5-fpm.sock;         fastcgi_index index.php;         fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;         include fastcgi_params;     } } 

<?php use DB; Route::get('/plaintext', function() {     return 'Hello, world!'; }); Route::get('/json', function() {     return [         'array' => [1, 2, 3],         'dict' => [             'one' => 1,             'two' => 2,             'three' => 3         ],         'int' => 42,         'string' => 'test',         'double' => 3.14,         'null' => null     ]; }); Route::get('/sqlite-fetch', function() {     return DB::select('SELECT * FROM users ORDER BY random() LIMIT 1'); }); 

<?php $app->get('/plaintext', function() {     return 'Hello, world!'; }); $app->get('/json', function() {     return [         'array' => [1, 2, 3],         'dict' => [             'one' => 1,             'two' => 2,             'three' => 3         ],         'int' => 42,         'string' => 'test',         'double' => 3.14,         'null' => null     ]; }); $app->get('/sqlite-fetch', function() {     return \DB::select('SELECT * FROM users ORDER BY random() LIMIT 1'); }); 

var cluster = require('cluster');  if(cluster.isMaster) { 	var cpuCount = require('os').cpus().length;      for(var i = 0; i < cpuCount; i += 1) { 		cluster.fork(); 	}  	cluster.on('exit', function(worker) { 		console.log('Worker %d died, replacing', worker.id); 		cluster.fork(); 	}); } else { 	var app = require('./app.js');  	app.app.listen(app.port, function() { 		console.log('Benchmarking worker %d listening on %d', cluster.worker.id, app.port) 	}); } 

const express = require('express'); const app = express();  const sqlite3 = require('sqlite3'); const db = new sqlite3.Database('../database/test.sqlite');  app.get('/plaintext', function(req, res) {         res.setHeader('Content-Type', 'text/plain');         res.send('Hello, World!'); });  app.get('/json', function(req, res) {         res.send({                 array: [1, 2, 3],                 dict: {                         one: 1,                         two: 2,                         'three': 3                 },                 int: 42,                 string: 'test',                 double: 3.14,                 'null': null         }); });  app.get('/sqlite-fetch', function(req, res) {         db.get('select * from users where id = ?', Math.floor(Math.random() * 3) + 1, function(err, row) {                 if(err) {                         res.send(err.message);                 } else {                         res.send(row);                 }         }); });  module.exports = {         app: app,         port: 8400 } 

from django.conf.urls import url from django.http import HttpResponse from django.http import JsonResponse from django.db import connection  def plaintext(request):     return HttpResponse('Hello, world')  def json(request):     return JsonResponse({         "array": [1, 2, 3],         "dict": {"one": 1, "two": 2, "three": 3},         "int": 42,         "string": "test",         "double": 3.14,         "null": None     })  def sqlite(request):     cursor = connection.cursor()     cursor.execute("SELECT * FROM users ORDER BY random() LIMIT 1")     row = cursor.fetchone()      return JsonResponse(row, safe=False)  urlpatterns = [     url(r'^plaintext', plaintext),     url(r'^json', json),     url(r'^sqlite-fetch', sqlite) ] 

import sys import flask import random import sqlite3 import logging import socket  logging.basicConfig(level=logging.WARNING, format='%(levelname)s: %(message)s')  app = flask.Flask(__name__)  application = app  db = sqlite3.connect('./test.sqlite') conn = db.cursor() conn.row_factory = sqlite3.Row  @app.route("/plaintext") def plaintext():     return "Hello, world!"  @app.route("/json") def json():     return flask.jsonify(**{         "array": [1, 2, 3],         "dict": {"one": 1, "two": 2, "three": 3},         "int": 42,         "string": "test",         "double": 3.14,         "null": None     })  @app.route("/sqlite-fetch") def sqlite_fetch():     id = random.randint(1, 3)     r = conn.execute("select * from users where id = ?", (id,)).fetchone()     if r is not None:         d = dict(zip(r.keys(), r))         return flask.jsonify(d)     else:         flask.abort(404)   if __name__ == "__main__":     port = 8137     print 'Listening on port %s' % port     while True:         try:             app.run(port=port, host="107.170.131.198")             sys.exit(0)         except socket.error as e:             logging.warn("socket error: %s" % e) 

package main  import (         "encoding/json"         "flag"         "fmt"         "io"         "log"         "net/http"          "github.com/jmoiron/sqlx"         _ "github.com/mattn/go-sqlite3" )  func Plaintext(w http.ResponseWriter, req *http.Request) {         io.WriteString(w, "Hello World!\n") }  type JSONStruct struct {         Array  []int          `json:"array"`         Dict   map[string]int `json:"dict"`         Int    int            `json:"int"`         String string         `json:"string"`         Double float64        `json:"double"`         Null   interface{}    `json:"null"` }  func JSON(w http.ResponseWriter, req *http.Request) {         j := JSONStruct{Array: []int{1, 2, 3},                 Dict:   map[string]int{"one": 1, "two": 2, "three": 3},                 Int:    42,                 String: "test",                 Double: 3.14,                 Null:   nil}          b, _ := json.MarshalIndent(j, "", " ")         io.WriteString(w, string(b)) }  type User struct {         ID    int    `db:"id" json:"id,omitempty"`         Name  string `db:"name" json:"name,omitempty"`         Email string `db:"email" json:"email,omitempty"` }  // typical usage would keep or cache the open DB connection var db, _ = sqlx.Open("sqlite3", "../database/test.sqlite")  func SQLiteFetch(w http.ResponseWriter, req *http.Request) {         user := User{}         rows, err := db.Queryx("select * from users order by random() limit 1")         if err != nil {                 log.Fatal(err)         }         defer rows.Close()          for rows.Next() {                 err = rows.StructScan(&user)                 if err != nil {                         log.Fatal(err)                 }                  b, _ := json.MarshalIndent(user, "", " ")                 io.WriteString(w, string(b))         } }  var portNumber int  func main() {         flag.IntVar(&portNumber, "port", 8300, "port number to listen on")         flag.Parse()          http.HandleFunc("/plaintext", Plaintext)         http.HandleFunc("/json", JSON)         http.HandleFunc("/sqlite-fetch", SQLiteFetch)          log.Println("bench running on", fmt.Sprintf("%d", portNumber))          err := http.ListenAndServe(fmt.Sprintf(":%d", portNumber), nil)         if err != nil {                 log.Fatal(err)         } } 

package com.hlprmnky.vapor_spring_benchmark;  import java.util.Arrays; import java.util.List; import java.util.Random; import java.util.concurrent.atomic.AtomicLong;  import com.google.common.collect.ImmutableMap; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController;  @RestController public class ApplicationController {      private final AtomicLong counter = new AtomicLong();     private final Random random = new Random();      @Autowired     private UserRepository userRepository;      @RequestMapping("/json")     public Json json() {         return new Json(counter.incrementAndGet(), Arrays.asList(1, 2, 3),                 ImmutableMap.of("one", 1, "two", 2, "three", 3),                 "test", 42, 3.14);     }      @RequestMapping("/plaintext")     public String plaintext() {         return "Hello, World!";     }      @RequestMapping("/sqlite-fetch")     public User sqliteFetch() {         List<User> allUsers = userRepository.findAll();         return allUsers.get(random.nextInt(allUsers.size()));     } }