Mga Tampok at Pagpapabuti ng Java 9

Ang modular na balangkas na binuo sa ilalim ng Project Jigsaw at pangunahing mga tampok ng Java 9 sa blog na ito ay ang JShell (tool na REPL), mahalagang mga pagbabago sa API at mga pagbabago sa antas ng JVM.

Ang paglabas ng mga tampok na Java 9 at Java 9 ay isang milyahe para sa ecosystem ng Java.Ang pagsunod sa mga bagong paglabas ay mahalaga para sa panatiling napapanahon sa teknolohiya at pag-unawa sa pangangailangan sa likod ng kung ano ang ipakilala ay malapit ka sa iyong .Ang modular na balangkas na binuo sa ilalim ng Project Jigsaw ay magiging bahagi ng paglabas ng Java SE at mga pangunahing tampok dito ay ang JShell (REPL tool), mahalagang mga pagbabago sa API at mga pagbabago sa antas ng JVM upang mapabuti ang pagganap at debuggability ng JVM.

Bago namin malutas ang detalye ng Java 9 nang detalyado, suriin muna natin ang mga nakaraang bersyon ng Java at tingnan kung ano ang mga pagkukulang at kung paano tumulong ang Java 9 na mapagtagumpayan ang mga anomalya na iyon: -





  • Ang Java Standard Edition platform at ang JDK ay hindi nai-navigate para sa maliliit na aparato sa computing
  • Walang pangkalahatang seguridad at pagpapanatili ng JDK
  • Walang pangkalahatang pagpapabuti sa pagganap ng application
  • Mahirap para sa mga developer ng Java na itayo at itaguyod ang mga library ng code at mas malalaking mga application, para sa parehong Java SE at EE Platforms

Sa post sa blog na ito ay ikakategorya ko ang mga tampok ng Java 9 sa sumusunod na pamamaraan:



  1. Iproseso ang mga pag-update ng API sa Java 9
  2. HTTP / 2 client sa Java 9
  3. Java Shell Scripting (Read-Eval-Print-Loop) sa Java 9
  4. Nagtatampok ang mga multi-release na JAR file sa Java 9
  5. Higit pang tampok sa Mga Update sa Kasabay sa Java 9
  6. Project Jigsaw sa Java 9

Ano ang bago sa Java 9?

Pinili ko ang ilang mga bagong tampok sa Java 9, na sa palagay ko ay karapat-dapat na malaman. Tingnan natin kung ano ang mga tampok na ito: -

Iproseso ang mga pag-update ng API sa Java 9

Ang Proseso ng Java ng API ay naging primitive,na may suporta lamang upang ilunsad ang mga bagong proseso, i-redirect ang output ng mga proseso, at mga stream ng error. Sa paglabas na ito, ang mga pag-update sa Process API ay nagbibigay-daan sa sumusunod:

  • Pagkuha ng PID ng kasalukuyang proseso ng JVM at anumang iba pang mga proseso na natiwala ng JVM
  • Itala ang mga proseso na tumatakbo sa system upang makakuha ng impormasyon tulad ng PID, pangalan, at paggamit ng mapagkukunan
  • Pamamahala ng mga puno ng proseso
  • Pamamahala ng mga subproseso

Tingnan natin ang isang sample code, na naglilimbag ng kasalukuyang PID pati na rin ang kasalukuyang impormasyon sa proseso:



pampublikong klase NewFeature {public static void main (String [] args) {ProcessHandle currentProcess = ProcessHandle.current () System.out.println ('PID:' + currentProcess.getPid ()) ProcessHandleInfo currentProcessInfo = currentProcess.info () System.out.println ('Impormasyon:' + kasalukuyangProcessInfo)}

HTTP / 2 client sa Java 9

Ang tampok na Java 9 na ito ay inaasahang magbabago sa mga kasunod na paglabas at maaari ring tuluyang matanggal.

Kanina pa Ang mga developer ay madalas na gumagamit ng mga third-party na aklatan, tulad ng Apache HTTP, Jersey, at iba pa. Bilang karagdagan dito, ang HTTP API ng Java ay nauna pa sa HTTP / 1.1 na detalye at kasabay at mahirap panatilihin. Ang mga limitasyong ito ay tumawag sa pangangailangan na magdagdag ng isang bagong API. Nagbibigay ang bagong HTTP client API ng mga sumusunod:

  • Isang simple at madaling maintindihan na API upang harapin ang karamihan sa mga kahilingan sa HTTP
  • Suporta para sa pagtutukoy ng HTTP / 2
  • Mas magandang pagtanghal
  • Mas mahusay na seguridad
  • Ilang pagpapahusay pa

Tingnan natin ang isang sample code upang makagawa ng isang kahilingan sa HTTP GET gamit ang mga bagong API. Nasa ibaba ang kahulugan ng module na tinukoy sa file module-info.java:

mga bagong tampok na module {nangangailangan ng jdk.incubator.httpclient}

Ang sumusunod na code ay gumagamit ng HTTP Client API, na bahagi ng jdk.incubator.httpclient module:

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 bagong URI (http://httpbin.org/get)) .GET () .versi (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 ('Katawan ng Tugon:' + response.body ())}}}

Java Shell Scripting (Read-Eval-Print-Loop) sa Java 9

Dapat ay nakakita ka ng mga wika, tulad ng Ruby, Scala, Groovy, Clojure, at iba pa na nagpapadala gamit ang isang tool, na madalas tawaging REPL ( Basahin-Eval-Print-Loop ). Ang tool na REPL na ito ay lubos na kapaki-pakinabang sa pagsubok ng mga tampok sa wika. Halimbawa, sa Scala, maaari kaming magsulat ng isang simpleng programang Hello World bilang scala> println ('Hello World')

Ang ilan sa mga kalamangan ng JShell REPL ay ang mga sumusunod:

  • Ang mga nakaranasang developer ay maaaring mabilis na mag-prototype at mag-eksperimento bago ito gamitin sa kanilang pangunahing base code
  • Ang mga developer ng Java ay maaari nang magyabang ng isang REPL

Patakbuhin natin ang utos na JShell, tulad ng ipinakita sa sumusunod na imahe:

JShell Hello World Halimbawa - Java 9 - Edureka

Nagtatampok ang mga multi-release na JAR file sa Java 9

Tulad ng ngayon, ang mga file ng JAR ay maaaring maglaman ng mga klase na maaari lamang tumakbo sa bersyon ng Java na kanilang naipon. Upang magamit ang mga bagong tampok ng platform ng Java sa mga mas bagong bersyon, kailangang maglabas ang mga developer ng library ng isang mas bagong bersyon ng kanilang silid-aklatan. Sa madaling panahon, magkakaroon ng maraming bersyon ng library na pinapanatili ng mga developer, na maaaring isang bangungot. Upang mapagtagumpayan ang limitasyong ito, ang mga tampok na Java 9 ng mga multi-release na file na JAR ay nagbibigay-daan sa mga developer na bumuo ng mga JAR file na may iba't ibang mga bersyon ng mga file ng klase para sa iba't ibang mga bersyon ng Java.Ang sumusunod na halimbawa ay ginagawang mas malinaw.

Narito ang isang paglalarawan ng kasalukuyang mga JAR file:

ugat ng garapon - Klase - B.class - C.class

Narito kung paano ang hitsura ng multi-release na mga file ng JAR:

ugat ng garapon - Klase - B.class - C.class - META-INF - mga bersyon - 9 - Klase - 10 - B.class

Sa naunang paglalarawan, sinusuportahan ng mga file ng JAR ang mga file ng klase para sa dalawang mga bersyon ng Java – 9 at 10.

Kaya, kapag ang naunang JAR ay naisakatuparan sa Java 9, ang A.class sa ilalim ng mga bersyon - 9 na mga folder ang kinuha para sa pagpapatupad.

Sa isang platform na hindi sumusuporta sa mga multi-release na JAR file, ang mga klase sa ilalim ng direktoryo ng mga bersyon ay hindi kailanman ginamit. Kaya, kung patakbuhin mo ang multi-release na JAR file sa Java 8, kasing ganda ng pagpapatakbo ng isang simpleng JAR file.

Higit pang tampok sa Mga Update sa Kasabay sa Java 9

Sa update na ito, isang bagong klase, java.util.concurrent.Flow ay ipinakilala, na kung saan ay may pugad interface na sumusuporta sa pagpapatupad ng isang i-publish ang balangkas. Pinahihintulutan ng framework ng pag-publish-subscribe ang mga developer na bumuo ng mga bahagi na maaaring asinkron na kumonsumo ng isang live na stream ng data sa pamamagitan ng pagse-set up ng mga publisher na gumagawa ng data at mga subscriber na kumakain ng data sa pamamagitan ng subscription, na namamahala sa kanila. Ang apat na bagong mga interface ay ang mga sumusunod:

papet vs hindi nakakain vs chef
  • java.util.concurrent.Flow.Publisher
  • java.util.concurrent.Flow.Subscriber
  • java.util.concurrent.Flow.Subscription
  • java.util.concurrent.Flow.Processor (na gumaganap bilang parehong Publisher at Subscriber).

Project Jigsaw sa Java 9

Ang pangunahing layunin ng proyektong ito ay upang ipakilala ang konsepto ng modularity suporta para sa paglikha ng mga module sa Java 9 at pagkatapos ay ilapat ang pareho sa JDK yan ay, baguhin ang pagbabago sa JDK .

Ilan sa mga benepisyo ng modularity ay ang mga sumusunod:

  • Malakas na encapsulation : Maaaring i-access lamang ng mga module ang mga bahagi ng module na ginawang magagamit para magamit. Kaya, ang mga pampublikong klase sa isang pakete ay hindi pampubliko maliban kung ang pakete ay malinaw na na-export sa file ng impormasyon ng module.
  • Malinaw ang Mga Depende : Dapat ideklara ng mga module kung aling iba pang mga module ang gagamitin nila sa pamamagitan ng kinakailangang sugnay.
  • Ang pagsasama-sama ng mga module upang lumikha ng isang mas maliit na runtime, na maaaring madaling mai-scale sa mas maliit na mga aparato sa computing.
  • Maaasahan : Ang mga application ay mas maaasahan sa pamamagitan ng pag-aalis run-time mga pagkakamali . Halimbawa: - dapat naranasan mong mabigo ang iyong aplikasyon sa panahon ng run-time dahil sa nawawalang mga klase, na nagreresulta sa ClassNotFoundException .

May iba-iba Mga JEP , na bahagi ng proyektong ito, tulad ng sumusunod:

  • JEP 200 - modular JDK : Nalalapat nito ang sistema ng module ng Java platform upang baguhin ang JDK sa isang hanay ng mga module na maaaring pagsamahin sa oras ng pagsulat, oras ng pagbuo, o runtime.
  • JEP 201 - modular na source code : Binabago nito ang source code ng JDK sa mga module at pinahuhusay ang mga tool sa pagbuo upang maipon ang mga module.
  • JEP 220 - mga modular na imahe ng runtime : Muling binubuo nito ang mga imahe ng JDK at JRE runtime upang mapaunlakan ang mga module at upang mapabuti ang pagganap, seguridad, at mapanatili.
  • JEP 260 - encapsulate ang karamihan sa mga panloob na API : Pinapayagan nito ang maraming mga panloob na API na ma-access nang direkta o sa pamamagitan ng pagsasalamin. Ang pag-access sa panloob na mga API na tiyak na magbabago ay lubos na mapanganib. Upang maiwasan ang paggamit nito, ang mga ito ay nai-encapsulate sa mga module at ang mga panloob na API na malawakang ginagamit ay ginawang magagamit hanggang sa ang isang wastong API ay kapalit nito.
  • JEP 261 - system ng module : Ipinatutupad nito ang pagtutukoy ng system ng module ng Java sa pamamagitan ng pagbabago ng wika ng Java programming, JVM, at iba pang karaniwang mga API
  • JEP 282: jlink, ang Java linker : Pinapayagan nitong magbalot ng mga module at kanilang mga dependency sa mas maliit na mga oras ng pagtakbo.

Kaya, ito ay tungkol sa Java 9 at bagong mga tampok na Java 9.

Ngayon na naintindihan mo ang mga tampok ng Java 9, tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo.

G isang tanong para sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na 'Java 9' at babalikan ka namin sa lalong madaling panahon.