Traditionally, Java has been a statically typed and compiled programming language, but with the growing need for flexibility and dynamic behavior in applications, Java incorporated scripting support through the Java Scripting API (JSR 223). This allowed Java applications to embed and execute scripts written in dynamic languages, such as JavaScript, directly within Java code.

Scripting in Java refers to the integration of scripting languages (interpreted or dynamic languages like JavaScript, Groovy, Python, etc.) into Java applications using the javax.script API. It allows developers to:
• Execute scripts at runtime.
• Modify or extend application logic without recompiling Java code.
• Create dynamic and configurable applications.
• Support plugins or user-defined logic.

The Java Scripting API was introduced in Java SE 6 as part of javax.script package.

Key Interfaces and Classes:
1. ScriptEngineManager: Creates and manages ScriptEngine instances.
2. ScriptEngine: Represents an interpreter for a specific scripting language.
3. Bindings: A map of key-value pairs passed to the scripting context.
4. ScriptContext: Contains script execution context such as input/output and variable scope.

Rhino and Nashorn

• Rhino: Originally the default JavaScript engine (developed by Mozilla) until Java 7.
• Nashorn: Introduced in Java 8 to replace Rhino. It provides improved performance and better integration with Java.
📝 Note: Nashorn has been deprecated in Java 11 and removed in Java 15, but it remains an important historical and educational tool.

import javax.script.*;
public class ScriptExample {
  public static void main(String[] args) throws ScriptException {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("nashorn");
    engine.eval("print('Hello from JavaScript!');");
  }
}

You can pass variables from Java to the script using the Bindings object:

Bindings bindings = engine.createBindings();
bindings.put("x", 10);
bindings.put("y", 20);
engine.setBindings(bindings, ScriptContext.ENGINE_SCOPE);
engine.eval("print('Sum = ' + (x + y));");

Nashorn supports calling Java methods/classes from scripts:

engine.eval("var File = Java.type('java.io.File');"
+ "var file = new File('test.txt');"
+ "print(file.getAbsolutePath());");

You can invoke a script function defined in JavaScript using the Invocable interface:

String script ="function greet(name) { return 'Hello, ' + name; }";
engine.eval(script);
Invocable invocable = (Invocable) engine;
String result = (String) invocable.invokeFunction("greet", "Abraham");
System.out.println(result); // Output: Hello, Abraham

• Flexibility: Modify behavior without recompilation.
• Rapid Prototyping: Ideal for testing ideas quickly.
• User Customization: End-users can define custom logic.
• Integration: Easily combine compiled Java and dynamic scripting.

• Performance: Interpreted scripts are slower than compiled Java.
• Security: Executing arbitrary scripts can be risky; sandboxing is often required.
• Maintenance: Debugging scripts may be harder than Java code.
• Deprecation of Nashorn: Newer Java versions don’t include Nashorn by default.

With Nashorn deprecated, here are modern alternatives:

import org.codehaus.groovy.jsr223.GroovyScriptEngineImpl;
ScriptEngine engine = new GroovyScriptEngineImpl();
engine.eval("println 'Hello from Groovy!'");

String script = "if (orderTotal > 1000) { discount = 10; } else { discount = 0; }";
Bindings bindings = engine.createBindings();
bindings.put("orderTotal", 1200);
engine.eval(script, bindings);
System.out.println("Discount: " + bindings.get("discount"));

Java's scripting support provides a powerful bridge between the compiled robustness of Java and the flexibility of interpreted scripting languages. While Nashorn served as the cornerstone for JavaScript integration, modern solutions like GraalVM are now preferred for multi-language scripting. The ability to execute scripts dynamically enables new architectures like plugin-based systems, configurable engines, and dynamic business rule processing.