Java 9 – ทั้งหมดที่คุณต้องรู้เกี่ยวกับคุณสมบัติของ Java . ใหม่

เผยแพร่แล้ว: 2018-04-24

Java ซึ่งเป็นภาษาการเขียนโปรแกรมที่สามารถเข้าถึงได้ง่ายนั้นเป็นเกมง่ายๆ สำหรับนักพัฒนาทั่วโลก นับตั้งแต่เริ่มก่อตั้งในปี 2538 ภาษานี้มีการใช้งานอย่างกว้างขวางในอุตสาหกรรมต่างๆ

วันนี้ คุณจะพบ Java บนโทรศัพท์ของคุณ ขับเคลื่อนระบบปฏิบัติการ Android และแอพมากมายที่ Android นำเสนอ ใช้สำหรับพัฒนาเกมอย่าง Minecraft ซึ่งมีฐานผู้เล่นจำนวนมาก นอกจากนี้ยังพบการใช้งานในแอปพลิเคชันทางธุรกิจ เช่น การอ่านข้อมูลบัตรเครดิตที่หน้าร้าน และการป้อนข้อมูลระหว่างระบบกับธนาคาร

หลังจากห่างหายไป 3 ปี Java ได้เปิดตัวรุ่นใหม่ - Java SE 9 ด้วยการเปลี่ยนแปลงทางสถาปัตยกรรมที่สำคัญหลายประการและคุณสมบัติเสริม Java SE 9 นำเสนอโซลูชันอันทรงพลังที่นักพัฒนาต่างใฝ่หา

Java 7 ได้เพิ่ม try-with-resource ในปี 2011 ซึ่งนำเสนอฟังก์ชันการจัดการทรัพยากรที่ดีขึ้น
Java 8 เพิ่มนิพจน์แลมบ์ดาซึ่งเป็นการเคลื่อนไหวที่ดี แต่มีข้อบกพร่องเล็กน้อยภายใต้กระบวนทัศน์ OOP

ตอนนี้ Java Solutions ช่วยให้โปรแกรมเมอร์มีวิธีการส่วนตัว วิธีคงที่ส่วนตัว! ใช่ คุณอ่านถูกแล้ว!

Java SE 8 นำเสนอการเปลี่ยนแปลงโครงสร้างมากมายที่ได้รับจากอารมณ์ที่หลากหลายโดยนักพัฒนา หลักๆ แล้ว นี่คือจุดอ่อนของ Java SE 8 ที่ Java SE 9 พยายามเอาชนะ:

  1. JDK ไม่สามารถนำทางได้สำหรับอุปกรณ์คอมพิวเตอร์ขนาดเล็ก
  2. ไม่มีการปรับปรุงโดยรวมในประสิทธิภาพของแอปพลิเคชัน
  3. ไม่มีการรักษาความปลอดภัยโดยรวมและการบำรุงรักษา JDK
  4. นักพัฒนา Java ประสบปัญหาในการสร้างและรักษาไลบรารีโค้ดและแอปพลิเคชันขนาดใหญ่ขึ้น

มาดูการเปลี่ยนแปลงและการปรับปรุงที่สำคัญที่ Java 9 นำเสนอเหนือรุ่นก่อนๆ กัน

อัปเดตกระบวนการ API ใน Java 9

ตามเนื้อผ้า API ของ Java มีลักษณะดั้งเดิม ที่รองรับการเปิดกระบวนการใหม่ เปลี่ยนเส้นทางเอาต์พุต และสตรีมข้อผิดพลาด ใน Java 9 การอัปเดตใหม่สำหรับ Process API เปิดใช้งาน:

  1. รับ PID ของกระบวนการ JVM ปัจจุบันและอื่น ๆ
  2. การจัดการกระบวนการย่อย
  3. การจัดการกระบวนการย่อย
  4. รับข้อมูล เช่น PID ชื่อ และการใช้ทรัพยากรของกระบวนการที่ทำงานอยู่ในระบบ

นี่คือตัวอย่างโค้ด ซึ่งจะพิมพ์ PID ปัจจุบันและข้อมูลกระบวนการปัจจุบัน:

public class NewFeatures
{
public static void main(String [] args)
{
ProcessHandle currentProcess = ProcessHandle.current();
System.out.println("PID:"+ currentProcess.getPid());
ProcessHandle.Info currentProcessInfo = currentProcess.info();
System.out.println("Info:" + currentProcessInfo);
}
}

ไคลเอนต์ HTTP/2 ใน Java 9

ฟีเจอร์นี้คาดว่าจะได้รับการปฏิรูปในรุ่นต่อๆ ไป หรืออาจถูกลบออกโดยสิ้นเชิง
ก่อนหน้านี้นักพัฒนาซอฟต์แวร์จะใช้ไลบรารีของบุคคลที่สาม เช่น Apache HTTP, Jersey และอื่นๆ อีกมากมาย HTTP API ของ Java มีมาก่อนข้อกำหนด HTTP/1.1 และซิงโครนัสและดูแลรักษายาก ข้อจำกัดเหล่านี้เรียกร้องให้ต้องเพิ่ม API ใหม่ API ไคลเอ็นต์ HTTP ใหม่มีดังต่อไปนี้:

  1. API ที่ง่ายและรัดกุมเพื่อจัดการกับคำขอ HTTP ส่วนใหญ่
  2. รองรับข้อกำหนด HTTP/2
  3. ประสิทธิภาพที่ดีขึ้น
  4. ความปลอดภัยที่ดีขึ้น
  5. การปรับปรุงเพิ่มเติมอีกเล็กน้อย

นี่คือข้อมูลโค้ดสำหรับส่งคำขอ HTTP GET โดยใช้ API ใหม่ นี่คือโมดูลตามที่กำหนดไว้ในไฟล์ module-info.java:

module newfeatures{
requires jdk.incubator.httpclient;
}

รหัสต่อไปนี้ใช้ HTTP Client API นี่เป็นส่วนหนึ่งของโมดูล jdk.incubator.httpclient :

import jdk.incubator.http.*;
import java.net.URI;
public class Http2Feature{
public static void main(String[] args) throws Exception{
HttpClient client = HttpClient.newBuilder().build();
HttpRequest request = HttpRequest
.newBuilder(new URI(http://httpbin.org/get;))
.GET()
.version(HttpClient.Version.HTTP_1_1)
.build();
HttpResponse.String response = client.send(request,
HttpResponse.BodyHandler.asString());
System.out.println("Status code:" + response.statusCode());
System.out.println("Response Body:" + response.body());
}
}
}

คุณสมบัติการอัพเดทพร้อมกันเพิ่มเติมใน Java 9

ด้วย Java 9 คลาสใหม่ที่ชื่อ – java.util.concurrent.Flow ได้รับการแนะนำ ซึ่งสนับสนุนการใช้งานเฟรมเวิร์ก publish-subscribe เฟรมเวิร์กนี้ช่วยให้นักพัฒนาสามารถสร้างส่วนประกอบได้ ส่วนประกอบเหล่านี้สามารถใช้สตรีมข้อมูลแบบสดแบบอะซิงโครนัสโดยการตั้งค่าผู้เผยแพร่ที่สร้างข้อมูลและสมาชิกที่ใช้ข้อมูล นี่คืออินเทอร์เฟซใหม่:

  • java.util.concurrent.Flow.Publisher
  • java.util.concurrent.Flow.Subscriber
  • java.util.concurrent.Flow.Subscription
  • java.util.concurrent.Flow.Processor (ซึ่งทำหน้าที่เป็นทั้ง Publisher และ Subscriber)

การเขียนสคริปต์ Java Shell (Read-Eval-Print-Loop) ใน Java 9

เป้าหมายของ Project Kulla คือการตรวจสอบการเพิ่มเครื่องมือ REPL (Read-Eval-Print-Loop) สำหรับ Java 9 Java รุ่นนี้มีเครื่องมือบรรทัดคำสั่งพิเศษที่เรียกว่า JShell เป้าหมายที่นี่คือการทำให้เป็นที่นิยมและใช้งาน REPL ให้เกิดประโยชน์สูงสุด แล้วมันหมายความว่ายังไง? ตอนนี้ คุณไม่จำเป็นต้องห่อโค้ดสองสามบรรทัดในวิธีที่แยกต่างหากเพื่อเรียกใช้ มีประสิทธิภาพ? ฉันบอกว่าใช่.
ตัวอย่างเช่น ใน Scala โปรแกรม Hello World แบบธรรมดาเขียนเป็น scala>println("Hello World");
เรียกใช้คำสั่ง JShell ดังที่แสดงในภาพต่อไปนี้:

ภาษาโปรแกรม จาวา 9

โครงการจิ๊กซอว์ใน Java 9

ทรัมป์การ์ดของฟีเจอร์ใหม่ใน Java 9 คือระบบ aall-newmodule การสร้างระบบที่ซับซ้อนมักเกี่ยวข้องกับรหัสที่ซับซ้อนในระดับสูง ซึ่งส่งผลให้เกิดความคลุมเครือ ด้วยความซับซ้อนของโค้ด จะต้องเผชิญกับปัญหาพื้นฐานสองประการ: การห่อหุ้มโค้ดนั้นทำได้ยาก และไม่มีแนวคิดเรื่องการพึ่งพาที่ชัดเจนระหว่างไฟล์ JAR ต่างๆ ของระบบ ทุกคลาสสาธารณะสามารถเข้าถึงได้โดยคลาสสาธารณะอื่นบนพาธคลาส สิ่งนี้นำไปสู่การใช้งานคลาสที่ไม่จำเป็นซึ่งไม่ได้ตั้งใจให้เป็น API สาธารณะ นอกจากนี้ classpath เองก็มีปัญหา: คุณจะรู้ได้อย่างไรว่ามี JAR ที่จำเป็นทั้งหมดหรือไม่ แล้วรายการที่ซ้ำกันล่ะ? ระบบโมดูลสามารถแก้ไขปัญหาทั้งสองได้
นี่คือจุดที่มองเห็นธรรมชาติที่แข็งแกร่งของ Java 9 ไฟล์ JAR แบบแยกส่วนมีตัวอธิบายโมดูลเพิ่มเติม ในตัวอธิบายโมดูลนี้ คำสั่ง "requires" ถูกใช้เพื่อแสดงการพึ่งพาโมดูลอื่นๆ นอกจากนี้ คำสั่ง `exports` จะควบคุมว่าแพ็คเกจใดบ้างที่โมดูลต่างๆ สามารถเข้าถึงได้ ตามค่าเริ่มต้น แพ็คเกจที่ไม่ได้ส่งออกทั้งหมดจะถูกห่อหุ้มไว้ในโมดูล

มี JEP ต่างๆ ซึ่งเป็นส่วนหนึ่งของโครงการนี้ ดังนี้

JEP 200 – JDK แบบแยกส่วน: ใช้ระบบโมดูลแพลตฟอร์ม Java เพื่อสร้างโมดูล JDK ที่สามารถรวมกันได้ในเวลาคอมไพล์ เวลาสร้าง หรือรันไทม์
JEP 201 – ซอร์สโค้ดโมดูลาร์: ใช้ในการสร้างโมดูลและอนุญาตให้เครื่องมือสร้างคอมไพล์โมดูลที่สร้างขึ้น
JEP 220 – อิมเมจรันไทม์แบบแยกส่วน: JEP นี้ปรับปรุงประสิทธิภาพ ความปลอดภัย และการบำรุงรักษาโดยการปรับโครงสร้างอิมเมจรันไทม์ JDK และ JRE เพื่อรองรับโมดูล
JEP 282 - jlink หรือที่รู้จักในชื่อ Java linker: ใช้เป็นโมดูลบรรจุภัณฑ์ & การพึ่งพาของพวกเขาในเวลาทำงานน้อยลง

ไฟล์ JAR แบบหลายรีลีส

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

ภาพประกอบของไฟล์ JAR ปัจจุบันดังต่อไปนี้:

รากเหยือก
- ห้องเรียน
– บี.คลาส
– ซีคลาส

ไฟล์ JAR แบบหลายรีลีสมีลักษณะดังนี้:

รากเหยือก

- ห้องเรียน
– บี.คลาส
– ซีคลาส
– META-INF
– รุ่น
– – 9
- - - - ห้องเรียน
– – 10
– – – – บี.คลาส

ในภาพประกอบก่อนหน้านี้ ไฟล์ JAR รองรับไฟล์คลาสสำหรับ Java สองเวอร์ชัน 9 และ 10 ดังนั้น เมื่อ JAR ทำงานบน Java เวอร์ชัน 9 โฟลเดอร์ A.class ภายใต้เวอร์ชัน – 9 โฟลเดอร์จะถูกเลือกเพื่อดำเนินการ

Java เวอร์ชันก่อนหน้าที่ไม่รองรับไฟล์ JAR แบบหลายรีลีส คลาสที่อยู่ภายใต้ไดเร็กทอรีเวอร์ชันจะไม่ถูกใช้ ดังนั้น หากคุณเรียกใช้ไฟล์ JAR แบบหลายรีลีสบน Java 8 จะดีเท่ากับการรันไฟล์ JAR แบบธรรมดา

ในความคิดของฉัน สิ่งต่าง ๆ เริ่มเปลี่ยนไปด้วย Java และนี่คือเทรนด์ที่กำลังเติบโต หมายความว่าความนิยมของ Java และการใช้งานจะได้รับผลกระทบหรือไม่? ไม่เลย. Java เป็นและยังคงเป็นภาษาโปรแกรมที่มีประสิทธิภาพและแข็งแกร่งอย่างเหลือเชื่อในอุตสาหกรรมเทคโนโลยีในปัจจุบัน เริ่มเรียนรู้ Java และดูว่ามันสร้างความแตกต่างในอาชีพการงานของคุณ ขอให้โชคดี!

หมายเหตุของผู้เขียน:
บทความด้านเทคนิคนั้นสนับสนุนโดย Sumit ซึ่งทำงานเกี่ยวกับเทคโนโลยีที่ได้รับความนิยมเช่น DevOps, Big Data และ Python และในทีมการตลาดดิจิทัลที่ Edureka