Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Strutturazione della cartella di progetto
<a name="java-tomcat-platform-directorystructure"></a>

Per poter funzionare quando vengono distribuiti in un server Tomcat, gli archivi dell'applicazione Web (file WAR) Java Platform Enterprise Edition (*Java EE*) compilati devono essere strutturati in base a determinate [linee guida](https://docs.oracle.com/javaee/7/tutorial/packaging003.htm). La directory di progetto non deve necessariamente soddisfare gli stessi standard, ma è una buona idea strutturarla allo stesso modo per semplificare la compilazione e la creazione di pacchetti. La strutturazione della cartella di progetto come contenuto di file WAR, inoltre, aiuta a comprendere la relazione tra i file e il relativo comportamento su un server Web.

Nella seguente gerarchia consigliata il codice sorgente per l'applicazione Web viene posizionato in una directory `src`, in modo da isolarlo dallo script di creazione e dal file WAR che genera.

```
~/workspace/my-app/
|-- build.sh            - Build script that compiles classes and creates a WAR
|-- README.MD           - Readme file with information about your project, notes
|-- ROOT.war            - Source bundle artifact created by build.sh
`-- src                 - Source code folder
    |-- WEB-INF         - Folder for private supporting files
    |   |-- classes     - Compiled classes
    |   |-- lib         - JAR libraries
    |   |-- tags        - Tag files
    |   |-- tlds        - Tag Library Descriptor files
    |   `-- web.xml     - Deployment Descriptor
    |-- com             - Uncompiled classes
    |-- css             - Style sheets
    |-- images          - Image files
    |-- js              - JavaScript files
    `-- default.jsp     - JSP (JavaServer Pages) webpage
```

Il contenuto della cartella `src` corrisponde a ciò che verrà inserito in pacchetti e distribuito al server, ad eccezione della cartella `com`. La cartella `com` contiene le classi non compilate (file `.java`). Queste devono essere compilate e inserite nella directory `WEB-INF/classes` per essere accessibili dal codice dell'applicazione.

La directory `WEB-INF` contiene il codice e le configurazioni che non vengono gestiti pubblicamente nel server Web. Le altre cartelle nella root della directory di origine (`css`, `images` e `js`) sono disponibili pubblicamente nel percorso corrispondente nel server Web.

L'esempio seguente è identico alla directory di progetto precedente, ma contiene ulteriori file e sottodirectory. Questo progetto di esempio include tag semplici, classi di supporto e modello e un file Java Server Page (JSP) per una risorsa `record`. Include anche un foglio di stile e JavaScript per [Bootstrap](http://getbootstrap.com/), un file JSP predefinito e una pagina di errore per gli errori 404.

`WEB-INF/lib` include un file Java Archive (JAR) che contiene il driver Java Database Connectivity (JDBC) per PostgreSQL. `WEB-INF/classes` è vuoto perché i file di classe non sono ancora state compilate.

```
~/workspace/my-app/
|-- build.sh
|-- README.MD
|-- ROOT.war
`-- src
    |-- WEB-INF
    |   |-- classes
    |   |-- lib
    |   |   `-- postgresql-9.4-1201.jdbc4.jar
    |   |-- tags
    |   |   `-- header.tag
    |   |-- tlds
    |   |   `-- records.tld
    |   `-- web.xml
    |-- com
    |   `-- myapp
    |       |-- model
    |       |   `-- Record.java
    |       `-- web
    |           `-- ListRecords.java
    |-- css
    |   |-- bootstrap.min.css
    |   `-- myapp.css
    |-- images
    |   `-- myapp.png
    |-- js
    |   `-- bootstrap.min.js
    |-- 404.jsp
    |-- default.jsp
    `-- records.jsp
```

## Creazione di un file WAR con uno script di shell
<a name="java-tomcat-platform-directorystructure-building"></a>

`build.sh` è uno script di shell molto semplice che compila classi Java, crea un file WAR e lo copia nella directory `webapps` di Tomcat per test locali.

```
cd src
javac -d WEB-INF/classes com/myapp/model/Record.java
javac -classpath WEB-INF/lib/*:WEB-INF/classes -d WEB-INF/classes com/myapp/model/Record.java
javac -classpath WEB-INF/lib/*:WEB-INF/classes -d WEB-INF/classes com/myapp/web/ListRecords.java

jar -cvf ROOT.war *.jsp images css js WEB-INF
cp ROOT.war /Library/Tomcat/webapps
mv ROOT.war ../
```

All'interno del file WAR troverai la stessa struttura esistente nella directory `src` dell'esempio precedente, esclusa la cartella `src/com`. Il comando `jar` crea automaticamente il file `META-INF/MANIFEST.MF`.

```
~/workspace/my-app/ROOT.war
|-- META-INF
|   `-- MANIFEST.MF
|-- WEB-INF
|   |-- classes
|   |   `-- com
|   |       `-- myapp
|   |           |-- model
|   |           |   `-- Records.class
|   |           `-- web
|   |               `-- ListRecords.class
|   |-- lib
|   |   `-- postgresql-9.4-1201.jdbc4.jar
|   |-- tags
|   |   `-- header.tag
|   |-- tlds
|   |   `-- records.tld
|   `-- web.xml
|-- css
|   |-- bootstrap.min.css
|   `-- myapp.css
|-- images
|   `-- myapp.png
|-- js
|   `-- bootstrap.min.js
|-- 404.jsp
|-- default.jsp
`-- records.jsp
```

## Utilizzo `.gitignore`
<a name="java-tomcat-platform-gitignore"></a>

Per evitare il commit dei file di classe e dei file WAR compilati nel repository Git o la visualizzazione di messaggi relativi a questi file quando esegui comandi Git, aggiungi i tipi di file rilevanti a un file denominato `.gitignore` nella cartella di progetto.

**\$1/workspace/myapp/.gitignore**

```
*.zip
*.class
```