Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Estructuración de la carpeta de proyectos
<a name="java-tomcat-platform-directorystructure"></a>

Para que todo funcione al realizar la implementación en un servidor Tomcat, los archivos de aplicación web (archivos WAR) compilados con Java Platform Enterprise Edition (*Java EE*) deben estar estructurados de acuerdo con ciertas [directrices](https://docs.oracle.com/javaee/7/tutorial/packaging003.htm). El directorio de proyectos no tiene que ajustarse a los mismos estándares, pero es recomendable estructurarlo de la misma manera para simplificar la compilación y el empaquetado. Estructurar la carpeta de proyectos igual que el contenido del archivo WAR también le ayuda a comprender cómo se relacionan los archivos y cómo se comportan en un servidor web.

En la siguiente jerarquía recomendada, el código fuente de la aplicación web se coloca en un directorio `src` para aislarlo del script de compilación y del archivo WAR que 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
```

El contenido del archivo `src` coincide con lo que se va a empaquetar e implementar en el servidor, a excepción de la carpeta `com`. La carpeta `com` contiene las clases no compiladas (archivos `.java`). Deben compilarse y guardarse en el directorio `WEB-INF/classes` para que estén accesibles desde el código de la aplicación.

El directorio `WEB-INF` contiene código y configuraciones que no se proporcionan públicamente en el servidor web. Las demás carpetas de la raíz del directorio de código fuente (`css`, `images` y `js`) están disponibles públicamente en la ruta correspondiente del servidor web.

El siguiente ejemplo es idéntico al directorio de proyectos anterior, salvo que contiene más archivos y subdirectorios. En este ejemplo, el proyecto contiene etiquetas sencillas, un modelo y clases de compatibilidad, así como un archivo de Java Server Pages (JSP) para un recurso `record`. También incluye una hoja de estilos y, JavaScript para [Bootstrap](http://getbootstrap.com/), un archivo JSP predeterminado y una página de errores para los errores 404.

`WEB-INF/lib` contiene un archivo de Java Archive (JAR) con el controlador de Java Database Connectivity (JDBC) para PostgreSQL. `WEB-INF/classes` está vacío, ya que no se han compilado todavía los archivos de clase.

```
~/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
```

## Compilación de un archivo WAR con un script de shell
<a name="java-tomcat-platform-directorystructure-building"></a>

`build.sh` es un script de shell muy sencillo que compila las clases de Java, construye un archivo WAR y lo copia en el directorio `webapps` de Tomcat para las pruebas locales.

```
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 ../
```

Dentro del archivo WAR, encontrará la misma estructura que en el directorio `src` del ejemplo anterior, a excepción de la carpeta `src/com`. El comando `jar` crea automáticamente el archivo `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
```

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

Para evitar que se validen los archivos de clases compiladas y los archivos WAR en su repositorio de Git o que aparezcan mensajes cuando ejecute comandos Git, agregue los tipos de archivo pertinentes en un archivo denominado `.gitignore` en la carpeta de su proyecto.

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

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