DZone Java Zone

Taming the JVM Latency Monster

Theo Ezell — Thu, 26 Mar 2026 20:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

This website is using a security service to protect itself from online attacks. The action you just performed triggered the security solution. There are several actions that could trigger this block including submitting a certain word or phrase, a SQL command or malformed data.

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9e29bc7688bd07da • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Automating Maven Dependency Upgrades Using AI

Sravan Reddy Kathi — Thu, 26 Mar 2026 19:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9e29bc78890b9748 • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Data Driven API Testing in Java With REST Assured and TestNG: Part 4

Faisal Khatri — Thu, 26 Mar 2026 12:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9e29bc7a89fce282 • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Data-Driven API Testing in Java With REST Assured and TestNG: Part 3

Faisal Khatri — Wed, 25 Mar 2026 14:30:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9e22a9dd2ec48e2c • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Data-Driven API Testing in Java With REST Assured and TestNG: Part 2

Faisal Khatri — Tue, 24 Mar 2026 17:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9e22a9df2dff1e45 • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Scalable Cloud-Native Java Architecture With Microservices and Serverless

Harris Anderson — Fri, 20 Mar 2026 14:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9df60f34fc70340d • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Java Microservices (SCS) vs. Spring Modulith

Sven Loesekann — Wed, 18 Mar 2026 20:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9df60f36f85b39be • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Zero-Cost AI with Java

Fernando Boaglio — Wed, 18 Mar 2026 19:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9df60f38fcc91e68 • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Stranger Things in Java: Enum Types

Claudio De Sio Cesari — Mon, 16 Mar 2026 13:00:09 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9ddb9eb1cd128ab5 • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Extending Java Libraries with Service Loader

Dominik Przybysz — Fri, 13 Mar 2026 17:00:07 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9dca07b79da2c614 • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

What's New in Java 25: Key Changes From Java 21

Gunter Rotsaert — Thu, 12 Mar 2026 17:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9db7d1da8fc9dbbb • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Unblocking a Failed Solr 5 to Solr 8 Migration in a Large-Scale Ads Retrieval System

Parveen Saini — Tue, 10 Mar 2026 18:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9da6e820be00996f • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Square, SumUp, Shopify: Data Streaming for Real-Time Point-of-Sale (POS)

Kai Wähner — Mon, 09 Mar 2026 14:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9da6e822cae637f1 • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Building a Java 17-Compatible TLD Generator for Legacy JSP Tag Libraries

Sravan Reddy Kathi — Wed, 04 Mar 2026 17:00:00 GMT

Java 17-Compatible TLD Generator for Legacy JSP Tag Library

When TLD Generation Tooling Falls Behind Java 17

The vulnerabilities introduced by upgrades to the Java platform tend not to lie in the application code itself, but rather in the ecosystem of build-time tools that enterprise systems rely on. This was made clear by a migration to Java 17, in which a long-standing dependency on TldDoclet to generate Tag Library Descriptor (TLD) was compromised.

TldDoclet, a widely used tool for generating TLD metadata from Java tag handler classes, is no longer supplied or compatible with current Java versions. The effect of this gap was not so obvious. The application itself compiled and executed well with Java 17, and the underlying JSP tag handlers remained functional. But TLD generation did not come up with a congenial mechanism, consequently placing a hard blocker late in the build. What once was a constant and unseen component of the toolchain turned into a migration issue with a high risk.

Another solution was to rewrite all custom tags to use .tag files, which was technically feasible but operationally impractical. The system contained more than 700 custom tags, scattered across more than 6,000 production files, spanning years of production experience and implicit contracts that depended on several teams. Massive rewrites at this tier come with a great deal of regression risk, extended validation, and unpredictability that large organizations often cannot afford. This paper explains the origins of these constraints that prompted the design and development of a custom, annotation-based TLD generator, which is compatible with both Java versions, including Java 17, and none of the existing JSP tag libraries are altered. It will not focus on the replacement of JSP or tag libraries, but rather on bridging a tooling gap that remains in the promotion of modern Java, both in the context of the realities of large and long-lived enterprise codebases.

The Hidden Cost of Abandoned TLD Generation Tooling

TldDoclet handled a little yet very important issue, viz., to locate the metadata within Amazon Java tag handler classes and automatically create valid TLD files. The functions have, over time, been incorporated into the full build pipelines of many enterprise systems, in most cases without active maintenance or inspection. That dependence has been intangible ever since Java versions had not acquired much speed, and the backward compatibility assumption had been introduced.

With Java 9 and later releases, this assumption no longer holds. The Java Platform Module System and changes to compiler APIs, limitations on the use of reflection and doclets, among others, were fundamental changes that transformed the landscape on which the TldDoclet tools would operate. To a large extent, TldDoclet must be modified in order to be able to make use of Java 17, as old-fashioned doclet APIs and classpath behavior no longer work with Java 17 anyway.

There is scarcely any such negligence regarding the cost of a tool. It was due to the inability of a TLD generator to obtain the desired results in this case that led to a re-shift in thinking in terms of the generation and validation of tag metadata. The building failures were late in the pipeline, as they were already mostly done with the migration work, and the building failures were by then a point in the architecture decision rather than a mechanical upgrade.

At the enterprise scale, these situations also give rise to unwanted requirements, such as halting Java version upgrades, internal maintenance of obsolete tools, or high-risk refactorings that provide no business value. The challenge was, then, not only to rid herself of TldDoclet, but to do it such that they are caused with minimal uproar, which will be sustainable as long as the next iterations of Java will persist.

Why Rewriting .tag Files Was Not a Viable Option

From a modern Jakarta perspective, tag files are a clean and supported way to define custom JSP tags. For small systems or greenfield projects, migrating to .tag files can be an attractive solution. In large enterprise systems, however, the cost profile is very different. The application in question contained hundreds of custom tags, many with complex attribute definitions and custom data types. These tags were referenced across thousands of JSP files, often with implicit assumptions about attribute behavior that were not fully documented. Rewriting these tags would have required coordinated changes across multiple teams, extensive regression testing, and prolonged stabilization periods.

More importantly, the migration effort was not driven by a desire to modernize the presentation layer, but by a Java platform upgrade. Introducing widespread functional changes unrelated to the original goal would have increased risk without delivering proportional value. In regulated or business-critical systems, this level of uncertainty is often unacceptable. The guiding constraint, therefore, was clear: existing JSPs and tag handlers had to remain unchanged. Any solution that required widespread rewrites was considered non-viable, regardless of its theoretical elegance.

From a modern Jakarta perspective, .tag files give a subtle and authorized way of formulating custom JSP tags. In the case of small systems or greenfield projects, the temptation to migrate to .tag files may become viable. But at very large-scale enterprise systems, the profile is quite different. The application under question had hundreds of custom tags, many of which contained the complex definition of the attributes and custom data types. The tags were referenced in thousands of JSP files only half as often, due to implicit assumptions about the behavior of unspecified attributes. It would have required both cross-functional coordination and extensive regression testing, as well as an extended shelf life, to reimplement these tags.

A desire to modernize the presentation layer was not the purpose of undertaking the migration exercise, but rather a Java platform upgrade. The threat of making pervasive functional modifications that were unrelated to the original rationale would have been greater when there was not a corresponding value increment. Uncertainties of this kind are not allowed among regulated or business-critical systems. The motivation force was very self-evident, though: the very existence of JSPs and tag handlers could not be limited. A solution that required a wholesale overhaul was considered, in any case, non-viable regardless of its theoretical loveliness.

Defining the Design Goals for a Replacement TLD Generator

It was not supposed to be feature-to-feature, but a replacement under these constraints that would suit modern realities in the Java world and business requirements. Among the basic design goals, which were also formulated at the initial stages, the following are:

Java version independence: The solution should be compatible with Java 17 and all prior versions of Java, without relying on deprecated APIs.
Zero JSP change: Base Existing JSP program and tag usages do not have to be changed.
Accurate TLD compatibility: Built TLD files must be the same as the old descriptors without semantic differences.
Integration of builds: Build TLD will be added to the existing build pipeline.
Scalability: The solution must have the capacity to serve hundreds of tags and thousand files.

These targets removed the heavy-exercise reflection run-time solutions and favoured a deterministic build-time model with explicit metadata.

Using Annotations to Model Tag and Attribute Metadata

The solution essentially includes an annotation-based metadata model. Tag and attribute information is provided as explicit custom annotations rather than as output from Javadoc parsing or doclet APIs.

Higher still, a tag handler class is annotated with @Tag, which stores tag-level information, such as the tag name. The individual attributes are modeled with the assistance of the annotations as the @Attribute on the setter methods level primarily, which is one way of implementing JSP tags.

An annotation is a capture of each annotation attribute, which captures:

Attribute name
The attribute may be compulsory or not.
The attribute type
Metadata expression: runtime support.

One of the more complex aspects of this type of approach is type resolution. The names of types are not most often physical primitives (or strings), but domain types of a custom type. The generator is not entirely dependent on reflection; however, it exploits a symbol and type resolver, which is used depending on compiled class files to arrive at the conclusion of the appropriate nature of attributes on module boundaries.

The explicit annotation model puts the developer intent rather than the tooling heuristics in the metadata and makes the metadata more explicit, maintainable, and less delicate due to the parsing logic of the metadata.

Build-Time Class Scanning in a Modern Java Environment

To keep up with current Java, the generator is entirely build-time, that is, it scans compiled class files and not source code. The generation stage is carried out as part of a Maven phase and coordinated by an Ant task that can be easily integrated with an existing Jenkins pipeline.

Compiled classes have a number of benefits:

Java compatibility: Compatibility across Java versions.
Accurate type resolution
No reliance on the outdated compiler or documentation APIs.

The generator first searches the corresponding classpath and purports the classes that are annotated with the annotation of Tag, analyzes method annotations that have been annotated, resolves attribute metadata, and builds the corresponding TLD representation in a deterministic manner.

Since the process uses a bytecode format and annotations, there is no reason it should be affected by changes to the source format or documentation style.

Generating Deterministic and Backward-Compatible TLD Files

One of the most important conditions was that the generated TLD files had to match the legacy descriptors. This contains tag names, attribute definitions, ordering, and the namespace declaration. Even the slightest variations might lead to some unexpected behaviour or make validation harder in enterprise settings.

The generator uses a controlled, deterministic process that generates TLD files to be compatible. The results are compared to the available descriptors to establish the semantic equivalence. As a matter of fact, the TLDs generated coincided with the legacy files with zero difference, and thus, they could be dropped and left to rest without any additional modifications.

This fidelity was a requirement of adoption. Teams might believe that the new generator made no difference, only the means by which metadata was created.

Integrating the Generator Into Existing CI/CD Pipelines

The generator is included in the typical construction, and it is automatically run when CI builds are being done. Its requirement to run on compiled classes as well as to generate artifacts identical to those generated previously meant that it did not need much modification to existing pipelines.

This combination meant that the generation of TLD remained:

Automated
Repeatable
Open to tag consumers.

The generator acts like any other build step, which, in terms of CI/CD, eases the cognitive and operational load of the migration.

Migration Outcomes at Enterprise Scale

The effects of such a strategy became visible when implemented on a large scale. There was support of over 700 custom tags in more than 6000 files without ever having to rewrite a JSP or tag handler. Migration to Java 17 was done without presentation-layer risk, and the same generator still remains compatible across Java versions. Probably the most crucial argument is that the solution was future-proofed. Since it is based on annotations and scanning of the bytecode, it is not sensitive to most of the changes that have occurred with previous tools.

Lessons for Enterprise Java Modernization

The experience provides several general lessons:

Tooling gaps can be the real impediments to platform upgrades.
Large-scale rewrites are not often acceptable in the enterprise setting.
The explicit metadata model is more sustainable than the tooling on the basis of a heuristic.
Whereas it is not always safe, build-time solutions can be safer than the runtime adaptations when migrating.

To manage such issues, tooling should be treated as a first-class issue and not as something that happens afterwards.

Looking Ahead

JSP and tag libraries are not trendy, but they are ingrained in numerous enterprise systems. As Java is still evolving, it will probably become the case that other areas will have similar tooling gaps. The method outlined below, which is annotation-driven, build-time, and backward-compatible, provides a model for addressing such gaps in a pragmatic manner.

Instead of making them rewrite portions that need not be rewritten, teams are able to maintain the steady functionality and conform their tooling to the current platform restrictions. In large, long-serving systems, this equilibrium can lead to successful modernization or to a nonprogressive effort.

Opinions expressed by DZone contributors are their own.

Generated by Readability.php.

Comparing Top 3 Java Reporting Tools

Sergei Iudaev — Tue, 03 Mar 2026 18:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9d713c28ac2cd36e • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Rethinking Java Web UIs With Jakarta Faces and Quarkus

Nicolas Duminil — Fri, 27 Feb 2026 18:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9d5db9c40a559c0d • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

A Practical Guide to Building Generative AI in Java

Xavier Portilla Edo — Thu, 26 Feb 2026 16:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9d42db43cbe5d260 • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

How to Configure JDK 25 for GitHub Copilot Coding Agent

Bruno Borges — Wed, 25 Feb 2026 13:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9d42db45cacf9b9a • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Data Driven API Testing in Java with Rest-Assured and TestNG: Part 1

Faisal Khatri — Mon, 23 Feb 2026 18:00:00 GMT

Attention Required! | Cloudflare

Please enable cookies.

You are unable to access dzone.com

Why have I been blocked?

What can I do to resolve this?

You can email the site owner to let them know you were blocked. Please include what you were doing when this page came up and the Cloudflare Ray ID found at the bottom of this page.

Cloudflare Ray ID: 9d2ea4fdc86cd22a • Your IP: 5.1.64.146 • Performance & security by Cloudflare

Generated by Readability.php.

Building a Sentiment Analysis Pipeline With Apache Camel and Deep Java Library (DJL)

Vignesh Durai — Mon, 23 Feb 2026 13:00:00 GMT

Build a Sentiment Analysis Pipeline With Apache Camel & DJL

Sentiment analysis is now a key part of many applications. Whether you’re processing customer feedback, sorting support tickets, or tracking social media, knowing how users feel can be just as important as knowing what they say.

For Java developers, the main challenge isn’t finding machine learning models, but applying them within the existing or new Java applications without relying on Python. Most NLP models are shown in Python notebooks, while real systems use file pipelines, routing, retries, fallbacks, and monitoring. Many teams find it hard to connect these pieces smoothly.

This tutorial will show you how to build a sentiment analysis pipeline in pure Java with Apache Camel and the Deep Java Library (DJL). We will cover handling text files, running sentiment checks with a ready-to-go DistilBERT model, tidying up the outputs, and gracefully handling glitches, all while leaning on those trusty Enterprise Integration Patterns you are probably already familiar with.

What You'll Learn

By the time you're done here, you'll be comfortable with:

Develop a file-based NLP pipeline using Apache Camel.
Use a pre-trained sentiment analysis model via Camel’s DJL component.
Understand the djl: URI syntax and model configuration in Apache Camel.
Structure routes with fallback handling and clean output formatting.
Run sentiment analysis locally using the Java and Apache Camel frameworks, without external APIs or Python services.

Frameworks Used

Apache Camel

Apache Camel is an awesome open-source integration framework built on Enterprise Integration Patterns. It has great components for connecting systems, moving data, and orchestrating workflows using declarative routes.

In this example, we look at file ingestion, Message transformation, routing, conditional logic, error handling, and output persistence.

Deep Java Library (DJL)

DJL is a deep learning framework for Java that is engine-agnostic. It strikes a nice balance between quick performance and solid accuracy, making it perfect for sentiment tasks without bogging things down.

We use the Camel-DJL component to download and cache a pre-trained DistilBERT model, run sentiment inference inside the JVM, and return structured classification results.

DistilBERT for Sentiment Analysis

DistilBERT is a smaller, fast transformer model based on BERT. It gives a good mix of speed and accuracy for sentiment analysis tasks.

Project Structure

Let's look at the project structure below:

camel-sentiment-analysis/
├── src/main/java/com/example/sentimentanalysis/
│   ├── MainApp.java                          # Application entry point
│   ├── routes/
│   │   └── SentimentAnalysisRoutes.java      # Camel route for text processing
│   └── processor/
│       ├── ClassificationsFormatter.java     # Formats sentiment results
│       └── FallbackFormatter.java            # Handles unexpected outputs
├── src/main/resources/
│   └── application.properties                # Camel configuration
├── data/
│   ├── input/                                # Input text files
│   │   ├── sample-positive.txt               # Sample positive text
│   │   └── sample-negative.txt               # Sample negative text
│   ├── output/                               # Sentiment analysis results
│   └── analyzed/                             # Processed files archive
├── gradle/wrapper/                           # Gradle wrapper files
├── build.gradle                              # Project dependencies
├── settings.gradle                           # Gradle settings
├── gradlew.bat                               # Gradle wrapper script
├── README.md                                 # Main documentation

Gradle Dependencies

build.gradle

plugins {
	id 'java'
	id 'application'
}

group = 'com.example'
version = '1.0.0'
description = 'Sentiment Analysis with Apache Camel and DJL'

java {
	toolchain {
		languageVersion = JavaLanguageVersion.of(21)
	}
}

application {
	mainClass = 'com.example.sentimentanalysis.MainApp'
}

repositories {
	mavenCentral()
}

dependencies {
	// Apache Camel
	implementation 'org.apache.camel:camel-core:4.17.0'
	implementation 'org.apache.camel:camel-main:4.17.0'
	implementation 'org.apache.camel:camel-file:4.17.0'
	implementation 'org.apache.camel:camel-djl:4.17.0'
	
	// DJL (Deep Java Library) for sentiment analysis
	implementation platform('ai.djl:bom:0.36.0')
	implementation 'ai.djl:api'
	
	// PyTorch engine for DistilBERT sentiment analysis
	implementation 'ai.djl.pytorch:pytorch-engine'
	implementation 'ai.djl.pytorch:pytorch-model-zoo'
	
	// Use CPU-only PyTorch runtime for Windows
	runtimeOnly 'ai.djl.pytorch:pytorch-native-cpu:2.1.1:win-x86_64'
	
	// Logging
	implementation 'org.slf4j:slf4j-simple:2.0.16'
}

The DJL BOM make sures the versions are consistent across engines and models.

Application Entry Point

The application starts up using the MainApp class and starts Camel using Main:

package com.example.sentimentanalysis;

import com.example.sentimentanalysis.routes.SentimentAnalysisRoutes;
import org.apache.camel.main.Main;

public class MainApp {

    public static void main(String[] args) throws Exception {
      
        // Create and configure Camel Main
        Main main = new Main();

        // Add routes
        main.configure().addRoutesBuilder(new SentimentAnalysisRoutes());

        main.run();
    }
}

Sentiment Analysis Route

The SentimentAnalysisRoutes.java is where the core logic is implemented using camel-djl component's URI. It uses the "from" component for file ingestion (Watches for a file, processes them one at a time to extract the text, archives them with a timestamp), and uses a single "to" URI endpoint to run sentiment analysis using the DJL component URI with a lazy producer, which allows the route to start even if the endpoint can't connect. The producer starts on the first message, enabling error handling during routing.

SentimentAnalysisRoutes.java

package com.example.sentimentanalysis.routes;

import com.example.sentimentanalysis.processor.ClassificationsFormatter;
import com.example.sentimentanalysis.processor.FallbackFormatter;
import org.apache.camel.builder.RouteBuilder;

import java.io.File;
import java.nio.file.Files;

/**
 * Apache Camel routes for sentiment analysis.
 * Processes text files from input folder, runs sentiment analysis using DJL,
 * and writes results to output folder.
 */
public class SentimentAnalysisRoutes extends RouteBuilder {

    @Override
    public void configure() throws Exception {

        // Route to process text files from input folder
        from("file:data/input?include=.*\\.txt&noop=false&move=../analyzed/${date:now:yyyyMMdd-HHmmss}-${file:name}")
                .routeId("sentiment-analysis-route")
                .log("Processing text file: ${file:name}")

                // Read file content as String
                .process(exchange -> {
                    File textFile = exchange.getIn().getBody(File.class);
                    String content = Files.readString(textFile.toPath());
                    exchange.getIn().setBody(content);
                })

                .to("djl:nlp/sentiment_analysis?artifactId=ai.djl.pytorch:distilbert:0.0.1&lazyStartProducer=true")

                // Convert output to a text report using Camel choice/bean components
                .choice()
                    .when(body().isInstanceOf(ai.djl.modality.Classifications.class))
                        .bean(new ClassificationsFormatter(), "format")
                    .otherwise()
                        .bean(new FallbackFormatter(), "format")
                .end()

                .log("Sentiment analysis done for ${file:name}")

                // Write results to output folder
                .to("file:data/output?fileName=${date:now:yyyyMMdd-HHmmss}-${file:name.noext}-sentiment.txt")
                .log("Results saved to output folder");
    }
}

Let’s break this down:

.to("djl:nlp/sentiment_analysis?artifactId=ai.djl.pytorch:distilbert:0.0.1&lazyStartProducer=true")

djl – Camel DJL component
nlp/sentiment_analysis – NLP task type
artifactId – Identifies the model from DJL’s Model Zoo
lazyStartProducer=true – Defers model loading until first use

This single line replaces hundreds of lines of traditional ML plumbing.

How to Run the Application

Build and run using Gradle:

Then drop text files into data/input/, for example:

This is an amazing product! I absolutely love it and would highly recommend it.

The analyzed sentiment is written to data/output/, and the original file is archived.

ClassificationsFormatter.java

package com.example.sentimentanalysis.processor;

import ai.djl.modality.Classifications;
import org.apache.camel.Exchange;

import java.util.List;

/**
 * Bean to format DJL Classifications object into a text report for sentiment
 * analysis.
 */
public class ClassificationsFormatter {

	public String format(Classifications classifications, Exchange exchange) {
		StringBuilder sb = new StringBuilder();
		String fileName = exchange.getIn().getHeader("CamelFileName", String.class);

		sb.append("Text File: ").append(fileName).append('\n');
		sb.append("Sentiment Analysis Results\n");
		sb.append("==========================\n\n");

		List<Classifications.Classification> allResults = classifications.topK();

		if (!allResults.isEmpty()) {
			Classifications.Classification top = allResults.get(0);
			sb.append("Overall Sentiment: ").append(top.getClassName().toUpperCase()).append(" (Confidence: ")
					.append(String.format("%.2f%%", top.getProbability() * 100)).append(")\n\n");
		}

		sb.append("Sentiment Breakdown:\n");
		for (int i = 0; i < allResults.size(); i++) {
			Classifications.Classification c = allResults.get(i);
			sb.append(String.format("  %s: %.2f%%\n", c.getClassName(), c.getProbability() * 100));
		}

		return sb.toString();
	}
}

On a successful classification, ClassificationsFormatter converts DJL’s output into a clean, human-readable report like below:

Text File: sample-positive.txt
Sentiment Analysis Results
==========================

Overall Sentiment: POSITIVE (Confidence: 99.98%)

Sentiment Breakdown:
  Positive: 99.98%
  Negative: 0.02%

In case of an ML failure, there is a FallbackFormatter that ensures the pipeline continues to produce meaningful output rather than crashing, which follows a critical production pattern to fail softly.

FallbackFormatter.java

package com.example.sentimentanalysis.processor;

import org.apache.camel.Exchange;

/**
 * Bean to format unexpected result types into a text report.
 */
public class FallbackFormatter {

	public String format(Object result, Exchange exchange) {
		StringBuilder sb = new StringBuilder();
		String fileName = exchange.getIn().getHeader("CamelFileName", String.class);

		sb.append("Text File: ").append(fileName).append('\n');
		sb.append("Raw result type: ").append(result == null ? "null" : result.getClass().getName()).append('\n');
		sb.append("Result:\n").append(String.valueOf(result)).append('\n');

		return sb.toString();
	}
}

DJL Behind the Scenes

On first execution, the DistilBERT model is downloaded automatically, & Native PyTorch libraries are initialized. The model is cached locally, and on subsequent runs it loads from cache, resulting in significantly faster startup.

Production Considerations

For performance reasons, always warm up the model on startup if latency is a concern and allocate sufficient JVM heap (models are memory-intensive).

Scale horizontally with multiple Camel instances or vertically using GPU-enabled DJL engines. Always use lazyStartProducer for ML endpoints.

Conclusion

This tutorial demonstrates that machine learning does not need to be a separate system. With Apache Camel and DJL, sentiment analysis becomes just another step in your integration flow, composable, observable, and production-ready. Compared to external ML APIs, there is no per-request cost, data is not going out, and there is full control over routing and error handling.

Compared to Python pipelines, it is native integration with enterprise Java systems & first class support for integration patterns.

If you already use Camel, adding NLP capabilities is no longer a leap. It is a small, well-structured step.

Opinions expressed by DZone contributors are their own.

Generated by Readability.php.