Difference between revisions of "Java package guidelines (Italiano)"

From ArchWiki
Jump to: navigation, search
(Arch Java Packaging)
(Arch Java Packaging)
Line 48: Line 48:
 
  "$JAVA_HOME/bin/java" '/usr/share/java/PROGRAMNAME/PROGRAMCLASSNAME'
 
  "$JAVA_HOME/bin/java" '/usr/share/java/PROGRAMNAME/PROGRAMCLASSNAME'
  
* Set the <code>CLASSPATH</code> using the <code>-cp</code> option to the Java interpreter unless there is an explicit reason not to (ie: the <code>CLASSPATH</code> is used as a plugin mechanism). The <code>CLASSPATH</code> should include all jar files in the <code>/usr/share/java/myprogram</code> direcory, as well as jar files that are from dependency libraries that have been refactored to other directories. You can use something like the following code:
+
* Impostare il il <code>CLASSPATH</code> mediante l'opzione <code>-cp</code> nell'interprete Java, am meno che non vi sia una motivazione esplicita di non farlo (per esempio: il <code>CLASSPATH</code> è usato come un plugin ). Il <code>CLASSPATH</code> dovrebbe includere tutti i file jar nella directory <code>/usr/share/java/myprogram</code>, così come i file jar derivanti da librerie dipendenti che sono state sottoposte a refactoring in altre directory. Si potrebbe usare qualcosa di simile al codice seguente:
 +
 
 
  for name in /usr/share/java/myprogram/*.jar ; do
 
  for name in /usr/share/java/myprogram/*.jar ; do
 
   CP=$CP:$name
 
   CP=$CP:$name
Line 55: Line 56:
 
  java -cp $CP myprogram.java.MainClass
 
  java -cp $CP myprogram.java.MainClass
  
* Make sure the shellscript is executable!
+
* Assicurarsi che lo script sia eseguibile!
  
* Other files distributed with the package should be stored in a directory named after the package under <code>/usr/share</code>. You may need to set the location of this directory in a variable like <code>MYPROJECT_HOME</code> inside the shellscript. This guideline assumes that the program expects all files to be in the same directory (as is standard with Java packages). If it seems more natural to put a configuration file elsewhere (for example, a daemon in <code>/etc/rc.d</code> or logs in <code>/var/log</code>), then feel free to do so.
+
* Altri files distribuiti col pacchetto dovrebbero essere archiviati in una directory col nome del pacchetto dentro a <code>/usr/share</code>. La posizione di tale directory potrebbe essere impostata in una variabile come <code>MYPROJECT_HOME</code> dentre lo script. Questa regola assume che il programma si aspetti che tutti i files siano nella stessa directory (come è lo standard per i pacchetti Java ). Se sembra più naturale mettere un file di configurazione da un'altra parte (per esempio, un demone in <code>/etc/rc.d</code> o dei log in <code>/var/log</code>), si è liberi di farlo.
  
Bear in mind that <code>/usr</code> may be mounted as read-only on some systems. If there are files in the shared directory that need to be written by the application, they may have to be relocated to <code>/etc</code>, <code>/var</code>, or the user's home directory.
+
Tenere a mente che <code>/usr</code> potrebbe essere montata in modalità read-only in alcuni sistemi.
 +
Se ci sono file nella directory condivisa che necessitano di essere scritti dall'applicazione, questi potrebbero essere riposizionati sotto <code>/etc</code>, <code>/var</code>, o la home dell'utente.
  
* As is standard with Arch Linux packages, if the above standards cannot be adhered to without a serious amount of work, the package should be installed in its preferred manner, with the resulting directory located in <code>/opt</code>. This is useful for programs that bundle JREs or include customized versions of dependencies, or do other strange or painful tasks.
+
* Come è lo standard per i pacchetti Arch Linux, se non si può aderire agli standard proposti sopra senza un considerevole lavoro, il pacchetto dovrebbe essere installato nella maniera preferita, con la directory risultante posizionata sotto <code>/opt</code>.  
 +
Ciò è utile per programmi che includono JREs o versioni personalizzate delle dipendenze, o altri strani o difficili sistemi.
  
 
===Multiple API implementations===
 
===Multiple API implementations===

Revision as of 17:01, 9 January 2011

This template has only maintenance purposes. For linking to local translations please use interlanguage links, see Help:i18n#Interlanguage links.


Local languages: Català – Dansk – English – Español – Esperanto – Hrvatski – Indonesia – Italiano – Lietuviškai – Magyar – Nederlands – Norsk Bokmål – Polski – Português – Slovenský – Česky – Ελληνικά – Български – Русский – Српски – Українська – עברית – العربية – ไทย – 日本語 – 正體中文 – 简体中文 – 한국어


External languages (all articles in these languages should be moved to the external wiki): Deutsch – Français – Română – Suomi – Svenska – Tiếng Việt – Türkçe – فارسی

Tango-preferences-desktop-locale.pngThis article or section needs to be translated.Tango-preferences-desktop-locale.png

Notes: please use the first argument of the template to provide more detailed indications. (Discuss in Talk:Java package guidelines (Italiano)#)
Nota: Questo articolo è in fase di traduzione. Seguite per ora le istruzioni della versione inglese.
Questo documento definisce uno standard proposto per pacchettizzare i programmi Java sotto Arch Linux. I programmi Java sono notoriamente difficili da pacchettizzare in maniera pulita senza sovrascrivere dipendenze. Questo documento descrive un metodo per rimediare a questa situazione. Queste linee guida sono flessibili nell'ottica di coprire i molti possibili scenari che si possono verificare quando si ha a che fare con applicazioni Java.

Introduzione

I packagers Arch Linux non sembrano trovare un accordo su come gestire i pacchetti Java. Vari metodi sono utilizzati nei PKGBUILD che si trovano sui repository ufficiali, in quelli non ufficiali e su AUR. Queste soluzioni includono la presenza dell'intero pacchetto in /opt con script da shelli in /usr/bin o profili posizionati in /etc/profile. Altri pacchetti sono collocati nelle directories in /usr/share con script posizionati in /usr/bin. Molti aggiungono file non necessari a CLASSPATH and PATH.

Struttura di una tipica Applicazione Java

La maggior parte delle applicazioni desktop Java ha una struttura simile. Esse sono installate da un installer indipendente dal sistema (ma dipendente dal pacchetto!). Questo installer solitamente installa tutto in una singola directory con sottodirectory chiamate bin, lib, jar, conf, etc. Solitamente c'è un file jar primario che contiene le principali classi eseguibili. Solitamente viene fornito uno script che esegue le classi fondamentali così che l'utente non debba invocare l'interprete Java direttamente. Questo script è solitamente abbastanza complesso, dato che è generico per tutte le distribuzioni, e spesso include opzioni particolari per i differenti sistemi (es: CYGWIN).

La directory lib spesso contiene dei file jar collegati tra loro che soddisfano le dipendenze dell'applicazione Java. Ciò rende semplice per l'utente installare il programma (essendo incluse tutte le dipendenze), ma rende il pacchetto un incubo per lo sviluppatore. È uno spreco di spazio quando diversi pacchetti contengono la stessa dipendenza. In passato, quando c'erano meno applicazioni e librerie Java, e quelle esistenti tendevano comunque ad essere molto grandi, non rappresentava un problema rilevante. Ora però le cose sono cambiate...

Altri file necessari ad eseguire il programma sono solitamente inclusi nella stessa cartella del file jar primario, in una sua sottodirectory. Dal momento che i programmi Java non sanno da dove le loro classi vengono prese, solitamente c'è bisogno di eseguirli nella stessa directory (per esempio uno scrpt potrebbe dare cd nella directory), oppure deve essere impostata una variabile d'ambiente che indichi la posizione della directory.

Arch Java Packaging

Pacchettizzare applicazioni Java in Arch richiederà un po' più di lavoro per i manutentori rispetto a quanto ne richieda attualmente. Tuttavia ne varrà la pena, dal momento che si otterrà un filesystem più pulito e con meno dipendenze inglobate (e man mano che sempre più librerie Java saranno ricompilate nei loro pacchetti, pacchettizzare diventerà sempre più facile). Nel creare un pacchetto Java per Arch Linux si dovrebbero seguire le seguenti linee guida:

  • Se una libreria Java ha un nome generico, il nome del pacchetto dovrebbe avere il prefisso java- in modo da distinguerlo dalle altre librerie. Ciò non è necessario per i pacchetti dal nome univoco (come JUnit), per i programmi end-user (come Eclipse), o per le librerie che possono essere descritte con un altro prefisso (come jakarta-commons-collections or apache-ant).
  • Non è necessario compilare le applicazioni Java dai sorgenti. Nel processo di compilazione ci va pochissima compilazione, come per i binari creati da gcc. Se il pacchetto originario fornisce un metodo semplice di costruire da sorgente, va usato quello; ma se è più semplice prendere semplicemente una release binaria di un file jar o un installer, si può usare anche quel metodo.
  • Tutti i file jar (e solo quelli) distrubuiti col programma vanno posizionati nella directory /usr/share/java/myprogram. Ciò comprende tutte i file jar dipendenti distribuiti con l'applicazione. Va comunque fatto lo sforzo di mettere le dipendenze comuni o le grandi librerie dentro i loro rispettivi pacchetti. Ciò può avvenire solo se il programma non dipende da una specifica versione di una libreria dipendente.

Questa regola rende possibile il refactoring iterarivo delle dipendenze. Cioè, il pacchetto e tutte le sue dipendendenze possono essere inizilamente messi dentro una sola directory, Dopo il test, le principali dipendenze possono essere sottoposte a refactoring una alla volta. È da notare come alcune applicazioni includono dipendenze bundle all'interno del file jar primario (cioè estraggono dal jar le dipendenze e le inglobano nel loro jar). Tali dipendenze sono solitamente poco ingombranti e vi è poco vantaggio nel sottoporle a refactoring.

  • Se il programma deve essere eseguito dall'utente, scrivere uno script personalizzato che esegua il file jar primario. Questo script dovrebbe essere posizionato in /usr/bin. Le librerie generalmente non richiedono script. È meglio scrivere lo script da zero piuttosto che usarne uno incluso nel programma. Rimuovere il codice che controlla l'esistenza di di ambienti personalizzati (come CYGWIN), e il codice che tenta di determinare se la variabile JAVA_HOME è stata inizializzata (il pacchetto J2RE assicrua che JAVA_HOME venga adeguatamente inizializzata)

Uno script con queste caratteristiche dovrebbe apparire così per i jar:

#!/bin/sh
"$JAVA_HOME/bin/java" -jar '/usr/share/java/PROGRAMNAME/PROGRAMNAME.jar'

e così per i singoli file delle classi:

#!/bin/sh
"$JAVA_HOME/bin/java" '/usr/share/java/PROGRAMNAME/PROGRAMCLASSNAME'
  • Impostare il il CLASSPATH mediante l'opzione -cp nell'interprete Java, am meno che non vi sia una motivazione esplicita di non farlo (per esempio: il CLASSPATH è usato come un plugin ). Il CLASSPATH dovrebbe includere tutti i file jar nella directory /usr/share/java/myprogram, così come i file jar derivanti da librerie dipendenti che sono state sottoposte a refactoring in altre directory. Si potrebbe usare qualcosa di simile al codice seguente:
for name in /usr/share/java/myprogram/*.jar ; do
  CP=$CP:$name
done
CP=$CP:/usr/share/java/dep1/dep1.jar
java -cp $CP myprogram.java.MainClass
  • Assicurarsi che lo script sia eseguibile!
  • Altri files distribuiti col pacchetto dovrebbero essere archiviati in una directory col nome del pacchetto dentro a /usr/share. La posizione di tale directory potrebbe essere impostata in una variabile come MYPROJECT_HOME dentre lo script. Questa regola assume che il programma si aspetti che tutti i files siano nella stessa directory (come è lo standard per i pacchetti Java ). Se sembra più naturale mettere un file di configurazione da un'altra parte (per esempio, un demone in /etc/rc.d o dei log in /var/log), si è liberi di farlo.

Tenere a mente che /usr potrebbe essere montata in modalità read-only in alcuni sistemi. Se ci sono file nella directory condivisa che necessitano di essere scritti dall'applicazione, questi potrebbero essere riposizionati sotto /etc, /var, o la home dell'utente.

  • Come è lo standard per i pacchetti Arch Linux, se non si può aderire agli standard proposti sopra senza un considerevole lavoro, il pacchetto dovrebbe essere installato nella maniera preferita, con la directory risultante posizionata sotto /opt.

Ciò è utile per programmi che includono JREs o versioni personalizzate delle dipendenze, o altri strani o difficili sistemi.

Multiple API implementations

If your package distributes commonly used api implementation(like jdbc driver) you should place the library under /usr/share/java/<apiname>. So that applications that allow user to select from various implementations will know where to look for them. Use this location only for raw library packages. If such a implementation is part of distribution of application, do not place this jarfile under common location, but use ordinary package structure.

Example Directory Structure

To clarify, here is an example directory structure for a hypothetical program called foo. Since foo is a common name, the package is named java-foo, but notice this is not reflected in the directory structure:

  • /usr/share/java/foo/
  • /usr/share/java/foo/foo.jar
  • /usr/share/java/foo/bar.jar (included dependency of java-foo)
  • /usr/share/foo/
  • /usr/share/foo/*.* (some general files required by java-foo)
  • /usr/bin/foo (executable shell script)

Dependencies

Java packages might specify 'java-runtime' or 'java-environment' as dependancy, depending on what they need.

For most of the package, 'java-runtime' is what is needed to simply run java software written in java.

java-runtime is a virtual dependancy provided by:

  • java-gcj-compat (free)
  • openjdk6 (free)
  • jre (non-free)

java-environment is needed by packages that will need to compile java source code into bytecode.

java-environment is a virtual dependancy provided by:

  • openjdk6 (free)
  • jdk (non-free)

gcj was a long time the only free java environment but was never really useable. Then Sun started to make more and more parts of java opensource which are now bundeled in the openjdk6 package. openjdk6 is way superior than gcj. Most java applications are at the moment with no problems useable with openjdk6. Some few do still need jdk. Nearly none run with gcj.

Note: java-gcj-compat package will be the first package providing java-runtime that pacman will find and install. But it is not the best one. Far from it. java-gcj-compat might be removed in a distant future.