Strutturazione della cartella di progetto

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. 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, un file JSP predefinito e una pagina degli errori per 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

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

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.

~/workspace/myapp/.gitignore

*.zip
*.class