Coffee break #148. Paano gawing standalone EXE file ang anumang Java program

Pinagmulan: Mccue.dev Ngayon ay matututunan mo kung paano lumikha ng isang executable EXE file mula sa isang Java program na tatakbo sa Windows operating system. Ang pag-double click upang ilunsad ay isa sa mga pinakamadaling paraan upang magbukas ng programa. Kung ang taong gusto mong ipakita ang iyong application ay mayroon nang tamang bersyon ng Java na naka-install, maaari nilang i-double click ang jar file upang patakbuhin ito. Kung wala itong naka-install na Java, may mga paraan para gumawa ng executable installer, gaya ng jpackage . Pagkatapos nito, upang patakbuhin ang code kailangan mo lamang mag-click sa installer na ito. Maaari mo ring gamitin ang Native Image upang gawing executable file ang code na hindi nangangailangan ng anumang karagdagang pag-install. Sa artikulong ito, tututuon kami sa isang medyo simpleng diskarte na gumagana para sa anumang application, anuman ang mga dependency na isasama mo o kung anong mga feature ng JVM ang ginagamit mo. Ang code na tatalakayin ngayon ay matatagpuan sa GitHub repository , at ang mga executable na file kasama ang program ay naka - post dito .

Salansan ang ginamit

Java 9+

Maven

NodeJS

Hakbang 1: I-compile at i-package ang iyong code sa isang garapon

Ang pangunahing program na ito ay lilikha ng isang simpleng window na may teksto na maaari mong baguhin sa pamamagitan ng pag-click sa isa sa mga pindutan sa interface.

package example;

import org.apache.commons.text.WordUtils;

import javax.swing.*;
import java.awt.*;

public class Main {
    public static void main(String[] args) {
        var label = new JLabel("Hello, World!");
        label.setFont(new Font("Serif", Font.PLAIN, 72));

        var uppercaseButton = new JButton("Uppercase");
        uppercaseButton.addActionListener(e ->
            label.setText(WordUtils.capitalize(label.getText()))
        );

        var lowercaseButton = new JButton("lowercase");
        lowercaseButton.addActionListener(e ->
            label.setText(WordUtils.uncapitalize(label.getText()))
        );

        var panel = new JPanel();
        panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
        panel.add(label);
        panel.add(uppercaseButton);
        panel.add(lowercaseButton);

        var frame = new JFrame("Basic Program");
        frame.add(panel);
        frame.pack();
        frame.setVisible(true);
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
}

Ang layunin namin ngayon ay i-package ang code kasama ang mga dependency nito sa isang garapon. Ang mga JAR file ay mga regular na ZIP archive na may kaunting dagdag na istraktura. Para sa isang proyekto ng Maven ang pagsasaayos ay magiging ganito. Dito ang "shade" na plugin ay hahawak kasama ang code mula sa lahat ng iyong mga dependency sa garapon. Sa kasong ito, ang tanging panlabas na dependency ay org.apache.commons/commons-text . Pagkatapos ay ililipat namin ang jar file na ito sa isang bagong target/ direktoryo kung saan ito ihihiwalay sa iba pang mga file.

Hakbang 2: Lumikha ng Java Runtime Environment (JRE)

Upang patakbuhin ang jar file na nagawa na namin, kailangan naming i-link ito sa Java runtime environment. Para dito gagamitin namin ang jlink . Dahil ang Java ecosystem ay hindi gumagamit ng mga module, malamang na hindi mo pa naririnig ang mga ito o gumamit ng jlink. Sa madaling salita, maaaring lumikha ang jlink ng "mga custom na executable na larawan". Halimbawa, gumagawa ka ng isang web server. Hindi mo kailangan ng AWT o Swing, kaya magiging kalabisan ang pagsasama ng mga ito sa iyong code. Sa jlink maaari kang lumikha ng isang JRE na hindi kasama ang java.desktop module sa lahat . Pinakamahusay na gagana ang system na ito kung ang iyong application at lahat ng mga dependency nito ay kasama ang mga pinagsama-samang module-info.java file , na nagsasabi sa jlink nang eksakto kung anong mga module ang gusto mong isama. Maaari mo ring manu-manong tukuyin ang listahan ng mga kinakailangang module gamit ang jdeps . At kahit na walang modular na proyekto, epektibo naming mai-clone ang aming pag-install ng Java sa isang direktoryo gamit ang jlink. Ang pagsasama ng bawat module nang paisa-isa ay nagsisiguro na ang mga aklatan tulad ng org.apache.commons/commons-text ay gagana ayon sa nilalayon. Kailangan lang nating malaman kung aling mga module ang kailangan natin.

Hakbang 3: Pagsamahin ang Jar at JRE sa isang executable

Ang pagkakaroon ng jar file na naglalaman ng code at lahat ng dependency nito, pati na rin ang JRE, ang natitira na lang ay pagsamahin ang mga ito. Upang gawin ito kailangan nating gawin ang sumusunod:

1. I-zip ang direktoryo na naglalaman ng JRE at jar ng iyong aplikasyon.
2. Maglakip ng stub script sa tuktok ng zip file na ito, na kukuha ng data sa isang pansamantalang direktoryo at patakbuhin ang code.

Mayroong JavaScript library para dito na tinatawag na caxa . Ang layunin nito ay gawing mga executable ang mga proyekto ng NodeJS, at maaari rin itong mag-bundle ng anumang mga pag-install ng NodeJS sa system. Sa kabutihang palad, maaari mong laktawan ang hakbang na ito sa pamamagitan ng pagtukoy sa --no-include-node flag . Gagawa ito ng executable file na pinangalanang "application". Kung nililikha mo ito para sa Windows, kailangan mong tukuyin ang "application.exe". Kapag tumakbo ang executable, ang {{caxa}} ay papalitan ng pansamantalang direktoryo kung saan na-deploy ang zip file. Pakitandaan na kapag gumagawa ng mga executable na file, ginagamit din ang mga mekanismo gaya ng code signing at awtomatikong pag-update. Gayunpaman, ang mga bagay na ito ay nangangailangan ng mas malalim na pag-aaral, na mahirap na magkasya sa isang publikasyon.