Gli antipiretici per i bambini sono prescritti da un pediatra. Ma ci sono situazioni di emergenza per la febbre in cui il bambino deve ricevere immediatamente le medicine. Quindi i genitori si assumono la responsabilità e usano farmaci antipiretici. Cosa è permesso dare ai bambini? Come abbassare la temperatura nei bambini più grandi? Quali farmaci sono i più sicuri?
Molti programmatori alle prime armi si trovano di fronte alla seguente domanda: "Ho creato la mia applicazione nell'IDE, ora come faccio a farla funzionare dalla riga di comando al di fuori dell'IDE?". Un'altra domanda che potrebbe sorgere è: "Come posso distribuire questa applicazione ad altri utenti senza fornire loro l'intero IDE allo stesso tempo?".
Le risposte a queste domande sono relativamente semplici, ma non sempre ovvie. A questo documento risponde dimostrando le basi dell'utilizzo dell'IDE per preparare le applicazioni per la distribuzione e la distribuzione. Inoltre, questo documento fornisce le informazioni che potrebbero essere necessarie per configurare il sistema di un programmatore (o che dovranno essere comunicate agli utenti dell'applicazione). Mostreremo diversi approcci alla distribuzione di un'applicazione, consentendo agli utenti di accedervi tramite:
- Fare doppio clic sul file JAR (Java archive) dell'applicazione.
- Chiamare un'applicazione dalla riga di comando.
- Chiamare un'applicazione da un file di script.
- Utilizzo di Java Web Start.
Questo tutorial richiede il software e i materiali elencati nella tabella seguente.
Creazione di un file JAR eseguibile
Questa parte del tutorial mostra come creare un'applicazione ridistribuibile nell'IDE e quindi eseguire l'applicazione al di fuori dell'IDE. Incorporiamo questa applicazione in un file JAR eseguibile.
Un file JAR è un file di archivio che può contenere file e cartelle. I file JAR sono simili ai file ZIP, ma i file JAR possono avere attributi aggiuntivi utili durante la distribuzione di applicazioni Java. Questi attributi includono la firma digitale dei file JAR, compressione aggiuntiva, compatibilità multipiattaforma e così via.
In questo esercizio creiamo un progetto IDE e quindi inseriamo due file sorgente Java pre-scritti nel progetto. Quindi compileremo le classi e creeremo un file JAR eseguibile. Successivamente, vedremo come eseguire file JAR al di fuori dell'IDE.
Le classi utilizzate in questo tutorial implementano le funzioni dell'utilità GNU grep, che può essere utilizzata per cercare testo o pattern di espressioni regolari nei file di testo. Questo progetto contiene sia una versione della riga di comando dell'applicazione che una versione che utilizza GUI, che ti darà un'occhiata ai diversi modi per eseguire l'applicazione.
Creazione di un progetto utilizzando file di codice sorgente esistenti
-
Distribuzione dell'applicazione ad altri utenti
Ora che hai confermato che la tua applicazione funziona al di fuori dell'IDE, puoi passare alla distribuzione.
Nota. Se la tua applicazione dipende da librerie aggiuntive diverse da quelle incluse nel JDK, devi includerle nella tua distribuzione (non si applica a questo esempio). I percorsi relativi a queste librerie vengono aggiunti alla voce del percorso di classe del file manifest JAR quando l'applicazione viene sviluppata nell'IDE. Se queste librerie aggiuntive non vengono trovate nel percorso classe specificato (ovvero percorso relativo) all'avvio, l'applicazione non verrà avviata.
Creare Archivio ZIP contenente il file JAR e la libreria, quindi caricarlo file zip utenti. Indicare agli utenti di decomprimere questo archivio ZIP in modo che il file JAR e i file JAR della libreria si trovino nella stessa cartella. Esegui il file jar dell'applicazione.Avvio di un'applicazione Java
Lo scopo di questo esercizio è dimostrare alcuni dei modi per eseguire un'applicazione dalla riga di comando.
Questo esercizio mostra come avviare un'applicazione Java nei due modi seguenti:
- Esecuzione di un comando java dalla riga di comando.
- Utilizzo di uno script per chiamare una classe in un file JAR.
Avvio di applicazioni dalla riga di comando
L'applicazione può essere avviata dalla riga di comando utilizzando il comando java. Se si desidera eseguire un file JAR eseguibile, utilizzare l'opzione -jar del comando.
Ad esempio, per eseguire l'applicazione AnotherGrep, effettuare le seguenti operazioni:
- Aprire una finestra del terminale. Sui sistemi Microsoft Windows, questo viene fatto facendo clic sul pulsante "Start" e selezionando "Esegui...", digitando cmd nel campo "Apri:" e facendo clic sul pulsante "OK".
- Vai alla directory PROGETTO_CASA/dist (usando il comando cd).
- Immettere la riga seguente per eseguire la classe dell'applicazione principale: java -jar AnotherGrep.jar
Se segui queste istruzioni e l'applicazione non si avvia, probabilmente dovresti eseguire una delle seguenti operazioni:
Avvio di applicazioni da uno script
Se l'applicazione che si desidera distribuire è un'applicazione console, potrebbe risultare più conveniente eseguirla da uno script, soprattutto se l'applicazione richiede argomenti lunghi e complessi per essere eseguita. In questa sezione, utilizziamo la versione console di Grep, in cui dobbiamo passare argomenti (un modello di ricerca e un elenco di file) al file JAR chiamato nel nostro script. Per ridurre la quantità di digitazione sulla riga di comando, utilizziamo un semplice script adatto per eseguire un'applicazione di test.
Il primo passaggio consiste nel modificare la classe principale nell'applicazione nella versione console della classe e ricostruire il file JAR:
- Nella finestra Progetti dell'IDE, fare clic con il pulsante destro del mouse sul nodo del progetto (AnotherGrep) e selezionare Proprietà.
- Seleziona il nodo Esegui e modifica la proprietà della classe principale in un altrogrep.Grep (da un altrogrep.xGrep). Fare clic sul pulsante OK per chiudere la finestra delle proprietà del progetto.
- Fare nuovamente clic con il pulsante destro del mouse sul nodo del progetto e selezionare Pulisci e crea progetto.
Al termine di questi passaggi, il file JAR verrà ricostruito e l'attributo Main-Class nel manifest del file JAR punterà a un altrogrep.Grep .
script bash - per computer che eseguono UNIX e Linux
Nella cartella in cui è stato estratto il contenuto del file, puoi trovare uno script bash chiamato grep.sh . Diamo un'occhiata:
#!/bin/bash java -jar dist/AnotherGrep.jar [email protetta]
La prima riga specifica quale interprete dei comandi utilizzare per interpretare questo script. Il secondo esegue il file JAR creato dall'IDE nella cartella PROGETTO_CASA/dist. [email protetta] copia semplicemente tutti gli argomenti passati allo script, racchiudendoli ciascuno tra virgolette.
Questo script presuppone che i binari Java facciano parte della variabile di ambiente PATH. Se questo script non funziona sul tuo computer, consulta .
Per ulteriori informazioni sulla creazione di script dell'interprete bash, vedere .
Script .bat per computer Windows
Sui computer Microsoft Windows, è possibile passare un massimo di nove argomenti alla volta a file batch. Se sono presenti più di nove argomenti, il file JAR dovrà essere eseguito più volte.
Lo script per questo potrebbe assomigliare a questo:
@echo off set jarpath="dist/AnotherGrep.jar" set pattern="%1" shift:loop if "%1" == "" goto:allprocessed set files=%1 %2 %3 %4 %5 %6 %7 %8 %9 java -jar %jarpath% %pattern% %files% per %%i in (0 1 2 3 4 5 6 7 8) fai shift vai a:loop:allprocessed
Questo script può essere trovato sotto il nome grep.bat nella cartella in cui sono stati estratti i contenuti dell'archivio, se vuoi vederlo in azione.
I nove argomenti sono forniti all'interno del file batch come %
, dove deve avere un valore dentro<0-9>. %0 è riservato per il nome dello script. Puoi vedere che solo nove argomenti vengono passati al programma alla volta (in un ciclo). L'istruzione for sposta semplicemente gli argomenti di nove per prepararli al ciclo successivo. Il ciclo termina quando un argomento file vuoto viene trovato dall'istruzione if (questo indica che non ci sono nuovi file da elaborare).
Ulteriori informazioni sullo scripting batch sono disponibili all'indirizzo .
Packaging di un'applicazione per Java Web Start
Java Web Start è una tecnologia utilizzata per avviare applicazioni Java da un browser Web con un solo clic. Vedere Abilitazione di Java Web Start in NetBeans IDE per i dettagli sulla creazione di pacchetti di applicazioni per la distribuzione con Java Web Start. In questa sezione viene fornita solo una breve descrizione dei passaggi necessari per rendere un'applicazione distribuibile utilizzando Java Web Start.
- Fare clic con il pulsante destro del mouse sul nodo del progetto nella finestra Progetti e selezionare Proprietà.
- Nella scheda Web Start della finestra delle proprietà del progetto, selezionare la casella di controllo Abilita Web Start.
- Seleziona Esecuzione locale dal menu a discesa Codebase poiché testeremo solo l'esecuzione locale.
Mantieni tutte le altre impostazioni predefinite e fai clic su OK. - Fare clic con il pulsante destro del mouse sul nodo del progetto e selezionare Pulisci e crea progetto.
Questo comando IDE rimuoverà tutti i file e le build precedentemente compilati, ricompilarà l'applicazione e costruirà il progetto con le nuove impostazioni. - Fuori dall'IDE, apri la cartella PROGETTO_CASA/dist , quindi apri il file launch.html nel tuo browser.
Apparirà un test. Pagina HTML con il pulsante Avvia. - Premi il pulsante Avvia per aprire l'app.
Potrai vedere che Java è caricato e l'applicazione è in esecuzione.Nota. Alcuni browser reindirizzano prima gli utenti alla pagina dei download di Java.
Specificare le associazioni di file JAR
Sulla maggior parte dei computer, un file JAR eseguibile può essere eseguito semplicemente facendo doppio clic su di esso. Se non accade nulla quando fai doppio clic su un file JAR, ciò potrebbe essere dovuto a uno dei due motivi seguenti:
- Il tipo di file JAR non è associato a Java Runtime Environment (JRE) su questo computer.
Se il tipo di file JAR è associato a un JRE, l'icona che rappresenta quel file deve includere il logo Java.
- Il tipo di file JAR è mappato su JRE, ma l'opzione -jar non fa parte del comando passato a JRE quando si fa doppio clic sull'icona.
Nota. A volte le associazioni di file JAR vengono modificate dal software installato, ad esempio, Software per elaborare file zip.
Il modo in cui un tipo di file JAR può essere associato a un launcher Java dipende dal sistema operativo.
Assicurati di avere una delle versioni di JRE installata sul tuo computer. Dovrebbe essere utilizzata la versione 1.4.2 o successiva. Le applicazioni Java non possono essere eseguite su computer su cui non è installata la piattaforma Java. (Se è installato un Java Development Kit (JDK), con esso viene installato anche JRE. Tuttavia, se il programma è distribuito a non programmatori, gli utenti potrebbero non disporre di JRE o JDK.)
- Su Windows XP installato Versione Java può essere verificato selezionando "Start" > "Pannello di controllo" > ("Aggiungi o rimuovi programmi") (dovrebbe esserci, ad esempio, Java (TM) 6 Update 33).
- Sul Windows Vista o la versione 7 installata di Java può essere verificata selezionando "Start" > "Pannello di controllo" > ("Programmi e funzionalità") (dovrebbe essere specificato, ad esempio, Java (TM) 6 Update 33).
Se il computer non dispone della piattaforma Java, è possibile scaricare JRE dal sito di download di Java SE.
Se lo hai già sul tuo computer, ma l'associazione file non funziona, segui i passaggi per aggiungere l'associazione file JAR in Microsoft Windows:
- Seleziona "Start" > "Pannello di controllo".
- (Si applica solo a Windows Vista). Fare clic su "Pannello di controllo" > "Programmi".
Per Windows Vista o 7, fare clic su Programmi predefiniti e selezionare Associa un tipo di file o un protocollo a un programma.- (In Windows XP, nella sezione Dettagli della finestra di dialogo, fare clic su Cambia programma.)
- Nella finestra di dialogo Selezione programma, selezionare Java Platform SE Binary.
- Fare clic sul pulsante "OK" per uscire dalla finestra di dialogo "Seleziona programma".
- Fare clic sul pulsante Chiudi per chiudere la finestra di dialogo Opzioni cartella (in Windows XP) o la finestra di dialogo per associare un tipo di file o protocollo a programmi specifici (in Windows 7).
Nota. Se i file JAR sono associati a Java Platform SE Binary sul sistema, ma il doppio clic continua a non avviare il file JAR, potrebbe essere necessario specificare l'opzione -jar nell'associazione file.
Per specificare l'opzione -jar nell'associazione file su Microsoft Windows XP, attenersi alla seguente procedura:
- Seleziona "Start" > "Pannello di controllo".
- In Windows XP, fai doppio clic su "Opzioni cartella" e seleziona la scheda "Tipi di file".
- Nell'elenco Tipi di file registrati, selezionare il file JAR.
- Nella sezione Dettagli della finestra di dialogo, fare clic su Avanzate.
- Nella finestra di dialogo Modifica proprietà tipo file, fare clic su Modifica....
- Nella casella di testo "Applicazione che esegue l'azione", aggiungi la seguente riga alla fine del percorso JRE: -jar "%1" %* Dopodiché, la casella dovrebbe contenere un testo simile al seguente: "C:\Programma File\Java\jre1.6.0_33\ bin\javaw.exe" -jar "%1" %*
- Fare clic su OK per uscire dalla finestra di dialogo Modifica tipo di azione.
- Fare clic su OK per uscire dalla finestra di dialogo Modifica proprietà tipo file.
- Fare clic sul pulsante Chiudi per uscire dalla finestra di dialogo Opzioni cartella.
Nota. A partire da Windows Vista, le associazioni di file estese possono essere configurate utilizzando RegEdit. Per ulteriori informazioni, vedere Che cosa è successo alla finestra di dialogo dei tipi di file? .
Per i sistemi UNIX e Linux, la procedura per modificare le associazioni di file dipende dall'ambiente desktop (come GNOME o KDE) utilizzato. Dai un'occhiata alle impostazioni dell'area di lavoro o leggi la documentazione dell'area di lavoro.
Impostazione della variabile di ambiente PATH
Se il computer non è in grado di eseguire una classe Java o un file JAR senza specificare la posizione di JDK o JRE, potrebbe essere necessario modificare il valore della variabile di ambiente PATH di sistema.Quando si esegue su un sistema Microsoft Windows, la procedura per impostare la variabile PATH dipende dalla versione di Windows in uso.
Di seguito sono riportati i passaggi per impostare la variabile PATH su Sistema Windows XP:
- Selezionare "Start" > "Pannello di controllo" e fare doppio clic su "Sistema".
- Nella finestra di dialogo Proprietà del sistema, selezionare la scheda Avanzate.
- Fare clic sulla scheda Variabili d'ambiente.
- Nell'elenco delle variabili di ambiente utente, selezionare PATH e fare clic sul pulsante Modifica.
- Aggiungere la posizione JRE alla fine dell'elenco dei percorsi. Le posizioni nell'elenco sono separate da punto e virgola (;).
Ad esempio, se JRE si trova in C:\Programmi\Java\jdk1.6.0_23, aggiungere quanto segue alla fine della variabile PATH: C:\Programmi\Java\jdk1.6.0_23\bin - Fare clic su OK per uscire dalla finestra di dialogo Variabili d'ambiente, quindi fare clic su OK per uscire dalla finestra di dialogo Proprietà del sistema.
Quando si lavora sistema operativo UNIX o Linux, il modo in cui modifichi la variabile di ambiente PATH dipende dal programma di interprete dei comandi che stai utilizzando. Per ulteriori informazioni, vedere la documentazione dell'interprete dei comandi.
Qual è il prossimo?
Per ulteriori informazioni sull'utilizzo dell'IDE NetBeans, vedere il sito Web di NetBeans.
Ulteriori informazioni sullo sviluppo di applicazioni Java nell'IDE, inclusa la gestione dei percorsi di classe, sono disponibili nel documento
Ora nessuno crea programmi nella console. Usando il tuo IDE preferito, lo sviluppatore si sente a disagio davanti al computer di qualcun altro, dove non lo è.
Decidendo di capire il lavoro di Ant e Maven, mi sono ritrovato incapace di costruire l'applicazione senza di loro nella console.
In questo articolo, ho cercato di adattare tutte le fasi della progettazione di un'applicazione demo in modo da non cercare aiuto su ogni comando su Internet.
Dal semplice al...
Ogni programma è solitamente contenuto in una directory separata. La mia regola è creare almeno due cartelle in questa directory: src e bin. Il primo contiene i codici sorgente, il secondo contiene il risultato della compilazione. Queste cartelle avranno una struttura di directory a seconda dei pacchetti.Un file
Puoi farlo senza cartelle aggiuntive.Prendiamo il file.
| 01 02 03 04 05 06 07 08 09 | public class HelloWorld ( public static void main(String args) ( System.out.println("Hello World!"); Calcolatrice calc=new Calcolatrice(); System.out.println("2+2="+calc.sum (2,2)); ) ) |
javac HelloWorld.java Il file HelloWorld.class apparirà in questa cartella. Quindi il programma è compilato. Per iniziare
java -percorso di classe. Ciao mondo
Separare i binari dai sorgenti
Ora faremo lo stesso, ma con le directory. Creiamo una directory HelloWorld con due cartelle src e bin al suo interno.Compilazione
javac -d bin src/HelloWorld.java Qui abbiamo indicato che i binari verranno salvati in una cartella bin separata e non verranno confusi con i sorgenti.
Lanciamo
java -classpath ./bin HelloWorld
Usiamo pacchetti
E poi, improvvisamente, il programma cesserà di essere solo HelloWorld. È meglio dare ai pacchetti un nome significativo e univoco. Questo aggiungerà questo programma a un altro progetto senza conflitto di nomi. Dopo aver letto alcuni articoli, potresti pensare che il nome del pacchetto abbia necessariamente bisogno di un dominio. Questo non è vero. I domini sono un modo conveniente per raggiungere l'unicità. Se non hai il tuo dominio, usa un account sul sito (ad esempio, ru.habrahabr.mylogin). Sarà unico. Tieni presente che i nomi dei pacchetti devono essere in minuscolo. Ed evita di usare caratteri speciali. I problemi sorgono a causa di piattaforme e file system diversi.Mettiamo la nostra classe in un pacchetto chiamato com.qwertovsky.helloworld. Per fare ciò, aggiungi una riga all'inizio del file
pacchetto com.qwertovsky.helloworld; Creiamo directory aggiuntive nella directory src in modo che il percorso del file assomigli a questo: src/com/qwertovsky/helloworld/HelloWorld.java.
Compilazione
javac -d bin src/com/qwertovsky/helloworld/HelloWorld.java La directory bin avrà automaticamente una struttura di directory simile a src.
HelloWorld "---bin " "---com " "---qwertovsky " "---helloworld " "---HelloWorld.class "---src "---com "---qwertovsky "-- -helloworld "---HelloWorld.java Esegui
java -classpath ./bin com.qwertovsky.helloworld.HelloWorld
Se sono presenti più file nel programma
Cambiamo il programma. Non prestare attenzione alla logica. Lei non è.HelloWorld.java
| 01 02 03 04 05 06 07 08 09 10 11 12 13 | pacchetto com.qwertovsky.helloworld; public class HelloWorld ( public static void main(String args) ( int a=2; int b=3; Calcolatrice calc=new Calcolatrice(); System.out.println("Hello World!"); System.out.println( a+"+"+b+"="+calc.sum(a,b)); ) ) |
Calcolatrice.java
| 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 | pacchetto com.qwertovsky.helloworld; import com.qwertovsky.helloworld.operation.Adder; public class Calcolatrice ( public int sum(int... a) ( Adder adder=new Adder(); for(int i:a) ( adder.add(i); ) return adder.getSum(); ) ) |
Adder.java
| 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | pacchetto com.qwertovsky.helloworld.operation; public class Adder ( private int sum; public Adder() ( sum=0; ) public Adder(int a) ( this.sum=a; ) public void add(int b) ( sum+=b; ) public int getSum() (somma di ritorno; ) ) |
javac -d bin src/com/qwertovsky/helloworld/HelloWorld.java src\com\qwertovsky\helloworld\HelloWorld.java:9: impossibile trovare il simbolo simbolo: classe Posizione della calcolatrice: classe com.qwertovsky.helloworld.HelloWorld Calcolatrice calc=new calcolatrice(); ^ src\com\qwertovsky\helloworld\HelloWorld.java:9: impossibile trovare il simbolo simbolo: classe Posizione della calcolatrice: classe com.qwertovsky.helloworld.HelloWorld Calculator calc=new Calculator(); ^ 2 errori L'errore si è verificato a causa del fatto che per la compilazione sono necessari file con i codici sorgente delle classi utilizzate (la classe Calcolatrice). È necessario specificare la directory con i file nel compilatore utilizzando la chiave -sourcepath.
Compilazione
javac -sourcepath ./src -d bin src/com/qwertovsky/helloworld/HelloWorld.java Esegui
java -classpath ./bin com.qwertovsky.helloworld.HelloWorld Hello Word 2+3=5
Se sei sorpreso dal risultato
È possibile avviare un debugger. Ecco a cosa serve jdb.Innanzitutto, compiliamo con l'opzione -g in modo che il debugger abbia informazioni.
javac -g -sourcepath ./src -d bin src/com/qwertovsky/helloworld/HelloWorld.java Avvia il debugger
jdb -classpath bin -sourcepath src com.qwertovsky.helloworld.HelloWorld Inizializzazione di jdb ... > Il debugger avvia il suo terminale interno per immettere i comandi. L'aiuto su quest'ultimo può essere visualizzato usando il comando di aiuto.
Imposta un punto di interruzione sulla riga 9 nella classe Calcolatrice
> fermarsi a com.qwertovsky.helloworld.Calculator:9 Rinviare il punto di interruzione com.qwertovsky.helloworld.Calculator:9. Verrà impostato dopo il caricamento della classe. Lanciamo per l'esecuzione.
> esegui corri com.qwertovsky.helloworld.HelloWorld Imposta uncaught java.lang.Throwable Imposta differito uncaught java.lang.Throwable > VM avviata: Imposta punto di interruzione differito com.qwertovsky.helloworld.Calculator:9 Hello World! Punto di interruzione raggiunto: "thread=main", com.qwertovsky.helloworld.Calculator.sum(), line=9 bci=0 9 Adder adder=new Adder(); Per orientarti, puoi visualizzare un pezzo di codice sorgente in cui si trova attualmente il cursore.
lista principale 5 public class Calcolatrice 6 ( 7 public int sum(int... a) 8 ( 9 => Adder adder=new Adder(); 10 for(int i:a) 11 ( 12 adder.add(i); 13) 14 return adder.getSum(); Scopri qual è la variabile a.
main print a a = istanza di int (id=340) main dump a a = ( 2, 3 ) main stop a com.qwertovsky.helloworld.operation.Adder:19 Defering breakpoint com.qwertovsky.helloworld.operation.Adder:19. Verrà impostato dopo il caricamento della classe. Continuiamo l'esecuzione.
main cont > Imposta punto di interruzione differito com.qwertovsky.helloworld.operation.Adder:19 Punto di interruzione raggiunto: "thread=main", com.qwertovsky.helloworld.operation.Adder.add(), line=19 bci=0 19 sum+=b ; lista principale 15 ) 16 17 public void add(int b) 18 ( 19 => sum+=b; 20 ) 21 22 public int getSum() 23 ( 24 return sum; main print sum sum = 0 main print b b = 2 nel riga corrente e vedere che la somma è diventata uguale a 2.
passaggio principale > Passaggio completato: "thread=main", com.qwertovsky.helloworld.operation.Adder.add(), line=20 bci=10 20 ) main print sum sum = 2 Saliamo dalla classe Adder alla classe Calculator che lo ha chiamato.
passaggio principale > Passaggio completato: "thread=main", com.qwertovsky.helloworld.Calculator.sum(), line=10 bci=36 10 for(int i:a) Rimuovi punto di interruzione
main clear com.qwertovsky.helloworld.operation.Adder:19 Rimosso: punto di interruzione com.qwertovsky.helloworld.operation.Adder:19 passaggio principale > Passaggio completato: "thread=main", com.qwertovsky.helloworld.Calculator.sum() , riga=12 bci=30 12 sommatore.add(i); Puoi evitare di entrare nei metodi usando il comando successivo.
main next > Passaggio completato: "thread=main", com.qwertovsky.helloworld.Calculator.sum(), line=10 bci=36 10 for(int i:a) main next > Passaggio completato: "thread=main", com.qwertovsky.helloworld.Calculator.sum(), line=14 bci=42 14 return adder.getSum(); Verifichiamo il valore dell'espressione e completiamo l'esecuzione.
main eval adder.getSum() adder.getSum() = 5 main cont > 2+3=5 L'applicazione è terminata
Sarebbe bello fare una prova
Usiamo JUnit.| 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | pacchetto com.qwertovsky.helloworld; import org.junit.Assert.* statico; importare java.util.array; import java.util.Collection; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized.Parameters; @RunWith(value=org.junit.runners.Parameterized.class) public class TestCalculator ( int previsto; int arg; @Parameters public static Collection |
mkdir test_bin javac -classpath lib/path/junit-4.8.2.jar -sourcepath ./src -d test_bin test/com/qwertovsky/helloworld/TestCalculator.java Esegui. Il separatore del percorso di classe su Windows è ";", su Linux è ":". Entrambi i delimitatori non funzionano nella console Cygwin. Forse ";" dovrebbe funzionare, ma è considerato un separatore di comandi.
java -classpath lib/path/junit-4.8.2.jar:./test_bin org.junit.runner.JUnitCore com.qwertovsky.helloworld.TestCalculator JUnit versione 4.8.2 .... Tempo: 0.031 OK (4 test)
Creiamo una libreria
La classe Calcolatrice si è rivelata utile e può essere utilizzata in molti progetti. Spostiamo tutto ciò che riguarda la classe Calcolatrice in un progetto separato.HelloWorld "---bin "---src "---com "---qwertovsky "---helloworld "---HelloWorld.java Calcolatrice "---bin "---src ""---com " "---qwertovsky " "---calculator " "---Calculator.java " "---operazione " "---Adder.java "---test "---com "---qwertovsky " ---calculator "---TestCalculator.java Cambia anche i nomi dei pacchetti nei sorgenti. In HelloWorld.java dovrai aggiungere la riga
import com.qwertovsky.calculator.Calculator; Compilazione.
cd Calcolatrice javac -sourcepath src -d bin src/com/qwertovsky/calculator/Calculator.java Creare un archivio jar
jar cvf calcolatrice.jar -C bin . aggiunto manifest aggiungendo: com/(in = 0) (out= 0)(stored 0%) aggiungendo: com/qwertovsky/(in = 0) (out= 0)(stored 0%) aggiungendo: com/qwertovsky/calculator/ (in = 0) (out= 0)(stored 0%) aggiungendo: com/qwertovsky/calculator/Calculator.class(in = 497) (out= 373)(deflated 24%) aggiungendo: com/qwertovsky/calculator/operation /(in = 0) (out= 0)(stored 0%) aggiungendo: com/qwertovsky/calculator/operation/Adder.class(in = 441) (out= 299)(deflated 32%) esegue il programma nel cestino directory.
Dobbiamo scoprire cosa ha dentro la biblioteca
Puoi decomprimere l'archivio con un zip-unpacker e vedere quali classi ci sono nella libreria.È possibile ottenere informazioni su qualsiasi classe utilizzando il disassembler javap.
javap -c -classpath calculator.jar com.qwertovsky.calculator.Calculator Compilato dalla classe pubblica "Calculator.java" com.qwertovsky.calculator.Calculator estende java.lang.Object( public com.qwertovsky.calculator.Calculator(); Codice : 0: aload_0 1: invokespecial #1; //Metodo java/lang/Oggetto."
Senza l'opzione -c, il programma fornirà solo un elenco di variabili e metodi (se usi -private, allora tutto).
javap -private -classpath calcolatrice.jar com.qwertovsky.calculator.operation.Adder Compilato da "Adder.java" public class com.qwertovsky.calculator.operation.Adder estende java.lang.Object( private int sum; public com.qwertovsky .calculator.operation.Adder(); public com.qwertovsky.calculator.operation.Adder(int); public void add(int); public int getSum(); )
È meglio documentare la biblioteca
Cambiamo la classe calcolatrice per questo.La documentazione può essere generata con il seguente comando. Se si verifica un errore, il programma visualizzerà un elenco di possibili opzioni.
mkdir doc javadoc -d doc -charset utf-8 -sourcepath src -author -subpackages com.qwertovsky.calculator
è possibile firmare l'archivio jar
Se hai bisogno di firmare la tua libreria con una firma digitale, keytool e jarsigner verranno in soccorso.Generiamo una firma.
keytool -genkey -keyalg rsa -keysize 2048 -alias qwertokey -keystore path/to/qwerto.keystore Immettere la password dell'archivio chiavi: Reinserire la nuova password: Qual è il tuo nome e cognome? : Valery Qwertovsky Qual è il nome della tua unità organizzativa? : Qwertovsky Qual è il nome della tua organizzazione? : Qwertovsky Qual è il nome della tua città o località? : Tver Come si chiama il tuo Stato o Provincia? : Tverskaya obl. Qual è il codice paese di due lettere per questa unità? : RU CN=Valery Qwertovsky, OU=Qwertovsky, O=Qwertovsky, L=Tver, ST=Tverskaya obl., C=RU corretto? : y Immettere la password della chiave per
Generazione di una richiesta di firma del certificato (CSR)
keytool -certreq -file percorso/a/qwertokey.crt -alias qwertokey -keystore percorso/a/qwerto.keystore Invia il contenuto del file ricevuto all'autorità di certificazione. Riceviamo un certificato dall'autorità di certificazione. Lo salviamo in un file (ad esempio, qwertokey.cer) e lo importiamo nel repository
keytool -import -trustcacerts -keystore path/to/qwert.keystore -alias qwertokey -file path/to/qwertokey.cer Firma l'archivio jar
jarsigner -keystore percorso/a/qwerto.keystore calculator.jar qwertokey Inviamo il file qwertokey.cer a chiunque voglia controllare l'archivio. È controllato in questo modo
jarsigner -verify -verbose -certs -keystore path/to/qwerto.keystore calculator.jar
Utilizzando la libreria
Esiste un programma HelloWorld che utilizza la classe della libreria Calcolatrice. Per compilare ed eseguire il programma, è necessario includere la libreria.Compilazione
cd HelloWorld javac -sourcepath src -d bin -classpath path/to/calculator.jar src/com/qwertovsky/helloworld/HelloWorld.java Esegui
java -classpath bin:path/to/calculator.jar com.qwertovsky.helloworld.HelloWorld
Mettere insieme il programma
Questo può essere fatto in diversi modi.Primo modo
cd HelloWorld echo classe principale: com.qwertovsky.helloworld.HelloWorld>manifest.mf echo class-path: lib/calculator.jar >>manifest.mf mkdir lib cp path/to/calculator.jar lib/calculator.jar jar - cmf manifest.mf helloworld.jar -C bin . Ci sono sottigliezze qui.In linea
classe principale: com.qwertovsky.helloworld.HelloWorld non dovrebbe avere spazi finali.
La seconda sottigliezza è descritta in: nella stessa riga dovrebbe esserci un trasferimento alla riga successiva. Questo è se il manifest viene archiviato da un archiviatore di terze parti.
Il programma jar non includerà l'ultima riga del manifest nel manifest a meno che non sia presente un'interruzione di riga alla fine.
Un altro punto: nel manifest non dovrebbero esserci righe vuote tra le righe. Verrà generato un errore "java.io.IOException: formato manifest non valido".
Quando usi il comando echo, devi solo guardare lo spazio alla fine della riga della classe principale.
Secondo modo
cd HelloWorld echo class-path: lib/calculator.jar >manifest.mf mkdir lib cp path/to/calculator.jar lib/calculator.jar jar -cmef manifest.mf com.qwertovsky.helloworld.HelloWorld helloworld.jar -C bin . In questo modo evitiamo l'errore con uno spazio in main-class.Terza via
cd HelloWorld mkdir lib cd lib jar -xvf path/to/calculator.jar com/ creato: com/ creato: com/qwertovsky/ creato: com/qwertovsky/calculator/ inflated: com/qwertovsky/calculator/Calculator.class creato: com /qwertovsky/calculator/operation/ inflated: com/qwertovsky/calculator/operation/Adder.class cd .. cp -r bin/* lib/ jar -cef com.qwertovsky.helloworld.HelloWorld helloworld.jar -C lib . rm -r lib Include il codice della libreria richiesto nell'eseguibile.Esecuzione del file jar eseguibile
Il file calculator.jar non è eseguibile. Ma helloworld.jar può essere eseguito.Se l'archivio è stato creato nei primi due modi, accanto ad esso nella stessa directory dovrebbe esserci una cartella lib con il file calculator.jar. Tali restrizioni sono dovute al fatto che il percorso relativo al file eseguibile è specificato nel percorso classe nel manifest.
cd Calcolatrice ls ../HelloWorld/lib calculator.jar java -jar ../HelloWorld/helloworld.jar Il terzo metodo include le librerie richieste nell'eseguibile. Non è necessario tenere le librerie necessarie nelle vicinanze. Funziona allo stesso modo.
java -jar ../HelloWorld/helloworld.jar
Come gestire le applicazioni JavaEE
Allo stesso modo. Solo le librerie per la compilazione devono essere prelevate dal server delle applicazioni in uso. Se sto usando JBoss, per compilare il servlet dovrei fare qualcosa del generejavac -classpath path/to/jboss/common/lib/jboss-servlet*.jar -d ./classes src/com/qwertovsky/app/servlets/MenuSt.java
La struttura di un archivio di applicazioni JavaEE deve seguire un determinato formato. Per esempio
mio.orecchio `---META-INF | `---manifest.mf `---lib | `---mylib.jar `---my.war | `---META-INF | | `---manifest.mf | `---INF-WEB | | `---lib | | | `---myweblib.jar | | `---classi | | | `---com | | | `---... | | `---web.xml | `---indice.html | `---<остальное веб-содержимое (страницы, изображения)>`---myejb.jar
Il modo per eseguire l'applicazione sul server stesso utilizzando la riga di comando è diverso per ciascun server.
Spero che questo articolo diventi per qualcuno un cheat sheet per lavorare con Java in riga di comando. Queste abilità ti aiuteranno a comprendere il contenuto e il significato degli script di Ant e a rispondere a domande più complicate del colloquio rispetto a "Quale IDE ti piace di più?".
Ora mostrerò come eseguire un semplice programma java senza alcun ambiente come un server delle applicazioni. È sufficiente una classe, in cui verrà definito il metodo principale.
pacchetto com.blogspot;Nella riga di comando, all'avvio del programma, è necessario passare il testo che verrà visualizzato sullo schermo. In caso contrario, verrà visualizzato un messaggio corrispondente. Tutti i parametri passati al programma saranno contenuti nell'array di stringhe args che il metodo main accetta. Se non vengono passati parametri, la lunghezza dell'array sarà zero.
public class DeveloperRemarks(
public static void main(String args) (
if (args.length == 0) (
Sistema.out
.println("Passa come parametro della riga di comando il testo che vuoi vedere.");
) altro (
System.out.println("Hai inserito: " + args);
}
System.out.println("Fonte disponibile su developer-remarks.blogspot.com");
}
}
Ora configuriamo Eclipse per poter eseguire il file jar dal terminale. Per fare ciò, devi prima creare una configurazione di esecuzione. Seleziona Esegui - Esegui configurazioni dal menu in alto. Si aprirà la seguente finestra:
Nell'elenco a sinistra, seleziona il tipo di applicazione: Applicazione Java. Lì, crea una nuova configurazione come mostrato nello screenshot. Per fare ciò, seleziona il progetto di destinazione e la classe che ha il metodo principale.
Ora siamo pronti per esportare il nostro progetto in un file jar eseguibile. Per fare ciò, clicca sul progetto con il tasto destro del mouse, seleziona "Esporta...", si aprirà la seguente finestra:
Seleziona File Jar eseguibile dalla vista ad albero. La ricerca può essere notevolmente semplificata se si filtra il tipo di progetto per nome. Fare clic su Fine. Successivamente, si aprirà una finestra per le impostazioni di esportazione:
In esso, seleziona la configurazione di avvio creata in precedenza. Quindi fornire il nome completo del file jar. Nella sezione "Gestione librerie", seleziona "Estrai le librerie richieste nel JAR generato" (decomprimi le librerie richieste nell'archivio generato). Fare clic su Fine e verrà creato l'archivio eseguibile.
Poiché in questo esempio non ci sono dipendenze da altre librerie, scegliamo il primo elemento. Ma se avessimo diverse decine o addirittura centinaia di dipendenze, sarebbe più corretto selezionare il terzo elemento "Copia le librerie richieste in una sottocartella accanto al JAR generato" (copia le librerie richieste in una sottodirectory, parte del nome di cui corrisponde all'archivio in fase di creazione) per evitare di "gonfiare" l'eseguibile. Se avessimo scelto il terzo elemento, le librerie necessarie sarebbero state copiate in una cartella separata.
Ora apri un terminale e vai alla directory in cui è stato creato l'eseguibile jar. Immettere il seguente comando:
java -jar developer-remarks.jar ciao mondo!
Questo è il modo in cui dici all'interprete java di eseguire il nostro archivio. Si noti che lo spazio e il punto esclamativo sulla riga di comando devono essere preceduti da una barra rovesciata.
L'approccio dimostrato può essere utile per scopi didattici e di test. Ad esempio, per creare un client che chiamerà EJB e stamperà il risultato del suo lavoro sulla console. Il vantaggio di questo approccio è il lancio dell'archivio jar senza alcun tipo di ambiente. È sufficiente avere un JDK/JRE. Le fonti sono disponibili.
Attività: eseguire un'applicazione java dalla riga di comando.
Ad esempio, ho creato un piccolo programma che dovrebbe calcolare l'area di un cerchio per un determinato raggio. Il programma contiene due classi: GeometryWF (principale) e Circle. Dovrebbe creare un'applicazione console. L'avvio di un'applicazione java deve essere eseguito dalla riga di comando.
geometria del pacchettowf;
classe pubblica GeometryWF(
public static void main(String args) (
Tentativo(
if (args. equals("cerchio")) (
Cerchio c = nuovo Cerchio(Double.parseDouble(args));
System.out.println("Perimetro cerchio: "+c.perimetro());
System.out.println("Aria circolare: "+c.area());
}
}
catch(ArrayIndexOutOfBoundsException e) (
System.out.println("Parametri di input non validi!");
}
}
}
geometria del pacchettowf;
classe pubblica Cerchio(
doppia pubblica r = 0;
cerchio pubblico(doppia r) (
questo.r = r;
}
doppia area pubblica() (
return(Math.PI*r*r);
}
doppio perimetro pubblico() (
return(2*Math.PI*r);
}
}
Il prossimo passo è costruire il progetto. Uso NetBeans IDE per lo sviluppo. Di conseguenza, l'assemblaggio viene eseguito premendo la combinazione "Shift + F11" ("Cancella e crea il progetto"). Di conseguenza, ottengo un file jar finito
(C:\Utenti\Gen\Documents\NetBeansProjects\GeometryWF\dist\GeometryWF.jar).
Avvia dalla riga di comando.
Prima di avviare il prompt dei comandi, fare clic con il pulsante destro del mouse sull'icona "Risorse del computer" e aprire "Proprietà". Vai su "Impostazioni di sistema avanzate"->"Variabili d'ambiente". Nella sezione "Variabili di sistema", devi creare una nuova variabile "JAVA_HOME" con il valore "" (l'ho "C:\glassfish3\jdk\bin"). Lo stesso percorso deve essere scritto nella variabile Path esistente dopo il punto e virgola. Salviamo tutto ed eseguiamo la riga di comando.
Cambiamo la directory nella cartella con il file jar usando il comando CHDIR:
C:\Utenti\Giovanni> CHDIR C:\Utenti\John\Documents\NetBeansProjects\GeometryWF\dist\
Lanciamo l'applicazione java dalla riga di comando usando il comando "java -jar .
C:\Utenti\John\Documents\NetBeansProjects\GeometryWF\dist> java -jar GeometryWF.jar circle 9
In uscita otteniamo:
Perimetro del cerchio: 56.5486677764616276
Cerchio quadrato: 254.46900494077323
