In Java development, efficient JSON processing is critical for building high-performance applications. While many libraries exist, Avaje JSONB stands out for its speed, low memory footprint, and intuitive API.

It offers a powerful alternative to traditional JSON libraries, promising significant performance gains and a more streamlined development experience.

For developers looking to optimize their applications, integrating Avaje JSONB can be a game-changing decision.

This guide explores the practical steps for integrating Avaje JSONB into popular Java frameworks.

We will cover everything from initial setup to advanced configuration, demonstrating how to leverage its features for superior JSON processing.

By the end of this post, you will have a clear understanding of how to enhance your projects with this high-performance library and unlock new levels of efficiency in your Java integration efforts.

Preparing for Avaje JSONB Integration

Before you begin integrating Avaje JSONB, it is essential to prepare your development environment.

This initial setup ensures a smooth transition and helps you avoid potential conflicts or compatibility issues with your existing frameworks.

Assess Your Project Dependencies

Start by reviewing your project’s pom.xml or build.gradle file. Identify any existing JSON processing libraries, such as Jackson or Gson.

It’s important to understand how these libraries are used throughout your application, as you may need to replace them incrementally or run them in parallel during a transition phase.

Make a note of any custom configurations or modules associated with your current library.

Set Up the Avaje JSONB Dependency

To get started with Avaje JSONB, add its dependency to your build configuration.

  • For Maven: Add the following to your pom.xml:
    <dependency>
        <groupId>io.avaje</groupId>
        <artifactId>avaje-jsonb</artifactId>
        <version>LATEST_VERSION</version>
    </dependency>
    <dependency>
        <groupId>io.avaje</groupId>
        <artifactId>avaje-jsonb-generator</artifactId>
        <version>LATEST_VERSION</version>
        <scope>provided</scope>
    </dependency>
  • For Gradle: Add this to your build.gradle file:
    dependencies {
        implementation ‘io.avaje:avaje-jsonb:LATEST_VERSION’
        annotationProcessor ‘io.avaje:avaje-jsonb-generator:LATEST_VERSION’
    }

Remember to replace LATEST_VERSION with the most recent version available from the Maven Central repository.

The avaje-jsonb-generator is an annotation processor that generates adapters at compile time, which is key to Avaje JSONB’s performance.

Integration with Spring Boot

Spring Boot is one of the most widely used frameworks in the Java ecosystem.

Integrating Avaje JSONB can replace the default Jackson library for JSON processing, leading to significant performance improvements in your RESTful services.

Replacing the Default JSON Mapper

By default, Spring Boot uses Jackson for serializing and deserializing JSON objects. To replace it with Avaje JSONB, you need to configure a custom HttpMessageConverter.

  1. Create the JsonbHttpMessageConverter:
    You can create a custom converter that wraps an AvajeJsonb instance. This allows Spring to use Avaje for handling application/json requests and responses.
  2. Configure Spring MVC:
    Register your custom converter within your Spring configuration. This tells Spring to prioritize Avaje JSONB for all JSON-related tasks.

Example Configuration

Here is an example of how to register a Jsonb bean and a custom HttpMessageConverter in your Spring Boot application:

import io.avaje.jsonb.Jsonb;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.http.converter.HttpMessageConverter;

 

@Configuration

public class JsonbConfig {

 

   @Bean

   public Jsonb jsonb() {

       return Jsonb.builder().build();

   }

 

   @Bean

   public HttpMessageConverter<Object> jsonbHttpMessageConverter(Jsonb jsonb) {

       // This is a simplified example. You’d create a converter

       // class that implements Spring’s HttpMessageConverter interface.

       return new AvajeJsonbHttpMessageConverter(jsonb);

   }

}

With this configuration, any @RestController in your application will automatically use Avaje JSONB for JSON processing.

Integration with Jakarta EE and JAX-RS

For applications built on Jakarta EE (formerly Java EE), integrating Avaje JSONB with JAX-RS provides a high-performance alternative to the standard JSON-B or other providers like Jackson.

Create a Custom MessageBodyWriter and MessageBodyReader

JAX-RS uses MessageBodyWriter and MessageBodyReader implementations to handle serialization and deserialization. To integrate Avaje JSONB, you must create custom implementations of these interfaces.

  • MessageBodyWriter: This component will be responsible for serializing your Java objects into a JSON OutputStream.
  • MessageBodyReader: This will handle deserializing an incoming JSON InputStream into your Java objects.

Registering the Custom Providers

Once you have created your custom writer and reader, register them as providers in your JAX-RS application. You can do this by annotating your implementation classes with @Provider.

import io.avaje.jsonb.Jsonb;

import jakarta.ws.rs.Produces;

import jakarta.ws.rs.ext.MessageBodyWriter;

import jakarta.ws.rs.ext.Provider;

import java.io.OutputStream;

import java.lang.annotation.Annotation;

import java.lang.reflect.Type;

import jakarta.ws.rs.core.MediaType;

import jakarta.ws.rs.core.MultivaluedMap;

 

@Provider

@Produces(MediaType.APPLICATION_JSON)

public class JsonbMessageBodyWriter implements MessageBodyWriter<Object> {

 

   private final Jsonb jsonb;

 

   public JsonbMessageBodyWriter() {

       this.jsonb = Jsonb.builder().build();

   }

 

   // Implementation of writeTo, isWriteable, etc.

}

The framework will then discover and use these providers for all JSON media types, enabling efficient JSON processing across your Jakarta EE application.

Leveraging Avaje JSONB with Javalin

Javalin is a lightweight and modern web framework for Java and Kotlin. Its simplicity makes integrating custom JSON mappers like Avaje JSONB straightforward.

Implement the JsonMapper Interface

Javalin provides a JsonMapper interface for handling JSON serialization and deserialization. To integrate Avaje JSONB, create a class that implements this interface.

import io.avaje.jsonb.Jsonb;

import io.javalin.json.JsonMapper;

import java.lang.reflect.Type;

 

public class AvajeJsonbMapper implements JsonMapper {

 

   private final Jsonb jsonb;

 

   public AvajeJsonbMapper() {

       this.jsonb = Jsonb.builder().build();

   }

 

   @Override

   public String toJsonString(Object obj, Type type) {

       return jsonb.adapter(type).toJson(obj);

   }

 

   @Override

   public <T> T fromJsonString(String json, Type type) {

       return jsonb.adapter(type).fromJson(json);

   }

}

Configure Javalin to Use Your Mapper

After creating your AvajeJsonbMapper, configure your Javalin instance to use it. This is done when you initialize your Javalin application.

import io.javalin.Javalin;

 

public class Main {

   public static void main(String[] args) {

       Javalin app = Javalin.create(config -> {

           config.jsonMapper(new AvajeJsonbMapper());

       }).start(7000);

 

       app.get(“/”, ctx -> ctx.json(new MyDataObject()));

   }

}

With this setup, all ctx.json() and ctx.bodyAsClass() calls in your Javalin application will be handled by the high-performance Avaje JSONB library.

Advanced Configuration and Customization

Avaje JSONB is not just fast; it is also highly customizable. You can tailor its behavior to meet the specific needs of your application, from handling custom data types to modifying serialization output.

Creating Custom Adapters

For types that Avaje JSONB does not support out of the box or for when you need custom serialization logic, you can create your own JsonAdapter. This gives you full control over the JSON processing of specific classes.

For example, you could create an adapter to serialize a java.time.Duration object into a more human-readable format.

Modifying Serialization Behavior

Avaje JSONB offers several options to control the output of your JSON.

  • Null Handling: Configure whether to include or suppress null values in the serialized output.
  • Property Naming: While the default is camelCase, you can configure other naming conventions like snake_case or kebab-case.
  • Polymorphic Types: Use annotations like @Json.SubType to handle serialization and deserialization of objects in an inheritance hierarchy.

These customization options ensure that your Java integration with Avaje JSONB is not only fast but also flexible enough for complex enterprise requirements.

Performance Considerations and Benchmarks

One of the primary reasons to choose Avaje JSONB is its outstanding performance.

Its compile-time code generation approach minimizes the overhead associated with reflection, which is a common performance bottleneck in other JSON libraries.

Low Memory Footprint

Benchmarks consistently show that Avaje JSONB has a lower memory footprint compared to libraries like Jackson and Gson.

This is particularly beneficial for applications running in resource-constrained environments, such as microservices or serverless functions.

Faster Startup and Throughput

Because adapters are generated at compile time, Avaje JSONB achieves faster startup times. There is no need for runtime analysis of class structures.

This also translates to higher throughput, as serialization and deserialization operations are executed more efficiently.

For high-traffic APIs, this performance boost can lead to reduced latency and lower operational costs.

Achieve Superior Performance with Avaje JSONB

Integrating Avaje JSONB into your Java frameworks is a strategic move toward building more efficient, high-performance applications.

Its modern, annotation-based approach simplifies JSON processing while delivering top-tier speed and a low memory footprint.

By replacing default libraries like Jackson or Gson, you can unlock significant performance gains in your REST APIs and data-intensive services.

Whether you are working with Spring Boot, Jakarta EE, or a lightweight framework like Javalin, the integration process is straightforward.

The flexibility to create custom adapters and configure serialization behavior ensures that Avaje JSONB can meet the demands of any project. We encourage you to explore Avaje JSONB and see how it can elevate your application’s performance.