Micronaut Framework Overview

Description

OVERVIEW OF MICRONAUT FRAMEWORK

               Micronaut is an open source JVM-based software framework for building lightweight, modular application. Micronaut is known for its ability to help developers create apps and microservices with small memory footprint and short startup times. An advantage of the Micronaut frameworks is that startup time and memory consumption are not tied to the size of an app's codebase.Micronaut analyze metadata as soon as the application is compiled. During this compilation phase Micronaut will generate an additional set of classe that represent the state of the application already preconfigured. This enables dependency injection and aspect-oriented programming behavior to be applied much more efficiently when the applications finally run.

Micronaut provide native support for service discovery, distributed configuration, client-side load balancing and authentication.The Micronaut framework was designed for building and testing low-memory microservices, serverless applications and message-driven microservices.It does not make use of  traditional Java frameworks, including runtime reflection for dependency injection, dynamic classloading, runtime byte code generation and proxy generation.

Micronaut does not use Java Reflection APIs. Instead, it integrates directly with the Java compiler through annotation processors. This allows Micronaut to compute an additional set of classes that sit alongside user-defined classes. The classes serve to perform dependency injection, as well as define compilation time and aspect-oriented proxies in a completely reflection-free manner.Micronaut integrates directly with language compilers, however, the only JVM languages Micronaut can currently support are Java, Kotlin or Groovy .

Micronaut applications can be compiled into GraalVM native images to reduce startup times even more. GraalVM uses a closed-world static analysis approach to produce native images that require configuration for any dynamic parts of the application. Micronaut's relative lack of reflection and dynamic classloading mean that less configuration is required to get a GraalVM native image operational.

Assuming, we have the following main class defined, we only need to run it:

public class MainApp {

    public static void main(String[] args) {
        Micronaut.run(MainApp.class);
    }

}
 

Micronaut supports the development, testing and deployment of serverless functions for many different cloud providers, including AWS Lambda, Oracle Functions, Google Cloud Functions and Azure Functions.Micronaut CLISDKManThe Micronaut framework provides a solid foundation for building Cloud native Java microservices based on a compilation-time approach. Tight integration with GraalVM Native Image Ahead-of-Time Compilation (AOT) makes it easy to convert applications to native executables, which has massive benefits, particularly for serverless and microservice workloads. Active compilation-time checking increases type safety and improves developer productivity by surfacing errors at build time rather than runtime. A large ecosystem of modules and integrations, such as Micronaut Data for database access, has helped provide further innovations within the Micronaut framework.Oracle Labs does not only own GraalVM but also, in addition to Object Computing, contributes significantly to the Micronaut framework's ongoing development.

Why Should I Use the Micronaut Framework?

The goal of the Micronaut framework is to provide a lightweight alternative to traditional Java frameworks by eliminating completely the dynamic parts of these frameworks that use features such as Java reflection, dynamic class loading, and the runtime generation of proxies and byte code.The elimination of these aspects of traditional frameworks has a profound impact on improving performance, memory consumption, security, robustness, ease of debugging, and testing. And unlike other solutions, a Micronaut framework application starts up quickly in the JVM, too!The improvements to startup time often completely eliminate the need to split code between integration and unit testing, greatly improving the code to test cycle time. Too often in the past, we wrote fewer integration tests because the application started up too slowly. The Micronaut framework eliminates this concern and hence doesn’t include extensive mocking facilities for the HTTP layer. Many frameworks do in order to avoid the cost of having to start the application.Eliminating reflection also helps debugging with a reduction in the size of stack traces which can often be enormous in traditional frameworks. The Micronaut framework also provides mechanisms and APIs to shift your own code to build-time approaches. That’s why, by integrating directly with the Java compiler, the Micronaut framework can and does produce compilation errors when annotations are used incorrectly, improving the type safety of code and overall developer experience.