The NoSQL database that
lives inside your JVM.

EmbedJNoSQL is synchronous and in-process. The single rule for Vert.x: never call it directly from the event loop. Wrap with executeBlocking() in route handlers, or deploy as a Worker Verticle for batch/event-bus workloads.

public class ProductVerticle extends AbstractVerticle {
    private EmbedJNoSQL db;
    private DocumentCollection products;

    @Override
    public void start(Promise<Void> startPromise) {
        // ✅ Safe — called once at startup, not on the hot event loop
        db = EmbedJNoSQL.create(EmbedJNoSQLConfig.builder()
            .storageEngine(IN_MEMORY).buildConfig());
        products = db.documentCollection("products");

        Router router = Router.router(vertx);
        router.get("/api/products").handler(this::getAll);
        vertx.createHttpServer().requestHandler(router).listen(8080)
            .onSuccess(s -> startPromise.complete());
    }

    private void getAll(RoutingContext ctx) {
        // ⚠️  executeBlocking keeps the event loop free
        vertx.<List<Product>>executeBlocking(() ->
            products.findAll().stream().map(Product::fromDocument).toList()
        ).onSuccess(list -> ctx.response()
            .putHeader("content-type", "application/json")
            .end(Json.encode(list)))
         .onFailure(ctx::fail);
    }
}

public class DbWorkerVerticle extends AbstractVerticle {
    private EmbedJNoSQL db;

    @Override
    public void start() {
        db = EmbedJNoSQL.open("./data/myapp");
        vertx.eventBus().<JsonObject>consumer("db.products.upsert", msg -> {
            try {
                Product p = msg.body().mapTo(Product.class);
                db.documentCollection("products").insert(p.toDocument());
                msg.reply(new JsonObject().put("status", "ok"));
            } catch (Exception e) { msg.fail(500, e.getMessage()); }
        });
    }
    @Override
    public void stop() { if (db != null) db.close(); }
}

// Deploy as a worker (thread-pool isolated)
vertx.deployVerticle(new DbWorkerVerticle(),
    new DeploymentOptions().setWorker(true));

Javalin handles requests on virtual threads (Java 21+) or regular threads — both are fine for synchronous EmbedJNoSQL calls. Open once, share, close on shutdown.

public class Application {
    public static void main(String[] args) {
        EmbedJNoSQL db = EmbedJNoSQL.inMemory();
        DocumentCollection users = db.documentCollection("users");

        var app = Javalin.create().start(8080);

        app.get("/users", ctx -> ctx.json(users.findAll()));
        app.post("/users", ctx -> {
            var doc = ctx.bodyAsClass(Map.class);
            users.insert(Document.of(doc));
            ctx.status(201).json(doc);
        });

        Runtime.getRuntime().addShutdownHook(
            new Thread(() -> { app.stop(); db.close(); }));
    }
}

Helidon SE 4 routes run on Java virtual threads — blocking I/O (including EmbedJNoSQL) is perfectly safe without any wrapping.

EmbedJNoSQL db = EmbedJNoSQL.open("./data");
DocumentCollection products = db.documentCollection("products");

WebServer server = WebServer.builder()
    .routing(rules -> rules
        .get("/products",
            (req, res) -> res.send(products.findAll()))
        .post("/products", (req, res) -> {
            // Virtual thread — blocking is fine
            var doc = req.content().as(Map.class);
            products.insert(Document.of(doc));
            res.status(201).send();
        }))
    .port(8080).build().start();

Runtime.getRuntime().addShutdownHook(
    new Thread(() -> { server.stop(); db.close(); }));

Dropwizard's managed lifecycle makes it easy to open and close EmbedJNoSQL in sync with the application lifecycle.

public class MyApplication extends Application<MyConfiguration> {

    @Override
    public void run(MyConfiguration cfg, Environment env) {
        EmbedJNoSQL db = EmbedJNoSQL.open(cfg.getDataDir());

        env.jersey().register(new ProductResource(
            db.documentCollection("products")));

        // Managed lifecycle: Dropwizard calls stop() on shutdown
        env.lifecycle().manage(new Managed() {
            public void start() {}
            public void stop() { db.close(); }
        });
    }
}

The universal pattern for any JVM framework — servlet, reactive, or otherwise.

// 1. OPEN — once at application startup
EmbedJNoSQL db = EmbedJNoSQL.open("./data/myapp");

// 2. USE — from any thread; the instance is thread-safe
DocumentCollection col = db.documentCollection("events");
col.insert(Document.of("type", "BOOT_UP")
    .add("timestamp", System.currentTimeMillis()));

// 3. CLOSE — on graceful shutdown
Runtime.getRuntime().addShutdownHook(
    new Thread(db::close));