How to Use GraalVM to Execute JavaScript Code Making REST Calls Using Java?

Introduction

GraalVM is a powerful runtime that allows developers to execute multiple programming languages, including JavaScript, alongside Java. This flexibility makes it ideal for scenarios like integrating JavaScript logic into Java applications. In this tutorial, we will show you how to execute JavaScript code using GraalVM, specifically focusing on making REST API calls from JavaScript in a Java environment.

Problem Statement

You want to run the following JavaScript code in a Java program using GraalVM. The code uses Axios to make a REST API call to fetch posts from a public API.

JavaScript Code:

import axios from "axios";
const API_URL = "https://jsonplaceholder.typicode.com/posts";
const fetchPosts = async () => {
    try {
        const response = await axios.get(API_URL);
        console.log("Posts:", response.data);
    } catch (error) {
        console.error("Error fetching posts:", error);
    }
};
// Call the function
fetchPosts();

Solution: Using GraalVM to Execute the Code

Step 1: Install GraalVM

1. Download and install GraalVM.
2. Set up GRAALVM_HOME in your environment variables.
3. Install the JavaScript language plugin for GraalVM:

   gu install js

Step 2: Add Dependencies
Ensure that your project has the necessary dependencies to execute JavaScript. Use Maven or Gradle to include the graal-sdk library.

Maven Dependency:

<dependency>
    <groupId>org.graalvm.js</groupId>
    <artifactId>js</artifactId>
    <version>22.3.0</version>
</dependency>

Step 3: Write the Java Code

The JavaScript code provided imports Axios, which is a Node.js module. Since GraalVM doesn’t include Node.js modules by default, we need to handle the HTTP request using GraalVM’s Fetch API or replace Axios with Java-based libraries.

Here’s a modified JavaScript code that uses fetch (native to GraalVM):

const API_URL = "https://jsonplaceholder.typicode.com/posts";
const fetchPosts = async () => {
    try {
        const response = await fetch(API_URL);
        const data = await response.json();
        console.log("Posts:", data);
    } catch (error) {
        console.error("Error fetching posts:", error);
    }
};
// Call the function
fetchPosts();

Step 4: Execute the Code in Java
Here is the complete Java program to execute the above JavaScript code:

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.Value;

public class GraalVMJavaScriptExample {
    public static void main(String[] args) {
        // Create a GraalVM context for JavaScript
        try (Context context = Context.create("js")) {
            // JavaScript code
            String jsCode = """
                const API_URL = "https://jsonplaceholder.typicode.com/posts";
                const fetchPosts = async () => {
                    try {
                        const response = await fetch(API_URL);
                        const data = await response.json();
                        console.log("Posts:", data);
                    } catch (error) {
                        console.error("Error fetching posts:", error);
                    }
                };
                fetchPosts();
            """;
            // Evaluate JavaScript code
            context.eval("js", jsCode);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Step 5: Run the Program

1. Compile the program:

   javac GraalVMJavaScriptExample.java

2. Run the program using the GraalVM java command:

   java GraalVMJavaScriptExample

Solution Explanation

• Polyglot Context: The Context class provided by GraalVM allows running JavaScript inside Java.
• Fetch API: The native fetch API in GraalVM is used to make REST API calls. It’s simpler than using Axios in this case.
• Asynchronous Execution: GraalVM handles async JavaScript functions effectively, allowing you to await responses.

Keywords

• “Run JavaScript in Java using GraalVM”
• “Execute JavaScript with REST API in Java”
• “GraalVM Polyglot JavaScript example”
• “Fetch API using GraalVM Java”
• “Integrate JavaScript with REST calls in Java application”

Conclusion

GraalVM makes it easy to run JavaScript code, including REST calls, in a Java environment. By leveraging GraalVM’s Context and native features like the fetch API, you can seamlessly integrate JavaScript logic into your Java applications. Try this approach in your next polyglot project to take full advantage of GraalVM’s capabilities!