Introduction to Light-4J

1. Introduction

Traditional frameworks, while robust, often introduced complexities that challenged agility. Modern development demands frameworks that aren’t just powerful but nimble. Lightweight frameworks, including Light-4J, adopt a minimalistic design philosophy. They focus on providing essential features without unnecessary complexities, thereby reducing the learning curve for developers and prioritizing swift development cycles.

Light-4J is a cutting-edge Java framework that revolutionizes development by combining agility and performance. It embraces modern development paradigms, aligning with the principles of microservices and catering to the needs of today’s dynamic software architecture.

In this tutorial, we’ll delve into its core philosophy, key features, and architectural concepts. We’ll dissect what makes it lightweight and how this quality translates into enhanced development speed and resource efficiency.

Finally, we’ll uncover how it aligns with contemporary development needs by generating a ready-to-use RESTful API project.

2. What Is Light-4J?

The Light platform offers a variety of frameworks tailored for developing diverse API styles or microservices, depending on the contract specifications. Light-4J is a part of the Light platform designed to build cloud-native Web apps and APIs with different options.

It’s a cutting-edge, open-source microservices framework for Java developers, designed to streamline the development and deployment of scalable, lightweight microservices architectures. With a focus on simplicity, efficiency, and optimal performance, Light-4J empowers developers to build robust, modular applications that can seamlessly adapt to the demands of modern software development.

One of the important characteristics of Light-4J is the prioritization of addressing cross-cutting concerns in cloud-native services by embedding a gateway within its frameworks. This gateway seamlessly manages various aspects of the request/response chain. The functionalities are encapsulated into plugins or middleware handlers and are integrated into the framework through an inversion of control (IoC) service during server initialization.

Importantly, developers have the flexibility to enable, disable, or modify the behavior of these plugins through configurations. This design philosophy empowers developers to focus solely on writing business logic, abstracting away the complexities of managing cross-cutting concerns.

Developers can quickly prototype, iterate, and deploy applications, promoting agility in responding to changing requirements and market demands. Moreover, Light-4J reduces the production operation cost by fulfilling millions of requests per second. This results in lower memory consumption and faster execution, which is crucial for optimizing application performance.

3. Features of Light-4J

Let’s examine the core features of Light-4J:

• Microservices Architecture: Light-4J is architectured with microservices in mind, allowing developers to effortlessly build, deploy, and manage independent and scalable microservices, thus promoting flexibility, agility, and easier maintenance.
• Asynchronous and Non-blocking Communication: It harnesses asynchronous and non-blocking communication patterns. This results in improved responsiveness, as the framework efficiently handles concurrent requests, making it suitable for applications with high concurrency requirements.
• Decentralized Data Management: Unlike monolithic architectures, Light-4J promotes a decentralized approach to data management. Each microservice manages its own data, offering flexibility in choosing appropriate data storage solutions tailored to specific service needs.
• High Performance and Low Latency: Light-4J is engineered for high performance and low latency. By leveraging asynchronous processing and a minimalist design, it ensures faster response times, meeting the expectations for speed and efficiency in modern applications.
• Performance Optimization Techniques: Light-4J offers robust caching strategies to enhance application speed and efficiency. Moreover, the framework includes features for load balancing, ensuring applications can scale seamlessly to meet growing demands.
• Security Middleware: It seamlessly integrates security middleware for robust authentication and authorization, ensuring the protection of microservices and sensitive data. Additionally, it provides middleware for effective logging and monitoring, offering insights into application behavior and performance.
• Customization Capabilities: Light-4J features a powerful plugin system that enables developers to extend its functionality. This modularity facilitates customization, allowing the integration of additional features or third-party plugins tailored to specific project requirements.
• Comprehensive Documentation and Community Support: It also boasts comprehensive documentation, tutorials, and learning paths. Developers can access a wealth of resources that help them understand the framework, implement best practices, and troubleshoot issues.
• Community: Moreover, Light-4J benefits from a vibrant and active developer community. Engaging with this community provides valuable insights, support, and collaborative opportunities for developers working with the framework.

4. Design Principles

Light-4J is guided by several design principles that shape its development and contribute to its effectiveness as a microservices framework. These design principles empower Light-4J to provide a lightweight, efficient, and flexible platform for building microservices in Java. Let’s see some of the key design principles guiding Light-4J development.

Light-4J is specifically designed to cater to the demands of microservices architecture. Therefore, it must excel in several key areas simultaneously. These include achieving high throughput to efficiently handle a large volume of requests, maintaining low latency to ensure quick response times, and being lightweight to minimize resource consumption.

Additionally, Light-4J effectively addresses various cross-cutting concerns inherent in microservices, such as routing, security, logging, and monitoring, while maintaining optimal performance. This multifaceted approach is essential for enabling the seamless development and deployment of microservices-based applications with Light-4J.

Underpinning Light-4J is the JBoss Undertow HTTP server, renowned for its robustness and efficiency. By leveraging this foundation, it inherits the reliability and performance benefits of Undertow, further enhancing its capabilities in handling HTTP requests and responses.

Additionally, Light-4J minimizes dependencies on third-party libraries, adhering to a minimalist approach that enhances stability, security, and ease of maintenance.

4.1. Design-First Approach

Light-4J fundamentally adopts a design-first approach, prioritizing the careful consideration and definition of API contracts and specifications before any actual implementation. By embracing the design-first approach, Light-4J encourages us to meticulously plan and document the desired functionality and behavior of the APIs upfront. This involves leveraging industry-standard specifications such as OpenAPI or AsyncAPI to define the API contract in a machine-readable format.

These specifications serve as a blueprint for the API, detailing its endpoints, request and response payloads, authentication requirements, and other pertinent information. Moreover, it promotes collaboration and alignment between different stakeholders involved in the development process.

Additionally, the design-first approach facilitates the automatic generation of code and documentation based on the API specification. This streamlines the development process, as developers can use tools like the Light-4J code generator to scaffold the initial project structure, generate boilerplate code for API endpoints, and automatically generate API documentation from the API contract. We’ll understand more about this in the upcoming sections.

4.2. Security-First Approach

Light-4J also prioritizes security as a foundational aspect of its design philosophy, adopting a “security-first” approach. This ensures that the applications built on the framework are robustly protected against potential threats and vulnerabilities. Central to this approach is the seamless integration of the OAuth2 protocol for authentication and authorization. This enables the easy implementation of secure authentication and authorization mechanisms for our applications.

Furthermore, Light-4J leverages its embedded distributed gateway to facilitate distributed verification of OAuth2 tokens across a network of services. The distributed gateway acts as a centralized authentication and authorization hub, intercepting incoming requests and validating OAuth2 tokens before allowing access to protected resources. This distributed approach to token verification ensures consistent and reliable security enforcement across all services in a microservices architecture.

5. Setting up Our Development Environment With Light-4J

Setting up a robust development environment is a crucial step in leveraging the capabilities of Light-4J for microservices development. This process involves installing and configuring the framework, defining a project structure that aligns with best practices, and integrating Light-4J seamlessly into our workflow.

Light-4J is compatible with Java. Light-4J v1.5.x and v1.6.x versions are production-ready and are dependent on Java 8, while v2.0.x is built on Java 11. So, having JDK 8 or JDK 11 on our machine is essential for Light-4J.

To get started with Light-4J, we have two options: using the light-codegen generator or starting from an example project.

5.1. Using the light-codegen Generator

We can use the light-codegen tool to facilitate project scaffolding for all frameworks available within Light. It’s powered by the Rocker template engine and can serve both as a utility and as a web service for project scaffolding. It encourages users to essentially create a service contract specification before coding and then scaffold a project based on the designed specification. We can use it in various ways, including command-line, Docker, scripting, and Web UI.

Let’s understand the use of this generator for building a basic REST API project with Light-4J and OpenAPI 3.0.

First, let’s create a base directory and navigate inside it:

$ mkdir baseDir
$ cd baseDir

To start with, we can clone the light-codegen repository into baseDir:

$ git clone git@github.com:networknt/light-codegen.git

Similarly, we can clone the model-config repository, a configuration project for the code generation tool, into the baseDir:

$ git clone git@github.com:networknt/model-config.git

This project contains model definitions and configuration files for frameworks such as light-rest-4j, light-hybrid-4j-server, light-hybrid-4j-service, and light-graphql-4j.

Next, we need to change into the light-codegen directory and build the project:

$ cd light-codegen
$ mvn install -DskipTests

Once the build finishes, we can get back to the baseDir. Then, we can execute the CLI tool that generates the sample PetStore REST API project based on the OpenAPI 3.0 specification. The newly generated project will contain the configuration file for staging of the request-response chain:

$ java -jar light-codegen/codegen-cli/target/codegen-cli.jar \ 
  -f openapi \
  -o light-example-4j/Rest/openAPI/petstore \
  -m model-config/rest/openapi/petstore/1.0.0/openapi.yaml \
  -c model-config/rest/openapi/petstore/1.0.0/config.json

Let’s break down the meanings of these parameters and options:

• -f (framework) – REST framework specification type for the generator
• -o (output) – The target directory for the generated project
• -m (model) – IDL specifications with request and response format for each REST API
• -c (config) – The configuration file that provides details like HTTP ports, packages, and name of the project to be generated

Thus, on successful execution of the above command, we’ll have our new petstore project generated in a new light-example-4j folder in our baseDir:

..... A project has been generated successfully in light-example-4j/Rest/openAPI/petstore folder. Have fun!!!

Finally, we can change to the petstore directory in the newly generated light-example-4j, and launch the project to access its REST APIs:

$ cd light-example-4j/Rest/openAPI/petstore
$ mvn install exec:exec

This will start the HTTPS server on the 8443 port. Thus, we can verify if the REST service is up by hitting the API:

https://127.0.0.1:8443/v1/pets

This will print all the pets:

[{"id":1,"name":"catten","tag":"cat"},{"id":2,"name":"doggy","tag":"dog"}]

We can also access a specific pet with its id:

https://127.0.0.1:8443/v1/pets/1

This will simply return:

{"id":1,"name":"catten","tag":"cat"}

Thus, we can easily manipulate the ready-made configurations and specifications according to our needs and develop our framework on top of Light-4J.

The other way to generate scaffolded projects locally is by invoking light-codegen through the Java command line. We can download the codegen-cli.jar from the release page, place it into our working directory, and run it through the command line.

Finally, we can refer to the light-codegen tutorial for step-by-step guidelines to develop various other API frameworks.

5.2. Starting From an Example Project

The light-example-4j repository contains various example APIs based on various features of the Light-4J framework. We can use these to build and develop our own frameworks on top of Light-4J.

We can directly clone the light-example-4J repository from GitHub to our local machine:

$ git clone git@github.com:networknt/light-example-4j.git

Once we clone the repository, we can choose any available projects according to our use case. For example, to build a RESTful API with the OpenAPI 3.0 specification, we change to the below directory within the cloned repository:

$ cd light-example-4j/rest/openapi

Otherwise, we can also build with Swagger 2.0 and launch a specific project to access its REST APIs as we discussed above:

$ cd light-example-4j/rest/swagger

Similarly, we can get started with many other available frameworks according to our needs.

Also, we can refer to various tutorials that explain step-by-step processes on how to use each component of the Light framework based on our needs.

6. Conclusion

Light-4J is a modern Java framework designed for microservices development, emphasizing agility, performance, and scalability. Its lightweight design philosophy ensures simplicity and efficiency, while its microservices architecture promotes flexibility and easier maintenance. With features like asynchronous communication and a security-first approach, Light-4J empowers developers to build robust applications seamlessly.

In this article, we discussed various features and design principles of Light-4J. We also understood how to use the light-codegen tool to quickly scaffold a REST API project.

As Light-4J continues to evolve, we can expect new features and enhancements, making it a preferred choice for building next-generation microservices architectures.