Redisson VS Vert.x

In the final verdict, Reliable Queue is the more durable and feature-rich option. Standard Valkey/Redis streams will suffice for smaller applications, but Reliable Queue provides the enterprise-grade reliability that businesses depend on. To learn more, visit the Redisson PRO website today.

Redis Official Documentation Redisson GitHub Repository

Local caches, like Caffeine, provide extremely fast data retrieval because they operate in memory and are close to the application. These are ideal for reducing response times for frequently accessed data. On the other hand, distributed caches, such as those powered by Redisson with Redis, offer scalability and consistency across multiple instances of an application. Distributed caches ensure all nodes in a distributed system access the same up-to-date data, which is crucial in multi-node environments.

Source code you can find in the GitHub repository. he main idea of this project is the implementation of microservice using Kotlin, Spring WebFlux, PostgresSQL, and Redis with metrics and monitoring and deploying it to k8s. For interacting with PostgresSQL we will use reactive Spring Data R2DBC and for Redis caching using Redisson.

I came up empty handed in search of an alternative to Quartz for scheduling Crons in a clustered/distributed environment. Redisson has a scheduler, but it came with its own issues: - https://github.com/redisson/redisson/issues/4020 - https://github.com/redisson/redisson/issues/3991 - https://github.com/redisson/redisson/issues/4321

4. We use the open-source library Redisson to connect to Redis instance and use Redis as Hibernate 2nd level cache. Please see their Github repo for more information.

Vert.x is the layer where Floci uses things directly. It's Netty with ergonomics: an event loop, a router, protocol-specific APIs for HTTP, DNS, TCP, WebSockets, gRPC, all sharing the same threading model.

Traditionally, JDBC interfaces are all synchronous, so JdbcTemplate and HibernateTemplate are also synchronous. But as asynchronous high-concurrency programming spreads, reactive programming has entered mainstream frameworks. Spring now proposes the R2DBC standard, and the vertx framework includes asynchronous connectors for MySQL, PostgreSQL, etc. On the other hand, if an ORM engine acts as a data fusion access engine, its storage might be async-supported NoSQL sources (Redis, ElasticSearch, MongoDB). ORM also needs to cooperate with a GraphQL async execution engine. Given these, NopOrm’s OrmTemplate adds an asynchronous invocation mode:

The sixth release candidate of Eclipse Vert.x 5.0.0 provides support for the Java Platform Module System and a new VerticleBase class. Further details are available in the release notes.

I see your point, but I still don't think you can just say "If you want to get get a job as a Go developer, you must know gRPC." Even more so for Kafka, I've only heard about it being popular in the Java world. You can't even say "If you want to get a job as a Java developer, you must know Spring." Nowadays, sane Java projects use https://vertx.io, it's just too good. I would argue that Spring is for legacy projects only.

Vert.x is a toolkit for developing reactive applications on the JVM. I wrote a short introductory post about it earlier, when I used it for a commercial project. I had to revisit a Vert.x-based hobby project a few weeks ago, and I learned that there were some gaps in my knowledge about how Vert.x handles failures and errors. To fill those gaps, I did some experiments, wrote a few tests, and then wrote this blog post.

https://vertx.io/

It's actively maintained with full time developers, performant, supports Kotlin out of the box, and has more features?

Hibernate Reactive integrates with Vert.x, but an extension allows to bridge to Project Reactor if wanted

Have you looked at Vert.x?

Explicitly so: