[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]


170. Java: preparazione

Java è un linguaggio di programmazione realizzato da Sun Microsystems. Il suo scopo principale è l'inserzione di programmi all'interno di pagine HTML (applet), un po' come si fa con le immagini. Per questo motivo, il risultato della compilazione di un sorgente Java è una codifica intermedia, indipendente dalla piattaforma, che deve poi essere interpretata localmente dal navigatore web o da un altro programma indipendente.

In questo senso, Java potrebbe essere molto utile anche al di fuori della programmazione legata ai serventi HTTP, proprio per la portabilità dei suoi programmi.

Per programmare in Java occorre un compilatore, generalmente noto come `javac', che sia in grado di generare il formato binario Java, il cosiddetto Java bytecode. Il file che si ottiene non è propriamente un eseguibile, in quanto necessita di un interprete che generalmente è il programma `java'.

Esiste una versione ufficiale di questi strumenti, definita JDK (Java Development Kit), e almeno una versione indipendente per la maggior parte degli ambienti Unix (GNU/Linux incluso): Kaffe.

Nelle sezioni seguenti viene descritto in particolare come utilizzare Kaffe; alla fine del capitolo si trovano alcune sezioni sull'installazione e la configurazione del JDK originale.

170.1 Kaffe

Kaffe è un compilatore di sorgenti Java e un interprete di compilati in formato Java (Java bytecode). Attualmente, si tratta di un pacchetto standard delle distribuzioni GNU/Linux, per cui non ci dovrebbero essere problemi nella sua installazione. Attualmente, assieme al compilatore e all'interprete, dovrebbero essere disponibili anche le classi, ovvero le librerie Java. *1*

170.1.1 Classi

Le classi di Kaffe, che ormai accompagnano questo applicativo, dovrebbero essere contenute in un solo file compresso, che deve rimanere tale. Potrebbe trattarsi di `/usr/share/kaffe/Klasses.jar'.

170.1.2 Configurazione

Se si installa Kaffe autonomamente, senza affidarsi a un pacchetto già predisposto per la propria distribuzione GNU/Linux, potrebbe essere necessario definire alcune variabili di ambiente. Nell'esempio seguente si fa riferimento a uno script per una shell Bourne o derivata.

CLASSPATH=.:/usr/share/kaffe/Klasses.jar
KAFFEHOME=/usr/share/kaffe
LD_LIBRARY_PATH=/usr/lib:/usr/local/lib
export CLASSPATH
export KAFFEHOME
export LD_LIBRARY_PATH

Se Kaffe fosse stato installato a partire dalla directory `/usr/local/', si dovrebbe usare la definizione seguente:

CLASSPATH=.:/usr/local/share/kaffe/Klasses.jar
KAFFEHOME=/usr/local/share/kaffe
LD_LIBRARY_PATH=/usr/lib:/usr/local/lib
export CLASSPATH
export KAFFEHOME
export LD_LIBRARY_PATH

Merita un po' di attenzione la variabile `LD_LIBRARY_PATH' che potrebbe essere utilizzata anche da altri programmi. `LD_LIBRARY_PATH' deve contenere i percorsi in cui si trovano i file di libreria, e se il proprio sistema utilizza applicazioni che collocano le proprie librerie all'interno di directory inconsuete, queste devono essere aggiunte all'elenco. Segue un esempio esplicativo.

LD_LIBRARY_PATH=/usr/lib:/usr/local/lib:/opt/mio_prog/lib:/opt/tuo_prog/lib

170.1.3 Compilazione

Per verificare che la compilazione funzioni correttamente, basta preparare il solito programma banale che visualizza un messaggio attraverso lo standard output e poi termina.

class CiaoMondoApp {
    public static void main(String[] args) {
	System.out.println( "Ciao Mondo!" );
    }
}

Il file deve essere salvato con il nome `CiaoMondoApp.java'. Kaffe, tra le altre cose, fornisce un collegamento simbolico, denominato `javac', attraverso cui avviare la compilazione. Così la compilazione avviene nello stesso modo in cui si fa utilizzando gli strumenti del JDK originale.

javac CiaoMondoApp.java[Invio]

Se la sintassi del sorgente Java è corretta, si ottiene un file in formato binario Java, denominato `CiaoMondoApp.class'.

170.1.4 Esecuzione

Per eseguire il binario Java generato, ovvero il file `.class', occorre un interprete. In questo senso, questo file non ha bisogno necessariamente dei permessi in esecuzione, perché verrà solo letto dall'interprete.

kaffe CiaoMondoApp[Invio]

Ciao Mondo!

Come si può osservare dalla riga di comando, il file binario Java deve essere indicato senza l'estensione, che di conseguenza è obbligatoriamente `.class'. Kaffe si compone anche dello script `java', il cui scopo è quello di rendere il comando di interpretazione conforme al JDK; in pratica, `java' si limita ad avviare il comando `kaffe'.

java CiaoMondoApp

Tuttavia, questo script potrebbe essere modificato in modo da permettere l'avvio di un eseguibile Java anche se è stato fornito il nome del file corrispondente, completo di estensione `.class'. L'esempio seguente rappresenta le modifiche che potrebbero essere apportate in tal senso.

#! /bin/sh
#
# /usr/bin/java

CLASSE=`/bin/basename $1 .class`
shift
kaffe $CLASSE $@

170.2 Kernel

Come è noto, uno script viene interpretato automaticamente in base alla convenzione per cui la prima riga inizia con l'indicazione del programma adatto. Per esempio: `#/bin/sh', `#/bin/bash' e `#/usr/bin/perl'. Con i binari Java ciò non è possibile, quindi, per ottenere l'avvio automatico dell'interprete `java', occorre che il kernel ne sia informato. Per la precisione, occorre attivare la funzionalità generica di riconoscimento dei binari.

Questo comporta poi una configurazione per definire quali file devono essere riconosciuti e quali interpreti devono essere avviati di conseguenza. Nel caso dei binari Java normali, si tratta di eseguire il comando seguente (il percorso dell'interprete, `/usr/bin/java' può essere cambiato a seconda delle proprie necessità).

echo ':Java:M::\xca\xfe\xba\xbe::/usr/bin/java:' > /proc/sys/fs/binfmt_misc/register

In alternativa, se si è sicuri dell'estensione `.class', si può utilizzare il comando seguente:

echo ':Java:E::class::/usr/bin/java:' > /proc/sys/fs/binfmt_misc/register

Per verificare che la definizione sia stata recepita correttamente dal kernel, si può leggere il contenuto del file virtuale `/proc/sys/fs/binfmt_misc/Java', creato a seguito di uno dei due comandi mostrati sopra.

Quando il kernel è predisposto nel modo appena visto, si possono rendere eseguibili i file binari Java, e quando si tenta di avviarli, il kernel stesso avvia invece il comando seguente:

java <file-binario-java> <argomenti>

Lo svantaggio di questo, sta nel fatto che il nome del file binario Java viene indicato con tutta l'estensione, cosa che normalmente crea dei problemi, sia a Kaffe che al JDK. Per questo, conviene che `/usr/bin/java' sia uno script che risolva questo problema, come già mostrato nella sezione precedente.

Se invece di usare Kaffe si usa il JDK originale, conviene modificare il nome dell'interprete Java, per esempio in `java1', e realizzare un file script analogo a quello già visto.

#! /bin/sh
#
# /usr/bin/java

CLASSE=`/bin/basename $1 .class`
shift
java1 $CLASSE $@

C'è però una cosa che occorre tenere a mente. Con GNU/Linux, e così anche con altri sistemi, non è possibile avviare un eseguibile se il nome non viene indicato per esteso. In pratica, non è pensabile che succeda quanto accade in Dos in cui i file che finiscono per `.COM' o `.EXE' sono avviati semplicemente nominandoli senza estensione.

Per chi ha usato GNU/Linux da un po' di tempo ciò dovrebbe essere logico, ma con Java si rischia ancora di essere ingannati: il fatto che, sia l'interprete `java' originale, sia `kaffe', vogliano il nome dell'eseguibile Java senza l'estensione `.class', non deve fare supporre che ciò valga anche per il kernel. Per cui, se si avvia `CiaoMondoApp.class' nel modo seguente,

java CiaoMondoApp

quando si vuole che sia il kernel a fare tutto questo per noi, il comando sarà il seguente:

CiaoMondoApp.class

Se si tentasse si eseguire il comando seguente,

CiaoMondoApp

si otterrebbe un semplice: `command not found'.

170.3 Applet

Un applet Java è un programma particolare che può essere incorporato in un documento HTML. Il meccanismo è simile all'inserzione di immagini, e l'effetto è quello di un programma grafico che, invece di utilizzare una finestra, utilizza un'area prestabilita del documento HTML. Un applet Java non può quindi vivere da solo, richiede sempre l'abbinamento a una pagina HTML.

Il modo migliore per vedere il funzionamento di un programma del genere è attraverso l'utilizzo di un navigatore in grado di eseguire tali applet, per esempio Netscape.

170.3.1 Verifica del funzionamento

Per verificare il funzionamento di un applet si può provare il solito programma banale. In questo caso si comincia con la realizzazione di una pagina HTML che incorpori l'applet che si vuole realizzare.

<!-- CiaoMondo.html -->
<HTML>
<HEAD>
	<TITLE>Il mio primo applet</TITLE>
</HEAD>

<BODY>

<OBJECT CODETYPE="application/java"
    CLASSID="java:CiaoMondo.class"
    WIDTH=150
    HEIGHT=25>
Applet Java
</OBJECT>

</BODY>
</HTML>

Come si vede, l'elemento `OBJECT' dichiara l'utilizzo dell'applet `CiaoMondo.class' che si collocherà nello spazio di un rettangolo di 150 per 25 pixel. Segue il sorgente dell'applet.

// CiaoMondo.java

import java.applet.Applet;
import java.awt.Graphics;

public class CiaoMondo extends Applet {
    public void paint(Graphics g) {
        g.drawString("Ciao Mondo!", 50, 25);
    }
}

Si compila il sorgente `CiaoMondo.java' nel solito modo, ottenendo il binario Java `CiaoMondo.class'

javac CiaoMondo.java

Quando si carica il file `CiaoMondo.html' attraverso un browser come Netscape, incontrando l'elemento `OBJECT' che fa riferimento al binario Java `CiaoMondo.class', viene caricato il programma `CiaoMondo.class' nell'area stabilita.

All'interno di quell'area, a partire dall'angolo superiore sinistro, vengono calcolate le coordinate (x=50, y=25) dell'istruzione `g.drawString("Ciao mondo!", 50, 25)' vista nell'applet.

170.4 JDK

Il JDK è il pacchetto standard per la compilazione e l'esecuzione di applicativi Java. Viene distribuito in forma binaria, già compilata. Per ottenerlo, si può consultare http://www.blackdown.org/ o eventualmente si può fare una ricerca attraverso http://ftpsearch.lycos.com per i file contenenti la stringa `linux-jdk' (si potrebbero trovare nomi come `linux-jdk.1.1.3-v2.tar.gz'). Se si desidera installare il JDK è importante verificare di non avere tracce di Kaffe.

170.4.1 Collocazione

Il JDK può essere installato a partire da qualunque punto del proprio filesystem. La directory più conveniente, secondo la gerarchia standard di GNU/Linux (FHS), dovrebbe essere `/opt/'.

Se nel proprio sistema non è presente, si può creare, e al suo interno si può espandere il contenuto del pacchetto JDK. Si ottiene la directory `jdk<versione>/', per esempio `jdk1.1.3/'. Per motivi pratici, è opportuno modificare il nome della directory, o creare un collegamento simbolico, in modo che vi si possa accedere utilizzando il nome `/opt/java/'.

170.4.2 Configurazione

Prima di poter funzionare, il JDK deve essere configurato attraverso delle variabili di ambiente opportune. Nell'esempio seguente si mostra un pezzo di script per una shell Bourne o derivata, in grado di predisporre le variabili necessarie.

PATH="/opt/java/bin:$PATH"
CLASSPATH=.:/opt/java/lib/classes.zip:/opt/java/lib/classes
JAVA_HOME=/opt/java
export PATH
export CLASSPATH
export JAVA_HOME

170.4.3 Funzionamento

Per il funzionamento, si può rivedere quanto già indicato per Kaffe. In questo caso, utilizzando il JDK originale, il compilatore è proprio `javac' e l'esecutore (o interprete) è `java'.

170.5 Riferimenti

---------------------------

Appunti Linux 2000.04.12 --- Copyright © 1997-2000 Daniele Giacomini --  daniele @ pluto.linux.it


1.) In passato era necessario procurarsele a parte, dal momento che la versione libera realizzata appositamente per Kaffe non era stata ancora completata.


[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]