Java වල JavaScript: Java Apps වල JS Run කරමු | Sinhala Guide
Java Applications ඇතුලේ JavaScript: සිංහලෙන් සම්පූර්ණ Guide එකක්!
Java Developer කෙනෙක් විදිහට, ඔයාගේ Applications වලට Dynamic බවක්, Flexibility එකක් සහ නවීන Features එකතු කරන්න කැමතිද? එහෙනම් මේ ලිපිය ඔයාටයි! අද අපි කතා කරන්න යන්නේ Java Application එකක් ඇතුලේ JavaScript scripts execute කරන ආකාරය සහ Java Objects සමඟ JavaScript වලින් interact කරන ආකාරය ගැනයි.
මුලින්ම මේක ටිකක් අමුතු දෙයක් විදිහට පෙනුනත්, Java වලට JavaScript add කිරීමෙන් අපිට incredible power එකක් ලැබෙනවා. විශේෂයෙන්ම, Dynamic Rule Engines, User-defined Scripts, සහ Configuration Logic වැනි දේවල් පහසුවෙන් implement කරන්න මේක ගොඩක් ප්‍රයෝජනවත් වෙනවා. අද අපි GraalVM JavaScript engine එක භාවිතා කරලා මේක කරන්නේ කොහොමද කියලා පියවරෙන් පියවර බලමු.
ඔයාගේ Java Project එකට අලුත් Dimension එකක් එකතු කරගන්න මේක හොඳ අවස්ථාවක්. එහෙනම්, අපි පටන් ගනිමු!
මොකක්ද මේ Java වලට JavaScript? (What's JavaScript in Java?)
සරලව කිව්වොත්, Java Application එකක් ඇතුලේ JavaScript code කෙලින්ම Run කරන්න පුළුවන් වෙන එක තමයි මේකෙන් අදහස් වෙන්නේ. මේ සඳහා Java Platform එකේ තියෙන Scripting API (JSR 223) භාවිතා කරනවා.
ඉස්සර Java 8 ඉඳලා Java 14 වෙනකම් Nashorn engine එක මේ සඳහා තිබුණා. නමුත් Java 15 වල සිට එය සම්පූර්ණයෙන්ම ඉවත් කළා (deprecated). ඒ වෙනුවට දැන් අපිට GraalVM JavaScript engine එක භාවිතා කරන්න පුළුවන්. මේක Nashorn වලට වඩා ගොඩක් performance වැඩි සහ නවීන Features තියෙන JavaScript engine එකක්.
ඇයි අපිට මේක ඕන වෙන්නේ? (Why Do We Need This?)
- Dynamic Logic: ඔයාගේ Application එකේ Business Rules නිතර වෙනස් වෙනවා නම්, JavaScript වලින් ඒ Rules ලියලා, Application එක recompile නොකරම runtime එකේදී update කරන්න පුළුවන්.
- User Customization: Users ලට තමන්ගේම scripts ලියලා Application එකේ functionality එක customize කරන්න අවස්ථාව දෙන්න පුළුවන්.
- Configuration Flexibility: Complex configurations files JavaScript වලින් ලියන්න පුළුවන්, plain text files වලට වඩා powerful විදිහට.
- Leveraging JavaScript Libraries: ඇතැම් අවස්ථාවලදී පවතින JavaScript libraries, Java project එකක් ඇතුලේ භාවිතා කරන්න මේක උදව් වෙනවා.
- Hybrid Applications: Java වල performance සහ stability එකත්, JavaScript වල flexibility එකත් එකට පාවිච්චි කරන්න පුළුවන්.
GraalVM JavaScript Engine එක Setup කරමු (Setting Up GraalVM JavaScript Engine)
ඔයා Maven හෝ Gradle වැනි Build Tool එකක් භාවිතා කරනවා නම්, pom.xml (Maven) හෝ build.gradle (Gradle) file එකට මේ Dependencies එකතු කරන්න ඕනේ. GraalVM JavaScript engine එක JSR 223 compatible නිසා, අපිට ScriptEngineManager හරහා මේක පාවිච්චි කරන්න පුළුවන්.
Maven Dependency:
<dependency>
<groupId>org.graalvm.js</groupId>
<artifactId>js</artifactId>
<version>23.1.2</version> <!-- නවතම Version එකක් භාවිතා කරන්න -->
</dependency>
<dependency>
<groupId>org.graalvm.js</groupId>
<artifactId>js-scriptengine</artifactId>
<version>23.1.2</version> <!-- නවතම Version එකක් භාවිතා කරන්න -->
</dependency>
Gradle Dependency:
// build.gradle
implementation 'org.graalvm.js:js:23.1.2'
implementation 'org.graalvm.js:js-scriptengine:23.1.2'
Tip: version එක සඳහා GraalVM එකේ නවතම stable version එක භාවිතා කරන්න. මේවා සාමාන්‍යයෙන් GraalVM documentation එකේ හොයාගන්න පුළුවන්.
සරලව JavaScript එකක් Java ඇතුලේ Execute කරමු (Simply Executing JavaScript in Java)
දැන් අපි බලමු කොහොමද Java code එකක් ඇතුලෙන් සරල JavaScript String එකක් Run කරන්නේ කියලා. මේ සඳහා අපි ScriptEngineManager සහ ScriptEngine Interfaces භාවිතා කරනවා.
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class SimpleJsExecution {
public static void main(String[] args) {
// ScriptEngineManager instance එකක් හදාගමු
ScriptEngineManager manager = new ScriptEngineManager();
// JavaScript Engine එක ලබාගමු
// "graal.js" කියන්නේ GraalVM JavaScript engine එක identify කරන නමයි.
// "javascript" හෝ "js" කියලත් උත්සාහ කරන්න පුළුවන්, නමුත් graal.js වඩාත් නිවැරදියි.
ScriptEngine engine = manager.getEngineByName("graal.js");
if (engine == null) {
System.err.println("Error: GraalVM JavaScript engine not found! " +
"Make sure you have added the correct dependencies.");
return;
}
try {
// සරල JavaScript code එකක් Execute කරමු
engine.eval("print('Hello from JavaScript inside Java!');");
// ගණිතමය ගණනය කිරීමක්
Object result = engine.eval("10 + 25");
System.out.println("Result of JS calculation: " + result);
// JavaScript variable එකක් define කරලා ඒක print කරමු
engine.eval("var name = 'Sri Lanka';");
engine.eval("print('Greetings from ' + name + '!');");
} catch (ScriptException e) {
// JavaScript execution එකේදී error එකක් ආවොත් අල්ලගමු
System.err.println("JavaScript Execution Error: " + e.getMessage());
e.printStackTrace();
}
}
}
මේ Code එක Run කලාම ඔයාට Console එකේ මේ වගේ Output එකක් බලාගන්න පුළුවන් වෙයි:
Hello from JavaScript inside Java!
Result of JS calculation: 35
Greetings from Sri Lanka!
දැන් ඔයා සාර්ථකව Java Application එකක් ඇතුලෙන් JavaScript Run කරන්න පුළුවන් තත්ත්වයට ඇවිත් තියෙනවා. නියමයි නේද!
Java Objects JavaScript වලට නිරාවරණය කිරීම (Exposing Java Objects to JavaScript)
අපිට Java වල තියෙන Objects, JavaScript code එක ඇතුලේ භාවිතා කරන්න අවස්ථාව දෙන්න පුළුවන්. මේකෙන් අපිට Java වල Data structures සහ Custom Objects, JavaScript වලින් manipulate කරන්න පුළුවන් වෙනවා. මේ සඳහා අපි Bindings සහ put() method එක භාවිතා කරනවා.
import javax.script.Bindings;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class JavaObjectToJs {
public static void main(String[] args) throws ScriptException {
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("graal.js");
if (engine == null) {
System.err.println("Error: GraalVM JavaScript engine not found!");
return;
}
// Java List එකක් හදාගමු
java.util.List<String> javaList = new java.util.ArrayList<>();
javaList.add("Apple");
javaList.add("Banana");
javaList.add("Cherry");
// Java object එක JavaScript engine context එකට දාමු
// 'myJavaList' කියන නමින් JavaScript ඇතුලෙන් මේ List එකට access කරන්න පුළුවන්.
engine.put("myJavaList", javaList);
// Simple Java object එකක් (String) එකක් දාමු
String message = "Hello from Java!";
engine.put("javaMessage", message);
// JavaScript code එකෙන් මේ Java Objects භාවිතා කරමු
String jsCode = ""
+ "print('Accessing Java List from JS:');\n"
+ "for (var i = 0; i < myJavaList.size(); i++) {\n"
+ " print(' - ' + myJavaList.get(i));\n"
+ "}\n"
+ "print('Java message: ' + javaMessage);\n"
+ "var newItem = 'Date';\n"
+ "myJavaList.add(newItem);\n"
+ "print('Item added to Java list from JS: ' + newItem);\n"
+ "print('New size of Java list: ' + myJavaList.size());\n";
engine.eval(jsCode);
// JavaScript වලින් වෙනස් කරපු Java List එක නැවත Java වලින් බලමු
System.out.println("\nJava List after JS modification: " + javaList);
}
}
මේ Code එක Run කලාම ඔයාට මේ වගේ Output එකක් බලාගන්න පුළුවන් වෙයි:
Accessing Java List from JS:
- Apple
- Banana
- Cherry
Java message: Hello from Java!
Item added to Java list from JS: Date
New size of Java list: 4
Java List after JS modification: [Apple, Banana, Cherry, Date]
මේකෙන් පෙන්නුම් කරන්නේ Java Objects වලට JavaScript වලින් Direct Access කරන්නත්, ඒවා Modify කරන්නත් පුළුවන් බවයි. මේක ගොඩක්ම Powerful Feature එකක්!
JavaScript වලින් Java Objects පාවිච්චි කරමු (Using Java Objects from JavaScript)
මේක කලින් එකේ අනිත් පැත්ත. JavaScript code එක ඇතුලේ ඉඳන්, අපිට කෙලින්ම Java Classes වලට access කරලා, Java Objects create කරලා, ඒවායේ methods call කරන්න පුළුවන්. GraalVM JavaScript engine එකේ මේ සඳහා Java.type() කියන Global Function එක භාවිතා වෙනවා.
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.time.LocalDateTime;
public class JsAccessToJavaObjects {
public static void main(String[] args) throws ScriptException {
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("graal.js");
if (engine == null) {
System.err.println("Error: GraalVM JavaScript engine not found!");
return;
}
String jsCode = ""
+ "// Java.type() භාවිතා කරලා Java Class එකකට Reference එකක් ගන්නවා\n"
+ "var ArrayList = Java.type('java.util.ArrayList');\n"
+ "var System = Java.type('java.lang.System');\n"
+ "var LocalDateTime = Java.type('java.time.LocalDateTime');\n"
+ "\n"
+ "// Java Object එකක් Create කරනවා\n"
+ "var myList = new ArrayList();\n"
+ "myList.add('First Item from JS');\n"
+ "myList.add('Second Item from JS');\n"
+ "\n"
+ "// Java Object එකේ Methods call කරනවා\n"
+ "System.out.println('List created by JS: ' + myList.toString());\n"
+ "System.out.println('List size: ' + myList.size());\n"
+ "\n"
+ "// Java Static Methods call කරනවා\n"
+ "var now = LocalDateTime.now();\n"
+ "System.out.println('Current Java Time from JS: ' + now);\n"
+ "\n"
+ "// Java Exception එකක් Create කරලා අල්ලගන්න උත්සාහ කරමු\n"
+ "try {\n"
+ " var file = new Java.type('java.io.File')('nonExistentFile.txt');\n"
+ " file.createNewFile(); // මේක error එකක් දෙයි\n"
+ "} catch (e) {\n"
+ " System.err.println('Caught Java Exception in JS: ' + e.getMessage());\n"
+ "}\n"
+ "";
engine.eval(jsCode);
}
}
මේ Code එක Run කලාම ඔයාට මේ වගේ Output එකක් බලාගන්න පුළුවන් වෙයි:
List created by JS: [First Item from JS, Second Item from JS]
List size: 2
Current Java Time from JS: 2023-10-27T10:30:00.123456789 (approx. current time)
Caught Java Exception in JS: nonExistentFile.txt (The system cannot find the path specified)
මේකෙන් පෙනෙනවා වගේ, JavaScript code එක ඇතුලෙන් Java's powerful libraries සහ APIs වලට පහසුවෙන් access කරන්න පුළුවන්. java.io.File වගේ Classes පවා JavaScript වලින් handle කරන්න පුළුවන්. ඒ වගේම Java Exceptions පවා JavaScript try-catch block එකක් ඇතුලේ අල්ලාගන්න පුළුවන්.
ප්‍රායෝගික භාවිතයන් සහ වැදගත් කරුණු (Practical Use Cases & Important Points)
දැන් අපි මේ Power එක කොහෙද ප්‍රායෝගිකව භාවිතා කරන්නේ කියලා බලමු:
- Dynamic Business Rules: ඔයාගේ Application එකේ Business Logic නිතර වෙනස් වෙනවා නම්, ඒවා JavaScript Files විදිහට deploy කරලා, Application එක restart නොකර update කරන්න පුළුවන්. උදාහරණයක් විදිහට, Discount Calculations, Shipping Rules වැනි දේවල්.
- Customizable User Workflows: Users ලට තමන්ගේම JavaScript Scripts ලියලා, Application එකේ behavior එක customize කරන්න අවස්ථාව දෙන්න පුළුවන්. Report Generation, Data Processing වැනි Task වලදී මේක ප්‍රයෝජනවත් වෙන්න පුළුවන්.
- Scripting for Configuration: XML, YAML වගේ Static Configuration Files වලට වඩා JavaScript Configuration Files වලින් ඔයාට Dynamic Logic එකතු කරන්න පුළුවන්.
- Extending Existing Applications: දැනට තියෙන Java Application එකකට අලුත් Features එකතු කරන්න, recompile නොකරම JavaScript භාවිතා කරන්න පුළුවන්.
වැදගත් කරුණු (Important Points):
- Performance: JavaScript execution, pure Java වලට වඩා slow වෙන්න පුළුවන්. Critical Performance Paths වලදී මේක සැලකිල්ලට ගන්න. නමුත් GraalVM JavaScript engine එක ගොඩක් optimized.
- Security: Untrusted JavaScript code Run කරනකොට ගොඩක් පරිස්සම් වෙන්න ඕනේ. ඒ Scripts වලට System Resources (File System, Network) වලට access දෙන්න කලින් දෙපාරක් හිතන්න. Sandboxing ගැන අධ්‍යනය කරන්න.
- Debugging: Java IDEs වලට JavaScript debugging සඳහා native support එකක් අඩු වෙන්න පුළුවන්. GraalVM debugger tools මේ සඳහා උදව් වෙන්න පුළුවන්.
- Error Handling: JavaScript code එකේ Errors එන අවස්ථාවලදී
ScriptExceptionඑක නිවැරදිව handle කරන්න මතක තියාගන්න.
සාරාංශය සහ ඉදිරි පියවර (Summary & Next Steps)
මේ tutorial එකෙන් අපි Java Applications ඇතුලේ JavaScript code execute කරන ආකාරය, Java Objects JavaScript වලට expose කරන ආකාරය සහ JavaScript වලින් Java Objects භාවිතා කරන ආකාරය ගැන ඉගෙන ගත්තා. විශේෂයෙන්ම, අපි GraalVM JavaScript engine එකේ powerful capabilities දැක්කා.
මේ Feature එක ඔයාගේ Java Applications වලට Dynamic Logic, Flexibility සහ Customization options එකතු කරගන්න ගොඩක් ප්‍රයෝජනවත් වෙයි. ඉතින්, බය නැතුව මේක ඔයාගේ ඊළඟ Project එකේදී උත්සාහ කරලා බලන්න!
ඔයාට මේ ගැන තියෙන අදහස්, ප්‍රශ්න, හෝ මේ වගේ Feature එකක් ඔයාගේ Projects වලදී භාවිතා කරලා තියෙනවා නම්, පහළින් Comment කරන්න! අපි හැමෝටම දැනුම බෙදාගමු.
