Forem: Mauro Mazzocchetti

The Missing Bridge: Running Java Seamlessly Inside Your Node.js App

Mauro Mazzocchetti — Fri, 10 Oct 2025 07:38:52 +0000

Have you ever been deep into a Node.js project and thought, "I wish I could just use that amazing Java library for this one task"? Or maybe you have a full-fledged Spring Boot server that you need to manage and orchestrate from a Node.js application.

Bridging the gap between the Node.js and Java ecosystems isn't always straightforward. You might end up writing complex shell scripts, managing child processes manually, or struggling with complicated inter-process communication. It often feels clunky and fragile.

I wanted a simpler way. A "just works" solution to run Java code, whether it's a simple .jar file or an entire server, directly from my JavaScript code.

That’s why I created java-js-node.

What is `java-js-node`?

It's a small, cross-platform library that does one thing and does it well: it runs Java code from Node.js.

The best part? It doesn't require the user to have Java pre-installed. If a suitable Java runtime isn't found on the system, the library will automatically download a lightweight JRE and use that. This makes your application portable and removes a major setup headache for your users.

Key Features:

🚀 Run Java from Node.js: Execute .jar files or Java classes effortlessly.
☕ Automatic Java Setup: Downloads a JRE if Java is not found on the system PATH.
🖥️ Cross-Platform: Designed to work on Windows, macOS, and Linux.
📝 Simple API: A straightforward and easy-to-use promise-based API.

How it Works: A Quick Example

Let's see it in action. First, install the library in your Node.js project:

npm install java-js-node

Now, imagine you have a simple Java JAR file named helloworld-1.0-SNAPSHOT.jar that takes some file paths as arguments to perform heavy processing a task where Java might outperform JavaScript.

Here’s how you can run it from your Node.js script:

// index.js
const { runJar } = require('java-js-node');

// Basic execution with security validation
async function helloWorld() {
    // ✅ JAR validation mandatory for security
    const isValid = await runJar.validateJar('./test/helloworld-1.0.0-SNAPSHOT.jar');
    if (!isValid) {
        throw new Error('JAR unsafe or corrupted');
    }

    const result = await runJar('./test/helloworld-1.0-SNAPSHOT.jar');
    console.log('Exit code:', result.exitCode);
    console.log('Output:', result.stdout);
}

If you want, you can instantiate specific version of java, if you need a minimum version or a specific one, here is how:


const NodeJavaRunner = require('java-js-node');
const path = require('path');

async function test() {
    console.log('🚀 Test Java 25 - Specific version\n');
    console.log('🔥 This code will force java to version 25');
        const runner = new NodeJavaRunner({
            debug: true
        });
        let versions = await runner.getAvailableJavaVersions();
        console.log('📋 Available Java versions:', versions);

        await runner.init({
            jreMajor: 25,  // Force to 25
            workdir: path.join(__dirname, 'runtime')
        });

        // Percorso del JAR di test
        const jarPath = path.join(__dirname, 'test', 'helloworld-1.0.0-SNAPSHOT.jar');

        console.log(`📋 Test del JAR: ${jarPath}`);
        console.log(`⚙️ Configuration: Java 25, debug enabled\n`);
        const result = await runner.runJar(jarPath, [--someArgs], {
                                         onStdout:(text)=>{
                                               //Some logging function
                                           },
                                         onStderr:(text)=>{
                                               //Some logging function
                                           }
                                        } );
}

That's it! The library handles finding Java (or downloading it), launching the process, and piping the output back to your Node script.

Expanding Architectural Possibilities

This simple tool opens up some fascinating architectural possibilities:

Hybrid Systems: Use Node.js for its powerful networking and API capabilities while offloading CPU-intensive tasks (like data processing, image manipulation, or complex calculations) to a robust Java library.
Microservices Orchestration: Spin up and manage an entire Spring Boot or Quarkus server from a Node.js controller script.
Legacy Code Integration: Interact with existing Java-based tools or enterprise systems without needing a full rewrite. You can just wrap them and call them from your modern Node.js backend.

I Need Your Help! 🙏

java-js-node is still new, and I would love for the community to get involved. This is where you come in!

Testing on Different Platforms: I've tested it on my setup, but the world is full of different operating systems and configurations. If you could try it on your machine (especially different Linux distros or Windows versions) and report back, it would be incredibly helpful.
Feedback and Suggestions: Do you have ideas for new features? Is there a way to improve the API? Open an issue on GitHub and let's discuss it!
Contributions: Pull requests are always welcome, whether for bug fixes, new features, or documentation improvements.

You can find the project and contribute on GitHub:
https://github.com/drakonkat/java-js-node

Let's work together to make bridging the gap between Java and Node.js easier for everyone.

Happy coding!

How to Build a Java Torrent Server with Spring Boot and JLibtorrent

Mauro Mazzocchetti — Fri, 03 Oct 2025 09:22:55 +0000

Introduction

In the world of software development, managing torrents presents a fascinating technical challenge, especially when it comes to integrating peer-to-peer download functionality into Java applications. Today, we'll explore how to build a torrent server using Java, leveraging the power of Spring Boot and jlibtorrent, a native Java library for the BitTorrent protocol. This combination allows you to create robust applications for managing torrents, offering complete control over downloads, uploads, and session configuration.

Jlibtorrent is a Java binding for Libtorrent, one of the most efficient C++ libraries for BitTorrent. By integrating it with Spring Boot, we can provide a RESTful API for common torrent operations, making it simple to implement custom clients or servers. In this article, we will explore step-by-step how to build and configure our server, focusing on four key aspects: Maven dependency management, torrent session creation, download/preview/remove operations, and modifying settings.

1. Managing the `pom.xml` and Dependencies

The first step to integrating jlibtorrent into a Java project is to correctly configure the Maven pom.xml file. Our application will use Spring Boot as its main framework, so we'll start with a standard configuration.

Repository Configuration

Jlibtorrent is not available in the central Maven repository, so we need to add the Frostwire repository:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.5.6</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>java-torrent-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>java-torrent-server</name>
    <description>A simple Java torrent server</description>
    <properties>
        <java.version>17</java.version>
        <jlibtorrent.version>2.0.12.5</jlibtorrent.version>
    </properties>
    <repositories>
        <repository>
            <id>frostwire-maven</id>
            <url>https://dl.frostwire.com/maven</url>
        </repository>
    </repositories>
    <!-- ... -->
</project>

The Frostwire repository hosts the latest versions of jlibtorrent. Note that we are using Java 17 and Spring Boot 3.5.6 to ensure compatibility.

Core Dependencies

The key dependencies include Spring Boot Web for the REST API, jlibtorrent for the torrent logic, and some additional utilities:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    <dependency>
        <groupId>com.frostwire</groupId>
        <artifactId>jlibtorrent</artifactId>
        <version>${jlibtorrent.version}</version>
    </dependency>
    <dependency>
        <groupId>com.frostwire</groupId>
        <artifactId>jlibtorrent-windows</artifactId>
        <version>${jlibtorrent.version}</version>
    </dependency>
    <!-- Other dependencies for testing and documentation -->
</dependencies>

The jlibtorrent-windows dependency is specific to Windows systems and can be included in a conditional Maven profile for different platforms. Make sure you have the appropriate native libraries installed on the target system.

2. Creating the Torrent Session

The torrent session is the heart of the application. In our application, it is managed through a Spring configuration class that initializes the jlibtorrent SessionManager.

Session Configuration

We use a @Configuration class to define the SessionManager bean:

@Configuration
public class TorrentSessionConfig {
    private SessionManager sessionManager;

    @Bean
    public SessionManager sessionManager() {
        sessionManager = new SessionManager();
        sessionManager.addListener(new AlertListener() {
            @Override
            public int[] types() {
                return null; // Listen to all alerts
            }

            @Override
            public void alert(Alert<?> alert) {
                AlertType type = alert.type();
                switch (type) {
                    case ADD_TORRENT:
                        AddTorrentAlert addAlert = (AddTorrentAlert) alert;
                        addAlert.handle().resume();
                        // Handle torrent addition
                        break;
                    case TORRENT_FINISHED:
                        // Handle download completion
                        break;
                    // Other cases...
                }
            }
        });
        sessionManager.start();
        return sessionManager;
    }
}

The SessionManager handles communication with the BitTorrent network, including DHT (Distributed Hash Table) for peer discovery. The AlertListener allows you to react to events such as a torrent being added or a download completing.

Initialization and Shutdown

For proper resource management, we implement a shutdown method:

@PreDestroy
public void shutdown() {
    if (sessionManager != null && sessionManager.isRunning()) {
        sessionManager.stop();
    }
}

This ensures that the session is properly closed when the Spring application shuts down.

3. Downloading, Previewing, and Removing Torrents

With the session configured, we can proceed with the main torrent operations.

Adding a Torrent

Our server will support adding torrents from both magnet URIs and .torrent files:

public String addTorrent(String magnetUri, String path) {
    byte[] data = sessionManager.fetchMagnet(magnetUri, 30, new File("tmp"));
    if (data == null) {
        throw new RuntimeException("Unable to fetch torrent metadata");
    }
    TorrentInfo ti = TorrentInfo.bdecode(data);
    File saveDir = new File(path);
    sessionManager.download(ti, saveDir);
    return ti.infoHashV1().toString();
}

For local files:

public String addTorrentFromFile(String torrentFilePath, String path) {
    File torrentFile = new File(torrentFilePath);
    TorrentInfo ti = new TorrentInfo(torrentFile);
    File saveDir = new File(path);
    sessionManager.download(ti, saveDir);
    return ti.infoHashV1().toString();
}

Previewing Metadata

Before downloading, we can get information about the torrent:

public TorrentInfoDto getMagnetInfo(String magnetUri) {
    byte[] data = sessionManager.fetchMagnet(magnetUri, 30, new File("tmp"));
    TorrentInfo ti = TorrentInfo.bdecode(data);
    TorrentInfoDto dto = new TorrentInfoDto();
    dto.setName(ti.name());
    dto.setSize(ti.totalSize());
    dto.setInfoHash(ti.infoHashV1().toString());
    return dto;
}

This method retrieves the torrent's name, size, and hash without starting the download.

Removing a Torrent

Removal can also include deleting the downloaded files:

public void removeTorrent(String infoHash, boolean deleteFiles) {
    Sha1Hash sha1Hash = new Sha1Hash(infoHash);
    TorrentHandle handle = sessionManager.find(sha1Hash);
    if (deleteFiles) {
        sessionManager.remove(handle, SessionHandle.DELETE_FILES);
    } else {
        sessionManager.remove(handle);
    }
}

4. Changing Settings

Jlibtorrent offers granular control over session and individual torrent settings.

Session Settings

We can use a DTO to update global settings:

public void updateSessionSettings(UpdateSettingsRequest request) {
    SettingsPack sp = new SettingsPack();
    if (request.getDownloadRateLimit() != null) {
        sp.downloadRateLimit(request.getDownloadRateLimit());
    }
    if (request.getUploadRateLimit() != null) {
        sp.uploadRateLimit(request.getUploadRateLimit());
    }
    if (request.getMaxConnections() != null) {
        sp.connectionsLimit(request.getMaxConnections());
    }
    // Other settings...
    sessionManager.applySettings(sp);
}

Conclusion

This guide demonstrates how jlibtorrent can be effectively integrated into modern Java applications using Spring Boot. The combination of a RESTful API with the power of Libtorrent allows for the creation of flexible solutions for torrent management, from simply adding files to advanced configuration of limits and priorities.

The features explored in this article cover the most common use cases, but jlibtorrent offers many more possibilities, such as peer management, multi-file torrent support, and performance optimization. For more complex projects, consider implementing caching mechanisms for torrent states and more robust error handling. The code snippets provided here offer a practical foundation for structuring a torrent application in Java.

From Build-Time to Real-Time: A Better i18n Workflow for React

Mauro Mazzocchetti — Wed, 01 Oct 2025 08:49:17 +0000

Localization in React often starts simple. You install a library, add a couple of JSON files, and you're done. But as your project grows, that simple setup starts to show its cracks. Soon, you're reviewing PRs just to fix a typo, dealing with merge conflicts in massive translation files, and your translation team is blocked, waiting on developers for every single text update.

The core problem? We start by treating translations—which are content—as code.

Let's walk through an evolutionary path for managing translations in React, moving from a basic local setup to a fully automated, live-updating system that will make your life, and your team's life, so much easier.

Phase 1: The Humble Beginning - Local Files

Almost every project starts here. We pick a solid library like react-intl or react-i18next and create our language files.

The structure is familiar to us all:

/src
  /locales
    en.json
    it.json

en.json

{
  "sidebar.home": "Home",
  "buttons.submit": "Submit"
}

Then we wire it up in our app.

import { IntlProvider } from 'react-intl';
import messages_en from './locales/en.json';
// ... other locales

function App() {
  // Logic to determine locale and messages
  return (
    <IntlProvider messages={messages} locale={locale}>
      {/* The rest of your app */}
    </IntlProvider>
  );
}

The Drawback: While simple, this approach tightly couples your content to your codebase. Every change requires a developer, a PR, and a full deployment. It's slow and doesn't scale.

Phase 2: The First Big Leap - Automating at Build-Time 🚀

The first major improvement is to decouple translations from your source code. Let's treat them as data, fetching them from an external source of truth right before we build our app.

This is where a dedicated localization platform (like POEditor, Lokalise, or in our case, TnT - Terms and Translations, which has a generous free tier) comes in.

The workflow is straightforward:

Your translation team works on a user-friendly dashboard (TnT).
Before every build, a script pulls the latest versions of the language files into your project.

Let's create a simple script in scripts/fetch-translations.js:

// scripts/fetch-translations.js
const https = require('https');
const fs = require('fs');

const projectId = process.env.TNT_PROJECT_ID; // From your .env file
const apiKey = process.env.TNT_API_SECRET;   // From your .env file

const LANGUAGES = ['en', 'it', 'de'];
const TARGET_PATH = './src/locales';

async function fetchAllTranslations() {
  console.log('Fetching latest translations...');
  for (const lang of LANGUAGES) {
    const url = `https://localizationpro.tnl.one/api/v1/read-all/${projectId}?locale=${lang}`;
    // Add your fetch logic here to call the API with the key
    // and save the response to `${TARGET_PATH}/${lang}.json`
    console.log(`✅ Updated ${lang}.json successfully!`);
  }
}

fetchAllTranslations();

Then, we hook it into our package.json:

"scripts": {
  "translate:fetch": "node ./scripts/fetch-translations.js",
  "build": "npm run translate:fetch && react-scripts build",
  "start": "react-scripts start"
}

The Wins:

Automation: Translations are always fresh on deployment.
CI/CD Friendly: This script runs perfectly in GitHub Actions, GitLab CI, or any other pipeline.
Single Source of Truth: Your Git repo is clean. The truth lives on the localization platform.

Phase 3: The Ultimate Goal - Live Client-Side Updates ✨

This is the holy grail. What if we could update translations without a new deploy at all? This is the most agile approach, perfect for dynamic web apps where you want to push content changes instantly.

The idea is to stop bundling the JSON files altogether. Instead, the client's browser fetches them on its own and uses localStorage for intelligent caching.

Here's the workflow, which you can implement with TnT's specific APIs:

App Load:
- The app first checks localStorage for translations_it and a timestamp, last_update_it.
- If they exist, it loads them into react-intl instantly. The user sees translated text immediately.
Async Check:
- In the background, the app makes a lightweight call to TnT's check-last-edit endpoint for the current language. This endpoint is hyper-efficient—it only returns the timestamp of the last modification.
- GET /api/v1/check-last-edit/{projectId}?locale=it
- Response: { "updatedAt": "2025-10-01T10:00:00.000Z" }
Compare and Update:
- The app compares the updatedAt timestamp from the API with the one stored in localStorage.
- If the server's timestamp is newer, it means fresh translations are available! Only then does the app make a call to the read-all endpoint to download the full, updated JSON payload.
- The new translations and the new updatedAt timestamp are saved to localStorage, ready for the next visit.

The Superpower: Git-like Branching for Your Translations 🤯

This live-update model becomes incredibly powerful when combined with a feature like translation branching, which TnT supports. Just like Git, you can have a dev and a main branch for your content.

Staging Environment: Your staging app can be configured to fetch translations from the dev branch. This is where you test new features with their corresponding new text.
Production Environment: Your live app points to the main branch.

When the new feature is ready for release, a project admin can merge the translations from dev to main right from the TnT dashboard. The moment the merge happens, the updatedAt timestamp on the main branch changes. The next time a user opens your production app, it will automatically detect the change and download the updated text.

The Final Wins:

Instant Updates: Fix a typo in TnT, and it's live for your users in minutes. No deploy needed.
Safe, Collaborative Workflow: Developers, translators, and copywriters can work in parallel. An admin reviews and merges content, ensuring quality control.
Total Decoupling: The content lifecycle is now completely independent of the code deployment cycle.

By starting with a simple local file setup and evolving towards a live, API-driven model, you can build a robust, scalable, and incredibly efficient localization process for any React application.

Let's Build This Together

I'm building TnT as an open-source project, and feedback from fellow developers is the most valuable resource there is.

I'd love to hear what you think. If you try out the platform, have ideas, or run into any issues, please let me know.

I'm also exploring the idea of creating a dedicated React library (maybe react-tnt?) to make the live-update workflow even more seamless. If a helper library like that sounds useful to you, or you have ideas for what it should include, the best way to share your thoughts is by opening an issue on the GitHub repository.

Thanks for reading, and happy building