As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Estruturar a pasta do projeto
<a name="java-tomcat-platform-directorystructure"></a>

Para funcionarem quando implantados em um servidor Tomcat, os arquivos de aplicativo web (arquivos WAR) do Java Platform Enterprise Edition (*Java EE*) precisam ser estruturados de acordo com determinadas [diretrizes](https://docs.oracle.com/javaee/7/tutorial/packaging003.htm). O diretório de seu projeto não precisa atender aos mesmos padrões, mas é uma boa ideia estruturá-lo da mesma forma para simplificar a compilação e o empacotamento. A estruturação da pasta do projeto de modo similar ao conteúdo do arquivo WAR também ajuda você a entender como os arquivos estão relacionados e como eles se comportam em um servidor da web.

Na hierarquia recomendada a seguir, o código-fonte do aplicativo web é colocado em um diretório `src`, a fim e isolá-lo do script de compilação e do arquivo WAR gerado.

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

O conteúdo da pasta `src` corresponde ao que você empacotará e implantará no servidor, com exceção da pasta `com`. A pasta `com` contém as classes não compiladas (arquivos `.java`). Elas precisam ser compiladas e colocadas no diretório `WEB-INF/classes` para ficarem acessíveis do código do aplicativo.

O diretório `WEB-INF` contém código e configurações que não são atendidos publicamente no servidor web. As outras pastas na raiz do diretório de origem (`css`, `images` e `js`) estão disponíveis publicamente no caminho correspondente no servidor web.

O exemplo a seguir é idêntico ao diretório do projeto anterior, exceto pelo fato de conter mais arquivos e subdiretórios. Esse exemplo de projeto inclui tags, modelos e classes de suporte simples e um arquivo Java Server Pages (JSP) para um recurso `record`. Também inclui uma folha de estilo e, JavaScript para o [Bootstrap](http://getbootstrap.com/), um arquivo JSP padrão e uma página de erro para erros 404.

`WEB-INF/lib` inclui um arquivo Java Archive (JAR) contendo o driver Java Database Connectivity (JDBC) para PostgreSQL. `WEB-INF/classes` está vazio porque os arquivos de classe não foram compilados ainda.

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

## Criar um arquivo WAR com um script Shell
<a name="java-tomcat-platform-directorystructure-building"></a>

`build.sh` é um script de shell muito simples que compila classes Java, constrói um arquivo WAR e o copia no diretório `webapps` do Tomcat para testes locais.

```
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 do arquivo WAR, você encontra a mesma estrutura existente no diretório `src` no exemplo anterior, com exceção da pasta `src/com`. O comando `jar` cria automaticamente o arquivo `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
```

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

Para evitar a confirmação de arquivos de classe compilados e de arquivos WAR em seu repositório Git ou a visualização de mensagens sobre a exibição deles quando você executa comandos do Git, adicione os tipos de arquivo relevantes a um arquivo denominado `.gitignore` na pasta do projeto.

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

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