Learn Vert.x - Reactive microservices with Java

Explore the Vertex toolkit for building reactive applications on the JVM, with core concepts like non-blocking I/O, event loops, the event bus, and modules for databases, messaging, and testing.

Bootstraps your first Vertex application with start.vertex.io, uses Java with Gradle, unpacks the zip, imports into IntelliJ, and runs a basic http server on port 888.

Learn how the Vert.x object serves as the application's control center to deploy verticals, spin up an http server with a builder pattern, and respond on port 8088.

Explore Vertex verticals, a scalable, non-blocking concurrency model with multiple event loops and child verticals, and learn to deploy, undeploy, and manage start and stop promises on the event bus.

Deploy multiple instances of a verticle using Vert.x by passing the verticle name and deployment options to set four instances, enabling concurrency across four threads while utilizing CPU resources.

pass a json config to a verticle via deployment options, create id and name fields, and print the config from the verticle start to show consistent configuration.

Configure Vert.x logging with asynchronous log4j2, use Gradle bom for dependency management, and implement a log4j2.xml with pattern layout for colorized, structured logs.

Explore how non-blocking event loop threads enable parallel task processing, why never blocking the event loop matters, and how worker threads handle blocking I/O.

Learn to run blocking operations on a Vertex worker pool or worker vertical with executeBlocking, using deployment options to keep the event loop responsive.

Learn how vertex applications structure and enable inter-vertical communication through the event bus, the nervous system of vertex. Explore publish-subscribe, point-to-point, and request-response messaging with hands-on examples.

Demonstrate request–response messaging on the Vert.x event bus by deploying a request and a response vertical, sending a message to a custom address, and replying.

Demonstrate point to point messaging on the event bus by wiring sender and receiver verticals, using a named address and a periodic timer for one-way, thread-safe communication.

Learn how the vertex event bus enables publish-subscribe messaging by broadcasting a message to multiple subscribers on the same address, with a publisher and two subscribers deployed and periodically publishing.

Learn how Vert.x provides a json object and json array in Java, encode and decode json, map java objects, and test with JUnit five using a json object example.

Explore the Json array object in vert.x, learning that an array holds numbers, strings, booleans, or objects. Build, encode, and test arrays containing Json objects and mixed content.

maps a Java object to and from json using Vertex version four, with a person class (id, name, loves vertex) and Jackson core/data bind for deserialization.

Learn to send json objects and arrays over the vertex event bus in a thread-safe way, building json objects with dot put and returning a json array as the response.

Learn to send custom Java objects over the vert.x event bus by implementing a ping pong example with a custom codec, plus error handling and asynchronous checks.

Learn how to send Java objects over the vert.x event bus using a custom local message codec. You'll explore immutability, codec registration, and how JSON objects and types are handled.

Learn how Vert.x uses asynchronous event loops to scale efficiently and avoid callback hell. Understand how a promise yields an eventual value and a future reads it.

Demonstrate vertex promise and future in unit tests, using a vertex extension with JUnit to access the vertex instance, event loops, bus, timers, and complete or fail flows.

Learn to work with futures in Vert.x by mapping promise results, chaining futures, and coordinating tasks with composite futures such as all, any, and join.

Use the vertex launcher to achieve clean start and stop for vertex applications, bundle a fetcher with Gradle, and run via IntelliJ.

Enable live redeploy in the vertex launcher to restart the application and deploy new code during development, using run configurations and redeploy arguments for quick testing.

Bundle a Vert.x fat jar into a Docker container using a Dockerfile and Java 11 base image. Expose port 8888, run the container, and verify http server outputs hello world.

Bundle your Java application into a Docker container using Google Jib, enabling daemonless builds with Maven or Gradle plugins and no Docker files.

Discover how Vertex powers reactive Java microservices by building a stockbroker rest API with non blocking endpoints and a web client, using Netty, Jackson json binding, Http/2, WebSockets, and RxJava2.

Bootstraps a Vert.x web project, selects version four with Maven, adds the Vertex web dependency, configures Logback, deploys the main vertical, and starts the http server on port 8088.

Create a Vertex web router and a http get endpoint that returns a json array of objects, showcasing routing, logging, and refactoring into an assets rest api.

Implement a custom asset object for the rest api, add a global failure handler to return structured json errors, and enable serialization with jackson databind.

Configure project Lombok to reduce boilerplate by generating getters and builders for Maven or Gradle projects. Enable annotation processing in IntelliJ and use the add value annotation for immutable classes.

Add a new quotes rest api endpoint with a path parameter, returning a json quote for a given asset and verify behavior with a junit test using vert.x http routing.

Create an in-memory store of assets to power the quotes rest api, syncing assets with a cache of quotes, and return an error when an asset is not found.

Implement a custom http response for missing assets in a Vert.x rest api, returning 404 with a structured json error message and leveraging an in-memory cache and endpoint tests.

Master building a watch list rest api with vert.x in java, adding http put, get, and delete endpoints, in-memory storage per account, and json mapping.

Enable and register the body handler in Vert.x, chain pre-handlers for requests, and implement a working http put and follow-up get with json body handling.

Implement a http delete endpoint for the watch list rest api by parsing the account id from the path and deleting the watch list entry in the in-memory map.

Set the http content-type header to application Json in a rest API and verify it with a test assertion, ensuring the assets rest API returns the correct header.

Define custom headers with Vertex web using put header, send them in http responses, fetch via the assets rest api web client, and verify with test asserts.

Refactor http handlers by introducing dedicated get assets, get quote, and watchlist handlers that implement the Vertex handler interface and use routing context, improving testability and end-to-end endpoint clarity.

Learn to scale a non-blocking http server with Vertex by deploying multiple servers on separate event loops and CPU cores, and move rest API routes to a dedicated vertical.

scale the rest api vertically, introduce a 200 ms artificial delay, and run a Witchita load test with four workers across four event loops to measure latencies and 100% success.

Configure a vertex application using vertex config with multiple stores in json, properties, and yaml formats, and apply environment variable filtering and priority rules.

Use the vertex config module to load server port from environment variables, replacing the hard-coded port and enabling dynamic port selection for the http server.

Learn how to configure the Vert.x server port with environment variables and system properties, add multiple config stores, and understand how store order overrides values.

Configure a test port of 9000 and update web client to use it, enabling tests by extending an abstract rest api test and bootstrapping port via environment and system properties.

Learn to read configuration from a yaml file in Vert.x by adding a yaml store, wiring it to the config retriever, and mapping the version from application.yaml into broker config.

Explore the vertex reactive sql client, a non-blocking, high-performance tool that uses multi-connection pools on one event loop and via sql templates supports PostgreSQL, MySQL, SQL Server, and IBM DB2.

Spin up a PostgreSQL database with Docker using docker run or docker compose. Connect to it and verify via IntelliJ's database tool and the admin tool.

Set up Flyway to version-control the database schema, configure db config, migrate on startup, log the migration status, and show pending migrations.

Create a Flyway migration (0.1) to build assets and quotes tables with snake_case fields, a foreign key, and checks; then verify migrations and review the schema history.

Extend the config loader to load db host, db port, db database, db user, and db password from environment variables and expose them in the db config object.

Use Vertex's reactive sql client for non-blocking, event loop–based relational access, with four connections per thread and one pool per vertical that scales with rest api verticals.

Configure a Postgres database pool per rest API vertical with the vertex pg client at server startup using host, port, database, user, and password; default max pool size is four.

Create a new assets endpoint with the Vertex reactive sql client and PostgreSQL pool to fetch assets from broker.assets, returning a json array and logging errors.

Learn to map sql query results to custom Java objects using Vertex's sql client template library, define templates, and expose a rest endpoint to fetch quotes.

Learn to map watchlist rows to vertex json objects using sql template, expose a get endpoint under /account/watchlist, and return a json array of assets for an account.

Extend the watchlist rest api with a put endpoint that uses a sql template to insert watchlist data into the database, mapping body to watchlist objects.

Replace for-each inserts with a batch operation in a Vert.x Java microservice, construct parameter maps, execute batch inserts, and handle duplicates with on conflict, http 204.

Create an http delete endpoint in the watchlist rest api using a sql template to delete by account, via a database pool and a Vert.x handler, returning 204.

Implement database transactions with Vert.x by deleting and re-inserting watch list items inside a single transaction, using Vertex futures compose to chain operations and ensure rollback on failure.

Switch from Postgres to MySQL with the Vert.x reactive SQL client, configure MySQL options, create a MySQL pool, and execute queries using client.query.

Configure a reactive MySQL client in a Vert.x project by creating a DB pools factory for postgres and mysql, updating dependencies and run configs, and ensuring Flyway migrations connect correctly.

Configure flyway to use MySQL as the data store by updating jdbc driver dependencies, migration code, and sql syntax, validate migrations, and verify data via a rest endpoint.

Explore Mutiny, a simple reactive library for Java built on the Reactive Streams API, with uni and multi types, designed for seamless use with vertex and Quarkus.

Learn Mutiny's uni in a Java application by creating a uni that emits one item or a failure, transforming it, and subscribing to log the result.

Learn to use Mutiny's multi to create streams, transform numbers by doubling and converting to strings, and log results. Handle failures with recover and per-step error handlers.

Integrate mutiny into a vert.x core and web app to build a reactive, non-blocking http server with routes and json responses using mutiny and vert.x bindings.

Build reactive microservices with Vert.x and Mutiny by querying a Postgres database via the reactive sql client, transforming rows into a json array of users for the api.

Explore how Quarkus uses Vert.x for reactive, non-blocking microservices, with Mutiny models like Uni and Multi, reactive database access, and native compilation with GraalVM.

Set up a Quarkus project by selecting extensions rest easy, hibernate reactive with panache, and reactive Postgres client, using website, IntelliJ, or Maven to generate and run in dev mode.

Explore building a reactive API with Quarkus, Hibernate Reactive, Panache, and Mutiny, backed by PostgreSQL, exposing /users and demonstrating Vertex in the background.

Deploy Vert.x verticles in a Quarkus application using Mutiny integration, creating a periodic user fetcher that logs every five seconds. Leverage a vertical deployer to auto-deploy verticals on startup.

Learn to expose Quarkus rest endpoints using Vert.x types, return JSON arrays, and proxy requests with Mutiny Vert.x web client, injecting Vertex instance for a reactive Quarkus app.

Learn to integrate vert.x with a quarkus application by publishing and consuming user data on the event bus, using a web client and mutiny to fetch from a rest endpoint.

Explore Vertex and WebSocket fundamentals, compare persistent full-duplex connections with REST, and learn to build a simple WebSocket server, handle frames, broadcast to clients, and connect a WebSocket client.

Bootstraps a Vert.x project to implement a simple WebSocket server in Java, showing how to accept connections, send a 'connected' message, and log events on port 8900 for reactive microservices.

Learn to implement a price broadcaster with a Vert.x WebSocket server that registers connected clients, broadcasts updates every second, and handles client connect/disconnect via a HashMap and a periodic timer.

Create a Vert.x websocket client unit test that connects to the websocket server, receives the message 'connected', and asserts its content.

Celebrate finishing the Learn Vertex Chorus and recap core concepts like the vertex event loop, how to use vertex, the vertex event bus, promises and futures, and directive database access.