Introduction
With the deprecation of Nashorn in JDK 11, new approaches for running JavaScript on the JVM have emerged. The primary successors are GraalVM's JavaScript engine and alternative solutions that provide seamless JavaScript integration with Java applications.
GraalVM JavaScript Engine
Setting Up GraalVM JavaScript
// Maven dependencies for GraalVM JavaScript
/*
<dependency>
<groupId>org.graalvm.polyglot</groupId>
<artifactId>polyglot</artifactId>
<version>23.0.0</version>
</dependency>
<dependency>
<groupId>org.graalvm.js</groupId>
<artifactId>js</artifactId>
<version>23.0.0</version>
</dependency>
<dependency>
<groupId>org.graalvm.js</groupId>
<artifactId>js-scriptengine</artifactId>
<version>23.0.0</version>
</dependency>
*/
public class GraalVMSetup {
public void checkGraalVMAvailability() {
try {
Context context = Context.create("js");
System.out.println("GraalVM JavaScript engine is available");
context.close();
} catch (Exception e) {
System.err.println("GraalVM JavaScript engine not available: " + e.getMessage());
}
}
}
Basic JavaScript Execution
Simple Script Execution
import org.graalvm.polyglot.*;
import org.graalvm.polyglot.proxy.*;
public class BasicJavaScriptExecution {
public void executeSimpleScript() {
try (Context context = Context.create("js")) {
// Execute simple JavaScript
Value result = context.eval("js", "1 + 2 * 3");
System.out.println("Result: " + result.asInt()); // Result: 7
// Execute JavaScript functions
context.eval("js", "function greet(name) { return 'Hello, ' + name; }");
Value greetFunction = context.getBindings("js").getMember("greet");
Value greeting = greetFunction.execute("World");
System.out.println(greeting.asString()); // Hello, World
}
}
public void executeScriptWithVariables() {
try (Context context = Context.create("js")) {
// Set variables in JavaScript context
context.getBindings("js").putMember("x", 10);
context.getBindings("js").putMember("y", 20);
Value result = context.eval("js", "x + y");
System.out.println("x + y = " + result.asInt()); // x + y = 30
// Modify variables from JavaScript
context.eval("js", "z = x * y;");
Value z = context.getBindings("js").getMember("z");
System.out.println("z = " + z.asInt()); // z = 200
}
}
public void executeFileScript(String filePath) {
try (Context context = Context.create("js")) {
// Read and execute JavaScript from file
String script = new String(Files.readAllBytes(Paths.get(filePath)));
Value result = context.eval("js", script);
System.out.println("Script result: " + result);
} catch (IOException e) {
System.err.println("Error reading script file: " + e.getMessage());
}
}
}
Java-JavaScript Interoperability
Calling Java from JavaScript
public class JavaToJavaScriptInterop {
public static class UserService {
public String getUserName(int userId) {
return "User_" + userId;
}
public boolean isUserActive(int userId) {
return userId % 2 == 0;
}
public List<String> getUserRoles(int userId) {
return Arrays.asList("user", "reader");
}
}
public void exposeJavaToJavaScript() {
try (Context context = Context.create("js")) {
// Expose Java object to JavaScript
UserService userService = new UserService();
context.getBindings("js").putMember("userService", userService);
// Call Java methods from JavaScript
String script = """
var userName = userService.getUserName(123);
var isActive = userService.isUserActive(123);
var roles = userService.getUserRoles(123);
console.log('User: ' + userName);
console.log('Active: ' + isActive);
console.log('Roles: ' + roles);
// Return result to Java
{
name: userName,
active: isActive,
roles: roles
};
""";
Value result = context.eval("js", script);
System.out.println("User data: " + result);
}
}
public void useProxyObjects() {
try (Context context = Context.create("js")) {
// Create proxy objects for more control
ProxyObject userProxy = ProxyObject.fromMap(Map.of(
"name", "John Doe",
"age", 30,
"email", "[email protected]"
));
context.getBindings("js").putMember("user", userProxy);
String script = """
console.log('User: ' + user.name);
console.log('Age: ' + user.age);
user.age = 31; // Modify property
user.country = 'USA'; // Add new property
""";
context.eval("js", script);
// Access modified object from Java
Value user = context.getBindings("js").getMember("user");
System.out.println("Updated age: " + user.getMember("age").asInt());
System.out.println("New country: " + user.getMember("country").asString());
}
}
}
Calling JavaScript from Java
public class JavaScriptToJavaInterop {
public void callJavaScriptFunctions() {
try (Context context = Context.create("js")) {
// Define JavaScript functions
String script = """
function calculateArea(width, height) {
return width * height;
}
function formatUser(user) {
return user.name + ' (' + user.email + ')';
}
function processArray(numbers) {
return numbers.map(n => n * 2).filter(n => n > 10);
}
""";
context.eval("js", script);
// Call JavaScript functions from Java
Value calculateArea = context.getBindings("js").getMember("calculateArea");
Value area = calculateArea.execute(5, 10);
System.out.println("Area: " + area.asInt()); // Area: 50
// Pass Java objects to JavaScript
Map<String, Object> user = Map.of("name", "Alice", "email", "[email protected]");
Value formatUser = context.getBindings("js").getMember("formatUser");
Value formatted = formatUser.execute(user);
System.out.println("Formatted user: " + formatted.asString());
// Pass arrays between Java and JavaScript
Value processArray = context.getBindings("js").getMember("processArray");
Value processed = processArray.execute(new int[]{1, 5, 8, 12, 3});
System.out.println("Processed array: " + processed);
}
}
public void useJavaScriptLibraries() {
try (Context context = Context.create("js")) {
// Load and use JavaScript libraries
String lodashScript = """
// Simplified lodash-like functions
const _ = {
chunk: function(array, size) {
const chunks = [];
for (let i = 0; i < array.length; i += size) {
chunks.push(array.slice(i, i + size));
}
return chunks;
},
groupBy: function(array, key) {
return array.reduce((groups, item) => {
const group = item[key];
if (!groups[group]) groups[group] = [];
groups[group].push(item);
return groups;
}, {});
}
};
""";
context.eval("js", lodashScript);
// Use JavaScript library functions from Java
Value chunkFunction = context.getBindings("js").getMember("_").getMember("chunk");
Value chunks = chunkFunction.execute(new int[]{1, 2, 3, 4, 5, 6}, 2);
System.out.println("Chunks: " + chunks);
}
}
}
Advanced GraalVM Features
Performance Optimization
public class GraalVMOptimizations {
public void enableOptimizations() {
Context.Builder contextBuilder = Context.newBuilder("js")
.option("js.ecmascript-version", "2023") // Use latest ECMAScript
.option("js.experimental-foreign-object-prototype", "true") // Better interop
.allowExperimentalOptions(true)
.allowAllAccess(true); // Allow full access between Java and JS
try (Context context = contextBuilder.build()) {
// Optimized context for performance
String complexScript = """
function fibonacci(n) {
if (n <= 1) return n;
return fibonacci(n - 1) + fibonacci(n - 2);
}
// This will be optimized by GraalVM
fibonacci(35);
""";
long startTime = System.nanoTime();
Value result = context.eval("js", complexScript);
long endTime = System.nanoTime();
System.out.println("Fibonacci result: " + result.asInt());
System.out.println("Execution time: " + (endTime - startTime) / 1_000_000 + "ms");
}
}
public void useEngineCaching() {
// Cache compiled scripts for better performance
Map<String, Source> scriptCache = new ConcurrentHashMap<>();
public Value executeCachedScript(Context context, String scriptId, String scriptCode) {
Source source = scriptCache.computeIfAbsent(scriptId, id ->
Source.newBuilder("js", scriptCode, scriptId).build());
return context.eval(source);
}
public void demonstrateCaching() {
try (Context context = Context.create("js")) {
String script = "Math.pow(2, 10)";
// First execution - compiles and caches
long start1 = System.nanoTime();
Value result1 = executeCachedScript(context, "powerScript", script);
long end1 = System.nanoTime();
// Second execution - uses cached version
long start2 = System.nanoTime();
Value result2 = executeCachedScript(context, "powerScript", script);
long end2 = System.nanoTime();
System.out.println("First execution: " + (end1 - start1) / 1000 + "µs");
System.out.println("Second execution: " + (end2 - start2) / 1000 + "µs");
System.out.println("Result: " + result1.asInt());
}
}
}
}
Multi-Language Integration
public class MultiLanguageIntegration {
public void mixJavaScriptWithOtherLanguages() {
try (Context context = Context.newBuilder()
.allowAllAccess(true)
.build()) {
// Use JavaScript with other GraalVM languages
String multiLangScript = """
// JavaScript code
function processData(data) {
// Call R for statistical analysis
const rResult = Polyglot.eval('R',
'mean(c(' + data.join(',') + '))');
// Call Python for ML processing
const pythonResult = Polyglot.eval('python',
'import numpy as np; np.array([' + data.join(',') + ']).std()');
return {
mean: rResult,
stdDev: pythonResult
};
}
processData([1, 2, 3, 4, 5]);
""";
Value result = context.eval("js", multiLangScript);
System.out.println("Multi-language result: " + result);
}
}
public void useBuildersForComplexScripts() {
Source.Builder scriptBuilder = Source.newBuilder("js",
"""
function complexCalculation(input) {
let result = 0;
for (let i = 0; i < input.length; i++) {
result += input[i] * Math.sin(i * Math.PI / 180);
}
return result;
}
complexCalculation(data);
""", "complexCalculation.js");
try (Context context = Context.create("js")) {
Source source = scriptBuilder.build();
context.getBindings("js").putMember("data", new double[]{10, 20, 30, 40, 50});
Value result = context.eval(source);
System.out.println("Complex calculation result: " + result.asDouble());
} catch (IOException e) {
System.err.println("Error building source: " + e.getMessage());
}
}
}
Alternative Approaches
Using ScriptEngineManager (Compatibility Layer)
public class ScriptEngineCompatibility {
public void useScriptEngineAPI() {
try {
// Create script engine for JavaScript
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("graal.js");
if (engine == null) {
System.err.println("Graal.js engine not available");
return;
}
// Traditional ScriptEngine API usage
engine.put("name", "World");
Object result = engine.eval("'Hello, ' + name + '!'");
System.out.println(result); // Hello, World!
// Invoke JavaScript functions
engine.eval("function multiply(a, b) { return a * b; }");
Invocable invocable = (Invocable) engine;
Object multiplyResult = invocable.invokeFunction("multiply", 6, 7);
System.out.println("6 * 7 = " + multiplyResult); // 42
} catch (ScriptException | NoSuchMethodException e) {
System.err.println("Script execution error: " + e.getMessage());
}
}
public void nashornCompatibilityLayer() {
try {
ScriptEngine engine = new ScriptEngineManager().getEngineByName("graal.js");
// Enable Nashorn compatibility mode
if (engine instanceof GraalScriptEngine) {
GraalScriptEngine graalEngine = (GraalScriptEngine) engine;
graalEngine.eval("load('nashorn:mozilla_compat.js');");
}
// Use some Nashorn-specific features
engine.eval("""
// Nashorn compatibility
var ArrayList = Java.type('java.util.ArrayList');
var list = new ArrayList();
list.add('Hello');
list.add('World');
list;
""");
Object result = engine.eval("list");
System.out.println("Java list from JavaScript: " + result);
} catch (ScriptException e) {
System.err.println("Compatibility error: " + e.getMessage());
}
}
}
Spring Boot Integration
@Component
public class JavaScriptService {
private final Context context;
@Autowired
public JavaScriptService(UserRepository userRepository) {
this.context = Context.newBuilder("js")
.allowAllAccess(true)
.build();
// Expose Spring beans to JavaScript
context.getBindings("js").putMember("userRepository", userRepository);
context.getBindings("js").putMember("javaScriptService", this);
}
public Object executeBusinessRule(String ruleScript, Map<String, Object> parameters) {
try {
// Set parameters in JavaScript context
parameters.forEach((key, value) ->
context.getBindings("js").putMember(key, value));
// Execute business rule
Value result = context.eval("js", ruleScript);
return result.isNull() ? null : result.as(Object.class);
} catch (PolyglotException e) {
throw new JavaScriptExecutionException("Failed to execute JavaScript rule", e);
}
}
public List<User> filterUsersWithJavaScript(List<User> users, String filterScript) {
try {
context.getBindings("js").putMember("users", users);
String script = """
const filteredUsers = users.filter(user => %s);
javaScriptService.convertToJavaList(filteredUsers);
""".formatted(filterScript);
Value result = context.eval("js", script);
return result.as(new TypeLiteral<List<User>>() {});
} catch (PolyglotException e) {
throw new JavaScriptExecutionException("Failed to filter users", e);
}
}
// Called from JavaScript to convert results
public List<User> convertToJavaList(Value jsArray) {
List<User> result = new ArrayList<>();
for (long i = 0; i < jsArray.getArraySize(); i++) {
Value userValue = jsArray.getArrayElement(i);
User user = userValue.as(User.class);
result.add(user);
}
return result;
}
@PreDestroy
public void cleanup() {
if (context != null) {
context.close();
}
}
}
@RestController
public class JavaScriptRuleController {
@Autowired
private JavaScriptService jsService;
@PostMapping("/api/rules/execute")
public ResponseEntity<?> executeRule(@RequestBody RuleExecutionRequest request) {
try {
Object result = jsService.executeBusinessRule(
request.getScript(),
request.getParameters()
);
return ResponseEntity.ok(Map.of("result", result));
} catch (JavaScriptExecutionException e) {
return ResponseEntity.badRequest()
.body(Map.of("error", e.getMessage()));
}
}
}
Error Handling and Debugging
Comprehensive Error Handling
public class JavaScriptErrorHandling {
public void executeWithErrorHandling() {
try (Context context = Context.create("js")) {
String problematicScript = """
function divide(a, b) {
if (b === 0) {
throw new Error('Division by zero');
}
return a / b;
}
divide(10, 0);
""";
try {
Value result = context.eval("js", problematicScript);
System.out.println("Result: " + result);
} catch (PolyglotException e) {
System.err.println("JavaScript error: " + e.getMessage());
System.err.println("Source location: " + e.getSourceLocation());
System.err.println("Stack trace: " + Arrays.toString(e.getStackTrace()));
}
}
}
public void addErrorListener() {
try (Context context = Context.newBuilder("js")
.onPolyglotException((exception) -> {
System.err.println("Polyglot exception occurred:");
System.err.println(" Message: " + exception.getMessage());
System.err.println(" Language: " + exception.getLanguage());
if (exception.getSourceLocation() != null) {
System.err.println(" Location: " + exception.getSourceLocation());
}
return null; // Continue execution
})
.build()) {
String script = """
console.log('This will execute');
throw new Error('This is a test error');
console.log('This will not execute');
""";
context.eval("js", script);
}
}
public void validateScriptSyntax(String script) {
try (Context context = Context.create("js")) {
// Parse without executing to check syntax
Source source = Source.newBuilder("js", script, "validation.js").build();
source.getCharacters(); // This will throw if syntax is invalid
System.out.println("Script syntax is valid");
} catch (IOException e) {
System.err.println("Invalid script syntax: " + e.getMessage());
}
}
}
Real-World Use Cases
Dynamic Business Rules Engine
public class BusinessRulesEngine {
private final Map<String, Source> ruleCache = new ConcurrentHashMap<>();
private final Context context;
public BusinessRulesEngine() {
this.context = Context.newBuilder("js")
.allowAllAccess(true)
.build();
// Load utility functions
loadUtilityFunctions();
}
private void loadUtilityFunctions() {
String utils = """
function isWeekend(date) {
const day = date.getDay();
return day === 0 || day === 6;
}
function calculateDiscount(amount, percentage) {
return amount * (percentage / 100);
}
function isEligibleForPromotion(user, orderAmount) {
return user.memberLevel === 'GOLD' && orderAmount > 100;
}
""";
context.eval("js", utils);
}
public void registerRule(String ruleId, String ruleScript) {
Source source = Source.newBuilder("js", ruleScript, ruleId + ".js").build();
ruleCache.put(ruleId, source);
}
public Object executeRule(String ruleId, Map<String, Object> contextVars) {
Source source = ruleCache.get(ruleId);
if (source == null) {
throw new IllegalArgumentException("Rule not found: " + ruleId);
}
try {
// Set context variables
contextVars.forEach((key, value) ->
context.getBindings("js").putMember(key, value));
return context.eval(source).as(Object.class);
} catch (PolyglotException e) {
throw new RuleExecutionException("Failed to execute rule: " + ruleId, e);
}
}
// Example usage
public void demonstrateRuleEngine() {
// Register pricing rule
registerRule("discountRule", """
function applyDiscount(order) {
let discount = 0;
if (isEligibleForPromotion(order.user, order.amount)) {
discount = calculateDiscount(order.amount, 10);
}
if (order.amount > 500) {
discount += calculateDiscount(order.amount, 5);
}
return {
originalAmount: order.amount,
discount: discount,
finalAmount: order.amount - discount
};
}
applyDiscount(order);
""");
// Execute rule
Map<String, Object> order = Map.of(
"amount", 600.0,
"user", Map.of("memberLevel", "GOLD", "name", "John Doe")
);
Object result = executeRule("discountRule", Map.of("order", order));
System.out.println("Discount result: " + result);
}
}
Template Rendering Engine
public class JavaScriptTemplateEngine {
private final Context context;
public JavaScriptTemplateEngine() {
this.context = Context.newBuilder("js")
.allowAllAccess(true)
.build();
// Load template engine library (simplified)
loadTemplateLibrary();
}
private void loadTemplateLibrary() {
String templateLib = """
function renderTemplate(template, data) {
return template.replace(/\\{\\{([^}]+)\\}\\}/g, function(match, key) {
return data[key.trim()] || '';
});
}
function renderLoopTemplate(template, items, itemName) {
const loopPattern = new RegExp(
`{% for ${itemName} in items %}(.*?){% endfor %}`,
'gs'
);
return template.replace(loopPattern, function(match, content) {
return items.map(item =>
renderTemplate(content, {[itemName]: item})
).join('');
});
}
""";
context.eval("js", templateLib);
}
public String renderTemplate(String template, Map<String, Object> data) {
try {
context.getBindings("js").putMember("template", template);
context.getBindings("js").putMember("data", data);
Value result = context.eval("js",
"renderTemplate(template, data)");
return result.asString();
} catch (PolyglotException e) {
throw new TemplateRenderingException("Failed to render template", e);
}
}
public String renderWithLoop(String template, List<Object> items, String itemName) {
try {
context.getBindings("js").putMember("template", template);
context.getBindings("js").putMember("items", items);
context.getBindings("js").putMember("itemName", itemName);
Value result = context.eval("js",
"renderLoopTemplate(template, items, itemName)");
return result.asString();
} catch (PolyglotException e) {
throw new TemplateRenderingException("Failed to render template with loop", e);
}
}
}
Performance Best Practices
public class JavaScriptPerformanceTips {
public void performanceBestPractices() {
// 1. Reuse Context objects
try (Context context = Context.create("js")) {
// Multiple evaluations in same context
for (int i = 0; i < 100; i++) {
context.eval("js", "Math.sqrt(" + i + ")");
}
}
// 2. Use Value objects efficiently
try (Context context = Context.create("js")) {
Value array = context.eval("js", "[1, 2, 3, 4, 5]");
// Prefer Value methods over converting to Java objects
long size = array.getArraySize();
for (long i = 0; i < size; i++) {
Value element = array.getArrayElement(i);
System.out.println(element.asInt());
}
}
// 3. Batch operations
try (Context context = Context.create("js")) {
String batchScript = """
function processBatch(items) {
return items.map(item => ({
id: item.id,
processed: item.value * 2,
timestamp: Date.now()
}));
}
""";
context.eval("js", batchScript);
Value processFunction = context.getBindings("js").getMember("processBatch");
List<Map<String, Object>> batchData = createBatchData(1000);
Value result = processFunction.execute(batchData);
// Process result without converting to Java immediately
}
}
private List<Map<String, Object>> createBatchData(int size) {
List<Map<String, Object>> data = new ArrayList<>();
for (int i = 0; i < size; i++) {
data.add(Map.of("id", i, "value", i * 10));
}
return data;
}
// 4. Use proper memory management
public void memoryManagement() {
Context context = Context.newBuilder("js")
.option("js.experimental-foreign-object-prototype", "true")
.build();
try {
// Large data processing
Value largeArray = context.eval("js", "new Array(1000000).fill(0).map((_, i) => i)");
// Process in chunks to avoid memory issues
long chunkSize = 10000;
long arraySize = largeArray.getArraySize();
for (long i = 0; i < arraySize; i += chunkSize) {
Value chunk = context.eval("js",
"largeArray.slice(" + i + ", " + (i + chunkSize) + ")");
processChunk(chunk);
}
} finally {
context.close();
}
}
private void processChunk(Value chunk) {
// Process chunk of data
System.out.println("Processing chunk of size: " + chunk.getArraySize());
}
}
Conclusion
GraalVM's JavaScript engine provides a robust, high-performance replacement for Nashorn with several advantages:
- Better Performance - Advanced JIT compilation and optimizations
- Modern ECMAScript - Full support for ES2023+ features
- Seamless Interop - Excellent Java-JavaScript interoperability
- Multi-Language - Integration with other GraalVM languages
- Enterprise Ready - Production-ready with good tooling and monitoring
By following these patterns and best practices, you can successfully migrate from Nashorn and leverage the full power of modern JavaScript execution on the JVM while maintaining compatibility with existing codebases.