หน้าแรก>บทช่วยสอนการเขียนโปรแกรมเครือข่าย>การสอนจาวา

เจาะลึกคุณสมบัติใหม่บางอย่างของ Java 7 และการแนะนำ API ที่รองรับภาษาสคริปต์

ผู้เขียน：Eve Cole เวลาอัปเดต：2024-11-24 09:00:02

1. สามารถเพิ่มสตริงลงในคำสั่งแบบมีเงื่อนไขของสวิตช์ได้ วิธีการคือการใช้ค่า hashcode() ของสตริงเพื่อให้ได้ค่าที่แท้จริง
2. เพิ่มระบบฐานที่สามารถใช้ในตัวอักษร ไบนารี่ โดยเติม "0b" หรือ "0B" หน้าตัวเลข
3. ใช้ขีดล่างในตัวอักษรตัวเลขเพื่อแยกตัวเลขเพื่อให้อ่านง่ายขึ้นโดยไม่กระทบต่อขนาดของค่า หลักการพื้นฐานคือขีดเส้นใต้จะปรากฏได้ก็ต่อเมื่อมีตัวเลขอยู่ก่อนและหลังตัวเลขเท่านั้น
4.java7 ได้ทำการเปลี่ยนแปลงข้อยกเว้นสองประการ:

4.1 รองรับการจับข้อยกเว้นหลายรายการพร้อมกันในส่วนคำสั่ง catch และอีกอันคือทำให้ประเภทข้อยกเว้นมีความแม่นยำมากขึ้นเมื่อจับและเขียนข้อยกเว้นใหม่ เมธอด addSuppressed ถูกเพิ่มในคลาส Throwable ใน Java 7 เมื่อมีการโยนข้อยกเว้น ข้อยกเว้นอื่นๆ อาจถูกระงับเนื่องจากข้อยกเว้น และดังนั้นจึงไม่สามารถโยนได้ตามปกติ ในขณะนี้ คุณสามารถบันทึกวิธีการระงับเหล่านี้ผ่านทางวิธี addSuppressed ข้อยกเว้นที่ถูกระงับจะปรากฏในข้อมูลสแต็กของข้อยกเว้นที่ส่งออกไป ข้อดีของสิ่งนี้คือไม่มีข้อยกเว้นใดๆ สูญหาย ทำให้นักพัฒนาทดสอบได้ง่ายขึ้น

คัดลอกรหัสรหัส ดังต่อไปนี้:

ReadFile คลาสสาธารณะ () {
โมฆะสาธารณะอ่าน (ชื่อไฟล์ String) พ่น IOException {
อินพุต FileInputStream = null;
IOException readException = null;
พยายาม {
input = FileInputStream ใหม่ (ชื่อไฟล์);
} จับ (IOException เช่น) {
readException = อดีต;
} ในที่สุด {
ถ้า (อินพุต != null) {
พยายาม {
อินพุต.ปิด();
} จับ (IOException เช่น) {
ถ้า (readException != null) {
readException.addSuppressed (เช่น);
} อื่น {
readException = อดีต;
-
-
-
ถ้า (readException != null) {
โยน readException;
-
-
-
-

กุญแจสำคัญในแนวทางนี้คือการเพิ่มข้อยกเว้นที่สร้างขึ้นในคำสั่งสุดท้ายให้กับข้อยกเว้นที่สร้างโดยคำสั่ง try ผ่านวิธี addSuppressed


Java7 ปรับปรุงไวยากรณ์ของ catch clause เพื่อให้สามารถระบุข้อยกเว้นได้หลายรายการ ข้อยกเว้นแต่ละประเภทจะถูกคั่นด้วย "|" ควรสังเกตว่าข้อยกเว้นที่บันทึกไว้ในส่วนคำสั่ง catch ไม่สามารถมีประเภทซ้ำได้ และเป็นหนึ่งในข้อยกเว้นที่ได้รับอนุญาตให้เป็นคลาสย่อยของพารามิเตอร์ข้อยกเว้นอื่น มิฉะนั้นจะเกิดข้อผิดพลาดในการคอมไพล์ (จากตัวพิมพ์เล็กไปจนถึงตัวพิมพ์ใหญ่ ไม่มีปัญหา ). หากมีการประกาศข้อยกเว้นหลายรายการในส่วนคำสั่ง catch ประเภทเฉพาะของพารามิเตอร์ข้อยกเว้นจะเป็นขอบเขตบนขั้นต่ำของประเภทข้อยกเว้นเหล่านี้ทั้งหมด

4.2 ใช้ try (แอปพลิเคชันทรัพยากร) {การประมวลผลทางธุรกิจ} เพื่อเผยแพร่ทรัพยากรที่สามารถจัดการได้โดยคำสั่ง try จะต้องตรงตามเงื่อนไขเดียว นั่นคือคลาส java ต้องใช้อินเทอร์เฟซ java.lang.AutoCloseable มิฉะนั้นจะเกิดข้อผิดพลาดในการคอมไพล์ จะเกิดขึ้น วิธีการปิดของอินเทอร์เฟซนี้จะถูกเรียกโดยอัตโนมัติเมื่อจำเป็นต้องปล่อยทรัพยากร

5. ปรับการเรียกเมธอดให้เหมาะสมด้วยพารามิเตอร์ความยาวผันแปร:
คุณลักษณะใหม่ที่นำมาใช้ใน j2se5.0 คือการอนุญาตให้ใช้พารามิเตอร์ความยาวผันแปรในการประกาศวิธีการ พารามิเตอร์ที่เป็นทางการสุดท้ายของวิธีการสามารถระบุเพื่อแสดงพารามิเตอร์ประเภทเดียวกันจำนวนเท่าใดก็ได้ เมื่อเรียก พารามิเตอร์เหล่านี้จะถูกส่งผ่านในรูปแบบของอาร์เรย์ พารามิเตอร์เหล่านี้ยังสามารถอ้างอิงเป็นอาร์เรย์ในเนื้อหาของวิธีการได้

6. Java 7 แนะนำคำอธิบายประกอบใหม่ @SafeVarargs หากนักพัฒนาแน่ใจว่าวิธีการที่ใช้พารามิเตอร์ความยาวผันแปรจะไม่ทำให้เกิดสถานการณ์ที่คล้ายกันเมื่อใช้กับคลาสทั่วไป ก็สามารถประกาศด้วยคำอธิบายประกอบนี้ได้ คำอธิบายประกอบ @SafeVarargs สามารถใช้ได้เฉพาะกับเมธอดหรือคอนสตรัคเตอร์ที่มีความยาวพารามิเตอร์ผันแปรได้เท่านั้น และจะต้องประกาศเมธอดแบบคงที่หรือขั้นสุดท้าย มิฉะนั้นจะเกิดข้อผิดพลาดในการคอมไพล์ หลักฐานสำหรับวิธีการที่จะใส่คำอธิบายประกอบด้วย @SafeVarargs คือ นักพัฒนาจะต้องตรวจสอบให้แน่ใจว่าการประมวลผลพารามิเตอร์ประเภททั่วไปในการใช้งานวิธีการนี้ไม่ทำให้เกิดปัญหาด้านความปลอดภัยของประเภท

7.Java รองรับภาษาสคริปต์บางภาษาใน Java Virtual Machine ผ่านทางเครื่องมือสคริปต์ ในความเป็นจริง ตัวจัดการสคริปต์สนับสนุนวิธีการค้นหาสามวิธี ซึ่งกรอกตามชื่อ นามสกุลไฟล์ และประเภท MIME ชอบ

คัดลอกรหัสรหัส ดังต่อไปนี้:

โมฆะสาธารณะทักทาย () พ่น ScriptException {
ผู้จัดการ ScriptEngineManager = ScriptEngineManager ใหม่ ();
กลไก ScriptEngine = manager.getEngineByName("JavaScript");
ถ้า (เครื่องยนต์ == null) {
โยน RuntimeException ใหม่ ("ไม่พบเครื่องมือดำเนินการภาษา JavaScript");
-
engine.eval("println('สวัสดี');");
-

นอกจากนี้ยังสามารถพบได้ผ่าน getEngingByExtension("js") และ getEngineByMimeType("text/javascript") หลังจากได้รับอ็อบเจ็กต์ของกลไกสคริปต์ ScriptEngine แล้ว คุณสามารถรันโค้ดบางส่วนผ่านเมธอด eval และส่งคืนผลลัพธ์การดำเนินการของโค้ดนี้

7.1 การเชื่อมโยงภาษา:
ข้อได้เปรียบที่ยอดเยี่ยมของ API การรองรับภาษาสคริปต์คือ สร้างมาตรฐานการโต้ตอบระหว่างภาษา Java และภาษาสคริปต์ เพื่อให้โปรแกรมที่เขียนด้วยภาษา Java สามารถทำการเรียกเมธอดแบบสองทางและถ่ายโอนข้อมูลด้วยสคริปต์ได้ การถ่ายโอนข้อมูลทำได้ผ่านออบเจ็กต์การเชื่อมโยงภาษา สิ่งที่เรียกว่าอ็อบเจ็กต์การผูกภาษาคือตารางแฮชแบบธรรมดาที่ใช้จัดเก็บและรับข้อมูลที่จำเป็นต้องแชร์ ข้อมูลทั้งหมดสอดคล้องกับรายการในตารางแฮชนี้ และเป็นคู่ชื่อ-ค่าแบบง่าย อินเทอร์เฟซ javax.script.Bingings กำหนดอินเทอร์เฟซของอ็อบเจ็กต์การเชื่อมโยงภาษา ซึ่งสืบทอดมาจากอินเทอร์เฟซ java.util.Map กลไกจัดการสคริปต์อาจใช้วัตถุการผูกภาษาหลายภาษาระหว่างการดำเนินการ ภาษาที่ต่างกันมีขอบเขตที่แตกต่างกันสำหรับการเชื่อมโยงวัตถุ ตามค่าเริ่มต้น โปรแกรมสคริปต์จะให้ออบเจ็กต์การเชื่อมโยงภาษาหลายภาษาเพื่อจัดเก็บออบเจ็กต์ส่วนกลางที่สร้างขึ้นระหว่างการดำเนินการ คลาส ScriptEnging จัดเตรียมวิธีการใส่และรับเพื่อดำเนินการกับอ็อบเจ็กต์การเชื่อมโยงภาษาเริ่มต้นที่ใช้โดยเฉพาะในกลไกสคริปต์ โปรแกรมสามารถใช้ออบเจ็กต์การผูกภาษาเริ่มต้นนี้ได้โดยตรง หรือสามารถใช้ออบเจ็กต์การผูกภาษาของตนเองก็ได้ ในระหว่างการดำเนินการสคริปต์ ออบเจ็กต์การเชื่อมโยงภาษาถือได้ว่าเป็นตารางการแมปตัวแปรเพิ่มเติม ชื่อในอ็อบเจ็กต์การเชื่อมโยงภาษาจะถูกนำมาพิจารณาด้วยเมื่อแยกวิเคราะห์ค่าตัวแปร ตัวแปรร่วมและเนื้อหาอื่นๆ ที่สร้างขึ้นระหว่างการเรียกใช้สคริปต์จะปรากฏในอ็อบเจ็กต์การเชื่อมโยงภาษา ด้วยวิธีนี้ การถ่ายโอนข้อมูลแบบสองทางระหว่าง Java และภาษาสคริปต์จึงเสร็จสมบูรณ์
ตัวอย่างเช่น สตริงที่ชื่อ "ชื่อ" จะถูกเพิ่มให้กับอ็อบเจ็กต์การผูกภาษาเริ่มต้นของกลไกสคริปต์ผ่านเมธอด put ของ ScriptEngine จากนั้นอ็อบเจ็กต์นั้นจะถูกอ้างอิงโดยตรงด้วยชื่อในสคริปต์ ในทำนองเดียวกัน ตัวแปรโกลบอล "ข้อความ" ที่สร้างขึ้นในสคริปต์ยังสามารถรับได้ผ่านเมธอด get ของ ScriptEnging ช่วยให้สามารถถ่ายโอนข้อมูลแบบสองทางระหว่างโปรแกรม Java และสคริปต์ได้ การแปลงประเภทระหว่างการถ่ายโอนข้อมูลจะเสร็จสิ้นโดยกลไกสคริปต์ และกฎการแปลงจะขึ้นอยู่กับไวยากรณ์ของภาษานั้นๆ

คัดลอกรหัสรหัส ดังต่อไปนี้:

โมฆะสาธารณะ useDefaultBinging() พ่น ScriptException {
ผู้จัดการ ScriptEngineManager = ScriptEngineManager ใหม่ ();
กลไก ScriptEngine = manager.getEngineByName("JavaScript");
// เอ็นจิ้น ScriptEngine = getJavaScriptEnging();
engine.put("ชื่อ", "โลก");
engine.eval("var message = 'hello,'+name;");
engine.eval("println(ข้อความ)");
วัตถุ obj = engine.get("ข้อความ");
System.out.println(obj);
-

ในกรณีส่วนใหญ่ การใช้วิธี put and get ของ ScriptEnging ก็เพียงพอแล้ว หากใช้เฉพาะวิธีใส่และรับ อ็อบเจ็กต์การเชื่อมโยงภาษาจะโปร่งใสสำหรับนักพัฒนา ในบางกรณี จำเป็นต้องใช้อ็อบเจ็กต์การผูกภาษาของโปรแกรมเอง ตัวอย่างเช่น อ็อบเจ็กต์การผูกภาษามีข้อมูลเฉพาะของโปรแกรม หากคุณต้องการใช้อ็อบเจ็กต์การผูกภาษาของคุณเอง คุณสามารถเรียกใช้เมธอด creatBingings ของเอ็นจิ้นสคริปต์ หรือสร้างอ็อบเจ็กต์ javax.script.SimpleBingings แล้วส่งต่อไปยังเมธอด eval ของเอ็นจิ้นสคริปต์ เช่น:

คัดลอกรหัสรหัส ดังต่อไปนี้:

โมฆะสาธารณะ useCustomBinding() พ่น ScriptException
-
เอ็นจิ้น ScriptEngine = getJavaScriptEngine();
การผูก การผูก = SimpleBindings ใหม่ ();
Bindings.put("งานอดิเรก", "เล่นเกม");
engine.eval("println('ฉันชอบ'+งานอดิเรก);",ผูกมัด);
-

วัตถุการผูกภาษาที่ส่งผ่านวิธีการ eval จะมีผลเฉพาะในการเรียก eval ปัจจุบันเท่านั้น และไม่ได้เปลี่ยนวัตถุการผูกภาษาเริ่มต้นของกลไกจัดการ

7.2 บริบทการดำเนินการสคริปต์ อินเทอร์เฟซที่สำคัญอีกประการหนึ่งที่เกี่ยวข้องกับการดำเนินการของสคริปต์เอ็นจิ้นคือ javax.script.ScriptContext ซึ่งมีข้อมูลบริบทที่เกี่ยวข้องระหว่างการดำเนินการของเอ็นจิ้นสคริปต์ ซึ่งสามารถนำมาเปรียบเทียบกับอินเทอร์เฟซ javax.servlet.ServletContext ในข้อกำหนดเซิร์ฟเล็ตใน JavaEE . โปรแกรมสคริปต์ได้รับข้อมูลที่เกี่ยวข้องกับการดำเนินการสคริปต์โดยการอ้างอิงวัตถุบริบท และยังช่วยให้นักพัฒนาสามารถกำหนดค่าลักษณะการทำงานของโปรแกรมสคริปต์ผ่านวัตถุนี้ ออบเจ็กต์ด้านบนและด้านล่างประกอบด้วยข้อมูลสามประเภทต่อไปนี้เป็นหลัก
7.2.1 อินพุตและเอาต์พุต ขั้นแรก ข้อมูลการกำหนดค่าที่เกี่ยวข้องกับอินพุตและเอาต์พุตของสคริปต์จะถูกนำเสนอ รวมถึงอ็อบเจ็กต์ java.io.Reader ที่ใช้โดยสคริปต์เพื่ออ่านอินพุตข้อมูลระหว่างการดำเนินการ และ java.io.Writer ที่เอาต์พุตเนื้อหาที่ถูกต้องและ ข้อมูลข้อผิดพลาด ตามค่าเริ่มต้น อินพุตและเอาต์พุตของสคริปต์จะเกิดขึ้นในคอนโซลมาตรฐาน หากคุณต้องการเขียนเอาต์พุตของสคริปต์ลงในไฟล์ คุณสามารถใช้โค้ดต่อไปนี้ เปลี่ยนเส้นทางเอาต์พุตของสคริปต์ไปยังไฟล์ผ่านเมธอด setWriter ด้วยเมธอด setReader และ setErrorWriter ของ ScriptContext คุณสามารถตั้งค่าแหล่งอินพุตข้อมูลเมื่อมีการเรียกใช้สคริปต์และปลายทางเอาต์พุตของข้อความแสดงข้อผิดพลาดเมื่อเกิดข้อผิดพลาดตามลำดับ

คัดลอกรหัสรหัส ดังต่อไปนี้:

โมฆะสาธารณะ scriptToFile() พ่น IOException, ScriptException {
เอ็นจิ้น ScriptEngine = getJavaScriptEngine();
บริบท ScriptContext = engine.getContext();
context.setWriter(ตัวเขียนไฟล์ใหม่("output.txt"));
engine.eval("println('สวัสดีชาวโลก!');");
-

7.2.2 คุณสมบัติที่กำหนดเอง

ScriptContext ยังมีวิธีการรับและตั้งค่าแอตทริบิวต์ที่คล้ายกับใน ServletContext นั่นคือ setAttribute และ getAttribute ความแตกต่างก็คือแอตทริบิวต์ใน ScriptContext นั้นมีการกำหนดขอบเขต ความแตกต่างระหว่างขอบเขตที่ต่างกันคือลำดับการค้นหา แต่ละขอบเขตจะใช้จำนวนเต็มที่สอดคล้องกันเพื่อแสดงลำดับการค้นหา ยิ่งค่าจำนวนเต็มน้อย ลำดับความสำคัญก็จะยิ่งสูงขึ้นตามลำดับการค้นหา คุณสมบัติในขอบเขตที่มีลำดับความสำคัญสูงกว่าจะซ่อนคุณสมบัติที่มีชื่อเดียวกันในขอบเขตที่มีลำดับความสำคัญต่ำกว่า ดังนั้นคุณต้องระบุขอบเขตอย่างชัดเจนเมื่อตั้งค่าคุณสมบัติ เมื่อได้รับแอตทริบิวต์ คุณสามารถเลือกค้นหาในขอบเขตที่ระบุ หรือคุณสามารถเลือกที่จะค้นหาโดยอัตโนมัติตามลำดับความสำคัญของขอบเขต
อย่างไรก็ตาม ขอบเขตที่รวมอยู่ในการใช้งานบริบทการดำเนินการสคริปต์ได้รับการแก้ไขแล้ว นักพัฒนาไม่มีอิสระในการกำหนดขอบเขตของตนเอง รายการขอบเขตที่มีอยู่ทั้งหมดสามารถรับได้ผ่านเมธอด getScopes ของ ScriptContext มีขอบเขตที่กำหนดไว้ล่วงหน้าสองขอบเขตใน SciptContext: ขอบเขตที่แสดงโดยค่าคงที่ ScriptContext.ENGINE_SCOPE สอดคล้องกับกลไกสคริปต์ปัจจุบัน และขอบเขตที่แสดงโดย ScriptContext.GLOBAL_SCOPE สอดคล้องกับออบเจ็กต์กลไกสคริปต์ทั้งหมดที่สร้างขึ้นจากโรงงานกลไกเดียวกัน แบบแรกมีลำดับความสำคัญสูงกว่า ตัวอย่างเช่น:

คัดลอกรหัสรหัส ดังต่อไปนี้:

โมฆะสาธารณะ scriptContextAttribute(){
เอ็นจิ้น ScriptEngine = getJavaScriptEnging();
บริบท ScriptContext = engine.getContext();
context.setAttribute("ชื่อ", "โลก", ScriptContext.GLOBAL_SCOPE);
context.setAttribute("ชื่อ", "บ๊อบ", ScriptContext.ENGINE_SCOPE);
context.getAttribute("name");//ค่าคือ Bob
-

7.2.3 วัตถุที่มีผลผูกพันภาษา

ข้อมูลประเภทสุดท้ายในบริบทการดำเนินการสคริปต์คืออ็อบเจ็กต์การเชื่อมโยงภาษา อ็อบเจ็กต์การเชื่อมโยงภาษายังสอดคล้องกับขอบเขตด้วย ลำดับความสำคัญของขอบเขตเดียวกันนี้ใช้กับออบเจ็กต์ที่ผูกกับภาษา ลำดับความสำคัญนี้จะมีผลกระทบต่อความละเอียดของตัวแปรระหว่างการเรียกใช้สคริปต์ ตัวอย่างเช่น:

คัดลอกรหัสรหัส ดังต่อไปนี้:

โมฆะสาธารณะ scriptContextBindings() พ่น ScriptException
-
เอ็นจิ้น ScriptEngine = getJavaScriptEnging();
บริบท ScriptContext = engine.getContext();
การผูก การผูก 1 = engine.createBindings();
Bindings1.put("ชื่อ", "โลก");
context.setBindings (bindings1, ScriptContext.GLOBAL_SCOPE);
การผูก การผูก2 = engine.createBindings();
Bindings2.put("ชื่อ", "บ๊อบ");
context.setBindings (bindings2, ScriptContext.ENGINE_SCOPE);
engine.eval("println(name);");//ผลลัพธ์คือ Bob
-

คุณยังสามารถ Bindingsbindings = context.getBindings(ScriptContext.ENGINE_SCOPE);

Bindings.put("ชื่อ", "โลก")
engine.eval("println(ชื่อ);");

7.3 การรวบรวมสคริปต์:
โดยทั่วไปภาษาสคริปต์จะถูกตีความและดำเนินการ เอ็นจิ้นสคริปต์จำเป็นต้องแยกวิเคราะห์สคริปต์ก่อนดำเนินการขณะรันไทม์ โดยทั่วไปแล้ว การรันสคริปต์ผ่านการตีความจะช้ากว่าการรันสคริปต์หลังจากการคอมไพล์ เมื่อสคริปต์จำเป็นต้องดำเนินการหลายครั้ง สคริปต์สามารถคอมไพล์ก่อนได้ สคริปต์ที่คอมไพล์แล้วไม่จำเป็นต้องแยกวิเคราะห์ซ้ำๆ เมื่อดำเนินการ ซึ่งสามารถปรับปรุงประสิทธิภาพการดำเนินการได้ เอ็นจิ้นสคริปต์บางตัวไม่รองรับการคอมไพล์สคริปต์ หากกลไกสคริปต์สนับสนุนคุณลักษณะนี้ ระบบจะใช้อินเทอร์เฟซ javax.script.Compilable เพื่อประกาศสิ่งนี้ ผู้ใช้เอ็นจิ้นสคริปต์สามารถใช้ประโยชน์จากความสามารถนี้เพื่อปรับปรุงประสิทธิภาพของสคริปต์ที่จำเป็นต้องดำเนินการหลายครั้ง เอ็นจิ้นสคริปต์ JavaScript ที่มาพร้อมกับ Java SE รองรับการคอมไพล์สคริปต์
ในโค้ดต่อไปนี้ วิธีการคอมไพล์ของอินเทอร์เฟซการคอมไพล์จะใช้ในการคอมไพล์โค้ดสคริปต์ และผลการคอมไพล์จะแสดงด้วย javax.script.CompiledScript เนื่องจากเอ็นจิ้นสคริปต์บางตัวไม่รองรับอินเทอร์เฟซแบบคอมไพล์ได้ จึงจำเป็นต้องใช้ instanceof เพื่อตัดสินที่นี่ ในวิธีการรัน สคริปต์สามารถดำเนินการผ่านวิธี eval ของ CompiledScript ในโค้ด สคริปต์จะถูกดำเนินการซ้ำๆ 100 ครั้งเพื่อแสดงให้เห็นถึงข้อได้เปรียบด้านประสิทธิภาพของสคริปต์ที่คอมไพล์แล้วเมื่อดำเนินการซ้ำๆ

คัดลอกรหัสรหัส ดังต่อไปนี้:

สาธารณะ CompiledScript คอมไพล์ (String scriptText) พ่น ScriptException {
เอ็นจิ้น ScriptEngine = getJavaScriptEngine();
ถ้า (อินสแตนซ์ของเครื่องยนต์ที่คอมไพล์ได้) {
สคริปต์ CompiledScript = ((คอมไพล์ได้) engine).compile(scriptText);
-
กลับเป็นโมฆะ;
-

การรันโมฆะสาธารณะ (String scriptText) พ่น ScriptException {
สคริปต์ CompiledScript = คอมไพล์ (scriptText);
ถ้า (สคริปต์ == null) {
กลับ;
-
สำหรับ (int i = 0; i < 100; i++) {
script.eval();
-
-


วิธี eval ของ CompiledScript ยอมรับพารามิเตอร์เดียวกันกับวิธี eval ของ ScriptEngine

7.4 การเรียกเมธอดในสคริปต์ ในสคริปต์ วิธีที่ใช้กันทั่วไปและใช้งานได้จริงที่สุดคือเมธอด เอ็นจิ้นสคริปต์บางตัวอนุญาตให้ผู้ใช้เรียกเมธอดในสคริปต์เป็นรายบุคคล เอ็นจิ้นสคริปต์ที่รองรับการเรียกใช้เมธอดนี้สามารถใช้อินเทอร์เฟซ javax.script.Invocable ได้ ผ่านอินเทอร์เฟซ Invocable คุณสามารถเรียกใช้เมธอดระดับบนสุดในสคริปต์และเมธอดสมาชิกในอ็อบเจ็กต์ได้ หากวิธีการระดับบนสุดในสคริปต์หรือวิธีการสมาชิกในออบเจ็กต์ใช้อินเทอร์เฟซใน Java คุณสามารถขอรับออบเจ็กต์การใช้งานของอินเทอร์เฟซ Java ที่สอดคล้องกันในสคริปต์ผ่านวิธีการในอินเทอร์เฟซที่เรียกใช้ได้ ด้วยวิธีนี้ คุณสามารถกำหนดอินเทอร์เฟซในภาษา Java และนำไปใช้ในสคริปต์ได้ ส่วนอื่นๆ ของโปรแกรมที่ใช้อินเทอร์เฟซไม่ทราบว่าสคริปต์ใช้งานอินเทอร์เฟซนั้น เช่นเดียวกับอินเทอร์เฟซที่คอมไพล์ได้ การใช้งานอินเทอร์เฟซ Invocable ของ ScriptEngine ก็เป็นทางเลือกเช่นกัน
รหัสต่อไปนี้เรียกเมธอดระดับบนสุดในสคริปต์ผ่านการเรียกใช้ฟังก์ชันของอินเทอร์เฟซที่เรียกใช้ได้ พารามิเตอร์ระหว่างการโทรจะถูกส่งผ่านไปยังเมธอดในสคริปต์ เนื่องจากกลไกสคริปต์ JavaScript ที่มาพร้อมกับ JavaSE ใช้อินเทอร์เฟซ Invocable การตัดสินว่ากลไกใช้อินเทอร์เฟซ Invocalbe จะถูกละไว้ที่นี่ ตัวอย่างของการเรียกเมธอดระดับบนสุดของสคริปต์ใน Java:

คัดลอกรหัสรหัส ดังต่อไปนี้:

โมฆะสาธารณะ invokeFunction() พ่น ScriptException, NoSuchMethodException {
เอ็นจิ้น ScriptEngine = getJavaScriptEngine();
String scriptText ="function ทักทาย(ชื่อ) { println('hello,'+name );}";
engine.eval(ข้อความสคริปต์);
Invocable invocable=เครื่องยนต์ (Invocable);
invocable.inurgeFunction("ทักทาย", "โลก");
-

หากวิธีการที่เรียกว่าเป็นวิธีการสมาชิกของออบเจ็กต์ในสคริปต์ คุณต้องใช้วิธี invokeMethod ดังที่แสดงในโค้ดต่อไปนี้ วิธีการ getGreeting ในโค้ดเป็นของวัตถุ obj และวัตถุนี้จะต้องถูกส่งผ่านเข้าไป เป็นพารามิเตอร์เมื่อโทร

//ตัวอย่างการเรียกเมธอดสมาชิกของอ็อบเจ็กต์สคริปต์ใน Java

คัดลอกรหัสรหัส ดังต่อไปนี้:

โมฆะสาธารณะ inokeMethod() พ่น ScriptException, NoSuchMethodException
-
เอ็นจิ้น ScriptEngine = getJavaScriptEngine();
String scriptText = "var obj={ getGreeting:function(name){return 'Hello,'+name;}};";
engine.eval(ข้อความสคริปต์);
Invocable invocable = (Invocable) เครื่องยนต์;
ขอบเขตวัตถุ = engine.get("obj");
ผลลัพธ์ของวัตถุ = invocable.inurgeMethod (ขอบเขต, "getGreeting", "Alxx");
System.out.println (ผลลัพธ์);
-

วิธีการเรียกใช้วิธีการจะคล้ายกับวิธีการเรียกใช้ฟังก์ชั่น ความแตกต่างก็คือการเรียกใช้วิธีการต้องระบุวัตถุที่มีวิธีการที่จะเรียก

7.5 ใช้อินเทอร์เฟซ Java ในสคริปต์

ในเอ็นจิ้นสคริปต์บางตัว อินเตอร์เฟสสามารถกำหนดได้ในภาษา Java และการใช้งานอินเตอร์เฟสสามารถเขียนได้ในสคริปต์ ด้วยวิธีนี้ ส่วนอื่น ๆ ของโปรแกรมสามารถโต้ตอบกับอินเตอร์เฟส Java เท่านั้น และไม่จำเป็นต้องสนใจ วิธีการใช้งานอินเทอร์เฟซ ในโค้ดต่อไปนี้ Greet เป็นอินเทอร์เฟซที่กำหนดใน Java ซึ่งมีเมธอด getGreeting ใช้อินเทอร์เฟซนี้ในสคริปต์ ด้วยเมธอด getInterface คุณสามารถรับออบเจ็กต์ของอินเทอร์เฟซที่สคริปต์นำไปใช้และเรียกใช้เมธอดในนั้น

คัดลอกรหัสรหัส ดังต่อไปนี้:

โมฆะสาธารณะ useInterface () พ่น ScriptException {
เอ็นจิ้น ScriptEngine = getJavaScriptEngine();
String scriptText = "function getGreeting(name){return 'Hello,'+name;}";
engine.eval(ข้อความสคริปต์);
โปรแกรม Invocable invocable = (Invocable);
ทักทาย ทักทาย = invocable.getInterface(Greet.class);
System.out.println(greet.getGreeting("โลก"));
-

การใช้งานอินเทอร์เฟซข้างต้นเสร็จสิ้นโดยวิธีระดับบนสุดในสคริปต์ ในทำนองเดียวกัน ยังสามารถนำไปใช้โดยวิธีการสมาชิกของอ็อบเจ็กต์ในสคริปต์ได้อีกด้วย สำหรับกรณีนี้ เมธอด getInterface รูปแบบอื่นที่โอเวอร์โหลดสามารถยอมรับพารามิเตอร์เพิ่มเติมเพื่อระบุอ็อบเจ็กต์ที่มีการติดตั้งอินเทอร์เฟซได้

เนื่องจากไวยากรณ์ของภาษาสคริปต์มีความเรียบง่ายและยืดหยุ่น จึงเหมาะมากสำหรับผู้ใช้ที่ไม่มีพื้นฐานการเขียนโปรแกรมเพียงเล็กน้อยหรือเพียงเล็กน้อย ผู้ใช้เหล่านี้สามารถใช้ภาษาสคริปต์เพื่อปรับแต่งตรรกะทางธุรกิจและส่วนติดต่อผู้ใช้ของโปรแกรมได้ ภาษาสามารถปรับปรุงความสะดวกในการใช้งานโปรแกรมได้ มีความสมดุลที่ดีขึ้นระหว่างความยืดหยุ่นและความยืดหยุ่น ตัวอย่างเช่น ภาษาสคริปต์ Lua ถูกนำมาใช้กันอย่างแพร่หลายในการพัฒนาเกมเพื่อปรับแต่งพฤติกรรมภายในและอินเทอร์เฟซผู้ใช้ของเกม

8. แม้ว่า Reflection API จะนำความยืดหยุ่นมาสู่โปรแกรม Java แต่ก็มีต้นทุนด้านประสิทธิภาพเพิ่มเติมด้วย เนื่องจากกลไกการใช้งาน Reflection API สำหรับการดำเนินการเดียวกัน เช่น การเรียกใช้เมธอด การใช้ Reflection API เพื่อนำไปใช้งานแบบไดนามิกจะเร็วขึ้น แทนที่จะดำเนินการโดยตรงในแหล่งที่มา วิธีการเขียนโค้ดอาจช้ากว่าหนึ่งถึงสองลำดับ ด้วยการปรับปรุงการใช้งานเครื่องเสมือน Java ประสิทธิภาพของ Reflection API ได้รับการปรับปรุงอย่างมาก อย่างไรก็ตาม ช่องว่างด้านประสิทธิภาพนี้มีอยู่อย่างเป็นกลาง ดังนั้น ในบางแอปพลิเคชันที่มีข้อกำหนดด้านประสิทธิภาพค่อนข้างสูง จึงควรใช้ Reflection API ด้วยความระมัดระวัง

บทความที่เกี่ยวข้อง