Eclipse Vert.x is event driven and non blocking. This means your app can handle a lot of concurrency using a small number of kernel threads. Vert.x lets your app scale with minimal hardware.
import io.vertx.core.AbstractVerticle;
public class Server extends AbstractVerticle {
public void start() {
vertx.createHttpServer().requestHandler(req -> {
req.response()
.putHeader("content-type", "text/plain")
.end("Hello from Vert.x!");
}).listen(8080);
}
}
vertx.createHttpServer()
.requestHandler(function (req) {
req.response()
.putHeader("content-type", "text/plain")
.end("Hello from Vert.x!");
}).listen(8080);
vertx.createHttpServer().requestHandler({ req ->
req.response()
.putHeader("content-type", "text/plain")
.end("Hello from Vert.x!")
}).listen(8080)
$vertx.create_http_server().request_handler() { |req|
req.response()
.put_header("content-type", "text/plain")
.end("Hello from Vert.x!")
}.listen(8080)
import io.vertx.ceylon.core { ... }
import io.vertx.ceylon.core.http { ... }
shared class Server() extends Verticle() {
start() => vertx.createHttpServer()
.requestHandler((req) =>
req.response()
.putHeader("content-type", "text/plain")
.end("Hello from Vert.x!")
).listen(8080);
}
import io.vertx.lang.scala.ScalaVerticle
class Server extends ScalaVerticle {
override def start(): Unit = {
vertx
.createHttpServer()
.requestHandler(_.response()
.putHeader("content-type", "text/plain")
.end("Hello from Vert.x"))
.listen(8080)
}
}}
import io.vertx.core.AbstractVerticle
class Server : AbstractVerticle() {
override fun start() {
vertx.createHttpServer()
.requestHandler { req ->
req.response()
.putHeader("content-type", "text/plain")
.end("Hello from Vert.x")
}.listen(8080)
}
}
$vertx->createHttpServer()
->requestHandler(function ($req) {
$req->response()
->putHeader("content-type", "text/plain")
->end("Hello from Vert.x!");
})->listen(8080);
You can use Vert.x with multiple languages including Java, JavaScript, Groovy, Ruby, Ceylon, Scala, Kotlin and Php.
Vert.x doesn't preach about what language is best — you choose the languages you want based on the task at hand and the skill-set of your team.
We provide idiomatic APIs for every language that Vert.x supports.
Vert.x is incredibly flexible - whether it's simple network utilities, sophisticated modern web applications, HTTP/REST microservices, high volume event processing or a full blown back-end message-bus application, Vert.x is a great fit.
Vert.x is used by many different companies from real-time gaming to banking and everything in between.
Vert.x is not a restrictive framework or container and we don't tell you a correct way to write an application. Instead we give you a lot of useful bricks and let you create your app the way you want to.
Need some guidance? We provide a large selection of examples to get you started for the particular type of application you want to write.
Enjoy being a developer again.
Unlike restrictive traditional application containers, Vert.x gives you incredible power and agility to create compelling, scalable, 21st century applications the way you want to, with a minimum of fuss, in the language you want.
Vert.x is lightweight - Vert.x core is around 650kB in size.
Vert.x is fast. Here are some independent numbers.
Vert.x is not an application server. There's no monolithic Vert.x instance into which you deploy applications. You just run your apps wherever you want to.
Vert.x is modular - when you need more bits just add the bits you need and nothing more.
Vert.x is simple but not simplistic. Vert.x allows you to create powerful apps, simply.
Vert.x is an ideal choice for creating light-weight, high-performance, microservices.
Have a private enquiry about Vert.x? Please contact us.
