Quarkus 3.0.0: A New Era for Java Development
Quarkus is an innovative framework that aims to make Java development faster, lighter, and more enjoyable. Quarkus combines the best-of-breed libraries and standards with a build-time optimization approach that produces native executables or containers with minimal footprint and startup time.
On April 26, 2023, Quarkus 3.0.0 was officially released, marking a new milestone in the evolution of the framework. Quarkus 3.0.0 is based on the latest versions of Jakarta EE and Eclipse MicroProfile, which introduce new APIs and packages for modern enterprise applications. Quarkus 3.0.0 also comes with a revamped Dev UI, a new gRPC server, an upgrade to Hibernate ORM 6, HTTP/3 support, io_uring integration, virtual threads, and structured concurrency support, and many other features and enhancements.
In this article, we will explore some of the highlights of Quarkus 3.0.0 and how they can benefit Java developers.
Jakarta EE 10 and Eclipse MicroProfile 6
One of the most significant changes in Quarkus 3.0.0 is the migration from Jakarta EE 8 to Jakarta EE 10 and from Eclipse MicroProfile 4 to Eclipse MicroProfile 6. These are the latest versions of the standards that define the core APIs and specifications for enterprise Java development.
Jakarta EE 10 is the first release of Jakarta EE under the jakarta.* namespace, following the transfer of the Java EE trademarks from Oracle to the Eclipse Foundation. This means that all the javax.* packages from Jakarta EE have been moved to jakarta.* packages, requiring changes in any source code and dependencies that rely on them.
Eclipse MicroProfile 6 is the latest update of the MicroProfile specifications that complement Jakarta EE with additional features for building cloud-native microservices. Eclipse MicroProfile 6 aligns with Jakarta EE 10 Core Profile and replaces MicroProfile OpenTracing with MicroProfile Telemetry.
The benefits of moving to Jakarta EE 10 and Eclipse MicroProfile 6 include:
- Better alignment with the broader Java ecosystem, which is also moving to Jakarta dependencies, allowing for easier sharing and compatible implementations.
- More flexibility and choice for developers, as Jakarta EE 10 introduces a Core Profile that defines a minimal set of APIs for web applications, and a Full Profile that adds more APIs for enterprise applications.
- Improved CDI support, as Jakarta EE 10 introduces CDI Lite and Build Compatible Extensions (BCE), which enable standard extensions that are compatible across CDI implementations and reap the benefits of Quarkus build time optimizations.
- Enhanced observability and tracing capabilities, as Eclipse MicroProfile 6 introduces MicroProfile Telemetry, which provides a unified API for metrics, health checks, distributed tracing, and fault tolerance.
New Dev UI
Quarkus 2 introduced the Dev UI, which provides a web UI to use during development. Extensions could provide their own Dev UI pages to provide additional functionality.
Quarkus 3.0.0 now has a new Dev UI that is more extensible and easier to use. It also has a new and much-improved look and feel.
The new Dev UI is available by default at /q/dev (but it’s actually hosted at /q/dev-ui). The old Dev UI is still accessible at /q/dev-v1 and will be retired once all its features have been ported to the new Dev UI.
Some of the biggest challenges for developers is to reduce the size and startup time of their applications. Hibernate ORM 6.2 addresses this issue by providing better support for bytecode enhancement, which enables lazy loading and other optimizations at runtime. Hibernate ORM 6.2 also introduces a new way of handling entity state transitions, called Reactive Entity State Transfer (REST), which provides better performance and scalability for highly concurrent applications.
HTTP/3 support Quarkus 3.0.0 also introduces support for HTTP/3, the latest version of the HTTP protocol that promises better performance and security than HTTP/2. HTTP/3 is based on QUIC (Quick UDP Internet Connections), a new transport protocol that aims to reduce latency and improve reliability over the Internet.
Quarkus 3.0.0 uses Netty 5 as the default network stack, which supports HTTP/3 out of the box. Netty 5 also provides better support for reactive programming and asynchronous I/O, which are essential for building scalable and responsive applications.
io_uring integration Another exciting feature of Quarkus 3.0.0 is the integration with io_uring, a new asynchronous I/O interface for Linux that provides better performance and scalability than traditional I/O interfaces like epoll and select.
Quarkus 3.0.0 leverages the io_uring support in Netty 5 to provide better performance for I/O-bound operations like file access and network communication. This can significantly improve the throughput and latency of your applications, especially in highly concurrent scenarios.
Virtual threads and structured concurrency Quarkus 3.0.0 also introduces support for virtual threads, a new feature in Java 17 that provides lightweight threads that are managed by the JVM. Virtual threads enable developers to write concurrent code that is easier to reason about and debug than traditional threads, without incurring the overhead of thread creation and context switching.
Quarkus 3.0.0 also provides support for structured concurrency, a new programming model that enables developers to write asynchronous code that is easier to read and maintain than traditional callback-based or future-based APIs. Structured concurrency provides a way to compose and control the lifecycle of concurrent tasks, ensuring that they complete in a predictable and deterministic way.
Conclusion
Quarkus 3.0.0 is a major release that brings many new features and enhancements to the framework. The migration to Jakarta EE 10 and Eclipse MicroProfile 6 provides better alignment with the broader Java ecosystem and enhances CDI support and observability capabilities. The new Dev UI makes it easier to develop and debug applications, while the upgrade to Hibernate ORM 6.2 provides better performance and scalability for data access. HTTP/3 support, io_uring integration, virtual threads, and structured concurrency provide better performance and scalability for I/O-bound and concurrent operations.
Quarkus 3.0.0 marks a new era for Java development, enabling developers to build faster, lighter, and more enjoyable applications than ever before. If you haven’t tried Quarkus yet, now is a great time to start!
Do support our publication by following it
