Sa mundo ngayon, ang paglikha ng Java application na maaaring isagawa sa pamamagitan ng standalone executable ay mahalaga, dahil pinapasimple nito ang pamamahagi at paggamit ng software. Ang Java ay isang versatile, makapangyarihang programming language na malawakang ginagamit para sa pagbuo ng malawak na hanay ng mga application, mula sa mga simpleng command-line tool hanggang sa mas kumplikado, web-based na mga application. Sa artikulong ito, tutuklasin namin ang proseso ng paglikha ng standalone executable para sa isang Java application, na nagdedetalye ng mga kinakailangang hakbang, code, at nauugnay na mga library at function na kasangkot.
Ang pangunahing solusyon sa paglikha ng executable file para sa isang Java application ay ang paggamit ng prosesong kilala bilang **compilation**. Ang prosesong ito ay nagsasangkot ng pag-compile ng Java code sa bytecode, na pagkatapos ay naka-package sa isang Java Archive (JAR) file. Mula dito, maaari tayong lumikha ng isang maipapatupad na file gamit ang iba't ibang mga tool at utility.
Sumisid tayo sa sunud-sunod na paliwanag ng code na kasangkot sa pamamaraang ito:
1. Una, tiyaking kumpleto at gumagana ang iyong Java code. I-save ang pangunahing file ng klase gamit ang .java extension, halimbawa, "MyApp.java".
public class MyApp {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
2. I-compile ang Java code sa bytecode gamit ang Java Compiler (javac) mula sa terminal (Linux/OSX) o command prompt (Windows):
""
javac MyApp.java
""
3. Ito ay bubuo ng "MyApp.class" na file na naglalaman ng pinagsama-samang bytecode. Susunod, lumikha ng isang Java Archive (JAR) na file kasama ang mga file ng klase ng iyong aplikasyon at mga kinakailangang aklatan:
""
jar cfe MyApp.jar MyApp MyApp.class
""
Dito, ang 'c' ay nangangahulugang "lumikha", 'f' para sa "file" at 'e' para sa "entry point". Ang MyApp ay ang pangunahing klase na mayroong pangunahing pamamaraan.
4. Ang JAR file (MyApp.jar) ay maaari na ngayong isagawa gamit ang Java Runtime Environment (JRE):
""
java -jar MyApp.jar
""
Gayunpaman, upang maipamahagi ang iyong application bilang isang executable file (.exe para sa Windows o isang executable binary para sa Linux/OSX), kinakailangan ang mga karagdagang hakbang:
Java Native Runtime (JNR)
Ang Java Native Runtime (JNR) ay isang library na nagbibigay-daan sa mga aplikasyon ng Java na tumawag ng katutubong code sa isang mahusay at madaling gamiting paraan. Nakakatulong ito sa paglikha ng isang katutubong executable converter para sa iba't ibang platform, tulad ng Launch4j para sa Windows at JWrapper para sa OSX/Linux.
Ilunsad4j
Ang Launch4j ay isang sikat na tool para sa pagbabalot ng mga JAR file bilang mga executable ng Windows (.exe). Nagbibigay ito ng simpleng GUI para sa paggawa ng EXE wrapper at may kasamang iba't ibang feature, tulad ng mga custom na icon, impormasyon ng bersyon, at paghawak ng error.
Sundin ang mga hakbang na ito upang lumikha ng Windows executable gamit ang Launch4j:
1. I-download at i-install ang Launch4j mula sa opisyal na website.
2. Patakbuhin ang Launch4j at kumpletuhin ang configuration, na tinutukoy ang input JAR file (MyApp.jar) at output EXE file (MyApp.exe).
3. Mag-click sa icon na gear para buuin ang wrapper, na bumubuo ng standalone na MyApp.exe file.
Para sa OSX at Linux, maaaring gamitin ang JWrapper upang lumikha ng mga katutubong executable batay sa nabuong JAR file.
Bilang konklusyon, ang paggawa ng isang Java application na may executable output ay binubuo ng pag-compile ng code sa bytecode, pagbuo ng JAR file, at paggamit ng mga kaugnay na tool tulad ng Launch4j o JWrapper upang i-convert ang JAR sa isang executable file. Sa pamamagitan ng pagsunod sa aming ipinakitang sunud-sunod na proseso, maaaring mahusay na maipamahagi at maibahagi ng mga developer ang kanilang mga Java application sa iba't ibang platform.
